Move the std::vector<std::byte> tests to unit-custom-binary-type-cpp17.cpp

The develop merge kept the test case that #5809 moved from unit-regression3.cpp in unit-custom-binary-type.cpp, but byte_binary_json is only defined in the C++17 file now, so the C++17 build of the former failed. Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Rename two more json_view test helpers that clash in the unity build
2026-10-27 16:28:57 +00:00 · 2026-10-21 19:21:53 +02:00 · 2026-10-21 15:17:30 +02:00 · 2026-10-21 11:05:27 +02:00 · 2026-10-21 10:45:45 +02:00 · 2026-10-10 09:49:13 +02:00
994 changed files with 611728 additions and 44831 deletions
@@ -1,33 +1,3 @@
 # Style or vendor rule sets that do not fit a header-only library:
 #   altera-*, fuchsia-*, llvmlibc-*, android-cloexec-fopen, boost-use-ranges, llvm-header-guard,
 #   llvm-include-order, llvm-prefer-static-over-anonymous-namespace, llvm-use-ranges,
 #   misc-use-anonymous-namespace, google-runtime-float, google-runtime-int, hicpp-signed-bitwise,
 #   bugprone-signed-bitwise, hicpp-explicit-conversions, google-explicit-constructor,
 #   cppcoreguidelines-explicit-constructor, misc-explicit-constructor (implicit conversions are the
 #   API), readability-trailing-comma,
 #   hicpp-avoid-goto / cppcoreguidelines-avoid-goto, hicpp-no-array-decay,
 #   hicpp-uppercase-literal-suffix, readability-uppercase-literal-suffix, modernize-use-trailing-return-type.
 # Constructs the library needs on purpose (the library supports C++11 and legacy compilers):
 #   cppcoreguidelines-macro-usage, cppcoreguidelines-avoid-do-while (macros),
 #   cppcoreguidelines-pro-bounds-*, cppcoreguidelines-pro-type-reinterpret-cast,
 #   cppcoreguidelines-pro-type-union-access (parsers, serializers, basic_json's value union),
 #   cppcoreguidelines-avoid-const-or-ref-data-members, cppcoreguidelines-rvalue-reference-param-not-moved,
 #   cppcoreguidelines-avoid-non-const-global-variables, misc-non-private-member-variables-in-classes,
 #   misc-no-recursion (value walks are recursive, bounded by detail::recursion_depth_limit()),
 #   modernize-type-traits, modernize-use-constraints, modernize-use-ranges, modernize-use-std-numbers,
 #   modernize-use-designated-initializers, modernize-use-nodiscard, modernize-concat-nested-namespaces,
 #   readability-redundant-typename, readability-redundant-parentheses,
 #   readability-redundant-access-specifiers, readability-simplify-boolean-expr,
 #   readability-use-concise-preprocessor-directives, modernize-use-string-view,
 #   modernize-use-integer-sign-comparison (needs std::cmp_less; the flagged
 #   static_cast<std::size_t>(end - pos) < n comparisons are deliberate)
 #   (all need a newer standard or compiler than C++11, or would change macro-generated or
 #   deliberately explicit code).
 # Too noisy to be useful (numeric parsing/formatting code, doctest, tests):
 #   bugprone-easily-swappable-parameters, cppcoreguidelines-avoid-magic-numbers, readability-magic-numbers,
 #   readability-identifier-length, readability-function-cognitive-complexity, performance-enum-size,
 #   concurrency-mt-unsafe, misc-confusable-identifiers, misc-include-cleaner (run on its own for
 #   the consumer headers in cmake/ci.cmake).
 # portability-avoid-pragma-once: kept disabled on purpose. #pragma once is accepted
 # by every supported compiler, and tools/amalgamate/amalgamate.py strips it from
 # single_include, so there is nothing left to fix here.
@@ -40,14 +10,14 @@ Checks: '*,
         -android-cloexec-fopen,
         -boost-use-ranges,
         -bugprone-easily-swappable-parameters,
-         -bugprone-signed-bitwise,
+         -cert-err58-cpp,
         -clang-analyzer-webkit.NoUncountedMemberChecker,
         -concurrency-mt-unsafe,
         -cppcoreguidelines-avoid-const-or-ref-data-members,
         -cppcoreguidelines-avoid-do-while,
         -cppcoreguidelines-avoid-goto,
         -cppcoreguidelines-avoid-magic-numbers,
         -cppcoreguidelines-avoid-non-const-global-variables,
         -cppcoreguidelines-explicit-constructor,
         -cppcoreguidelines-macro-usage,
         -cppcoreguidelines-pro-bounds-avoid-unchecked-container-access,
         -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
@@ -56,15 +26,19 @@ Checks: '*,
         -cppcoreguidelines-pro-type-reinterpret-cast,
         -cppcoreguidelines-pro-type-union-access,
         -cppcoreguidelines-rvalue-reference-param-not-moved,
         -cppcoreguidelines-virtual-class-destructor,
         -fuchsia-default-arguments-calls,
         -fuchsia-default-arguments-declarations,
         -fuchsia-overloaded-operator,
         -google-explicit-constructor,
         -google-readability-function-size,
         -google-runtime-float,
         -google-runtime-int,
         -hicpp-avoid-goto,
         -hicpp-explicit-conversions,
         -hicpp-function-size,
         -hicpp-no-array-decay,
         -hicpp-no-assembler,
         -hicpp-signed-bitwise,
         -hicpp-uppercase-literal-suffix,
         -llvm-header-guard,
@@ -74,7 +48,6 @@ Checks: '*,
         -llvmlibc-*,
         -misc-use-anonymous-namespace,
         -misc-confusable-identifiers,
         -misc-explicit-constructor,
         -misc-include-cleaner,
         -misc-no-recursion,
         -misc-non-private-member-variables-in-classes,
@@ -82,22 +55,20 @@ Checks: '*,
         -modernize-type-traits,
         -modernize-use-constraints,
         -modernize-use-designated-initializers,
         -modernize-use-integer-sign-comparison,
         -modernize-use-nodiscard,
         -modernize-use-ranges,
         -modernize-use-string-view,
         -modernize-use-std-numbers,
         -modernize-use-trailing-return-type,
         -performance-enum-size,
         -portability-avoid-pragma-once,
         -readability-function-cognitive-complexity,
         -readability-function-size,
         -readability-identifier-length,
         -readability-magic-numbers,
         -readability-redundant-access-specifiers,
         -readability-redundant-parentheses,
         -readability-redundant-typename,
         -readability-simplify-boolean-expr,
         -readability-trailing-comma,
         -readability-uppercase-literal-suffix,
         -readability-use-concise-preprocessor-directives'
@@ -108,9 +108,16 @@ The tests are located in [`tests/src/unit-*.cpp`](https://github.com/nlohmann/js
 are structured along the features of the library or the nature of the tests. Usually, it should be clear from the
 context which existing file needs to be extended, and only very few cases require creating new test files.
-When fixing a bug, edit `unit-regression3.cpp` and add a section referencing the fixed issue.
+When fixing a bug, edit `unit-regression3.cpp` and add a section referencing the fixed issue. Tests that need C++17 or
-`unit-regression2.cpp` holds the older tests; the two files exist because a single one grew large enough for the
+C++20 go into `unit-regression3-cpp17.cpp` or `unit-regression3-cpp20.cpp` instead, so the large file is not rebuilt
-MinGW linker to fail relocating it, so please keep adding to the smaller file rather than growing the larger one.
+for every C++ standard. `unit-regression2.cpp` holds the older tests; the two files exist because a single one grew
 large enough for the MinGW linker to fail relocating it, so please keep adding to the smaller file rather than growing
 the larger one.
 To keep compile times down, several test files are compiled together as one translation unit. This sets a few rules
 for test files, such as giving file-scope helpers file-specific names. See the README in the
 [`tests`](https://github.com/nlohmann/json/tree/develop/tests) folder for how the tests are built and what to keep in
 mind when adding them.
 #### Exceptions
@@ -18,8 +18,7 @@ environment:
  matrix:
    # The Visual Studio 2017 jobs compile everything with /std:c++17, so they
    # only build the C++17 variant of each test, split into two jobs each to
-    # stay below AppVeyor's 60-minute limit per job. The Visual Studio 2019
+    # stay below AppVeyor's 60-minute limit per job.
    # job builds the tests for all standards and is split for the same reason.
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      configuration: Debug
      platform: x86
@@ -51,13 +50,7 @@ environment:
      configuration: Release
      platform: x86
      CXX_FLAGS: "/W4 /WX"
-      CMAKE_OPTIONS: "-DJSON_ImplicitConversions=OFF -DJSON_TestShard=0/2"
+      CMAKE_OPTIONS: "-DJSON_ImplicitConversions=OFF"
      GENERATOR: Visual Studio 16 2019
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
      configuration: Release
      platform: x86
      CXX_FLAGS: "/W4 /WX"
      CMAKE_OPTIONS: "-DJSON_ImplicitConversions=OFF -DJSON_TestShard=1/2"
      GENERATOR: Visual Studio 16 2019
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
@@ -64,7 +64,6 @@ labels:
    - "tests/src/unit-json_view.*"
    - "tests/src/json_view_test_helpers\\.hpp"
    - "tests/src/fuzzer-(parse_json_view|json_view_image)\\.cpp"
    - "tests/benchmarks/json_view/.*"
    - "tools/amalgamate/config_json_view\\.json"
    - "docs/mkdocs/docs/features/json_view\\.md"
    - "docs/mkdocs/docs/api/basic_json_(document|view)/.*"
@@ -154,28 +154,6 @@ jobs:
          # PR content in a job without credentials.
          python3 tools/generate_natvis/generate_natvis.py $MAIN_DIR
      - name: Check the nlohmann_json.natvis generator options
        run: |
          cd $MAIN_DIR
          # The options for configurations outside the checked-in file write
          # to a temporary file, so they do not affect the diff below.
          GENERATOR=tools/generate_natvis/generate_natvis.py
          python3 $GENERATOR --list-tags
          TAG_COUNT=$(python3 $GENERATOR --list-tags | wc -l)
          python3 $GENERATOR --abi-tags diag,_dp,_ns --abi-tags _diag --output $RUNNER_TEMP/abi_tags.natvis
          grep -q '<!-- Namespace nlohmann::json_abi_diag_dp_ns -->' $RUNNER_TEMP/abi_tags.natvis
          grep -q '<!-- Namespace nlohmann::json_abi_diag_dp_ns_v[0-9_]* -->' $RUNNER_TEMP/abi_tags.natvis
          test $(grep -c '<!-- Namespace ' $RUNNER_TEMP/abi_tags.natvis) -eq $(( $(grep -c '<!-- Namespace ' nlohmann_json.natvis) + 2 ))
          python3 $GENERATOR --all --output $RUNNER_TEMP/all.natvis
          test $(grep -c '<!-- Namespace ' $RUNNER_TEMP/all.natvis) -eq $(( (1 << TAG_COUNT) * 2 + 1 ))
          if python3 $GENERATOR --abi-tags _unknown --output $RUNNER_TEMP/unknown.natvis; then
            echo "generate_natvis.py accepted an unknown ABI tag"
            exit 1
          fi
      - name: Build patch and check for differences
        id: diff
        run: |
@@ -38,14 +38,14 @@ jobs:
    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
-      uses: github/codeql-action/init@6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee # v4.39.0
+      uses: github/codeql-action/init@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.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@6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee # v4.39.0
+      uses: github/codeql-action/autobuild@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee # v4.39.0
+      uses: github/codeql-action/analyze@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
@@ -37,14 +37,6 @@ jobs:
            var matchArtifact = artifacts.data.artifacts.filter((artifact) => {
              return artifact.name == "pr"
            })[0];
            // a run that failed before its jobs started (e.g. a stale queued
            // run cancelled long after its push) has no artifact to report on
            if (!matchArtifact) {
              core.notice('Run ${{ github.event.workflow_run.id }} has no "pr" artifact; nothing to comment on.');
              core.setOutput('found', 'false');
              return;
            }
            core.setOutput('found', 'true');
            var download = await github.rest.actions.downloadArtifact({
               owner: context.repo.owner,
               repo: context.repo.repo,
@@ -59,11 +51,9 @@ jobs:
      # Extract the untrusted PR artifact into a dedicated empty directory and
      # read only the two expected files by fixed path afterwards. This avoids a
      # malicious archive overwriting workspace files or escaping via ../ paths.
-      - if: steps.download.outputs.found == 'true'
+      - run: unzip -o pr.zip -d ./pr_artifact
        run: unzip -o pr.zip -d ./pr_artifact
      - name: 'Comment on PR'
        if: steps.download.outputs.found == 'true'
        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
@@ -43,11 +43,10 @@ jobs:
      - name: flawfinder_scan
        uses: david-a-wheeler/flawfinder@c4216b74cf2639ffa98503768bd6e4299b5440c9 # v2.0.20
        with:
-          # single_include/ is generated from include/ and would report every finding twice
+          arguments: '--sarif ./'
          arguments: "--sarif --exclude '*/single_include/*' ./"
          output: 'flawfinder_results.sarif'
      - name: Upload analysis results to GitHub Security tab
-        uses: github/codeql-action/upload-sarif@6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee # v4.39.0
+        uses: github/codeql-action/upload-sarif@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
        with:
          sarif_file: ${{github.workspace}}/flawfinder_results.sarif
@@ -1,84 +0,0 @@
 name: "json_view benchmarks"
 # On demand only: runs the comparison of json_view with yyjson, simdjson, and
 # Boost.JSON (tests/benchmarks/json_view/compare.py) on GitHub-hosted runners,
 # for numbers from x86-64 and AArch64 Linux. It runs when started by hand, or
 # when a pull request gets the label "benchmark" (on both architectures, with
 # GCC and the default settings). Shared runners are noisy: the results show
 # where json_view stands, but published numbers need a quiet machine (see
 # tests/benchmarks/json_view/README.md).
 on:
  pull_request:
    types: [labeled]
  workflow_dispatch:
    inputs:
      runner:
        description: "Runner image"
        type: choice
        options:
          - ubuntu-24.04
          - ubuntu-24.04-arm
        default: ubuntu-24.04
      compiler:
        description: "Compiler"
        type: choice
        options:
          - g++
          - clang++
        default: g++
      native:
        description: "Compile for the runner's CPU (-march=native)"
        type: boolean
        default: false
      rounds:
        description: "Rounds of bench_view"
        type: number
        default: 30
 permissions:
  contents: read
 concurrency:
  # (the label is part of the group: adding an unrelated label must not cancel a running benchmark)
  group: json-view-benchmarks-${{ github.workflow }}-${{ github.ref }}-${{ github.event.label.name }}
  cancel-in-progress: true
 jobs:
  compare:
    if: github.event_name == 'workflow_dispatch' || github.event.label.name == 'benchmark'
    strategy:
      matrix:
        runner: ${{ fromJSON(github.event_name == 'workflow_dispatch' && format('["{0}"]', inputs.runner) || '["ubuntu-24.04", "ubuntu-24.04-arm"]') }}
    runs-on: ${{ matrix.runner }}
    timeout-minutes: 60
    steps:
      - name: Harden Runner
        uses: step-security/harden-runner@ccd8616d44fd3846e67624a50d5aad6d37bf2d25 # v2.22.1
        with:
          egress-policy: audit
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
        with:
          persist-credentials: false
      - name: Download test data
        run: |
          cmake -S . -B build -DJSON_BuildTests=On
          cmake --build build --target download_test_data
      - name: Run the comparison
        env:
          CXX: ${{ inputs.compiler || 'g++' }}
          CC: ${{ inputs.compiler == 'clang++' && 'clang' || 'gcc' }}
          ROUNDS: ${{ inputs.rounds || 30 }}
          NATIVE: ${{ inputs.native && '--native' || '' }}
        run: python3 tests/benchmarks/json_view/compare.py --data build/test_files --download --rounds "$ROUNDS" $NATIVE
      - name: Summary
        run: cat tests/benchmarks/json_view/results/*.md >> "$GITHUB_STEP_SUMMARY"
      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
        with:
          name: json_view-benchmarks-${{ matrix.runner }}-${{ inputs.compiler || 'g++' }}
          path: tests/benchmarks/json_view/results/
@@ -80,6 +80,6 @@ jobs:
      # Upload the results to GitHub's code scanning dashboard.
      - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee # v4.39.0
+        uses: github/codeql-action/upload-sarif@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
        with:
          sarif_file: results.sarif
@@ -65,7 +65,7 @@ jobs:
      # Upload SARIF file generated in previous step
      - name: Upload SARIF file
-        uses: github/codeql-action/upload-sarif@6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee # v4.39.0
+        uses: github/codeql-action/upload-sarif@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
        with:
          sarif_file: semgrep.sarif
        if: always()
@@ -37,7 +37,6 @@ cc_library(
        "include/nlohmann/detail/input/parser.hpp",
        "include/nlohmann/detail/input/position_t.hpp",
        "include/nlohmann/detail/input/pow5_table.hpp",
        "include/nlohmann/detail/input/simd_scan.hpp",
        "include/nlohmann/detail/input/string_scan.hpp",
        "include/nlohmann/detail/iterators/internal_iterator.hpp",
        "include/nlohmann/detail/iterators/iter_impl.hpp",
@@ -90,7 +89,6 @@ cc_library(
        "include/nlohmann/detail/view/simd.hpp",
        "include/nlohmann/detail/view/string_ref.hpp",
        "include/nlohmann/detail/view/value.hpp",
        "include/nlohmann/detail/view/view_mode.hpp",
        "include/nlohmann/json.hpp",
        "include/nlohmann/json_fwd.hpp",
        "include/nlohmann/json_literals.hpp",
@@ -6,7 +6,6 @@ This file describes the source for supporting files; that is, files that are not
 - [GitHub](#github)
 - [REUSE](#reuse)
 - [Package Managers](#package-managers)
 - [Debugging](#debugging)
 ## Continuous Integration
@@ -290,29 +289,3 @@ The module definition for [Bazel](https://bazel.build)'s [Bzlmod](https://bazel.
 Further documentation:
 - [Bazel modules](https://bazel.build/external/module)
 ## Debugging
 ### `nlohmann_json.natvis`
 The [Natvis](https://learn.microsoft.com/en-us/visualstudio/debugger/create-custom-views-of-native-objects) file that
 gives `json` values a friendly view in the Visual Studio debugger. The file is generated by
 `tools/generate_natvis/generate_natvis.py` from the template `tools/generate_natvis/nlohmann_json.natvis.j2` and the ABI
 tags and version in `include/nlohmann/detail/abi_macros.hpp`; change the script or the template rather than editing
 the file by hand. The file can be updated by calling
 ```shell
 make natvis
 ```
 The "Check amalgamation" workflow fails if the file is out of date.
 The file covers the namespace variants with up to two ABI tags. A Natvis file for other configurations can be
 generated with the `--abi-tags` or `--all` options, for example
 `make natvis NATVIS_ARGS="--abi-tags _diag,_dp,_ns --output my_nlohmann_json.natvis"`; see
 [`tools/generate_natvis`](tools/generate_natvis/README.md). With MSVC, CMake adds the file to the `nlohmann_json`
 target and installs it.
 Further documentation:
 - [Create custom views of C++ objects in the debugger using the Natvis framework](https://learn.microsoft.com/en-us/visualstudio/debugger/create-custom-views-of-native-objects)
@@ -46,7 +46,7 @@ all:
 	@echo "clean - remove built files"
 	@echo "(fuzzers) - see tests/fuzzing.md, or run 'make -C tests fuzzers' to build the AFL fuzzers"
 	@echo "macro_builder_check - check that macro_scope.hpp matches tools/macro_builder's output"
-	@echo "natvis - regenerate nlohmann_json.natvis from the current ABI tags and version (pass generator options via NATVIS_ARGS, see tools/generate_natvis/README.md)"
+	@echo "natvis - regenerate nlohmann_json.natvis from the current ABI tags and version"
 	@echo "pretty - beautify code with Artistic Style"
 	@echo "pvs_studio - run the PVS-Studio static analyzer and open the report"
 	@echo "release - create the release files (include.zip, json.tar.xz, single headers, signatures, hashes)"
@@ -120,15 +120,13 @@ $(AMALGAMATED_VIEW_FILE): $(SRCS)
 	tools/amalgamate/amalgamate.py -c tools/amalgamate/config_json_view.json -s . --verbose=yes
 NATVIS_VENV=tools/generate_natvis/venv
 # extra options for generate_natvis.py, e.g. NATVIS_ARGS="--abi-tags _diag,_dp,_ns --output my.natvis"
 NATVIS_ARGS=
 # regenerate nlohmann_json.natvis from the ABI tags and version in include/nlohmann/detail/abi_macros.hpp
 # (the dependencies are installed into a virtual environment first)
 natvis:
 	@test -d $(NATVIS_VENV) || python3 -mvenv $(NATVIS_VENV)
 	@$(NATVIS_VENV)/bin/python3 -c 'import jinja2' 2>/dev/null || $(NATVIS_VENV)/bin/pip3 install --quiet -r tools/generate_natvis/requirements.txt
-	$(NATVIS_VENV)/bin/python3 tools/generate_natvis/generate_natvis.py $(NATVIS_ARGS) .
+	$(NATVIS_VENV)/bin/python3 tools/generate_natvis/generate_natvis.py .
 # regenerate the two tools/macro_builder blocks of $(MACRO_SCOPE_HPP) (see its README.md) and diff against the
 # checked-in header; phony, because it never writes $(MACRO_SCOPE_HPP) itself
@@ -151,7 +151,7 @@ The `json` class provides an API for manipulating a JSON value. To create a `jso
 ```cpp
 #include <fstream>
 #include <nlohmann/json.hpp>
-using nlohmann::json;
+using json = nlohmann::json;
 // ...
@@ -164,7 +164,7 @@ If using modules (enabled with `NLOHMANN_JSON_BUILD_MODULES`), this example beco
 import std;
 import nlohmann.json;
-using nlohmann::json;
+using json = nlohmann::json;
 // ...
@@ -842,7 +842,7 @@ assert(p == p2);
 To make this work with one of your types, you only need to provide two functions:
 ```cpp
-using nlohmann::json;
+using json = nlohmann::json;
 namespace ns {
    void to_json(json& j, const person& p) {
@@ -1257,7 +1257,7 @@ See the page [quality assurance](https://json.nlohmann.me/community/quality_assu
 #include <nlohmann/json.hpp>
 // for convenience
-using nlohmann::json;
+using json = nlohmann::json;
 ```
 to the files you want to process JSON and set the necessary switches to enable C++11 (e.g., `-std=c++11` for GCC and Clang).
@@ -890,11 +890,11 @@ add_custom_target(ci_icpx
 # The following tests are excluded as they trigger known nvc++ 25.5 defects (not
 # library bugs); see https://github.com/nlohmann/json for tracking. Only the
 # affected language-standard variants are excluded so coverage is otherwise kept:
-#   - test-comparison_cpp20, test-comparison_legacy_cpp20
+#   - test-comparison-cpp20_cpp20, test-comparison_legacy-cpp20_cpp20
 #         miscompiles cross-type/<=> comparison (e.g. `-17 <= null`)
 #   - test-constructor1_cpp11
 #         std::initializer_list lifetime bug -> SIGSEGV
-#   - test-deserialization_cpp20
+#   - test-deserialization-cpp20_cpp20
 #         mangles the UTF-8 u8"" string literal in the char8_t (C++20) section
 add_custom_target(ci_nvhpc
    COMMAND ${CMAKE_COMMAND}
@@ -906,7 +906,7 @@ add_custom_target(ci_nvhpc
    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_nvhpc
    # the pipes are escaped so the surrounding shell passes them to ctest verbatim
    # instead of treating them as shell pipe operators
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_nvhpc && ${CMAKE_CTEST_COMMAND} --parallel ${N} --exclude-regex "test-comparison_cpp20\\|test-comparison_legacy_cpp20\\|test-constructor1_cpp11\\|test-deserialization_cpp20" --output-on-failure
+    COMMAND cd ${PROJECT_BINARY_DIR}/build_nvhpc && ${CMAKE_CTEST_COMMAND} --parallel ${N} --exclude-regex "test-comparison-cpp20_cpp20\\|test-comparison_legacy-cpp20_cpp20\\|test-constructor1_cpp11\\|test-deserialization-cpp20_cpp20" --output-on-failure
    COMMENT "Compile and test with NVIDIA HPC SDK (nvc++)"
 )
@@ -109,6 +109,55 @@ function(_json_test_apply_test_properties test_target properties_target)
    endif()
 endfunction()
 # for internal use by _json_test_add_test() and _json_test_add_unity_batch():
 # registers the CTest test <test_name>_cpp<cxx_standard> (plus its Valgrind
 # variant), which runs the executable target <test_target> with the arguments
 # in ARGN, and applies the test properties of the test- and standard-specific
 # interface targets
 function(_json_test_register_test test_name test_target cxx_standard)
    set(ctest_name ${test_name}_cpp${cxx_standard})
    if (JSON_FastTests)
        add_test(NAME ${ctest_name}
            COMMAND ${test_target} ${DOCTEST_TEST_FILTER} ${ARGN}
            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
        )
    else()
        add_test(NAME ${ctest_name}
            COMMAND ${test_target} ${DOCTEST_TEST_FILTER} ${ARGN} --no-skip
            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
        )
    endif()
    set_tests_properties(${ctest_name} PROPERTIES LABELS "all" FIXTURES_REQUIRED TEST_DATA)
    # apply standard-specific test properties
    if(TARGET _json_test_interface__cpp_${cxx_standard})
        _json_test_apply_test_properties(${ctest_name} _json_test_interface__cpp_${cxx_standard})
    endif()
    # apply test-specific test properties
    if(TARGET _json_test_interface_${test_name})
        _json_test_apply_test_properties(${ctest_name} _json_test_interface_${test_name})
    endif()
    # apply test- and standard-specific test properties
    if(TARGET _json_test_interface_${test_name}_cpp_${cxx_standard})
        _json_test_apply_test_properties(${ctest_name}
            _json_test_interface_${test_name}_cpp_${cxx_standard}
        )
    endif()
    if(JSON_Valgrind)
        add_test(NAME ${ctest_name}_valgrind
            COMMAND ${memcheck_command} $<TARGET_FILE:${test_target}> ${DOCTEST_TEST_FILTER} ${ARGN}
            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
        )
        set_tests_properties(${ctest_name}_valgrind PROPERTIES
            LABELS "valgrind" FIXTURES_REQUIRED TEST_DATA
        )
    endif()
 endfunction()
 # for internal use by json_test_add_test_for()
 function(_json_test_add_test test_name file main cxx_standard)
    set(test_target ${test_name}_cpp${cxx_standard})
@@ -143,45 +192,7 @@ function(_json_test_add_test test_name file main cxx_standard)
        )
    endif()
-    if (JSON_FastTests)
+    _json_test_register_test(${test_name} ${test_target} ${cxx_standard})
        add_test(NAME ${test_target}
            COMMAND ${test_target} ${DOCTEST_TEST_FILTER}
            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
        )
    else()
        add_test(NAME ${test_target}
            COMMAND ${test_target} ${DOCTEST_TEST_FILTER} --no-skip
            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
        )
    endif()
    set_tests_properties(${test_target} PROPERTIES LABELS "all" FIXTURES_REQUIRED TEST_DATA)
    # apply standard-specific test properties
    if(TARGET _json_test_interface__cpp_${cxx_standard})
        _json_test_apply_test_properties(${test_target} _json_test_interface__cpp_${cxx_standard})
    endif()
    # apply test-specific test properties
    if(TARGET _json_test_interface_${test_name})
        _json_test_apply_test_properties(${test_target} _json_test_interface_${test_name})
    endif()
    # apply test- and standard-specific test properties
    if(TARGET _json_test_interface_${test_name}_cpp_${cxx_standard})
        _json_test_apply_test_properties(${test_target}
            _json_test_interface_${test_name}_cpp_${cxx_standard}
        )
    endif()
    if(JSON_Valgrind)
        add_test(NAME ${test_target}_valgrind
            COMMAND ${memcheck_command} $<TARGET_FILE:${test_target}> ${DOCTEST_TEST_FILTER}
            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
        )
        set_tests_properties(${test_target}_valgrind PROPERTIES
            LABELS "valgrind" FIXTURES_REQUIRED TEST_DATA
        )
    endif()
 endfunction()
 #############################################################################
@@ -200,6 +211,14 @@ endfunction()
 # Use NAME <name> to override the filename-derived test name.
 # Use FORCE to create the test regardless of the file containing
 # JSON_HAS_CPP_<version_number>.
 #
 # Tests that depend on the C++ standard (e.g., because they use the macros
 # JSON_HAS_FILESYSTEM, JSON_HAS_RANGES, or JSON_HAS_THREE_WAY_COMPARISON)
 # should not make the whole of a large unit-foo.cpp be rebuilt for every
 # standard. Put them into a separate file unit-foo-cpp<NN>.cpp (see, e.g.,
 # unit-items-cpp17.cpp) which wraps its content in #ifdef JSON_HAS_CPP_<NN>.
 # Then, unit-foo.cpp itself contains no JSON_HAS_CPP_<NN> and is only built for
 # C++11.
 # Test targets are linked against <main>.
 # CXX_STANDARDS defaults to "11".
 #############################################################################
@@ -243,6 +262,314 @@ function(json_test_add_test_for file)
    endforeach()
 endfunction()
 # for internal use by json_test_add_unity_tests(): sets <result> to whether the
 # (absolute) <file> is built for <cxx_standard>; same rule as in
 # json_test_add_test_for(): C++11 always, others only if the file contains
 # JSON_HAS_CPP_<cxx_standard> or <force> is set
 function(_json_test_unity_applies file cxx_standard force result)
    set(${result} TRUE PARENT_SCOPE)
    if(NOT ("${cxx_standard}" STREQUAL 11 OR force))
        file(READ ${file} file_content)
        string(FIND "${file_content}" JSON_HAS_CPP_${cxx_standard} has_cpp_found)
        if(${has_cpp_found} EQUAL -1)
            set(${result} FALSE PARENT_SCOPE)
        endif()
    endif()
 endfunction()
 # for internal use by json_test_add_unity_tests(): creates the executable
 # test-unity-<batch_name>_cpp<cxx_standard> from the (absolute) source files
 # in ARGN, which are #include-d by a generated source file, and registers one
 # CTest test per source file that runs only the test cases of that file; if
 # <private> is true, the generated file defines JSON_TESTS_PRIVATE first
 function(_json_test_add_unity_batch batch_name cxx_standard main private)
    set(batch_target test-unity-${batch_name}_cpp${cxx_standard})
    set(batch_source ${PROJECT_BINARY_DIR}/tests/unity/${batch_target}.cpp)
    set(batch_content "// generated by cmake/test.cmake; do not edit\n")
    if(private)
        string(APPEND batch_content "// at least one file of this batch needs access to private members of the library\n")
        string(APPEND batch_content "#define JSON_TESTS_PRIVATE\n")
        # the files define the macro again; mark this definition as used, as
        # -Wunused-macros reports an unused definition when it is redefined
        string(APPEND batch_content "#ifdef JSON_TESTS_PRIVATE\n#endif\n")
    endif()
    foreach(file ${ARGN})
        string(APPEND batch_content "#include \"${file}\" // NOLINT(bugprone-suspicious-include)\n")
    endforeach()
    # only touch the generated file if it changed to keep incremental builds incremental
    set(old_content "")
    if(EXISTS ${batch_source})
        file(READ ${batch_source} old_content)
    endif()
    if(NOT "${old_content}" STREQUAL "${batch_content}")
        file(WRITE ${batch_source} "${batch_content}")
    endif()
    add_executable(${batch_target} ${batch_source})
    target_link_libraries(${batch_target} PRIVATE ${main})
    set_target_properties(${batch_target} PROPERTIES
        CXX_STANDARD ${cxx_standard}
        CXX_STANDARD_REQUIRED ON
    )
    if(TARGET _json_test_interface__cpp_${cxx_standard})
        target_link_libraries(${batch_target} PRIVATE _json_test_interface__cpp_${cxx_standard})
    endif()
    # rebuild the batch when one of its files changes, and show the files in IDEs;
    # files that are also built standalone (VARIANT_FILES) are left out, as
    # HEADER_FILE_ONLY is a per-file property and would also affect those targets
    set_source_files_properties(${batch_source} PROPERTIES OBJECT_DEPENDS "${ARGN}")
    foreach(file ${ARGN})
        if(NOT file IN_LIST _json_test_unity_variant_files)
            set_source_files_properties(${file} PROPERTIES HEADER_FILE_ONLY ON)
            target_sources(${batch_target} PRIVATE ${file})
        endif()
    endforeach()
    foreach(file ${ARGN})
        get_filename_component(file_basename ${file} NAME_WE)
        string(REGEX REPLACE "unit-(.+)" "test-\\1" test_name ${file_basename})
        # run only the test cases defined in this file (and in the shared
        # make_test_data_available.hpp if the file uses it)
        file(READ ${file} file_content)
        set(source_filter "--source-file=*${file_basename}.cpp")
        string(FIND "${file_content}" make_test_data_available.hpp uses_test_data)
        if(NOT ${uses_test_data} EQUAL -1)
            string(APPEND source_filter ",*make_test_data_available.hpp")
        endif()
        _json_test_register_test(${test_name} ${batch_target} ${cxx_standard} "${source_filter}")
    endforeach()
 endfunction()
 #############################################################################
 # json_test_add_unity_tests(
 #     FILES <files>...
 #     MAIN <main>
 #     [CXX_STANDARDS <version_number>...] [FORCE]
 #     [BATCH_SIZE <size>]
 #     [GROUPS <group>...]
 #     [VARIANT_FILES <files>...])
 #
 # Like calling json_test_add_test_for(<file> MAIN <main> ...) for each of the
 # <files>, but compiles several files together to speed up the build: for each
 # C++ standard, the files are split into batches of <size> files (default: 8)
 # and each batch is built as a single executable
 #
 #     test-unity-<pool><index>_cpp<version_number>
 #
 # whose generated source file #include-s the files of the batch (so they share
 # the template instantiations of the library). The tests are still named
 # test-foo_cpp<version_number>, one per file, but run the batch executable with
 # a doctest filter that selects the test cases of that file only.
 #
 # Files are only batched with files that agree on the macros defined before
 # the library is included: files that define at most JSON_TESTS_PRIVATE (or
 # macros derived from global compile definitions) form the pools "plain" and
 # "private". All other files are added with json_test_add_test_for() as usual,
 # as are files with test-specific build settings (see
 # json_test_set_test_options()) and the files listed in the explicit
 # exclusion list below.
 # Each <group> names a list variable json_test_unity_group_<group> of test file
 # stems (file names without "unit-" and ".cpp"). The batchable files of a group
 # are compiled together (regardless of BATCH_SIZE) as one executable
 #
 #     test-unity-<group>_cpp<version_number>
 #
 # so that related tests, which instantiate the same templates, share one
 # translation unit. A group may mix the pools "plain" and "private"; if any of
 # its files needs JSON_TESTS_PRIVATE, the whole group is built with it. Files
 # that cannot be batched stay standalone even if they are listed in a group.
 # Files in no group are batched by BATCH_SIZE as described above.
 # <files> in VARIANT_FILES are also built standalone with other settings, so
 # they are not marked as header-only sources of the batch.
 #############################################################################
 function(json_test_add_unity_tests)
    cmake_parse_arguments(args "FORCE" "MAIN;BATCH_SIZE" "FILES;CXX_STANDARDS;VARIANT_FILES;GROUPS" ${ARGN})
    if("${args_MAIN}" STREQUAL "")
        message(FATAL_ERROR "Required argument MAIN <main> missing.")
    endif()
    if("${args_BATCH_SIZE}" STREQUAL "")
        set(args_BATCH_SIZE 8)
    endif()
    if("${args_CXX_STANDARDS}" STREQUAL "")
        set(args_CXX_STANDARDS 11)
    endif()
    if(args_FORCE)
        set(force FORCE)
    else()
        set(force "")
    endif()
    set(_json_test_unity_variant_files "")
    foreach(file ${args_VARIANT_FILES})
        get_filename_component(file ${file} ABSOLUTE)
        list(APPEND _json_test_unity_variant_files ${file})
    endforeach()
    # files that must not be merged into a batch: unit-32bit.cpp is only built
    # for 32bit targets, and unit-no-macro-leak.cpp checks that including the
    # library defines no unprefixed macro, which any other file would disturb
    set(standalone_files unit-32bit.cpp unit-no-macro-leak.cpp)
    set(harmless_macros "^(DOCTEST_.*|SKIP_TESTS_FOR_.*|JSON_TEST_DEPRECATED_FUNCTIONS_DELETED|JSON_TEST_STRICT_NUL_HANDLING_ENABLED|JSON_TEST_STRINGIZE)$")
    # classify the files
    set(plain_files "")
    set(private_files "")
    set(standalone_abs_files "")
    foreach(file ${args_FILES})
        get_filename_component(file_name ${file} NAME)
        get_filename_component(file_basename ${file} NAME_WE)
        string(REGEX REPLACE "unit-(.+)" "test-\\1" test_name ${file_basename})
        set(batchable TRUE)
        if(file_name IN_LIST standalone_files)
            set(batchable FALSE)
        endif()
        if(TARGET _json_test_interface_${test_name})
            set(batchable FALSE)
        endif()
        foreach(cxx_standard ${args_CXX_STANDARDS})
            if(TARGET _json_test_interface_${test_name}_cpp_${cxx_standard})
                set(batchable FALSE)
            endif()
        endforeach()
        # files that suppress GCC's -Wnoexcept around their include of the
        # library: the suppression has no effect once another file of the
        # batch included the library first
        if(batchable)
            file(READ ${file} file_content)
            string(FIND "${file_content}" "SUPPRESS_WARNING(\"-Wnoexcept\")" suppresses_noexcept)
            if(NOT ${suppresses_noexcept} EQUAL -1)
                set(batchable FALSE)
            endif()
        endif()
        set(pool plain)
        if(batchable)
            # collect the macros (un)defined before the library is included
            file(READ ${file} file_content)
            string(FIND "${file_content}" "#include <nlohmann/" include_position)
            if(NOT ${include_position} EQUAL -1)
                string(SUBSTRING "${file_content}" 0 ${include_position} file_content)
            endif()
            string(REGEX MATCHALL "(^|\n)[ \t]*#[ \t]*(define|undef)[ \t]+[A-Za-z_0-9]+" directives "${file_content}")
            foreach(directive ${directives})
                string(REGEX REPLACE "^.*[ \t]([A-Za-z_0-9]+)$" "\\1" macro "${directive}")
                if(macro MATCHES "${harmless_macros}")
                    continue()
                elseif("${macro}" STREQUAL JSON_TESTS_PRIVATE)
                    set(pool private)
                else()
                    set(batchable FALSE)
                endif()
            endforeach()
        endif()
        get_filename_component(file_abs ${file} ABSOLUTE)
        if(NOT batchable)
            list(APPEND standalone_abs_files ${file_abs})
            json_test_add_test_for(${file} MAIN ${args_MAIN} CXX_STANDARDS ${args_CXX_STANDARDS} ${force})
            continue()
        endif()
        get_filename_component(file ${file} ABSOLUTE)
        list(APPEND ${pool}_files ${file})
    endforeach()
    # resolve the explicit groups: group_<name>_files are the (absolute) files
    # of the group, group_<name>_private tells whether one of them is private
    set(grouped_files "")
    foreach(group ${args_GROUPS})
        if(NOT DEFINED json_test_unity_group_${group})
            message(FATAL_ERROR "Unity test group '${group}' is not defined (json_test_unity_group_${group}).")
        endif()
        set(group_${group}_files "")
        set(group_${group}_private FALSE)
        foreach(stem ${json_test_unity_group_${group}})
            # check against the source directory, because FILES may be filtered (JSON_TestShard)
            get_filename_component(file ${CMAKE_CURRENT_SOURCE_DIR}/src/unit-${stem}.cpp ABSOLUTE)
            if(NOT EXISTS ${file})
                message(FATAL_ERROR "Unity test group '${group}' lists '${stem}', but ${file} does not exist.")
            endif()
            if(file IN_LIST grouped_files)
                message(FATAL_ERROR "Unity test file unit-${stem}.cpp is listed in more than one group (second: '${group}').")
            endif()
            list(APPEND grouped_files ${file})
            if(file IN_LIST standalone_abs_files)
                message(STATUS "Unity test group '${group}': unit-${stem}.cpp cannot be batched and stays standalone")
            elseif(file IN_LIST plain_files)
                list(APPEND group_${group}_files ${file})
                list(REMOVE_ITEM plain_files ${file})
            elseif(file IN_LIST private_files)
                list(APPEND group_${group}_files ${file})
                list(REMOVE_ITEM private_files ${file})
                set(group_${group}_private TRUE)
            endif()
        endforeach()
    endforeach()
    foreach(cxx_standard ${args_CXX_STANDARDS})
        if(NOT compiler_supports_cpp_${cxx_standard})
            continue()
        endif()
        # explicit groups: one batch per group
        foreach(group ${args_GROUPS})
            set(batch_files "")
            foreach(file ${group_${group}_files})
                _json_test_unity_applies(${file} ${cxx_standard} "${force}" applies)
                if(applies)
                    list(APPEND batch_files ${file})
                endif()
            endforeach()
            if(batch_files)
                _json_test_add_unity_batch(${group} ${cxx_standard} ${args_MAIN} ${group_${group}_private} ${batch_files})
            endif()
        endforeach()
        # remaining files: batches of BATCH_SIZE files per pool
        foreach(pool plain private)
            set(is_private FALSE)
            if(pool STREQUAL private)
                set(is_private TRUE)
            endif()
            set(batch_files "")
            set(batch_count 0)
            set(batch_index 0)
            foreach(file ${${pool}_files})
                _json_test_unity_applies(${file} ${cxx_standard} "${force}" applies)
                if(NOT applies)
                    continue()
                endif()
                list(APPEND batch_files ${file})
                math(EXPR batch_count "${batch_count} + 1")
                if(batch_count EQUAL args_BATCH_SIZE)
                    _json_test_add_unity_batch(${pool}${batch_index} ${cxx_standard} ${args_MAIN} ${is_private} ${batch_files})
                    set(batch_files "")
                    set(batch_count 0)
                    math(EXPR batch_index "${batch_index} + 1")
                endif()
            endforeach()
            if(batch_files)
                _json_test_add_unity_batch(${pool}${batch_index} ${cxx_standard} ${args_MAIN} ${is_private} ${batch_files})
            endif()
        endforeach()
    endforeach()
 endfunction()
 #############################################################################
 # json_test_should_build_32bit_test(
 #     <build_32bit_var> <build_32bit_only_var> <input>)
@@ -341,14 +341,13 @@ def download(url, docs) -> str:
        raise ValueError(f'not an http(s) URL: {url}')
    req = urllib.request.Request(u.geturl(), headers={'User-Agent': USER_AGENT})
    # (the scheme is checked above)
    # nosemgrep: python.lang.security.audit.dynamic-urllib-use-detected.dynamic-urllib-use-detected
    with urllib.request.urlopen(req, timeout=20) as r:  # nosec B310
        data = r.read()
        ctype = r.headers.get_content_type()
    path = urllib.parse.unquote(u.path).lstrip('/')
    ext = os.path.splitext(path)[1]
    if u.query or not ext or path.endswith('/'):
-        digest = hashlib.sha256(url.encode()).hexdigest()[:12]
+        digest = hashlib.sha1(url.encode(), usedforsecurity=False).hexdigest()[:12]
        path = os.path.join(os.path.dirname(path), digest + CONTENT_TYPE_EXT.get(ctype, ext or '.bin'))
    rel = os.path.normpath(os.path.join('assets', 'external', u.hostname, path))
    out = os.path.join(docs, rel)
@@ -30,7 +30,7 @@ class (either explicitly or via the conversion operators).
 ## Return value
-1. (none) — the converted value is written to the output parameter `val`.
+1. (none) -- the converted value is written to the output parameter `val`.
 2. the JSON value `j` converted to `TargetType`
 ## Examples
@@ -67,9 +67,7 @@ class (either explicitly or via the conversion operators).
 ## See also
- [`to_json`](to_json.md) - convert a C++ value to JSON
+- [to_json](to_json.md)
 - [Arbitrary Type Conversions](../../features/arbitrary_types.md) - write your own `from_json` and `to_json` functions
 - [Converting values](../../features/conversions.md) - overview of `get`, `get_to` and implicit conversions
 ## Version history
@@ -30,14 +30,6 @@ struct adl_serializer {
 - [**from_json**](from_json.md) - convert a JSON value to any value type
 - [**to_json**](to_json.md) - convert any value type to a JSON value
 ## See also
 - [Arbitrary type conversions](../../features/arbitrary_types.md) - how to make your types convertible
 - [`get`](../basic_json/get.md) - / [`get_to`](../basic_json/get_to.md) - convert a JSON value to a C++ type
 - [`basic_json`](../basic_json/basic_json.md) - construct a JSON value from a C++ value
 - [`NLOHMANN_DEFINE_TYPE_INTRUSIVE`](../macros/nlohmann_define_type_intrusive.md) - generate the conversion functions for a type
 - [Specializing enum conversion](../../features/enum_conversion.md) - serializing enums as JSON strings
 ## Version history
 - Added in version 2.1.0.
@@ -36,9 +36,7 @@ This function is usually called by the constructors of the [basic_json](../basic
 ## See also
- [`from_json`](from_json.md) - convert JSON to a C++ value
+- [from_json](from_json.md)
 - [Arbitrary Type Conversions](../../features/arbitrary_types.md) - write your own `from_json` and `to_json` functions
 - [Converting values](../../features/conversions.md) - overview of `get`, `get_to` and implicit conversions
 ## Version history
@@ -23,9 +23,6 @@ Checks whether the input is valid JSON.
    respectively as UTF-8, UTF-16, and UTF-32. If `SentinelType` differs from `IteratorType`, it must be comparable to
    the iterator type with `operator!=`.
    Ill-formed UTF-16 and UTF-32 sequences are rejected: a lone surrogate, a high surrogate that is not followed by its
    low surrogate, and a code point above `U+10FFFF` all make this function return `false`.
 Unlike the [`parse()`](parse.md) function, this function neither throws an exception in case of invalid JSON input
 (i.e., a parse error) nor creates diagnostic information.
@@ -38,12 +35,9 @@ Unlike the [`parse()`](parse.md) function, this function neither throws an excep
    - a `#!c FILE` pointer (throws if null)
    - a C-style array of characters
    - a pointer to a null-terminated string of single byte characters (throws if null)
-    - a `std::string` or a `std::string_view` (C++17)
+    - a `std::string`
    - a container `obj` for which `begin(obj)` and `end(obj)` produce a valid pair of iterators
      (as found via ADL or member functions, with semantics compatible to `std::begin` and `std::end`)
    - wide characters (`wchar_t`, `char16_t`, `char32_t`), which are converted to UTF-8: a wide string object
      (`std::wstring`, `std::u16string`, `std::u32string`) or an array (e.g. a wide string literal); a pointer to a
      null-terminated wide string (e.g. `std::u16string::c_str()`) is not supported
 `IteratorType`
 :   a compatible iterator type, for instance.
@@ -131,37 +125,17 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
    --8<-- "examples/accept__iterator_pair.output"
    ```
 ??? example "Example: (3) reading from UTF-16 strings"
    The encoding is deduced from the character type of the input. String literals like `u"..."`, `U"..."`, and
    `L"..."` work as well.
    ```cpp
    --8<-- "examples/accept__wide_string.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/accept__wide_string.output"
    ```
 ## See also
- [`parse`](parse.md) - deserialize from a compatible input
+- [parse](parse.md) - deserialize from a compatible input
- [`sax_parse`](sax_parse.md) - parse input using the SAX interface
+- [sax_parse](sax_parse.md) - parse input using the SAX interface
- [`operator>>`](../operator_gtgt.md) - deserialize from stream
+- [operator>>](../operator_gtgt.md) - deserialize from stream
 - [`JSON_STRICT_NUL_HANDLING`](../macros/json_strict_nul_handling.md) - opt in to rejecting a NUL byte in the input
  instead of treating it as end of input
 - [`JSON_DISABLE_STREAM_BULK_SCAN`](../macros/json_disable_stream_bulk_scan.md) - read a `std::istream` one character
  at a time
 - [`JSON_DISABLE_UNLOCKED_FILE_IO`](../macros/json_disable_unlocked_file_io.md) - read a `FILE*` with the locking stdio
  functions
 - [Parsing](../../features/parsing/index.md) - overview of the parsing functions
 - [Comments](../../features/comments.md) - ignore `//` and `/* */` comments while parsing
 - [Trailing Commas](../../features/trailing_commas.md) - accept trailing commas in arrays and objects
 - [Parsing and Exceptions](../../features/parsing/parse_exceptions.md) - handling parse errors and locating them in the input
 - [Parsing Untrusted Input](../../features/parsing/untrusted_input.md) - limits and checks for input you do not control
 ## Version history
@@ -177,9 +151,6 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
  ([`JSON_DISABLE_STREAM_BULK_SCAN`](../macros/json_disable_stream_bulk_scan.md)).
 - Parsing from a `FILE*` locks the file once instead of once per character in version 3.13.0
  ([`JSON_DISABLE_UNLOCKED_FILE_IO`](../macros/json_disable_unlocked_file_io.md)).
 - Ill-formed UTF-16 and UTF-32 input (a lone surrogate, a high surrogate that is not followed by its low surrogate, or
  a code point above `U+10FFFF`) is rejected in version 3.13.0; before that, some such sequences were accepted or
  ended the input silently.
 !!! warning "Deprecation"
@@ -29,9 +29,9 @@ Linear in the size of `init`.
 This function is only needed to express two edge cases that cannot be realized with the initializer list constructor
 ([`basic_json(initializer_list_t, bool, value_t)`](basic_json.md)). These cases are:
-1. creating an array whose elements are all pairs whose first element is a string — in this case, the initializer list
+1. creating an array whose elements are all pairs whose first element is a string -- in this case, the initializer list
   constructor would create an object, taking the first elements as keys
-2. creating an empty array — passing the empty initializer list to the initializer list constructor yields an empty
+2. creating an empty array -- passing the empty initializer list to the initializer list constructor yields an empty
   object
 ## Examples
@@ -69,12 +69,10 @@ Arrays are stored as pointers in a `basic_json` type. That is, for any access to
 ## See also
- [`object_t`](object_t.md) - the type used to store JSON objects
+- [object_t](object_t.md) the type used to store JSON objects
- [`binary_t`](binary_t.md) - the type used to store binary values
+- [binary_t](binary_t.md) the type used to store binary values
- [`is_array`](is_array.md) - checks whether the JSON value is an array
+- [is_array](is_array.md) checks whether the JSON value is an array
- [`max_size`](max_size.md) - returns the maximum possible number of elements
+- [max_size](max_size.md) returns the maximum possible number of elements
 - [Types](../../features/types/index.md) - how arrays are stored
 - [Template Parameter Requirements](../../features/types/template_parameters.md) - requirements on the `ArrayType` template parameter
 ## Version history
@@ -46,8 +46,7 @@ The function is equivalent to `static_cast<json_base_class_t&>(j)` (or `static_c
 ## See also
- [`json_base_class_t`](json_base_class_t.md) - type of the custom base class
+- [json_base_class_t](json_base_class_t.md) - type of the custom base class
 - [Template Parameter Requirements](../../features/types/template_parameters.md) - requirements on the `CustomBaseClass` template parameter
 ## Version history
@@ -230,19 +230,18 @@ Strong exception safety: if an exception occurs, the original value stays intact
 ## See also
- [Checked access](../../features/element_access/checked_access.md) - element access with range checking
+- documentation on [checked access](../../features/element_access/checked_access.md)
- [`operator[]`](operator%5B%5D.md) - unchecked access by reference
+- [`operator[]`](operator%5B%5D.md) for unchecked access by reference
- [`value`](value.md) - access with default value
+- [`value`](value.md) for access with default value
- [`basic_json_view::at`](../basic_json_view/at.md) - the same access on a zero-copy view
+- [basic_json_view::at](../basic_json_view/at.md) - the same access on a zero-copy view
 - [Element Access](../../features/element_access/index.md) - overview of all ways to access elements
 - [JSON Pointer](../../features/json_pointer.md) - access nested values with a pointer
 ## Version history
 1. Added in version 1.0.0.
 2. Added in version 1.0.0.
-3. Added in version 3.11.0. Support for keys convertible to `std::string_view` added in version 3.13.0, consistently
+3. Added in version 3.11.0. Fixed in version 3.13.0 to consistently accept `std::string_view`-convertible keys, as
-   across the lookup functions.
+   already supported by [`operator[]`](operator[].md), [`value`](value.md), [`find`](find.md), and other lookup
   functions.
 4. Added in version 2.0.0. Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) instead of
 [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) for a one-character array index that is not
 a digit (e.g., `/x`) in version 3.13.0, as it already did for longer ones.
@@ -57,11 +57,10 @@ Constant.
 ## See also
- [`front`](front.md) - to access the first element
+- [front](front.md) to access the first element
- [`basic_json_view::back`](../basic_json_view/back.md) - the same access on a zero-copy view
+- [basic_json_view::back](../basic_json_view/back.md) - the same access on a zero-copy view
 - [Element Access](../../features/element_access/index.md) - overview of all ways to access elements
 ## Version history
 - Added in version 1.0.0.
- Binary values are supported since version 3.8.0.
+- Adjusted code to return reference to binary values in version 3.8.0.
@@ -52,7 +52,7 @@ basic_json(basic_json&& other) noexcept;
    The postcondition of this constructor can be restored by calling [`clear()`](clear.md).
 2. Create a `#!json null` JSON value. It either takes a null pointer as parameter (explicitly creating `#!json null`)
-   or no parameter (implicitly creating `#!json null`). The passed null pointer itself is not read — it is only used to
+   or no parameter (implicitly creating `#!json null`). The passed null pointer itself is not read -- it is only used to
   choose the right constructor.
 3. This is a "catch all" constructor for all compatible JSON types; that is, types for which a `to_json()` method
@@ -113,22 +113,19 @@ basic_json(basic_json&& other) noexcept;
    ```mermaid
    flowchart TD
-        A(["initializer_list init"]) --> B{{"empty, or every element is a 2-element<br/>array whose first element is a string?"}}
+        A(["initializer_list init"]) --> B{"empty, or every element is a 2-element<br/>array whose first element is a string?"}
-        B -->|"yes"| C{{"type_deduction"}}
+        B -->|"yes"| C{"type_deduction"}
-        B -->|"no"| D{{"type_deduction"}}
+        B -->|"no"| D{"type_deduction"}
        C -->|"true"| OBJ["create object"]
-        C -->|"false"| E{{"manual_type"}}
+        C -->|"false"| E{"manual_type"}
        E -->|"object"| OBJ
        E -->|"array"| ARR["create array"]
        D -->|"true"| ARR
-        D -->|"false"| F{{"manual_type"}}
+        D -->|"false"| F{"manual_type"}
        F -->|"array"| ARR
        F -->|"object"| ERR["throw type_error.301"]
    ```
    <p class="nj-caption" markdown>Decision flow for an initializer list: hexagons are checks, edge labels are their
    outcomes, and rectangles are the resulting value or exception.</p>
    The rules aim to create the best fit between a C++ initializer list and JSON values. The rationale is as follows:
    1. The empty initializer list is written as `#!cpp {}` which is exactly an empty JSON object.
@@ -476,25 +473,24 @@ basic_json(basic_json&& other) noexcept;
 ## See also
- [`array`](array.md) - create a JSON array value, forcing array creation from an initializer list even when it looks like
+- [array](array.md) create a JSON array value, forcing array creation from an initializer list even when it looks like
  an object
- [`object`](object.md) - create a JSON object value, forcing object creation from an initializer list
+- [object](object.md) create a JSON object value, forcing object creation from an initializer list
- [`binary`](binary.md) - create a JSON binary array value
+- [binary](binary.md) create a JSON binary array value
- [`operator=`](operator=.md) - copy assignment operator
+- [operator=](operator=.md) copy assignment operator
 - [Creating JSON values](../../features/creating_values.md) - the article on creating JSON values
 - [Converting values](../../features/conversions.md) - which C++ types can be converted
 ## Version history
-1. Added in version 1.0.0.
+1. Since version 1.0.0.
-2. Added in version 1.0.0.
+2. Since version 1.0.0.
-3. Added in version 2.1.0.
+3. Since version 2.1.0.
-4. Added in version 3.1.2. Explicit for different string types if `JSON_USE_IMPLICIT_CONVERSIONS` is `0` since
+4. Since version 3.2.0. Explicit for different string types if `JSON_USE_IMPLICIT_CONVERSIONS` is `0` since
   version 3.13.0.
-5. Added in version 1.0.0.
+5. Since version 1.0.0.
-6. Added in version 1.0.0.
+6. Since version 1.0.0.
-7. Added in version 1.0.0. Fixed in version 3.13.0 to also check the iterator range for binary values; before, a range
+7. Since version 1.0.0. Fixed in version 3.13.0 to also check the iterator range for binary values; before, a range
   that did not cover the whole value (such as `(end(), end())`) was accepted and the whole binary value was copied,
   unlike the other primitive types.
-8. Added in version 1.0.0.
+8. Since version 1.0.0.
-9. Added in version 1.0.0.
+9. Since version 1.0.0.
@@ -7,12 +7,7 @@ const_iterator begin() const noexcept;
 Returns an iterator to the first element.
-<div class="nj-fig-wrap" markdown>
+![Illustration from cppreference.com](../../images/range-begin-end.svg)
 --8<-- "images/range-begin-end.svg"
 </div>
 <p class="nj-caption" markdown>`begin()` points to the first element and `end()` to the position after the last element;
 the dashed cell is the past-the-last position, which must not be dereferenced.</p>
 ## Return value
@@ -44,12 +39,12 @@ Constant.
 ## See also
- [`end`](end.md) - returns an iterator to one past the last element
+- [end](end.md) returns an iterator to one past the last element
- [`cbegin`](cbegin.md) - returns a const iterator to the first element
+- [cbegin](cbegin.md) returns a const iterator to the first element
- [`rbegin`](rbegin.md) - returns a reverse iterator to the last element
+- [rbegin](rbegin.md) returns a reverse iterator to the last element
- [`items`](items.md) - returns an iteration proxy to access keys and values during range-based for loops
+- [items](items.md) returns an iteration proxy to access keys and values during range-based for loops
 - [Iterators](../../features/iterators.md) - the article on iterators
- [`basic_json_view::begin`](../basic_json_view/begin.md) - the same iteration on a zero-copy view (in document order,
+- [basic_json_view::begin](../basic_json_view/begin.md) - the same iteration on a zero-copy view (in document order,
  not sorted by key)
 ## Version history
@@ -63,11 +63,10 @@ initialization of a binary array type, for backwards compatibility and so it doe
 ## See also
- [Binary formats](../../features/binary_formats/index.md) - formats that can store binary values
+- [binary_t](binary_t.md) type for binary values
- [`binary_t`](binary_t.md) - type for binary values
+- [get_binary](get_binary.md) get a reference to the stored binary value
- [`get_binary`](get_binary.md) - get a reference to the stored binary value
+- [is_binary](is_binary.md) return whether the value is binary
- [`is_binary`](is_binary.md) - return whether the value is binary
+- [byte_container_with_subtype](../byte_container_with_subtype/index.md) container for binary values with subtype
 - [`byte_container_with_subtype`](../byte_container_with_subtype/index.md) - container for binary values with subtype
 - [Binary Values](../../features/binary_values.md) - the article on binary values
 ## Version history
@@ -41,7 +41,7 @@ represent a byte array in modern C++.
    [`byte_container_with_subtype`](../byte_container_with_subtype/index.md) derives directly from it. Its
    `value_type` must additionally be exactly one byte wide (e.g., `std::uint8_t`/`char`/`std::byte`): the binary
    serializers (CBOR, MessagePack, BSON, UBJSON) read and write the container's raw bytes via
-    `reinterpret_cast`, which is only correct for byte-sized elements — a container like
+    `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.
@@ -90,9 +90,8 @@ type `#!cpp binary_t*` must be dereferenced.
 - MessagePack
    - If a subtype is given and the binary array contains exactly 1, 2, 4, 8, or 16 elements, the fixext family (fixext1,
-      fixext2, fixext4, fixext8, fixext16) is used. For other sizes, the ext family (ext8, ext16, ext32) is used. The
+      fixext2, fixext4, fixext8) is used. For other sizes, the ext family (ext8, ext16, ext32) is used. The subtype is
-      subtype is then written as the signed 8-bit ext type: subtypes 128 to 255 map to the negative (reserved) ext
+      then added as a signed 8-bit integer.
      types, and on reading the ext type is exposed as an unsigned subtype from 0 to 255.
    - If no subtype is given, the bin family (bin8, bin16, bin32) is used.
 - BSON
@@ -118,9 +117,7 @@ type `#!cpp binary_t*` must be dereferenced.
 ## See also
- [Binary values](../../features/binary_values.md) - how binary values and subtypes are handled
+- [byte_container_with_subtype](../byte_container_with_subtype/index.md)
 - [Binary formats](../../features/binary_formats/index.md) - formats that can store binary values
 - [`byte_container_with_subtype`](../byte_container_with_subtype/index.md) - container type used by binary values
 ## Version history
@@ -1,48 +0,0 @@
 # <small>nlohmann::basic_json::</small>bjdata_version_t
 ```cpp
 enum class bjdata_version_t
 {
    draft2,
    draft3
 };
 ```
 This enumeration is used in [`to_bjdata`](to_bjdata.md) to choose the version of the BJData specification to write:
 draft2
 :   BJData Draft 2 (the default). Binary values are written as arrays of `U` integers, and ND-arrays with
    `"_ArrayType_": "byte"` are written as regular objects, since the `B` marker is not part of Draft 2.
 draft3
 :   BJData Draft 3. Binary values are written as `B` elements: as an optimized binary array (`[$B#`) if both `use_size`
    and `use_type` are set, and as an array of `B`-prefixed elements otherwise. ND-arrays with
    `"_ArrayType_": "byte"` are written as packed arrays (`[$B#[...]`).
 Only the writer is affected by the version. [`from_bjdata`](from_bjdata.md) reads the markers of both drafts.
 ## Examples
 ??? example
    The example below shows how the different values of the `bjdata_version_t` influence the serialization of a binary
    value with [`to_bjdata`](to_bjdata.md).
    ```cpp
    --8<-- "examples/bjdata_version_t.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/bjdata_version_t.output"
    ```
 ## See also
 - [to_bjdata](to_bjdata.md) serializes a JSON value to BJData
 - [BJData](../../features/binary_formats/bjdata.md) - the article on the BJData format
 ## Version history
 - Added in version 3.12.0.
@@ -47,9 +47,7 @@ Boolean values are stored directly inside a `basic_json` type.
 ## See also
- [`is_boolean`](is_boolean.md) - checks whether the JSON value is a boolean
+- [is_boolean](is_boolean.md) checks whether the JSON value is a boolean
 - [Types](../../features/types/index.md) - how booleans are stored
 - [Template Parameter Requirements](../../features/types/template_parameters.md) - requirements on the `BooleanType` template parameter
 ## Version history
@@ -6,12 +6,7 @@ const_iterator cbegin() const noexcept;
 Returns an iterator to the first element.
-<div class="nj-fig-wrap" markdown>
+![Illustration from cppreference.com](../../images/range-begin-end.svg)
 --8<-- "images/range-begin-end.svg"
 </div>
 <p class="nj-caption" markdown>`cbegin()` points to the first element, like `begin()`, and `end()` to the position after
 the last element; the dashed cell is the past-the-last position, which must not be dereferenced.</p>
 ## Return value
@@ -43,11 +38,11 @@ Constant.
 ## See also
- [`begin`](begin.md) - returns an iterator to the first element
+- [begin](begin.md) returns an iterator to the first element
- [`cend`](cend.md) - returns a const iterator to one past the last element
+- [cend](cend.md) returns a const iterator to one past the last element
- [`crbegin`](crbegin.md) - returns a const reverse iterator to the last element
+- [crbegin](crbegin.md) returns a const reverse iterator to the last element
 - [Iterators](../../features/iterators.md) - the article on iterators
- [`basic_json_view::cbegin`](../basic_json_view/cbegin.md) - the same iteration on a zero-copy view
+- [basic_json_view::cbegin](../basic_json_view/cbegin.md) - the same iteration on a zero-copy view
 ## Version history
@@ -15,13 +15,11 @@ error
 :   report a parse error in case of a tag (the `from_cbor` overloads throw a `parse_error` exception by default)
 ignore
-:   ignore tags (also in front of a text string map key)
+:   ignore tags
 store
 :   store tagged byte strings (for bytes 0xd8..0xdb) as binary values with the tag as subtype; other tagged values are
-    read as if the tag were ignored. If several tags precede a byte string, only the tag directly in front of it is
+    read as if the tag were ignored. If several tags precede a byte string, only the innermost one is stored.
    stored, and only when it has the form 0xd8..0xdb (a tag 0..23 written as 0xc0..0xd7 is skipped). Tags in front of a
    text string map key are skipped.
 ## Examples
@@ -42,9 +40,8 @@ store
 ## See also
- [Binary values](../../features/binary_values.md) - how binary values and subtypes are handled
+- [from_cbor](from_cbor.md) deserializes a JSON value from CBOR
- [`from_cbor`](from_cbor.md) - deserializes a JSON value from CBOR
+- [input_format_t](input_format_t.md) the enumeration of supported input formats
 - [`input_format_t`](input_format_t.md) - the enumeration of supported input formats
 - [CBOR](../../features/binary_formats/cbor.md) - the article on the CBOR format
 ## Version history
@@ -6,12 +6,7 @@ const_iterator cend() const noexcept;
 Returns an iterator to one past the last element.
-<div class="nj-fig-wrap" markdown>
+![Illustration from cppreference.com](../../images/range-begin-end.svg)
 --8<-- "images/range-begin-end.svg"
 </div>
 <p class="nj-caption" markdown>`cend()` points to the position after the last element, like `end()`, and `begin()` to
 the first element; the dashed cell is the past-the-last position, which must not be dereferenced.</p>
 ## Return value
@@ -43,11 +38,11 @@ Constant.
 ## See also
- [`end`](end.md) - returns an iterator to one past the last element
+- [end](end.md) returns an iterator to one past the last element
- [`cbegin`](cbegin.md) - returns a const iterator to the first element
+- [cbegin](cbegin.md) returns a const iterator to the first element
- [`crend`](crend.md) - returns a const reverse iterator to one before the first element
+- [crend](crend.md) returns a const reverse iterator to one before the first element
 - [Iterators](../../features/iterators.md) - the article on iterators
- [`basic_json_view::cend`](../basic_json_view/cend.md) - the same iteration on a zero-copy view
+- [basic_json_view::cend](../basic_json_view/cend.md) - the same iteration on a zero-copy view
 ## Version history
@@ -54,9 +54,8 @@ All iterators, pointers, and references related to this container are invalidate
 ## See also
- [`erase`](erase.md) - removes elements from a JSON value
+- [erase](erase.md) removes elements from a JSON value
- [`empty`](empty.md) - checks whether the JSON value has no elements
+- [empty](empty.md) checks whether the JSON value has no elements
 - [Modifying values](../../features/modifying_values.md) - the article on modifying values
 ## Version history
@@ -61,18 +61,11 @@ Strong exception safety: if an exception occurs, the original value stays intact
 ## Complexity
-1. Logarithmic in the size of the JSON object.
+Logarithmic in the size of the JSON object.
 2. Logarithmic in the size of the JSON object.
 3. At most one lookup per reference token of `ptr`, each logarithmic in the size of the container at that level:
   O(*n* log *m*) for *n* reference tokens and containers of size at most *m*.
 4. Deleted; a call with an integral argument does not compile.
 ## Notes
- Overloads (1) and (2) always return `#!cpp false` when executed on a JSON type that is not an object. Overload (3)
+- This method always returns `#!cpp false` when executed on a JSON type that is not an object.
  also works on arrays and on primitive values: the empty JSON pointer resolves in every JSON value (so
  `#!cpp json(1).contains(""_json_pointer)` returns `#!cpp true`), and `#!cpp json({1, 2}).contains("/1"_json_pointer)`
  returns `#!cpp true`.
 - This method can be executed on any JSON value type.
 - Calling this function with an integer argument (for example, `#!cpp contains(0)`) does not compile: such an argument
  would otherwise implicitly convert to a null `#!cpp const char*` and, from there, cause undefined behavior when
@@ -141,16 +134,16 @@ Strong exception safety: if an exception occurs, the original value stays intact
 ## See also
- [`find`](find.md) - find a value in an object
+- [find](find.md) find a value in an object
- [`count`](count.md) - returns the number of occurrences of a key
+- [count](count.md) returns the number of occurrences of a key
- [`basic_json_view::contains`](../basic_json_view/contains.md) - the same check on a zero-copy view
+- [basic_json_view::contains](../basic_json_view/contains.md) - the same check on a zero-copy view
 - [Element Access](../../features/element_access/index.md#does-this-key-exist) - how to test whether a key exists
 ## Version history
 1. Added in version 3.11.0.
-2. Added in version 3.6.0. Extended template `KeyType` to support comparable types in version 3.11.0. Support for keys
+2. Added in version 3.6.0. Extended template `KeyType` to support comparable types in version 3.11.0. Fixed in
-   convertible to `std::string_view` added in version 3.13.0, consistently across the lookup functions.
+   version 3.13.0 to consistently accept `std::string_view`-convertible keys, as already supported by
   [`operator[]`](operator[].md), [`at`](at.md), [`value`](value.md), and other lookup functions.
 3. Added in version 3.7.0.
 4. Deleted overloads for integral key types added in version 3.13.0 to reject such calls at compile time instead of
   causing undefined behavior at runtime.
@@ -85,15 +85,15 @@ Logarithmic in the size of the JSON object.
 ## See also
- [`find`](find.md) - find a value in an object
+- [find](find.md) find a value in an object
- [`contains`](contains.md) - checks whether a key exists
+- [contains](contains.md) checks whether a key exists
- [`basic_json_view::count`](../basic_json_view/count.md) - the same check on a zero-copy view
+- [basic_json_view::count](../basic_json_view/count.md) - the same check on a zero-copy view
 - [Element Access](../../features/element_access/index.md#does-this-key-exist) - how to test whether a key exists
 ## Version history
 1. Added in version 3.11.0.
-2. Added in version 1.0.0. Changed to support comparable key types in version 3.11.0. Support for keys convertible to
+2. Added in version 1.0.0. Changed parameter `key` type to `KeyType&&` in version 3.11.0. Fixed in version 3.13.0 to
-   `std::string_view` added in version 3.13.0, consistently across the lookup functions.
+   consistently accept `std::string_view`-convertible keys, as already supported by [`operator[]`](operator[].md),
   [`at`](at.md), [`value`](value.md), and other lookup functions.
 3. Deleted overload for integral key types added in version 3.13.0 to reject such calls at compile time instead of
   causing undefined behavior at runtime.
@@ -6,13 +6,7 @@ const_reverse_iterator crbegin() const noexcept;
 Returns an iterator to the reverse-beginning; that is, the last element.
-<div class="nj-fig-wrap" markdown>
+![Illustration from cppreference.com](../../images/range-rbegin-rend.svg)
 --8<-- "images/range-rbegin-rend.svg"
 </div>
 <p class="nj-caption" markdown>`crbegin()` points to the last element, like `rbegin()`, and `rend()` to the position
 before the first element. The upper row is the reversed sequence and the lower row the forward sequence; dashed arrows
 link each reverse iterator to the forward iterator it stores, and dashed cells are past-the-last positions.</p>
 ## Return value
@@ -44,9 +38,9 @@ Constant.
 ## See also
- [`crend`](crend.md) - returns a const reverse iterator to one before the first element
+- [crend](crend.md) returns a const reverse iterator to one before the first element
- [`rbegin`](rbegin.md) - returns a reverse iterator to the last element
+- [rbegin](rbegin.md) returns a reverse iterator to the last element
- [`cbegin`](cbegin.md) - returns a const iterator to the first element
+- [cbegin](cbegin.md) returns a const iterator to the first element
 - [Iterators](../../features/iterators.md) - the article on iterators
 ## Version history
@@ -7,13 +7,7 @@ const_reverse_iterator crend() const noexcept;
 Returns an iterator to the reverse-end; that is, one before the first element. This element acts as a placeholder,
 attempting to access it results in undefined behavior.
-<div class="nj-fig-wrap" markdown>
+![Illustration from cppreference.com](../../images/range-rbegin-rend.svg)
 --8<-- "images/range-rbegin-rend.svg"
 </div>
 <p class="nj-caption" markdown>`crend()` points to the position before the first element, like `rend()`, and `rbegin()`
 to the last element. The upper row is the reversed sequence and the lower row the forward sequence; dashed arrows link
 each reverse iterator to the forward iterator it stores, and dashed cells are past-the-last positions.</p>
 ## Return value
@@ -45,9 +39,9 @@ Constant.
 ## See also
- [`crbegin`](crbegin.md) - returns a const reverse iterator to the last element
+- [crbegin](crbegin.md) returns a const reverse iterator to the last element
- [`rend`](rend.md) - returns a reverse iterator to one before the first element
+- [rend](rend.md) returns a reverse iterator to one before the first element
- [`cend`](cend.md) - returns a const iterator to one past the last element
+- [cend](cend.md) returns a const iterator to one past the last element
 - [Iterators](../../features/iterators.md) - the article on iterators
 ## Version history
@@ -32,10 +32,8 @@ The actual comparator used depends on [`object_t`](object_t.md) and can be obtai
 ## See also
- [`object_comparator_t`](object_comparator_t.md) - the comparator actually used by `object_t`
+- [object_comparator_t](object_comparator_t.md) the comparator actually used by `object_t`
- [`object_t`](object_t.md) - the type used to store JSON objects
+- [object_t](object_t.md) the type used to store JSON objects
 - [Template Parameter Requirements](../../features/types/template_parameters.md) - requirements on the `ObjectType` template parameter
 - [Object order](../../features/object_order.md) - preserve the insertion order of keys
 ## Version history
@@ -2,27 +2,17 @@
 ```cpp
 static basic_json diff(const basic_json& source,
-                       const basic_json& target,
+                       const basic_json& target);
                       const string_t& path = "");
 ```
 Creates a [JSON Patch](http://jsonpatch.com) so that value `source` can be changed into the value `target` by calling
 [`patch`](patch.md) function.
-For two JSON values `source` and `target`, the following code yields `#!cpp true`:
+For two JSON values `source` and `target`, the following code always yields `#!cpp true`:
 ```cpp
 source.patch(diff(source, target)) == target;
 ```
 The equality holds up to [`operator==`](operator_eq.md), so it has the following exceptions:
 - A value that is not equal to itself cannot round-trip. This applies to `NaN` (also nested in an array or object) and
  to [discarded](is_discarded.md) values: `diff` emits a `replace` operation for them. A `NaN` in the patch is
  serialized as `#!json null`, so a patch that was dumped and parsed again would set `#!json null`.
 - Numbers that compare equal produce no operation, even if their types or signs differ: `diff(1, 1.0)`,
  `diff(1u, 1)` (unsigned and signed integer) and `diff(0.0, -0.0)` all return `#!json []`. The patched value is then
  the `source` and keeps its number type.
 ## Parameters
 `source` (in)
@@ -31,12 +21,6 @@ The equality holds up to [`operator==`](operator_eq.md), so it has the following
 `target` (in)
 :   JSON value to compare against
 `path` (in)
 :   a prefix that is put verbatim in front of the `path` member of every operation (default: `""`, which addresses the
    root of the value). The prefix is neither escaped nor validated: `#!cpp diff(1, 2, "abc")` yields an operation with
    the `path` `abc`, which is not a valid JSON Pointer. Use it with a valid JSON Pointer such as `/root` and escape
    `~` and `/` in its reference tokens (see [JSON Pointer](../../features/json_pointer.md)).
 ## Return value
 a JSON patch to convert the `source` to `target`
@@ -47,32 +31,11 @@ Strong guarantee: `source` and `target` are never modified.
 ## Complexity
-Linear in the total number of values (including nested ones) in `source` and `target`, times the cost of a key-based
+Linear in the lengths of `source` and `target`.
 object operation (looking up a key in an object): logarithmic for [`json`](../json.md), and linear for
 [`ordered_json`](../ordered_json.md) (see [`ordered_map` complexity](../ordered_map.md#complexity)). For
 `ordered_json`, diffing two objects with `n` and `m` members therefore takes O((n+m)²) when their keys do not line up
 (e.g., a key was added or the keys are in a different order). The size of the patch is proportional to the number of
 operations times the length of their paths, so a small change deep inside a value yields a long `path`.
 ## Notes
- Currently, only `remove`, `add`, and `replace` operations are generated.
+Currently, only `remove`, `add`, and `replace` operations are generated.
 - The patch is correct, but not guaranteed to be minimal. For instance, `diff([1,2,3], [0,1,2,3])` yields three
  `replace` operations and one `add` operation instead of a single insertion.
 - Differences between two arrays are reported index by index. Elements that were added at the end of the array are added
  with `add` operations on the path `/-` (appended in order), and elements that were removed are removed with `remove`
  operations from the highest index down to the lowest, so that the remaining indices stay valid.
 - For objects, the operations for the members of `source` come first (`replace`, `remove`, or the operations for nested
  values, in the iteration order of `source`), followed by `add` operations for the members that only `target` has.
 - For [`ordered_json`](../ordered_json.md), objects with the same keys in a different order are different. As a patch
  cannot reorder members, `diff` removes all keys of the `source` object and adds them again in the order of the
  `target`.
 - If `source` and `target` differ as a whole (e.g., different types), the patch consists of a single `replace`
  operation for the root of the value, i.e., with the `path` `""` (or the given `path` prefix).
 - The `value` members of the patch hold copies of values of `target`. A [binary](../../features/binary_values.md) value
  has no JSON representation: when a patch that contains one is serialized, it becomes an object such as
  `#!json {"bytes":[1,3],"subtype":null}`, so a parsed patch no longer holds a binary value (and would set that object
  instead).
 ## Examples
@@ -92,12 +55,11 @@ operations times the length of their paths, so a small change deep inside a valu
 ## See also
- [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902) - specification of JSON Patch
+- [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
- [`patch`](patch.md) - applies a JSON Patch
+- [patch](patch.md) applies a JSON Patch
- [`patch_inplace`](patch_inplace.md) - applies a JSON Patch in place
+- [patch_inplace](patch_inplace.md) applies a JSON Patch in place
- [`merge_patch`](merge_patch.md) - applies a JSON Merge Patch
+- [merge_patch](merge_patch.md) applies a JSON Merge Patch
- [`merge_diff`](merge_diff.md) - creates a diff as a JSON Merge Patch
+- [merge_diff](merge_diff.md) creates a diff as a JSON Merge Patch
 - [JSON Patch and Diff](../../features/json_patch.md) - the article on JSON Patch
 ## Version history
@@ -89,9 +89,9 @@ Binary values are serialized as an object containing two keys:
 ## See also
- [`to_string`](to_string.md) - returns a string representation of a JSON value
+- [to_string](to_string.md) returns a string representation of a JSON value
- [`operator<<`](../operator_ltlt.md) - serialize to stream
+- [operator<<](../operator_ltlt.md) serialize to stream
- [`basic_json_view::dump`](../basic_json_view/dump.md) - the corresponding function of `basic_json_view`, serializing
+- [`basic_json_view::dump`](../basic_json_view/dump.md) the corresponding function of `basic_json_view`, serializing
  directly from a flat index without building a `basic_json` value
 - [Serialization](../../features/serialization.md) - the serialization article
@@ -63,12 +63,12 @@ Logarithmic in the size of the container, O(log(`size()`)).
 ## See also
- [`emplace_back`](emplace_back.md) - add a value to an array
+- [emplace_back](emplace_back.md) add a value to an array
- [`insert`](insert.md) - add values to an array/object
+- [insert](insert.md) add values to an array/object
 - [Modifying values](../../features/modifying_values.md) - the article on modifying values
 ## Version history
- Added in version 2.0.8.
+- Since version 2.0.8.
 - Fixed in version 3.13.0: for [`ordered_json`](../ordered_json.md), the value could previously only be passed as an
  rvalue; it can now also be passed as an lvalue or a `#!cpp const` lvalue, matching the behavior of `json`.
@@ -61,11 +61,11 @@ Amortized constant.
 ## See also
- [`operator+=`](operator+=.md) - add a value to an array/object
+- [operator+=](operator+=.md) add a value to an array/object
- [`push_back`](push_back.md) - add a value to an array/object
+- [push_back](push_back.md) add a value to an array/object
 - [Modifying values](../../features/modifying_values.md) - the article on modifying values
 ## Version history
- Added in version 2.0.8.
+- Since version 2.0.8.
 - Returns reference since 3.7.0.
@@ -41,7 +41,7 @@ bool empty() const noexcept
 ## Notes
-This function does not return whether a string stored as JSON value is empty — it returns whether the JSON container
+This function does not return whether a string stored as JSON value is empty -- it returns whether the JSON container
 itself is empty which is `#!cpp false` in the case of a string.
 ## Examples
@@ -62,9 +62,9 @@ itself is empty which is `#!cpp false` in the case of a string.
 ## See also
- [`size`](size.md) - returns the number of elements
+- [size](size.md) returns the number of elements
- [`clear`](clear.md) - clears the content and resets the value to the default value
+- [clear](clear.md) clears the content and resets the value to the default value
- [`basic_json_view::empty`](../basic_json_view/empty.md) - the same check on a zero-copy view
+- [basic_json_view::empty](../basic_json_view/empty.md) - the same check on a zero-copy view
 ## Version history
@@ -7,12 +7,7 @@ const_iterator end() const noexcept;
 Returns an iterator to one past the last element.
-<div class="nj-fig-wrap" markdown>
+![Illustration from cppreference.com](../../images/range-begin-end.svg)
 --8<-- "images/range-begin-end.svg"
 </div>
 <p class="nj-caption" markdown>`end()` points to the position after the last element and `begin()` to the first element;
 the dashed cell is the past-the-last position, which must not be dereferenced.</p>
 ## Return value
@@ -44,11 +39,11 @@ Constant.
 ## See also
- [`begin`](begin.md) - returns an iterator to the first element
+- [begin](begin.md) returns an iterator to the first element
- [`cend`](cend.md) - returns a const iterator to one past the last element
+- [cend](cend.md) returns a const iterator to one past the last element
- [`rend`](rend.md) - returns a reverse iterator to one before the first element
+- [rend](rend.md) returns a reverse iterator to one before the first element
 - [Iterators](../../features/iterators.md) - the article on iterators
- [`basic_json_view::end`](../basic_json_view/end.md) - the same iteration on a zero-copy view
+- [basic_json_view::end](../basic_json_view/end.md) - the same iteration on a zero-copy view
 ## Version history
@@ -60,9 +60,8 @@ Constant.
 ## See also
- [`start_pos`](start_pos.md) - to access the start position
+- [start_pos](start_pos.md) to access the start position
- [`JSON_DIAGNOSTIC_POSITIONS`](../macros/json_diagnostic_positions.md) - overview of the supported conversions
+- [JSON_DIAGNOSTIC_POSITIONS](../macros/json_diagnostic_positions.md) for an overview of the diagnostic positions
 - [Parsing and Exceptions](../../features/parsing/parse_exceptions.md) - handling parse errors and locating them in the input
 ## Version history
@@ -204,8 +204,8 @@ Strong exception safety: if an exception occurs, the original value stays intact
 ## See also
- [`clear`](clear.md) - clears the contents
+- [clear](clear.md) clears the contents
- [`insert`](insert.md) - add values to an array/object
+- [insert](insert.md) add values to an array/object
 - [Modifying values](../../features/modifying_values.md) - the article on modifying values
 ## Version history
@@ -213,6 +213,7 @@ Strong exception safety: if an exception occurs, the original value stays intact
 1. Added in version 1.0.0. Added support for binary types in version 3.8.0.
 2. Added in version 1.0.0. Added support for binary types in version 3.8.0.
 3. Added in version 1.0.0.
-4. Added in version 3.11.0. Support for keys convertible to `std::string_view` added in version 3.13.0, consistently
+4. Added in version 3.11.0. Fixed in version 3.13.0 to consistently accept `std::string_view`-convertible keys, as
-   across the lookup functions.
+   already supported by [`operator[]`](operator[].md), [`at`](at.md), [`value`](value.md), and other lookup
   functions.
 5. Added in version 1.0.0.
@@ -61,7 +61,7 @@ keep
 ## See also
- [`dump`](dump.md) - serializes a JSON value, with an `error_handler_t` parameter to configure invalid UTF-8 handling
+- [dump](dump.md) serializes a JSON value, with an `error_handler_t` parameter to configure invalid UTF-8 handling
 - [Handling invalid UTF-8](../../features/serialization.md#handling-invalid-utf-8) - the article on handling invalid UTF-8
 ## Version history
@@ -40,9 +40,6 @@ classDiagram
    style json_exception fill:#CCCCFF
 ```
 <p class="nj-caption" markdown>Class hierarchy of the library's exceptions; arrows point from a derived class to its
 base class, and the highlighted box is `basic_json::exception`.</p>
 Subclasses:
 - [`parse_error`](parse_error.md) for exceptions indicating a parse error
@@ -83,12 +80,8 @@ constructor.
 ## See also
- [List of exceptions](../../home/exceptions.md) - overview of all exceptions thrown by the library
+[List of exceptions](../../home/exceptions.md)
 - [Working Without Exceptions](../../features/no_exceptions.md) - using the library without exceptions
 - [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) - extended exception messages with the path of the failing value
 - [Parsing and Exceptions](../../features/parsing/parse_exceptions.md) - parsing alternatives that do not throw
 - [Debugging](../../home/debugging.md) - debugging aids
 ## Version history
- Added in version 3.0.0.
+- Since version 3.0.0.
@@ -91,16 +91,16 @@ Logarithmic in the size of the JSON object.
 ## See also
- [`count`](count.md) - returns the number of occurrences of a key
+- [count](count.md) returns the number of occurrences of a key
- [`contains`](contains.md) - checks whether a key exists
+- [contains](contains.md) checks whether a key exists
- [`basic_json_view::find`](../basic_json_view/find.md) - the same lookup on a zero-copy view (a duplicate key resolves
+- [basic_json_view::find](../basic_json_view/find.md) - the same lookup on a zero-copy view (a duplicate key resolves
  to the first member, whereas `parse()` keeps the last)
 - [Element Access](../../features/element_access/index.md#does-this-key-exist) - how to test whether a key exists
 ## Version history
 1. Added in version 3.11.0.
-2. Added in version 1.0.0. Changed to support comparable types in version 3.11.0. Support for keys convertible to
+2. Added in version 1.0.0. Changed to support comparable types in version 3.11.0. Fixed in version 3.13.0 to
-   `std::string_view` added in version 3.13.0, consistently across the lookup functions.
+   consistently accept `std::string_view`-convertible keys, as already supported by [`operator[]`](operator[].md),
   [`at`](at.md), [`value`](value.md), and other lookup functions.
 3. Deleted overloads for integral key types added in version 3.13.0 to reject such calls at compile time instead of
   causing undefined behavior at runtime.
@@ -58,8 +58,7 @@ Empty objects and arrays are flattened to `#!json null` and will not be reconstr
 ## See also
- [`unflatten`](unflatten.md) - the reverse function
+- [unflatten](unflatten.md) the reverse function
 - [JSON Pointer](../../features/json_pointer.md#flatten-unflatten) - the article on JSON Pointer and flattening
 ## Version history
@@ -86,8 +86,8 @@ std::string format_as(const BasicJsonType& j)
 ## See also
- [`dump`](dump.md) - serialize a JSON value to a string
+- [dump](dump.md)
- [`std::formatter<basic_json>`](std_formatter.md) - the `std::format` (C++20) equivalent
+- [std::formatter<basic_json>](std_formatter.md) - the `std::format` (C++20) equivalent
 - [Serialization](../../features/serialization.md) - the serialization article
 ## Version history
@@ -82,11 +82,8 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [parse_error.112](../../home/exceptions.md#jsonexceptionparse_error112) if a parse error occurs
 - Throws [parse_error.113](../../home/exceptions.md#jsonexceptionparse_error113) if a string could not be parsed
  successfully, or if a string value or object key is not valid UTF-8 and `error_handler` is `strict`
 - Throws [parse_error.115](../../home/exceptions.md#jsonexceptionparse_error115) if the text of a high-precision
  number (`H`) is not a valid number
 - Throws [out_of_range.408](../../home/exceptions.md#jsonexceptionout_of_range408) if the size of an optimized container
-  cannot be represented by `std::size_t` or exceeds the container's `max_size()`, or if the product of the dimensions of
+  or n-dimensional array cannot be represented by `std::size_t`
  an n-dimensional array overflows
 ## Complexity
@@ -110,16 +107,12 @@ Linear in the size of the input.
 ## See also
- [BJData](../../features/binary_formats/bjdata.md) - the format, its byte layout and how values are mapped
+- [to_bjdata](to_bjdata.md) create a BJData serialization of a JSON value
- [Binary formats](../../features/binary_formats/index.md) - overview and comparison of the supported binary formats
+- [from_cbor](from_cbor.md) create a JSON value from an input in CBOR format
- [Parsing untrusted input](../../features/parsing/untrusted_input.md) - limits and safe handling of hostile data
+- [from_msgpack](from_msgpack.md) create a JSON value from an input in MessagePack format
- [Binary values](../../features/binary_values.md) - how binary values and subtypes are handled
+- [from_bson](from_bson.md) create a JSON value from an input in BSON format
- [`to_bjdata`](to_bjdata.md) - create a BJData serialization of a JSON value
+- [from_ubjson](from_ubjson.md) create a JSON value from an input in UBJSON format
- [`from_cbor`](from_cbor.md) - create a JSON value from an input in CBOR format
+- [from_bon8](from_bon8.md) create a JSON value from an input in BON8 format
 - [`from_msgpack`](from_msgpack.md) - create a JSON value from an input in MessagePack format
 - [`from_bson`](from_bson.md) - create a JSON value from an input in BSON format
 - [`from_ubjson`](from_ubjson.md) - create a JSON value from an input in UBJSON format
 - [`from_bon8`](from_bon8.md) - create a JSON value from an input in BON8 format
 ## Version history
@@ -74,11 +74,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [parse_error.112](../../home/exceptions.md#jsonexceptionparse_error112) if a parse error occurs, for instance
  an invalid byte, a string that is not valid UTF-8, or an object key that is not a string
 The UTF-8 validity of strings is always checked, independent of
 [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md), because the end of a BON8 string is determined from
 its encoding. Duplicate object keys are accepted; the last value wins (see
 [BON8](../../features/binary_formats/bon8.md)).
 ## Complexity
 Linear in the size of the input.
@@ -101,15 +96,12 @@ Linear in the size of the input.
 ## See also
- [BON8](../../features/binary_formats/bon8.md) - the format, its byte layout and how values are mapped
+- [to_bon8](to_bon8.md) create a BON8 serialization of a JSON value
- [Binary formats](../../features/binary_formats/index.md) - overview and comparison of the supported binary formats
+- [from_cbor](from_cbor.md) create a JSON value from an input in CBOR format
- [Parsing untrusted input](../../features/parsing/untrusted_input.md) - limits and safe handling of hostile data
+- [from_msgpack](from_msgpack.md) create a JSON value from an input in MessagePack format
- [`to_bon8`](to_bon8.md) - create a BON8 serialization of a JSON value
+- [from_bson](from_bson.md) create a JSON value from an input in BSON format
- [`from_cbor`](from_cbor.md) - create a JSON value from an input in CBOR format
+- [from_ubjson](from_ubjson.md) create a JSON value from an input in UBJSON format
- [`from_msgpack`](from_msgpack.md) - create a JSON value from an input in MessagePack format
+- [from_bjdata](from_bjdata.md) create a JSON value from an input in BJData format
 - [`from_bson`](from_bson.md) - create a JSON value from an input in BSON format
 - [`from_ubjson`](from_ubjson.md) - create a JSON value from an input in UBJSON format
 - [`from_bjdata`](from_bjdata.md) - create a JSON value from an input in BJData format
 ## Version history
@@ -80,8 +80,7 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [`parse_error.110`](../../home/exceptions.md#jsonexceptionparse_error110) if the given input ends prematurely or
  the end of the input was not reached when `strict` was set to true
 - Throws [`parse_error.112`](../../home/exceptions.md#jsonexceptionparse_error112) if a parse error occurs (e.g., an
-  invalid string or byte array length, an invalid inner length of a binary value with subtype `0x02`, or a document size
+  invalid string or byte array length)
  that does not match the content; `strict` does not affect the document size checks)
 - Throws [`parse_error.114`](../../home/exceptions.md#jsonexceptionparse_error114) if an unsupported BSON record type is
  encountered
 - Throws [`parse_error.113`](../../home/exceptions.md#jsonexceptionparse_error113) if a string value or object key is
@@ -109,17 +108,13 @@ Linear in the size of the input.
 ## See also
- [BSON](../../features/binary_formats/bson.md) - the format, its byte layout and how values are mapped
+- [BSON specification](http://bsonspec.org/spec.html)
- [Binary formats](../../features/binary_formats/index.md) - overview and comparison of the supported binary formats
+- [to_bson](to_bson.md) for the analogous serialization
- [Parsing untrusted input](../../features/parsing/untrusted_input.md) - limits and safe handling of hostile data
+- [from_cbor](from_cbor.md) for the related CBOR format
- [Binary values](../../features/binary_values.md) - how binary values and subtypes are handled
+- [from_msgpack](from_msgpack.md) for the related MessagePack format
- [BSON specification](http://bsonspec.org/spec.html) - specification of the BSON format
+- [from_ubjson](from_ubjson.md) for the related UBJSON format
- [`to_bson`](to_bson.md) - the analogous serialization
+- [from_bjdata](from_bjdata.md) for the related BJData format
- [`from_cbor`](from_cbor.md) - the related CBOR format
+- [from_bon8](from_bon8.md) for the related BON8 format
 - [`from_msgpack`](from_msgpack.md) - the related MessagePack format
 - [`from_ubjson`](from_ubjson.md) - the related UBJSON format
 - [`from_bjdata`](from_bjdata.md) - the related BJData format
 - [`from_bon8`](from_bon8.md) - the related BON8 format
 ## Version history
@@ -32,10 +32,8 @@ The exact mapping and its limitations are described on a [dedicated page](../../
    - an `std::istream` object
    - a `FILE` pointer
-    - a C-style array of characters (its terminating NUL is read as trailing data: `parse_error.110` unless `strict` is
+    - a C-style array of characters
-      `false`)
+    - a pointer to a null-terminated string of single byte characters
    - a pointer to a null-terminated string of single byte characters (read up to the first 0x00 byte, which is a valid
      CBOR byte)
    - a container `obj` for which `begin(obj)` and `end(obj)` produce a valid pair of iterators
      (as found via ADL or member functions, with semantics compatible to `std::begin` and `std::end`)
@@ -91,14 +89,8 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [parse_error.112](../../home/exceptions.md#jsonexceptionparse_error112) if unsupported features from CBOR were
  used in the given input or if the input is not valid CBOR
 - Throws [parse_error.113](../../home/exceptions.md#jsonexceptionparse_error113) if a map key is not a string (keys of
-  other types are not supported, as JSON object keys are always strings), if the head of a string or byte string is
+  other types are not supported, as JSON object keys are always strings), or if a string value or object key is not
-  malformed (including a chunk of the wrong type or an indefinite-length string nested inside an indefinite-length
+  valid UTF-8 and `error_handler` is `strict`
  string), or if a string value or object key (or one chunk of an indefinite-length string) is not valid UTF-8 and
  `error_handler` is `strict`
 - Throws [out_of_range.408](../../home/exceptions.md#jsonexceptionout_of_range408) if an array or map announces
  a length that `std::size_t` cannot hold, or that equals `std::size_t(-1)` (for example `9B FF FF FF FF FF FF FF FF`)
 - Throws [out_of_range.406](../../home/exceptions.md#jsonexceptionout_of_range406) if a floating-point number does not
  fit into `number_float_t`
 ## Complexity
@@ -122,16 +114,12 @@ Linear in the size of the input.
 ## See also
- [CBOR](../../features/binary_formats/cbor.md) - the format, its byte layout and how values are mapped
+- [to_cbor](to_cbor.md) create a CBOR serialization of a JSON value
- [Binary formats](../../features/binary_formats/index.md) - overview and comparison of the supported binary formats
+- [from_msgpack](from_msgpack.md) create a JSON value from an input in MessagePack format
- [Parsing untrusted input](../../features/parsing/untrusted_input.md) - limits and safe handling of hostile data
+- [from_bson](from_bson.md) create a JSON value from an input in BSON format
- [Binary values](../../features/binary_values.md) - how binary values and subtypes are handled
+- [from_ubjson](from_ubjson.md) create a JSON value from an input in UBJSON format
- [`to_cbor`](to_cbor.md) - create a CBOR serialization of a JSON value
+- [from_bjdata](from_bjdata.md) create a JSON value from an input in BJData format
- [`from_msgpack`](from_msgpack.md) - create a JSON value from an input in MessagePack format
+- [from_bon8](from_bon8.md) create a JSON value from an input in BON8 format
 - [`from_bson`](from_bson.md) - create a JSON value from an input in BSON format
 - [`from_ubjson`](from_ubjson.md) - create a JSON value from an input in UBJSON format
 - [`from_bjdata`](from_bjdata.md) - create a JSON value from an input in BJData format
 - [`from_bon8`](from_bon8.md) - create a JSON value from an input in BON8 format
 ## Version history
@@ -107,16 +107,12 @@ Linear in the size of the input.
 ## See also
- [MessagePack](../../features/binary_formats/messagepack.md) - the format, its byte layout and how values are mapped
+- [to_msgpack](to_msgpack.md) create a MessagePack serialization of a JSON value
- [Binary formats](../../features/binary_formats/index.md) - overview and comparison of the supported binary formats
+- [from_cbor](from_cbor.md) create a JSON value from an input in CBOR format
- [Parsing untrusted input](../../features/parsing/untrusted_input.md) - limits and safe handling of hostile data
+- [from_bson](from_bson.md) create a JSON value from an input in BSON format
- [Binary values](../../features/binary_values.md) - how binary values and subtypes are handled
+- [from_ubjson](from_ubjson.md) create a JSON value from an input in UBJSON format
- [`to_msgpack`](to_msgpack.md) - create a MessagePack serialization of a JSON value
+- [from_bjdata](from_bjdata.md) create a JSON value from an input in BJData format
- [`from_cbor`](from_cbor.md) - create a JSON value from an input in CBOR format
+- [from_bon8](from_bon8.md) create a JSON value from an input in BON8 format
 - [`from_bson`](from_bson.md) - create a JSON value from an input in BSON format
 - [`from_ubjson`](from_ubjson.md) - create a JSON value from an input in UBJSON format
 - [`from_bjdata`](from_bjdata.md) - create a JSON value from an input in BJData format
 - [`from_bon8`](from_bon8.md) - create a JSON value from an input in BON8 format
 ## Version history
@@ -79,18 +79,11 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [parse_error.110](../../home/exceptions.md#jsonexceptionparse_error110) if the given input ends prematurely or
  the end of the file was not reached when `strict` was set to true
- Throws [parse_error.112](../../home/exceptions.md#jsonexceptionparse_error112) if an invalid type marker is read
+- Throws [parse_error.112](../../home/exceptions.md#jsonexceptionparse_error112) if a parse error occurs
  (including a type marker after `$` of an optimized container, even if its count is 0), or if `$` is not followed by `#`
 - Throws [parse_error.113](../../home/exceptions.md#jsonexceptionparse_error113) if a string could not be parsed
-  successfully (negative or non-integer length, `C` followed by a byte above 0x7F), if the count of an optimized
+  successfully, or if a string value or object key is not valid UTF-8 and `error_handler` is `strict`
-  container is negative, or if a string value or object key is not valid UTF-8 and `error_handler` is `strict`
+- Throws [out_of_range.408](../../home/exceptions.md#jsonexceptionout_of_range408) if the size of an optimized container
- Throws [parse_error.115](../../home/exceptions.md#jsonexceptionparse_error115) if the text of a high-precision number
+  or n-dimensional array cannot be represented by `std::size_t`
  (`H`) is not a valid JSON number
 - Throws [out_of_range.406](../../home/exceptions.md#jsonexceptionout_of_range406) if a high-precision number, or a
  float64 when `number_float_t` is `float`, does not fit into `number_float_t`
 - Throws [out_of_range.408](../../home/exceptions.md#jsonexceptionout_of_range408) if the count of an optimized
  container exceeds the capacity of the container (or of `std::size_t`), or if an optimized array of `Z`, `T`, or `F` has
  more than 1,048,576 elements
 ## Complexity
@@ -114,16 +107,12 @@ Linear in the size of the input.
 ## See also
- [UBJSON](../../features/binary_formats/ubjson.md) - the format, its byte layout and how values are mapped
+- [to_ubjson](to_ubjson.md) create a UBJSON serialization of a JSON value
- [Binary formats](../../features/binary_formats/index.md) - overview and comparison of the supported binary formats
+- [from_cbor](from_cbor.md) create a JSON value from an input in CBOR format
- [Parsing untrusted input](../../features/parsing/untrusted_input.md) - limits and safe handling of hostile data
+- [from_msgpack](from_msgpack.md) create a JSON value from an input in MessagePack format
- [Binary values](../../features/binary_values.md) - how binary values and subtypes are handled
+- [from_bson](from_bson.md) create a JSON value from an input in BSON format
- [`to_ubjson`](to_ubjson.md) - create a UBJSON serialization of a JSON value
+- [from_bjdata](from_bjdata.md) create a JSON value from an input in BJData format
- [`from_cbor`](from_cbor.md) - create a JSON value from an input in CBOR format
+- [from_bon8](from_bon8.md) create a JSON value from an input in BON8 format
 - [`from_msgpack`](from_msgpack.md) - create a JSON value from an input in MessagePack format
 - [`from_bson`](from_bson.md) - create a JSON value from an input in BSON format
 - [`from_bjdata`](from_bjdata.md) - create a JSON value from an input in BJData format
 - [`from_bon8`](from_bon8.md) - create a JSON value from an input in BON8 format
 ## Version history
@@ -50,12 +50,11 @@ Constant.
 ## See also
- [`back`](back.md) - to access the last element
+- [back](back.md) to access the last element
- [`basic_json_view::front`](../basic_json_view/front.md) - the same access on a zero-copy view (document order, not
+- [basic_json_view::front](../basic_json_view/front.md) - the same access on a zero-copy view (document order, not
  sorted; duplicate keys are visited)
 - [Element Access](../../features/element_access/index.md) - overview of all ways to access elements
 ## Version history
 - Added in version 1.0.0.
- Binary values are supported since version 3.8.0.
+- Adjusted code to return reference to binary values in version 3.8.0.
@@ -178,17 +178,16 @@ overload (3).
 ## See also
- [`get_to`](get_to.md) - convert and write into a passed value
+- [get_to](get_to.md) convert and write into a passed value
- [`get_ptr`](get_ptr.md) - get a pointer to the stored value
+- [get_ptr](get_ptr.md) get a pointer to the stored value
- [`get_ref`](get_ref.md) - get a reference to the stored value
+- [get_ref](get_ref.md) get a reference to the stored value
- [`operator ValueType`](operator_ValueType.md) - get a value via implicit conversion
+- [operator ValueType](operator_ValueType.md) get a value via implicit conversion
 - [Converting values](../../features/conversions.md) - the type conversions article
- [`basic_json_view::get`](../basic_json_view/get.md) - the same conversion on a zero-copy view (many types are
+- [basic_json_view::get](../basic_json_view/get.md) - the same conversion on a zero-copy view (many types are
  converted without ever building a `basic_json` value)
 - [Arbitrary Type Conversions](../../features/arbitrary_types.md) - make your own types usable with `get`
 ## Version history
-1. Added in version 2.1.0.
+1. Since version 2.1.0.
-2. Added in version 2.1.0. Extended to work with other specializations of `basic_json` in version 3.1.2.
+2. Since version 2.1.0. Extended to work with other specializations of `basic_json` in version 3.2.0.
-3. Added in version 1.0.0.
+3. Since version 1.0.0.
@@ -36,7 +36,7 @@ Constant.
 ## See also
- [`basic_json`](index.md#template-parameters) - the class template, with `AllocatorType` as one of its template parameters
+- [basic_json](index.md#template-parameters) the class template, with `AllocatorType` as one of its template parameters
 - [Template Parameter Requirements](../../features/types/template_parameters.md#allocatortype) - the requirements for `AllocatorType`
 ## Version history
@@ -42,11 +42,8 @@ Constant.
 ## See also
- [Binary values](../../features/binary_values.md) - how binary values and subtypes are handled
+- [get](get.md) get a value (explicit conversion)
- [`binary`](binary.md) - create a binary value
+- [get_ref](get_ref.md) get a reference to the stored value
 - [`is_binary`](is_binary.md) - check whether a value is binary
 - [`get`](get.md) - get a value (explicit conversion)
 - [`get_ref`](get_ref.md) - get a reference to the stored value
 ## Version history
@@ -45,7 +45,7 @@ Constant.
    #include <iostream>
    #include <nlohmann/json.hpp>
-    using nlohmann::json;
+    using json = nlohmann::json;
    int main()
    {
@@ -86,8 +86,7 @@ Constant.
 ## See also
- [`get_ref()`](get_ref.md) - get a reference value
+- [get_ref()](get_ref.md) get a reference value
 - [Converting values](../../features/conversions.md) - getting values out, with or without copying
 ## Version history
@@ -60,10 +60,9 @@ Constant.
 ## See also
- [`get_ptr()`](get_ptr.md) - get a pointer value
+- [get_ptr()](get_ptr.md) get a pointer value
- [`basic_json_view::get_string`](../basic_json_view/get_string.md) - the closest counterpart on a zero-copy view: a
+- [basic_json_view::get_string](../basic_json_view/get_string.md) - the closest counterpart on a zero-copy view: a
  string without a copy, but as a view rather than a reference to a value that must already exist
 - [Converting values](../../features/conversions.md) - getting values out, with or without copying
 ## Version history
@@ -68,14 +68,13 @@ Depends on the `json_serializer<ValueType>::from_json()` implementation.
 ## See also
- [`get`](get.md) - get a value (explicit conversion)
+- [get](get.md) get a value (explicit conversion)
- [`get_ref`](get_ref.md) - get a reference to the stored value
+- [get_ref](get_ref.md) get a reference to the stored value
- [`get_ptr`](get_ptr.md) - get a pointer to the stored value
+- [get_ptr](get_ptr.md) get a pointer to the stored value
 - [Converting values](../../features/conversions.md) - the type conversions article
- [`basic_json_view::get_to`](../basic_json_view/get_to.md) - the same conversion on a zero-copy view
+- [basic_json_view::get_to](../basic_json_view/get_to.md) - the same conversion on a zero-copy view
 - [Arbitrary Type Conversions](../../features/arbitrary_types.md) - make your own types usable with `get_to`
 ## Version history
- Added in version 3.3.0.
+- Since version 3.3.0.
 - Added a `static_assert` with a clear message for `const` arguments in version 3.13.0.
@@ -44,22 +44,6 @@ are collected in [Template Parameter Requirements](../../features/types/template
 - [**json**](../json.md) - default specialization
 - [**ordered_json**](../ordered_json.md) - a specialization that maintains the insertion order of object keys
 ## Documents and views
 Besides `basic_json`, the library offers a second way to hold a parsed JSON text: a
 [`basic_json_document`](../basic_json_document/index.md), which owns or borrows the text and holds a flat index of the
 values in it, and a [`basic_json_view`](../basic_json_view/index.md), a read-only handle to one value of such a document.
 Both are defined in the header `<nlohmann/json_view.hpp>`; see
 [Zero-copy JSON views](../../features/json_view.md) for the concept and the trade-offs.
 - [**json_document**](../json_document.md) / [**ordered_json_document**](../ordered_json_document.md) - read-only
  documents of the `basic_json` specialization they belong to
 - [**json_editable_document**](../json_editable_document.md) /
  [**ordered_json_editable_document**](../ordered_json_editable_document.md) - documents that can be modified in place
 - [**json_view**](../json_view.md) / [**ordered_json_view**](../ordered_json_view.md) - views of a document
 - [**json_editable_view**](../json_editable_view.md) /
  [**ordered_json_editable_view**](../ordered_json_editable_view.md) - views of an editable document
 ## Iterator invalidation
 All operations that add values to an **array** ([`push_back`](push_back.md) , [`operator+=`](operator+=.md),
@@ -121,7 +105,6 @@ The class satisfies the following concept requirements:
 - [**json_pointer**](../json_pointer/index.md) - JSON Pointer implementation
 - [**json_serializer**](json_serializer.md) - type of the serializer to for conversions from/to JSON
 - [**error_handler_t**](error_handler_t.md) - type to choose behavior on decoding errors
 - [**bjdata_version_t**](bjdata_version_t.md) - type to choose the BJData version to write
 - [**cbor_tag_handler_t**](cbor_tag_handler_t.md) - type to choose how to handle CBOR tags
 - **initializer_list_t** - type for initializer lists of `basic_json` values
 - [**input_format_t**](input_format_t.md) - type to choose the format to parse
@@ -189,7 +172,7 @@ The class satisfies the following concept requirements:
 Functions to inspect the type of a JSON value.
 - [**type**](type.md) - return the type of the JSON value
- [`operator value_t`](operator_value_t.md) - return the type of the JSON value
+- [**operator value_t**](operator_value_t.md) - return the type of the JSON value
 - [**type_name**](type_name.md) - return the type as string
 - [**is_primitive**](is_primitive.md) - return whether the type is primitive
 - [**is_structured**](is_structured.md) - return whether the type is structured
@@ -218,7 +201,7 @@ Direct access to the stored value of a JSON value.
 - [**get_to**](get_to.md) - get a value and write it to a destination
 - [**get_ptr**](get_ptr.md) - get a pointer value
 - [**get_ref**](get_ref.md) - get a reference value
- [`operator ValueType`](operator_ValueType.md) - get a value
+- [**operator ValueType**](operator_ValueType.md) - get a value
 - [**get_binary**](get_binary.md) - get a binary value
 - [**as_base_class**](as_base_class.md) - access the custom base class
@@ -359,15 +342,7 @@ Access to the JSON value
 ## See also
- [RFC 8259: The JavaScript Object Notation (JSON) Data Interchange Format](https://tools.ietf.org/html/rfc8259) -
+- [RFC 8259: The JavaScript Object Notation (JSON) Data Interchange Format](https://tools.ietf.org/html/rfc8259)
  specification of the JSON data interchange format
 - [`basic_json_document`](../basic_json_document/index.md) - / [`basic_json_view`](../basic_json_view/index.md) - parse a JSON
  text into a flat index and read it through a view
 - [Zero-copy JSON views](../../features/json_view.md) - when to use a document and a view instead of a `basic_json`
 - [Types](../../features/types/index.md) - how JSON values are stored and which types exist
 - [Converting values](../../features/conversions.md) - get values out of a JSON value and put values in
 - [Creating JSON values](../../features/creating_values.md) - all the ways to build a JSON value
 - [Arbitrary Type Conversions](../../features/arbitrary_types.md) - convert your own types to and from JSON
 ## Version history
@@ -53,9 +53,8 @@ bon8
 ## See also
- [`sax_parse`](sax_parse.md) - generic SAX parse interface, taking an `input_format_t` to select the input format
+- [sax_parse](sax_parse.md) generic SAX parse interface, taking an `input_format_t` to select the input format
- [`cbor_tag_handler_t`](cbor_tag_handler_t.md) - configures how CBOR tags are treated while parsing
+- [cbor_tag_handler_t](cbor_tag_handler_t.md) configures how CBOR tags are treated while parsing
 - [Binary Formats](../../features/binary_formats/index.md) - CBOR, MessagePack, BSON, and other formats
 ## Version history
@@ -185,11 +185,10 @@ Strong exception safety: if an exception occurs, the original value stays intact
 ## See also
- [`emplace`](emplace.md) - add a value to an object
+- [emplace](emplace.md) add a value to an object
- [`emplace_back`](emplace_back.md) - add a value to an array
+- [emplace_back](emplace_back.md) add a value to an array
- [`push_back`](push_back.md) - add a value to an array/object
+- [push_back](push_back.md) add a value to an array/object
- [`update`](update.md) - merges objects
+- [update](update.md) merges objects
 - [Modifying values](../../features/modifying_values.md) - the article on modifying values
 ## Version history
@@ -40,9 +40,6 @@ classDiagram
    style json_invalid_iterator fill:#CCCCFF
 ```
 <p class="nj-caption" markdown>Class hierarchy of the library's exceptions; arrows point from a derived class to its
 base class, and the highlighted box is `basic_json::invalid_iterator`.</p>
 ## Member functions
 - **what** - returns explanatory string
@@ -69,15 +66,13 @@ base class, and the highlighted box is `basic_json::invalid_iterator`.</p>
 ## See also
- [`exception`](exception.md) - the base class of all exceptions thrown by the library
+- [`exception`](exception.md) for the base class of all exceptions thrown by the library
- [List of iterator errors](../../home/exceptions.md#iterator-errors) - overview of iterator errors (`invalid_iterator`)
+- [List of iterator errors](../../home/exceptions.md#iterator-errors)
- [`parse_error`](parse_error.md) - exceptions indicating a parse error
+- [`parse_error`](parse_error.md) for exceptions indicating a parse error
- [`type_error`](type_error.md) - exceptions indicating executing a member function with a wrong type
+- [`type_error`](type_error.md) for exceptions indicating executing a member function with a wrong type
- [`out_of_range`](out_of_range.md) - exceptions indicating access out of the defined range
+- [`out_of_range`](out_of_range.md) for exceptions indicating access out of the defined range
- [`other_error`](other_error.md) - exceptions indicating other library errors
+- [`other_error`](other_error.md) for exceptions indicating other library errors
 - [Exceptions](../../home/exceptions.md) - all exceptions and their error codes
 - [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) - extended exception messages with the path of the failing value
 ## Version history
- Added in version 3.0.0.
+- Since version 3.0.0.
@@ -36,12 +36,11 @@ Constant.
 ## See also
- [`is_object`](is_object.md) - checks whether the JSON value is an object
+- [is_object](is_object.md) checks whether the JSON value is an object
- [`is_structured`](is_structured.md) - checks whether the JSON value is structured (array or object)
+- [is_structured](is_structured.md) checks whether the JSON value is structured (array or object)
- [`type`](type.md) - returns the type of the JSON value
+- [type](type.md) returns the type of the JSON value
- [`array_t`](array_t.md) - the type used to store JSON arrays
+- [array_t](array_t.md) the type used to store JSON arrays
- [`basic_json_view::is_array`](../basic_json_view/is_array.md) - the same check on a zero-copy view
+- [basic_json_view::is_array](../basic_json_view/is_array.md) - the same check on a zero-copy view
 - [Types](../../features/types/index.md) - the JSON value types and how they are stored
 ## Version history
@@ -36,11 +36,10 @@ Constant.
 ## See also
- [Binary values](../../features/binary_values.md) - how binary values and subtypes are handled
+- [is_primitive](is_primitive.md) checks whether the JSON value is primitive
- [`is_primitive`](is_primitive.md) - checks whether the JSON value is primitive
+- [binary_t](binary_t.md) the type used to store binary values
- [`binary_t`](binary_t.md) - the type used to store binary values
+- [get_binary](get_binary.md) returns a reference to the stored binary value
- [`get_binary`](get_binary.md) - returns a reference to the stored binary value
+- [basic_json_view::is_binary](../basic_json_view/is_binary.md) - the same check on a zero-copy view
 - [`basic_json_view::is_binary`](../basic_json_view/is_binary.md) - the same check on a zero-copy view
 ## Version history
@@ -36,10 +36,9 @@ Constant.
 ## See also
- [`boolean_t`](boolean_t.md) - the type used to store JSON booleans
+- [boolean_t](boolean_t.md) the type used to store JSON booleans
- [`is_primitive`](is_primitive.md) - checks whether the JSON value is primitive
+- [is_primitive](is_primitive.md) checks whether the JSON value is primitive
- [`basic_json_view::is_boolean`](../basic_json_view/is_boolean.md) - the same check on a zero-copy view
+- [basic_json_view::is_boolean](../basic_json_view/is_boolean.md) - the same check on a zero-copy view
 - [Types](../../features/types/index.md) - the JSON value types and how they are stored
 ## Version history
@@ -87,9 +87,8 @@ with `allow_exceptions` set to `#!cpp false`: a parse error then yields a discar
 ## See also
- [`basic_json_view::is_discarded`](../basic_json_view/is_discarded.md) - the corresponding check on a zero-copy view,
+- [basic_json_view::is_discarded](../basic_json_view/is_discarded.md) - the corresponding check on a zero-copy view,
  which is `#!cpp true` if the view refers to no value
 - [Types](../../features/types/index.md) - the JSON value types and how they are stored
 ## Version history
@@ -36,12 +36,11 @@ Constant.
 ## See also
- [`is_array`](is_array.md) - checks whether the JSON value is an array
+- [is_array](is_array.md) checks whether the JSON value is an array
- [`is_object`](is_object.md) - checks whether the JSON value is an object
+- [is_object](is_object.md) checks whether the JSON value is an object
- [`type`](type.md) - returns the type of the JSON value
+- [type](type.md) returns the type of the JSON value
- [`value_t`](value_t.md) - the enumeration of JSON types
+- [value_t](value_t.md) the enumeration of JSON types
- [`basic_json_view::is_null`](../basic_json_view/is_null.md) - the same check on a zero-copy view
+- [basic_json_view::is_null](../basic_json_view/is_null.md) - the same check on a zero-copy view
 - [Types](../../features/types/index.md) - the JSON value types and how they are stored
 ## Version history
@@ -46,12 +46,10 @@ constexpr bool is_number() const noexcept
 ## See also
- [`is_number_integer()`](is_number_integer.md) - check if the value is an integer or unsigned integer number
+- [is_number_integer()](is_number_integer.md) check if the value is an integer or unsigned integer number
- [`is_number_unsigned()`](is_number_unsigned.md) - check if the value is an unsigned integer number
+- [is_number_unsigned()](is_number_unsigned.md) check if the value is an unsigned integer number
- [`is_number_float()`](is_number_float.md) - check if the value is a floating-point number
+- [is_number_float()](is_number_float.md) check if the value is a floating-point number
- [`basic_json_view::is_number`](../basic_json_view/is_number.md) - the same check on a zero-copy view
+- [basic_json_view::is_number](../basic_json_view/is_number.md) - the same check on a zero-copy view
 - [Types](../../features/types/index.md) - the JSON value types and how they are stored
 - [Number Handling](../../features/types/number_handling.md) - how numbers are stored and converted
 ## Version history
@@ -37,12 +37,10 @@ Constant.
 ## See also
- [`is_number()`](is_number.md) - check if the value is a number
+- [is_number()](is_number.md) check if the value is a number
- [`is_number_integer()`](is_number_integer.md) - check if the value is an integer or unsigned integer number
+- [is_number_integer()](is_number_integer.md) check if the value is an integer or unsigned integer number
- [`is_number_unsigned()`](is_number_unsigned.md) - check if the value is an unsigned integer number
+- [is_number_unsigned()](is_number_unsigned.md) check if the value is an unsigned integer number
- [`basic_json_view::is_number_float`](../basic_json_view/is_number_float.md) - the same check on a zero-copy view
+- [basic_json_view::is_number_float](../basic_json_view/is_number_float.md) - the same check on a zero-copy view
 - [Types](../../features/types/index.md) - the JSON value types and how they are stored
 - [Number Handling](../../features/types/number_handling.md) - how numbers are stored and converted
 ## Version history
@@ -37,12 +37,10 @@ Constant.
 ## See also
- [`is_number()`](is_number.md) - check if the value is a number
+- [is_number()](is_number.md) check if the value is a number
- [`is_number_unsigned()`](is_number_unsigned.md) - check if the value is an unsigned integer number
+- [is_number_unsigned()](is_number_unsigned.md) check if the value is an unsigned integer number
- [`is_number_float()`](is_number_float.md) - check if the value is a floating-point number
+- [is_number_float()](is_number_float.md) check if the value is a floating-point number
- [`basic_json_view::is_number_integer`](../basic_json_view/is_number_integer.md) - the same check on a zero-copy view
+- [basic_json_view::is_number_integer](../basic_json_view/is_number_integer.md) - the same check on a zero-copy view
 - [Types](../../features/types/index.md) - the JSON value types and how they are stored
 - [Number Handling](../../features/types/number_handling.md) - how numbers are stored and converted
 ## Version history
@@ -40,12 +40,10 @@ Constant.
 ## See also
- [`is_number()`](is_number.md) - check if the value is a number
+- [is_number()](is_number.md) check if the value is a number
- [`is_number_integer()`](is_number_integer.md) - check if the value is an integer or unsigned integer number
+- [is_number_integer()](is_number_integer.md) check if the value is an integer or unsigned integer number
- [`is_number_float()`](is_number_float.md) - check if the value is a floating-point number
+- [is_number_float()](is_number_float.md) check if the value is a floating-point number
- [`basic_json_view::is_number_unsigned`](../basic_json_view/is_number_unsigned.md) - the same check on a zero-copy view
+- [basic_json_view::is_number_unsigned](../basic_json_view/is_number_unsigned.md) - the same check on a zero-copy view
 - [Types](../../features/types/index.md) - the JSON value types and how they are stored
 - [Number Handling](../../features/types/number_handling.md) - how numbers are stored and converted
 ## Version history
@@ -36,12 +36,11 @@ Constant.
 ## See also
- [`is_array`](is_array.md) - checks whether the JSON value is an array
+- [is_array](is_array.md) checks whether the JSON value is an array
- [`is_structured`](is_structured.md) - checks whether the JSON value is structured (array or object)
+- [is_structured](is_structured.md) checks whether the JSON value is structured (array or object)
- [`type`](type.md) - returns the type of the JSON value
+- [type](type.md) returns the type of the JSON value
- [`object_t`](object_t.md) - the type used to store JSON objects
+- [object_t](object_t.md) the type used to store JSON objects
- [`basic_json_view::is_object`](../basic_json_view/is_object.md) - the same check on a zero-copy view
+- [basic_json_view::is_object](../basic_json_view/is_object.md) - the same check on a zero-copy view
 - [Types](../../features/types/index.md) - the JSON value types and how they are stored
 ## Version history
@@ -56,14 +56,13 @@ This library extends primitive types to binary types, because binary types are r
 ## See also
- [`is_structured()`](is_structured.md) - returns whether the JSON value is structured
+- [is_structured()](is_structured.md) returns whether the JSON value is structured
- [`is_null()`](is_null.md) - returns whether the JSON value is `null`
+- [is_null()](is_null.md) returns whether the JSON value is `null`
- [`is_string()`](is_string.md) - returns whether the JSON value is a string
+- [is_string()](is_string.md) returns whether the JSON value is a string
- [`is_boolean()`](is_boolean.md) - returns whether the JSON value is a boolean
+- [is_boolean()](is_boolean.md) returns whether the JSON value is a boolean
- [`is_number()`](is_number.md) - returns whether the JSON value is a number
+- [is_number()](is_number.md) returns whether the JSON value is a number
- [`is_binary()`](is_binary.md) - returns whether the JSON value is a binary array
+- [is_binary()](is_binary.md) returns whether the JSON value is a binary array
- [`basic_json_view::is_primitive`](../basic_json_view/is_primitive.md) - the same check on a zero-copy view
+- [basic_json_view::is_primitive](../basic_json_view/is_primitive.md) - the same check on a zero-copy view
 - [Types](../../features/types/index.md) - the JSON value types and how they are stored
 ## Version history
@@ -36,11 +36,10 @@ Constant.
 ## See also
- [`is_primitive`](is_primitive.md) - checks whether the JSON value is primitive
+- [is_primitive](is_primitive.md) checks whether the JSON value is primitive
- [`type`](type.md) - returns the type of the JSON value
+- [type](type.md) returns the type of the JSON value
- [`string_t`](string_t.md) - the type used to store JSON strings
+- [string_t](string_t.md) the type used to store JSON strings
- [`basic_json_view::is_string`](../basic_json_view/is_string.md) - the same check on a zero-copy view
+- [basic_json_view::is_string](../basic_json_view/is_string.md) - the same check on a zero-copy view
 - [Types](../../features/types/index.md) - the JSON value types and how they are stored
 ## Version history
@@ -54,11 +54,10 @@ Note that though strings are containers in C++, they are treated as primitive va
 ## See also
- [`is_primitive()`](is_primitive.md) - returns whether JSON value is primitive
+- [is_primitive()](is_primitive.md) returns whether JSON value is primitive
- [`is_array()`](is_array.md) - returns whether the value is an array
+- [is_array()](is_array.md) returns whether the value is an array
- [`is_object()`](is_object.md) - returns whether the value is an object
+- [is_object()](is_object.md) returns whether the value is an object
- [`basic_json_view::is_structured`](../basic_json_view/is_structured.md) - the same check on a zero-copy view
+- [basic_json_view::is_structured](../basic_json_view/is_structured.md) - the same check on a zero-copy view
 - [Types](../../features/types/index.md) - the JSON value types and how they are stored
 ## Version history
@@ -54,7 +54,7 @@ using element_type = decltype(*j_object.items().begin());
 ```
 The per-element type (`iteration_proxy_value`) lives in the library's internal `detail` namespace and is
-intentionally unspecified as a stable, named type — `decltype` is the supported way to obtain it, but its exact
+intentionally unspecified as a stable, named type -- `decltype` is the supported way to obtain it, but its exact
 name/definition may change between versions.
 ## Return value
@@ -97,16 +97,15 @@ When iterating over an array, `key()` will return the index of the element as st
 ## See also
- [`begin`](begin.md) - returns an iterator to the first element
+- [begin](begin.md) returns an iterator to the first element
- [`end`](end.md) - returns an iterator to one past the last element
+- [end](end.md) returns an iterator to one past the last element
- [`basic_json_view::items`](../basic_json_view/items.md) - the same range on a zero-copy view (`#!cpp const auto`,
+- [basic_json_view::items](../basic_json_view/items.md) - the same range on a zero-copy view (`#!cpp const auto`,
  not `#!cpp const auto&`: items are produced on the fly; document order, not sorted; duplicate keys are visited)
 - [Iterators](../../features/iterators.md#access-object-keys-during-iteration) - the article on iterating over keys and values
 ## Version history
- Added in version 3.1.0 as the replacement of the static function `iterator_wrapper`, which was available since
+- Added `iterator_wrapper` in version 3.0.0.
-  version 1.0.0 and is deprecated since version 3.1.0.
+- Added `items` and deprecated `iterator_wrapper` in version 3.1.0.
 - Added structured binding support in version 3.5.0.
 !!! warning "Deprecation"
@@ -57,7 +57,7 @@ same name. Hidden members remain accessible via [`as_base_class`](as_base_class.
 ## See also
- [`as_base_class`](as_base_class.md) - access the custom base class
+- [as_base_class](as_base_class.md) - access the custom base class
 - [Template Parameter Requirements](../../features/types/template_parameters.md#custombaseclass) - the requirements for `CustomBaseClass`
 ## Version history
@@ -44,12 +44,11 @@ deserializes. See [Template Parameter Requirements](../../features/types/templat
 ## See also
- [`adl_serializer`](../adl_serializer/index.md) - the default `json_serializer`
+- [adl_serializer](../adl_serializer/index.md) the default `json_serializer`
- [`get`](get.md) - explicit type conversion using the `json_serializer`'s `from_json()` method
+- [get](get.md) explicit type conversion using the `json_serializer`'s `from_json()` method
- [`get_to`](get_to.md) - explicit type conversion into a variable using the `json_serializer`'s `from_json()` method
+- [get_to](get_to.md) explicit type conversion into a variable using the `json_serializer`'s `from_json()` method
 - [Arbitrary Type Conversions](../../features/arbitrary_types.md) - the article on converting between JSON values and arbitrary types
 - [Template Parameter Requirements](../../features/types/template_parameters.md) - requirements on the `JSONSerializer` template parameter
 ## Version history
- Added in version 2.1.0.
+- Since version 2.0.0.
@@ -33,7 +33,7 @@ constant complexity.
 ## Notes
-This function does not return the maximal length of a string stored as JSON value — it returns the maximal number of
+This function does not return the maximal length of a string stored as JSON value -- it returns the maximal number of
 string elements the JSON value can store which is `1`.
 ## Examples
@@ -56,9 +56,9 @@ string elements the JSON value can store which is `1`.
 ## See also
- [`size`](size.md) - returns the number of elements
+- [size](size.md) returns the number of elements
- [`array_t`](array_t.md) - the type used to store JSON arrays
+- [array_t](array_t.md) the type used to store JSON arrays
- [`object_t`](object_t.md) - the type used to store JSON objects
+- [object_t](object_t.md) the type used to store JSON objects
 ## Version history
@@ -70,10 +70,9 @@ object operation (looking up a key, or adding one to the patch): logarithmic for
 ## See also
- [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396) - specification of JSON Merge Patch
+- [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396)
- [`merge_patch`](merge_patch.md) - applies a JSON Merge Patch
+- [merge_patch](merge_patch.md) applies a JSON Merge Patch
- [`diff`](diff.md) - creates a diff as a JSON Patch
+- [diff](diff.md) creates a diff as a JSON Patch
 - [JSON Merge Patch](../../features/merge_patch.md) - the article on JSON Merge Patch
 ## Version history
@@ -39,33 +39,13 @@ Basic guarantee: if an exception is thrown during the operation, the JSON value
 ## Complexity
-Linear in the total number of values (including nested ones) in `apply_patch`, times the cost of a key-based object
+Linear in the lengths of `apply_patch`.
 operation (looking up, adding, or erasing a member): logarithmic for [`json`](../json.md), and linear for
 [`ordered_json`](../ordered_json.md) (see [`ordered_map` complexity](../ordered_map.md#complexity)). For
 `ordered_json`, patching an object that has `n` members with a patch that has `m` members therefore takes O(n·m). The
 cost also includes one copy of `apply_patch` (see the notes below).
 ## Notes
- `apply_patch` may be `#!cpp *this` itself or refer to a value contained in `#!cpp *this` (for example, a subobject
+`apply_patch` may be `#!cpp *this` itself or refer to a value contained in `#!cpp *this` (for example, a subobject
 returned by `#!cpp (*this)[key]`); it is read as it was when `merge_patch()` was called, before any modification of
-  `#!cpp *this`. To make this possible, the function copies `apply_patch` before it modifies `#!cpp *this`, so the cost
+`#!cpp *this`.
  includes one copy of the patch.
 - A merge patch uses `#!json null` to remove a member, so it cannot set a member to `#!json null`: applying
  `#!json {"a":null}` to `#!json {"a":1}` gives `#!json {}`.
 - Arrays are not merged: an array in the patch replaces the target value as a whole, and a `#!json null` inside an
  array is kept as an element. `#!json null` members of the target that the patch does not mention are preserved.
 - A `#!json null` in the patch only removes a member; it does not prevent the creation of the enclosing objects.
  Applying `#!json {"a":{"b":null}}` to `#!json {}` gives `#!json {"a":{}}` (see example 15 in Appendix A of the RFC).
 - If `apply_patch` is not an object, it replaces the target as a whole. In particular, a `#!json null` patch turns the
  target into `#!json null`. If `apply_patch` is an object and the target is not, the target is first replaced by an
  empty object, so applying `#!json {}` to `#!json 1` gives `#!json {}`.
 - A merge patch cannot express every change; for example, it cannot reorder array elements or remove a specific array
  element. Use [JSON Patch](../../features/json_patch.md) ([RFC 6902](https://tools.ietf.org/html/rfc6902)) for that.
  [`merge_diff`](merge_diff.md) has a matching limitation, see its notes.
 - A [discarded](is_discarded.md) value is treated like any other non-object value: a discarded
  `apply_patch` turns the target into a discarded value, and an object patch replaces a discarded target by an object
  as described above.
 ## Examples
@@ -85,13 +65,12 @@ cost also includes one copy of `apply_patch` (see the notes below).
 ## See also
- [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396) - specification of JSON Merge Patch
+- [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396)
- [`patch`](patch.md) - apply a JSON patch
+- [patch](patch.md) apply a JSON patch
- [`merge_diff`](merge_diff.md) - creates a diff as a JSON Merge Patch
+- [merge_diff](merge_diff.md) creates a diff as a JSON Merge Patch
 - [JSON Merge Patch](../../features/merge_patch.md) - the article on JSON Merge Patch
 ## Version history
- Added in version 3.1.0.
+- Added in version 3.0.0.
 - Fixed use of freed or relocated memory when `apply_patch` is `#!cpp *this` or refers to a value contained in
  `#!cpp *this`, in version 3.13.0.
@@ -48,11 +48,8 @@ Constant.
 ## See also
- [`NLOHMANN_JSON_VERSION_MAJOR`](../macros/nlohmann_json_version_major.md) /
+- [**NLOHMANN_JSON_VERSION_MAJOR**/**NLOHMANN_JSON_VERSION_MINOR**/**NLOHMANN_JSON_VERSION_PATCH**](../macros/nlohmann_json_version_major.md)
-  [`NLOHMANN_JSON_VERSION_MINOR`](../macros/nlohmann_json_version_major.md) /
+  \- library version information
  [`NLOHMANN_JSON_VERSION_PATCH`](../macros/nlohmann_json_version_major.md) - library version information
 - [Integration](../../integration/index.md) - integrate the library
 - [Supported Macros](../../features/macros.md) - guide to all supported macros
 ## Version history
@@ -84,11 +84,10 @@ Floating-point number values are stored directly inside a `basic_json` type.
 ## See also
- [`number_integer_t`](number_integer_t.md) - the type used to store JSON integer numbers
+- [number_integer_t](number_integer_t.md) the type used to store JSON integer numbers
- [`number_unsigned_t`](number_unsigned_t.md) - the type used to store JSON unsigned integer numbers
+- [number_unsigned_t](number_unsigned_t.md) the type used to store JSON unsigned integer numbers
- [`is_number_float`](is_number_float.md) - checks whether the JSON value is a floating-point number
+- [is_number_float](is_number_float.md) checks whether the JSON value is a floating-point number
 - [Number Handling](../../features/types/number_handling.md) - the article on number handling
 - [Template Parameter Requirements](../../features/types/template_parameters.md) - requirements on the number template parameters
 ## Version history
@@ -80,11 +80,10 @@ Integer number values are stored directly inside a `basic_json` type.
 ## See also
- [`number_unsigned_t`](number_unsigned_t.md) - the type used to store JSON unsigned integer numbers
+- [number_unsigned_t](number_unsigned_t.md) the type used to store JSON unsigned integer numbers
- [`number_float_t`](number_float_t.md) - the type used to store JSON floating-point numbers
+- [number_float_t](number_float_t.md) the type used to store JSON floating-point numbers
- [`is_number_integer`](is_number_integer.md) - checks whether the JSON value is a signed integer number
+- [is_number_integer](is_number_integer.md) checks whether the JSON value is a signed integer number
 - [Number Handling](../../features/types/number_handling.md) - the article on number handling
 - [Template Parameter Requirements](../../features/types/template_parameters.md) - requirements on the number template parameters
 ## Version history
@@ -82,11 +82,10 @@ Integer number values are stored directly inside a `basic_json` type.
 ## See also
- [`number_integer_t`](number_integer_t.md) - the type used to store JSON integer numbers
+- [number_integer_t](number_integer_t.md) the type used to store JSON integer numbers
- [`number_float_t`](number_float_t.md) - the type used to store JSON floating-point numbers
+- [number_float_t](number_float_t.md) the type used to store JSON floating-point numbers
- [`is_number_unsigned`](is_number_unsigned.md) - checks whether the JSON value is an unsigned integer number
+- [is_number_unsigned](is_number_unsigned.md) checks whether the JSON value is an unsigned integer number
 - [Number Handling](../../features/types/number_handling.md) - the article on number handling
 - [Template Parameter Requirements](../../features/types/template_parameters.md) - requirements on the number template parameters
 ## Version history
@@ -27,10 +27,8 @@ and [`default_object_comparator_t`](default_object_comparator_t.md) otherwise.
 ## See also
- [`object_t`](object_t.md) - the type used to store JSON objects
+- [object_t](object_t.md) the type used to store JSON objects
- [`default_object_comparator_t`](default_object_comparator_t.md) - the fallback comparator used when `object_t` has no `key_compare` member type
+- [default_object_comparator_t](default_object_comparator_t.md) the fallback comparator used when `object_t` has no `key_compare` member type
 - [Template Parameter Requirements](../../features/types/template_parameters.md) - requirements on the `ObjectType` template parameter
 - [Object order](../../features/object_order.md) - preserve the insertion order of keys
 ## Version history
@@ -20,7 +20,7 @@ To store objects in C++, a type is defined by the template parameters described
 `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
+    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.
@@ -125,12 +125,10 @@ the object is silently converted as an array of key-value pairs, which is incorr
 ## See also
- [`array_t`](array_t.md) - the type used to store JSON arrays
+- [array_t](array_t.md) the type used to store JSON arrays
- [`string_t`](string_t.md) - the type used to store JSON strings
+- [string_t](string_t.md) the type used to store JSON strings
- [`object_comparator_t`](object_comparator_t.md) - the comparator used to order object keys
+- [object_comparator_t](object_comparator_t.md) the comparator used to order object keys
 - [Object Order](../../features/object_order.md) - the article on object key ordering
 - [Types](../../features/types/index.md) - how objects are stored
 - [Template Parameter Requirements](../../features/types/template_parameters.md) - requirements on the `ObjectType` template parameter
 ## Version history
@@ -123,12 +123,11 @@ interpreted as `object_t::value_type` or `std::initializer_list<basic_json>`, se
 ## See also
- [`emplace_back`](emplace_back.md) - add a value to an array
+- [emplace_back](emplace_back.md) add a value to an array
- [`push_back`](push_back.md) - add a value to an array/object
+- [push_back](push_back.md) add a value to an array/object
 - [Modifying values](../../features/modifying_values.md) - the article on modifying values
 ## Version history
-1. Added in version 1.0.0.
+1. Since version 1.0.0.
-2. Added in version 1.0.0.
+2. Since version 1.0.0.
-3. Added in version 2.0.0.
+3. Since version 2.0.0.
@@ -45,9 +45,8 @@ Linear.
 ## See also
- [`basic_json`](basic_json.md) - create a JSON value
+- [basic_json](basic_json.md) create a JSON value
- [`swap`](swap.md) - exchanges the contents of two JSON values
+- [swap](swap.md) exchanges the contents of two JSON values
 - [Creating JSON values](../../features/creating_values.md) - ways to create and assign JSON values
 ## Version history
@@ -137,13 +137,10 @@ Strong exception safety: if an exception occurs, the original value stays intact
        When the JSON pointer traverses intermediate levels that don't exist at all yet (not just a missing
        leaf), each missing level is created as an array or an object depending on whether the corresponding
-        pointer token is a valid array index: the token `0`, a sequence of digits that does not begin with `0`,
+        pointer token parses as a non-negative integer: a numeric token creates an array, a non-numeric token
-        or the token `-` creates an array, and every other token creates an object. For example, on an
+        creates an object. For example, on an initially `#!json null` value, `/foo/0/0/0` creates nested arrays,
-        initially `#!json null` value, `/foo/0/0/0` creates nested arrays, while `/foo/one/one/one` creates
+        while `/foo/one/one/one` creates nested objects. This is not specified by the JSON Pointer RFC; it is
-        nested objects. Tokens such as `01` or the empty token cannot be array indices (cf. RFC 6901, Sect. 4)
+        this library's own, intentional disambiguation rule. See also [JSON Pointer](../../features/json_pointer.md).
        and therefore create objects, just as they would if the level already existed as an object. This is not
        specified by the JSON Pointer RFC; it is this library's own, intentional disambiguation rule. See also
        [JSON Pointer](../../features/json_pointer.md).
 !!! warning "Deprecation"
@@ -274,25 +271,23 @@ Strong exception safety: if an exception occurs, the original value stays intact
 ## See also
- [Unchecked access](../../features/element_access/unchecked_access.md) - element access without range checking
+- documentation on [unchecked access](../../features/element_access/unchecked_access.md)
- [Runtime assertions](../../features/assertions.md) - assertions guarding against undefined behavior
+- documentation on [runtime assertions](../../features/assertions.md)
- [`at`](at.md) - access by reference with range checking
+- see [`at`](at.md) for access by reference with range checking
- [`value`](value.md) - access with default value
+- see [`value`](value.md) for access with default value
- [`basic_json_view::operator[]`](../basic_json_view/operator%5B%5D.md) - the same access on a zero-copy view (a duplicate
+- [basic_json_view::operator[]](../basic_json_view/operator%5B%5D.md) - the same access on a zero-copy view (a duplicate
  key resolves to the first member, whereas `parse()` keeps the last; a missing key gives a discarded view instead of
  undefined behavior)
 - [Element Access](../../features/element_access/index.md) - overview of all ways to access elements
 - [JSON Pointer](../../features/json_pointer.md) - access nested values with a pointer
 ## Version history
 1. Added in version 1.0.0. Fixed in version 3.13.0 to throw `#!cpp std::length_error` instead of emptying the array and
   accessing it out of bounds when `idx` equals the maximum value of `size_type`. A missing index in the const version
   is guarded by a runtime assertion since version 3.13.0.
-2. Added in version 1.0.0. Added overloads for `T* key` in version 1.1.0. The `T* key` overloads forward to
+2. Added in version 1.0.0. Added overloads for `T* key` in version 1.1.0. Removed overloads for `T* key` (replaced by 3)
-   overload 3 since version 3.11.0.
+   in version 3.11.0.
-3. Added in version 3.11.0. Support for keys convertible to `std::string_view` added in version 3.13.0, consistently
+3. Added in version 3.11.0. Fixed in version 3.13.0 to consistently accept `std::string_view`-convertible keys, as
-   across the lookup functions.
+   already supported by [`at`](at.md), [`value`](value.md), [`find`](find.md), and other lookup functions.
 4. Added in version 2.0.0. A missing array index in the const version is guarded by a runtime assertion since
   version 3.13.0. Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) instead of
 [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) for a one-character array index that is not
Author	SHA1	Message	Date
Niels Lohmann	37cd434784	Move the std::vector<std::byte> tests to unit-custom-binary-type-cpp17.cpp The develop merge kept the test case that #5809 moved from unit-regression3.cpp in unit-custom-binary-type.cpp, but byte_binary_json is only defined in the C++17 file now, so the C++17 build of the former failed. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-21 19:21:53 +02:00
Niels Lohmann	3250b5ce46	Rename two more json_view test helpers that clash in the unity build In one batch, the exception_of() calls of unit-json_view_image.cpp bind to the exception_of(F) template of unit-json_view.cpp, so GCC reports the file's own exception_of() as unused (-Werror=unused-function), and a loop variable counter in unit-json_view_image.cpp hides the counter of unit-json_view_edit.cpp (MSVC C4459). Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-21 15:17:30 +02:00
Niels Lohmann	52724f5ae5	Rename the json_view test helpers that clash in the unity build unit-json_view_builder.cpp has its own document generator besides json_view_test::generator, and unit-json_view_edit.cpp and unit-json_view_image.cpp define rng() and bits() like unit-json_view.cpp, each in an anonymous namespace. In one batch these are ambiguous or redefined, so give the file-local ones their own names. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-21 11:05:27 +02:00
Niels Lohmann	d01e6382fe	Merge branch 'develop' into claude/test-compilation-speed-993125 Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-21 10:45:45 +02:00
Niels Lohmann	589c29d69b	Keep the unit-comparison.cpp types out of the anonymous namespace GCC reports a basic_json specialized with a type of an anonymous namespace in a file #include-d into a batch (-Wsubobject-linkage), so only the helper functions go into the anonymous namespace. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-10 09:49:13 +02:00
Niels Lohmann	80fd9c0fb4	Build files that suppress -Wnoexcept on their own unit-udt.cpp suppresses GCC's -Wnoexcept around its include of the library just like unit-noexcept.cpp, so instead of listing the files, leave every file that suppresses the warning out of the batches. Move the helpers of unit-comparison.cpp into an anonymous namespace inside unit_comparison_detail, as clang-tidy's misc-use-internal-linkage wants internal linkage for them. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-10 07:45:41 +02:00
Niels Lohmann	169f1fcb2d	Fix the Ubuntu CI failures of the unity test build - build unit-noexcept.cpp on its own: it suppresses GCC's -Wnoexcept around its include of the library, which has no effect once another file of the batch included the library first - unit-comparison.cpp: make make_unordered_object inline (-Wmissing-prototypes in a named namespace) and replace the using-directive by using-declarations, as Clang reports a using-directive in an #include-d file (-Wheader-hygiene) - unit-json_pointer-cpp20.cpp: include <compare> only with JSON_HAS_THREE_WAY_COMPARISON; GCC 9 and Clang 9 accept C++20 but have no <compare> Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-10 05:43:28 +02:00
Niels Lohmann	020a834128	Merge branch 'develop' into claude/test-compilation-speed-993125 Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-10 01:29:55 +02:00
Niels Lohmann	7dcff6b8cd	Merge branch 'develop' into claude/test-compilation-speed-993125 Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-09 23:45:36 +02:00
Niels Lohmann	769c5cde57	Fix CI failures of the unity test build - keep JSON_DISABLE_ENUM_SERIALIZATION and JSON_DISABLE_TUPLE_REFERENCE_CONVERSION defined with JSON_TEST_KEEP_MACROS, so that every file of a batch sees them, not only the first one - mark JSON_TESTS_PRIVATE in the generated batch file as used, as GCC and Clang report an unused definition when the first file defines it again (-Wunused-macros) - suppress bugprone-suspicious-include for the #include-d .cpp files - avoid local json aliases and variables that hide a global json of another file in the same batch (MSVC C4459) Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-09 23:23:04 +02:00
Niels Lohmann	993e37e7ec	Reduce test compile times (spike) Two changes roughly halve the CPU time needed to build the unit tests (clang 21: ~300 s -> ~150 s, GCC 16: ~750-820 s -> ~395-420 s, Debug): - Move the C++14/17/20-dependent tests into separate unit-<name>-cpp<N>.cpp files. A test file is built for every standard whose JSON_HAS_CPP_<N> macro it mentions, so far whole large files were rebuilt for C++14/17/20 because of a few #ifdef sections. The main files are now built for C++11 only; the ci_test_*_cxx<N> jobs still build every file for every standard. - Add the CMake option JSON_TestUnityBuild (ON by default, OFF with MinGW): compatible test files are compiled in batches as one translation unit so they share the template instantiations of the library. Each file keeps its own CTest test, which runs the batch executable filtered to that file's test cases. The binary-format tests form an explicit group; the rest is batched by JSON_TestUnityBatchSize. Fix the name clashes that merging files exposed, document the rules for test files in tests/README.md, and point CONTRIBUTING.md to it. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-09 16:49:45 +02:00