Remove accidentally committed Python bytecode

Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Check in CI that Meson and pkg-config offer the CMake options
2026-10-04 13:40:33 +00:00 · 2026-10-01 14:19:41 +02:00 · 2026-10-01 14:19:32 +02:00 · 2026-10-01 14:16:08 +02:00 · 2026-10-01 13:07:17 +02:00 · 2026-10-01 13:07:17 +02:00
369 changed files with 4432 additions and 15875 deletions
@@ -1,9 +1,18 @@
+# bugprone-use-after-move (hicpp-invalid-access-moved is its alias) still flags
+# the basic_json move constructor, which forwards the whole object to its base
+# class (#5724), and two forwards in the error-message construction of
+# at(KeyType&&) (json.hpp, both overloads: find(std::forward<KeyType>(key))
+# followed by string_t(std::forward<KeyType>(key)) in the throw), which #5689
+# rewrites. Re-enable both checks once those changes have landed.
 # 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.

 Checks: '*,

+         -bugprone-use-after-move,
+         -hicpp-invalid-access-moved,
+
         -altera-id-dependent-backward-branch,
         -altera-struct-pack-align,
         -altera-unroll-loops,
@@ -75,10 +84,6 @@ Checks: '*,
 CheckOptions:
  - key: hicpp-special-member-functions.AllowSoleDefaultDtor
    value: 1
-  # clang-tidy 22.1 extended this check to classes and enums; the test files
-  # define many such helper types at namespace scope, which is harmless
-  - key: misc-use-internal-linkage.AnalyzeTypes
-    value: false

 WarningsAsErrors: '*'

@@ -142,16 +142,6 @@ The documentation will then be available at <http://127.0.0.1:8000/>. See the do
 [mkdocs](https://www.mkdocs.org) and [Material for MkDocs](https://squidfunk.github.io/mkdocs-material/) for more
 information.

-Before opening a pull request, check the documentation like the CI does:
-
-```shell
-make build -C docs/mkdocs          # strict build: fails on broken links, anchors, and structure problems
-make check_mermaid -C docs/mkdocs  # checks the Mermaid diagrams (requires Node.js)
-```
-
-A new API page also needs an entry in [`docs/docset/docSet.sql`](https://github.com/nlohmann/json/blob/develop/docs/docset/docSet.sql),
-the search index of the docset; `make build` reports missing entries.
-
 ### Amalgamate the source code

 The single-header files
@@ -18,17 +18,6 @@ updates:
    cooldown:
      default-days: 7

-  - package-ecosystem: npm
-    directory: /docs/mkdocs/scripts/mermaid
-    schedule:
-      interval: daily
-    cooldown:
-      default-days: 7
-    ignore:
-      # Material for MkDocs loads mermaid@11; keep the checker on the same major version
-      - dependency-name: mermaid
-        update-types: ["version-update:semver-major"]
-
  - package-ecosystem: pip
    directory: /tools/astyle
    schedule:
@@ -1,46 +0,0 @@
-name: Check documentation links
-
-# check the links of the documentation weekly; external links break without any change in this repository
-on:
-  schedule:
-    - cron: '17 4 * * 1'
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-concurrency:
-  group: ${{ github.workflow }}
-  cancel-in-progress: true
-
-jobs:
-  check_docs_links:
-    if: github.repository == 'nlohmann/json'
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    steps:
-      - name: Harden Runner
-        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
-        with:
-          egress-policy: audit
-
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-
-      - name: Install virtual environment
-        run: make install_venv -C docs/mkdocs
-
-      - name: Check links
-        shell: bash  # adds -o pipefail, so tee does not hide the exit code
-        run: make link_check -C docs/mkdocs 2>&1 | tee link_check.log
-
-      - name: Summarize broken links
-        if: failure()
-        run: |
-          {
-            echo '### Broken documentation links'
-            echo '```'
-            grep 'invalid url' link_check.log || true
-            echo '```'
-          } >> "$GITHUB_STEP_SUMMARY"
@@ -38,14 +38,14 @@ jobs:

    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
-      uses: github/codeql-action/init@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
+      uses: github/codeql-action/init@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
      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@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
+      uses: github/codeql-action/autobuild@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1

    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
+      uses: github/codeql-action/analyze@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
@@ -47,6 +47,6 @@ jobs:
          output: 'flawfinder_results.sarif'

      - name: Upload analysis results to GitHub Security tab
-        uses: github/codeql-action/upload-sarif@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
+        uses: github/codeql-action/upload-sarif@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
        with:
          sarif_file: ${{github.workspace}}/flawfinder_results.sarif
@@ -43,9 +43,6 @@ jobs:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
        with:
          persist-credentials: false
-          # the git-revision-date-localized plugin needs the history for correct "last update" dates and so the
-          # strict build does not fail on a shallow clone
-          fetch-depth: 0

      - name: Install virtual environment
        run: make install_venv -C docs/mkdocs
@@ -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@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
+        uses: github/codeql-action/upload-sarif@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
        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@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
+        uses: github/codeql-action/upload-sarif@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
        with:
          sarif_file: semgrep.sarif
        if: always()
@@ -31,6 +31,48 @@ jobs:
      - name: Build
        run: cmake --build build --target ci_test_gcc

+  ci_meson_install:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+      - name: Get latest CMake and ninja
+        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
+      - name: Check that Meson and pkg-config offer the CMake options
+        run: make check_build_options
+      - name: Install Meson
+        run: pip install meson
+      - name: Install with Meson
+        run: |
+          meson setup build-meson --prefix=${{ github.workspace }}/install
+          meson install -C build-meson
+      - name: Use the installed package with find_package
+        run: |
+          cmake -S tests/cmake_import/project -B build-import -DCMAKE_PREFIX_PATH=${{ github.workspace }}/install
+          cmake --build build-import
+      - name: Install with Meson and non-default options
+        run: |
+          meson setup build-meson-options --prefix=${{ github.workspace }}/install-options -DMultipleHeaders=true -DDiagnostics=true -DGlobalUDLs=false -DDisableTupleReferenceConversion=true
+          meson install -C build-meson-options
+      - name: Check that the options reach the installed files
+        run: |
+          test -d install-options/include/nlohmann/detail
+          cflags=$(PKG_CONFIG_PATH=${{ github.workspace }}/install-options/share/pkgconfig pkg-config --cflags nlohmann_json)
+          echo "$cflags"
+          echo "$cflags" | grep -q -- '-DJSON_DIAGNOSTICS=1'
+          echo "$cflags" | grep -q -- '-DJSON_USE_GLOBAL_UDLS=0'
+          echo "$cflags" | grep -q -- '-DJSON_DISABLE_TUPLE_REFERENCE_CONVERSION=1'
+          grep -q 'JSON_USE_GLOBAL_UDLS=0;JSON_DISABLE_TUPLE_REFERENCE_CONVERSION=1;JSON_DIAGNOSTICS=1' install-options/share/cmake/nlohmann_json/nlohmann_jsonTargets.cmake
+          cmake -S tests/cmake_import/project -B build-import-options -DCMAKE_PREFIX_PATH=${{ github.workspace }}/install-options
+          cmake --build build-import-options
+      - name: Install with Meson and the include directory outside the prefix
+        run: |
+          meson setup build-meson-split --prefix=${{ github.workspace }}/install-split --includedir=${{ github.workspace }}/install-split-dev/include
+          meson install -C build-meson-split
+          cmake -S tests/cmake_import/project -B build-import-split -DCMAKE_PREFIX_PATH=${{ github.workspace }}/install-split
+          cmake --build build-import-split
+
  ci_infer:
    runs-on: ubuntu-latest
    steps:
@@ -400,7 +442,7 @@ jobs:
    runs-on: ubuntu-latest
    strategy:
      matrix:
-        target: [ci_test_examples, ci_test_build_documentation, ci_test_documentation_mermaid]
+        target: [ci_test_examples, ci_test_build_documentation]
    steps:
      - name: Harden Runner
        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
@@ -410,12 +452,6 @@ jobs:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
        with:
          persist-credentials: false
-          # the git-revision-date-localized plugin needs the history; a shallow clone makes the strict build fail
-          fetch-depth: ${{ matrix.target == 'ci_test_build_documentation' && '0' || '1' }}
-      - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0
-        if: matrix.target == 'ci_test_documentation_mermaid'
-        with:
-          node-version: 24
      - name: Run CMake
        run: cmake -S . -B build -DJSON_CI=On
      - name: Build
@@ -28,8 +28,6 @@
 /docs/docset/docSet.dsidx
 /docs/mkdocs/.cache/
 /docs/mkdocs/docs/__pycache__/
-/docs/mkdocs/hooks/__pycache__/
-/docs/mkdocs/scripts/mermaid/node_modules/
 /docs/mkdocs/site/
 /docs/mkdocs/venv/

@@ -53,11 +53,11 @@ cc_library(
        "include/nlohmann/detail/meta/detected.hpp",
        "include/nlohmann/detail/meta/identity_tag.hpp",
        "include/nlohmann/detail/meta/is_sax.hpp",
+        "include/nlohmann/detail/meta/logic.hpp",
        "include/nlohmann/detail/meta/std_fs.hpp",
        "include/nlohmann/detail/meta/type_traits.hpp",
        "include/nlohmann/detail/meta/void_t.hpp",
        "include/nlohmann/detail/output/binary_writer.hpp",
-        "include/nlohmann/detail/output/error_handler.hpp",
        "include/nlohmann/detail/output/output_adapters.hpp",
        "include/nlohmann/detail/output/serializer.hpp",
        "include/nlohmann/detail/recursion_depth_limit.hpp",
@@ -61,7 +61,6 @@ option(JSON_Install                        "Install CMake targets during install
 option(JSON_MultipleHeaders                "Use non-amalgamated version of the library." ON)
 option(JSON_SystemInclude                  "Include as system headers (skip for clang-tidy)." OFF)
 option(JSON_StrictNulHandling              "Build with strict NUL-byte handling enabled." OFF)
-option(JSON_StrictBinaryUTF8               "Build with UTF-8 checks in the CBOR, UBJSON, BJData, and BSON writers enabled." OFF)

 if (JSON_CI)
    include(ci)
@@ -119,10 +118,6 @@ if (JSON_StrictNulHandling)
    message(STATUS "Strict NUL-byte handling enabled (JSON_STRICT_NUL_HANDLING=1)")
 endif()

-if (JSON_StrictBinaryUTF8)
-    message(STATUS "Strict UTF-8 checks in binary writers enabled (JSON_STRICT_BINARY_UTF8=1)")
-endif()
-
 if (JSON_Diagnostic_Positions)
    message(STATUS "Diagnostic positions enabled (JSON_DIAGNOSTIC_POSITIONS=1)")
 endif()
@@ -158,7 +153,6 @@ target_compile_definitions(
    $<$<BOOL:${JSON_Diagnostic_Positions}>:JSON_DIAGNOSTIC_POSITIONS=1>
    $<$<BOOL:${JSON_LegacyDiscardedValueComparison}>:JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1>
    $<$<BOOL:${JSON_StrictNulHandling}>:JSON_STRICT_NUL_HANDLING=1>
-    $<$<BOOL:${JSON_StrictBinaryUTF8}>:JSON_STRICT_BINARY_UTF8=1>
 )

 target_include_directories(
@@ -180,7 +174,33 @@ if (MSVC)
    )
 endif()

-# Install a pkg-config file, so other tools can find this.
+# Install a pkg-config file, so other tools can find this. It carries the same
+# compile definitions as the target above.
+set(NLOHMANN_JSON_PKGCONFIG_CFLAGS "")
+if (NOT JSON_GlobalUDLs)
+    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_USE_GLOBAL_UDLS=0")
+endif()
+if (NOT JSON_ImplicitConversions)
+    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_USE_IMPLICIT_CONVERSIONS=0")
+endif()
+if (JSON_DisableEnumSerialization)
+    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_DISABLE_ENUM_SERIALIZATION=1")
+endif()
+if (JSON_DisableTupleReferenceConversion)
+    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_DISABLE_TUPLE_REFERENCE_CONVERSION=1")
+endif()
+if (JSON_Diagnostics)
+    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_DIAGNOSTICS=1")
+endif()
+if (JSON_Diagnostic_Positions)
+    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_DIAGNOSTIC_POSITIONS=1")
+endif()
+if (JSON_LegacyDiscardedValueComparison)
+    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1")
+endif()
+if (JSON_StrictNulHandling)
+    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_STRICT_NUL_HANDLING=1")
+endif()
 configure_file(
    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkg-config.pc.in"
    "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc"
@@ -249,9 +249,31 @@ make BUILD.bazel

 The "Check amalgamation" workflow fails if the file is out of date.

-### `meson.build`
+### `meson.build` and `meson_options.txt`

-The build definition for the [Meson](https://mesonbuild.com) build system.
+Meson build definitions suitable for use as a subproject ("wrap" in Meson terminology).
+
+Projects wishing to use the wrap can execute:
+```sh
+meson wrap install nlohmann_json
+```
+
+Which allows Meson to build from source when a system provided dependency isn't available.
+
+To build directly:
+```sh
+meson setup builddir
+ninja -C builddir
+```
+
+`meson_options.txt` defines the options, which mirror the CMake options that change the library's target (for example,
+`-DDiagnostics=true`). Meson requires this file next to `meson.build`, so it is also part of `include.zip`. `make check_build_options`
+([`tools/check_build_options`](tools/check_build_options/README.md)) checks in CI that both files and the pkg-config files
+stay in sync with the CMake options.
+
+When installing, `meson.build` installs the headers, a pkg-config file, and the CMake package config files, so that
+`find_package(nlohmann_json)` works. As Meson cannot generate `nlohmann_jsonTargets.cmake` itself, it is created from
+the template `cmake/nlohmann_jsonTargets.cmake.in`, which is only used by Meson.

 ### `Package.swift`

@@ -1,4 +1,4 @@
-.PHONY: pretty clean ChangeLog.md release update_hedley update_hedley_undef BUILD.bazel natvis macro_builder_check
+.PHONY: pretty clean ChangeLog.md release update_hedley update_hedley_undef BUILD.bazel natvis macro_builder_check check_build_options

 ##########################################################################
 # configuration
@@ -124,6 +124,10 @@ macro_builder_check:
 	diff "$$TMPDIR/paste.hpp" "$$TMPDIR/paste_actual.hpp" || (echo "===================================================================\n  $(MACRO_SCOPE_HPP) (NLOHMANN_JSON_EXPAND..NLOHMANN_JSON_DOUBLE_PASTE63) is out of date!\n  Regenerate it, see tools/macro_builder/README.md.\n===================================================================" ; exit 1); \
 	diff "$$TMPDIR/type_body.hpp" "$$TMPDIR/type_body_actual.hpp" || (echo "===================================================================\n  $(MACRO_SCOPE_HPP) (NLOHMANN_JSON_TYPE_BODY) is out of date!\n  Regenerate it, see tools/macro_builder/README.md.\n===================================================================" ; exit 1)

+# check that the Meson build and the pkg-config files offer the options of the CMake target
+check_build_options:
+	python3 tools/check_build_options/check_build_options.py .
+
 # check if file single_include/nlohmann/json.hpp has been amalgamated from the nlohmann sources
 check-amalgamation:
 	@mv $(AMALGAMATED_FILE) $(AMALGAMATED_FILE)~
@@ -181,7 +185,7 @@ json.tar.xz:
 # We use `-X` to make the resulting ZIP file reproducible, see
 # <https://content.pivotal.io/blog/barriers-to-deterministic-reproducible-zip-files>.
 include.zip: BUILD.bazel
-	zip -9 --recurse-paths -X include.zip $(SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) BUILD.bazel MODULE.bazel meson.build LICENSE.MIT
+	zip -9 --recurse-paths -X include.zip $(SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) BUILD.bazel MODULE.bazel meson.build meson_options.txt LICENSE.MIT

 # Create the files for a release and add signatures and hashes.
 release: include.zip json.tar.xz
@@ -12,6 +12,7 @@
 [![Documentation](https://img.shields.io/badge/docs-mkdocs-blue.svg)](https://json.nlohmann.me)
 [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/nlohmann/json/develop/LICENSE.MIT)
 [![GitHub Releases](https://img.shields.io/github/release/nlohmann/json.svg)](https://github.com/nlohmann/json/releases)
+[![Packaging status](https://repology.org/badge/tiny-repos/nlohmann-json.svg)](https://repology.org/project/nlohmann-json/versions)
 [![GitHub Downloads](https://img.shields.io/github/downloads/nlohmann/json/total)](https://github.com/nlohmann/json/releases)
 [![GitHub Issues](https://img.shields.io/github/issues/nlohmann/json.svg)](https://github.com/nlohmann/json/issues)
 [![Average time to resolve an issue](https://isitmaintained.com/badge/resolution/nlohmann/json.svg)](https://isitmaintained.com/project/nlohmann/json "Average time to resolve an issue")
@@ -596,13 +596,7 @@ foreach(SRC_FILE ${SRC_FILES})
    add_executable(single_${RELATIVE_SRC_FILE} EXCLUDE_FROM_ALL ${PROJECT_BINARY_DIR}/src_single/${RELATIVE_SRC_FILE}.cpp)
    target_include_directories(single_${RELATIVE_SRC_FILE} PRIVATE ${PROJECT_SOURCE_DIR}/include)
    target_compile_features(single_${RELATIVE_SRC_FILE} PRIVATE cxx_std_11)
-    if(RELATIVE_SRC_FILE STREQUAL "json" OR RELATIVE_SRC_FILE STREQUAL "json_literals")
-        # see below: report the diagnostics of json.hpp and json_literals.hpp without --error, so they
-        # do not fail the build
-        set_property(TARGET single_${RELATIVE_SRC_FILE} PROPERTY CXX_INCLUDE_WHAT_YOU_USE ${IWYU_TOOL} -Xiwyu --max_line_length=300)
-    else()
-        set_property(TARGET single_${RELATIVE_SRC_FILE} PROPERTY CXX_INCLUDE_WHAT_YOU_USE "${iwyu_path_and_options}")
-    endif()
+    set_property(TARGET single_${RELATIVE_SRC_FILE} PROPERTY CXX_INCLUDE_WHAT_YOU_USE "${iwyu_path_and_options}")
    # remember binary for ci_single_binaries
    list(APPEND single_binaries single_${RELATIVE_SRC_FILE})
    # json.hpp pulls together the whole library behind heavily templated, SFINAE-based code, and
@@ -612,10 +606,7 @@ foreach(SRC_FILE ${SRC_FILES})
    # reporting its diagnostics (informational, via CXX_INCLUDE_WHAT_YOU_USE above) but exclude it
    # from the hard gate below so a fresh IWYU/compiler combination does not fail this target on a
    # nondeterministic suggestion for a header that already re-exports everything on purpose.
-    # json_literals.hpp and json.hpp include each other on purpose (json.hpp includes it at its end
-    # unless JSON_NO_AUTOMATIC_UDLS is defined), and IWYU, not following the cycle, suggests replacing
-    # json.hpp with json_fwd.hpp although the literals need the complete basic_json; exclude it, too.
-    if(NOT RELATIVE_SRC_FILE STREQUAL "json" AND NOT RELATIVE_SRC_FILE STREQUAL "json_literals")
+    if(NOT RELATIVE_SRC_FILE STREQUAL "json")
        list(APPEND single_binaries_tus src_single/${RELATIVE_SRC_FILE}.cpp)
    endif()
 endforeach()
@@ -667,19 +658,14 @@ function(ci_get_cmake version var)
            OUTPUT ${${var}}
            COMMAND wget -nc https://github.com/Kitware/CMake/releases/download/v${version}/cmake-${version}-linux-x86_64.tar.gz
            COMMAND wget -nc https://github.com/Kitware/CMake/releases/download/v${version}/cmake-${version}-SHA-256.txt
-            # verify the archive against Kitware's published SHA-256 sums before unpacking it; old
-            # releases list the archive as "Linux-x86_64", so match case-insensitively and rewrite
-            # the name to the lowercase one the download was saved under
-            COMMAND sh -c "grep -i ' cmake-${version}-linux-x86_64[.]tar[.]gz$' cmake-${version}-SHA-256.txt | tr L l | sha256sum -c -"
-            # unpack into cmake-${version} directly, as the archive's top-level directory is spelled
-            # "Linux" in old releases and "linux" in newer ones
-            COMMAND ${CMAKE_COMMAND} -E rm -rf cmake-${version}
-            COMMAND ${CMAKE_COMMAND} -E make_directory cmake-${version}
-            COMMAND tar xfz cmake-${version}-linux-x86_64.tar.gz -C cmake-${version} --strip-components=1
+            # verify the archive against Kitware's published SHA-256 sums before unpacking it
+            COMMAND sh -c "grep ' cmake-${version}-linux-x86_64[.]tar[.]gz$' cmake-${version}-SHA-256.txt | sha256sum -c -"
+            COMMAND tar xfz cmake-${version}-linux-x86_64.tar.gz
            COMMAND rm cmake-${version}-linux-x86_64.tar.gz cmake-${version}-SHA-256.txt
+            COMMAND ${CMAKE_COMMAND} -E rm -rf cmake-${version}
+            COMMAND ${CMAKE_COMMAND} -E rename cmake-${version}-linux-x86_64 cmake-${version}
            WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
            COMMENT "Download prebuilt CMake ${version}"
-            VERBATIM
        )
    else()
        # no prebuilt archive for this platform (e.g. macOS or Linux aarch64): build from source
@@ -705,7 +691,7 @@ ci_get_cmake(4.0.0  CMAKE_4_0_0_BINARY)
 # the tests require CMake 3.13 or later, so they are excluded for CMake 3.5.0
 set(JSON_CMAKE_FLAGS_3_5_0 JSON_Diagnostics JSON_Diagnostic_Positions JSON_GlobalUDLs JSON_ImplicitConversions JSON_DisableEnumSerialization
    JSON_LegacyDiscardedValueComparison JSON_Install JSON_MultipleHeaders JSON_SystemInclude JSON_Valgrind
-    JSON_StrictNulHandling JSON_StrictBinaryUTF8)
+    JSON_StrictNulHandling)
 set(JSON_CMAKE_FLAGS_3_31_6 JSON_BuildTests ${JSON_CMAKE_FLAGS_3_5_0})
 set(JSON_CMAKE_FLAGS_4_0_0 JSON_BuildTests ${JSON_CMAKE_FLAGS_3_5_0})

@@ -905,12 +891,6 @@ add_custom_target(ci_test_build_documentation
    COMMENT "Build the documentation"
 )

-add_custom_target(ci_test_documentation_mermaid
-    COMMAND make check_mermaid
-    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}/docs/mkdocs
-    COMMENT "Check the Mermaid diagrams of the documentation"
-)
-
 ###############################################################################
 # Clean up all generated files.
 ###############################################################################
@@ -164,6 +164,7 @@ set(GCC_CXXFLAGS
    -Wenum-conversion
    -Wexceptions
    -Wexpansion-to-defined
+    -Wexperimental-fmv-target
    -Wexpose-global-module-tu-local
    -Wexternal-tu-local
    -Wextra
@@ -0,0 +1,42 @@
+# Imported target for installations made with Meson (see meson.build).
+#
+# CMake installations generate this file with install(EXPORT ...). Meson cannot
+# do that, but as the library is header-only, the target only needs an include
+# directory, the C++ standard, and the compile definitions of the options that
+# differ from their defaults. Paths are computed relative to this file so that
+# the installation can be relocated (e.g., into a sysroot), unless includedir or
+# datadir is outside the prefix.
+
+if(TARGET @PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@)
+    return()
+endif()
+
+get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_DIR}/@NLOHMANN_JSON_CONFIG_TO_PREFIX@" ABSOLUTE)
+# As in CMake's generated file: avoid "//include" for an installation to "/".
+if(_IMPORT_PREFIX STREQUAL "/")
+    set(_IMPORT_PREFIX "")
+endif()
+
+add_library(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ INTERFACE IMPORTED)
+set_target_properties(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
+    INTERFACE_INCLUDE_DIRECTORIES "@NLOHMANN_JSON_INCLUDE_DIR@"
+)
+if(CMAKE_VERSION VERSION_LESS 3.8)
+    set_target_properties(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
+        INTERFACE_COMPILE_FEATURES cxx_range_for
+    )
+else()
+    set_target_properties(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
+        INTERFACE_COMPILE_FEATURES cxx_std_11
+    )
+endif()
+
+set(_NLOHMANN_JSON_COMPILE_DEFINITIONS "@NLOHMANN_JSON_COMPILE_DEFINITIONS@")
+if(_NLOHMANN_JSON_COMPILE_DEFINITIONS)
+    set_target_properties(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
+        INTERFACE_COMPILE_DEFINITIONS "${_NLOHMANN_JSON_COMPILE_DEFINITIONS}"
+    )
+endif()
+
+unset(_NLOHMANN_JSON_COMPILE_DEFINITIONS)
+unset(_IMPORT_PREFIX)
@@ -4,4 +4,4 @@ includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
 Name: @PROJECT_NAME@
 Description: JSON for Modern C++
 Version: @PROJECT_VERSION@
-Cflags: -I${includedir}
+Cflags: -I${includedir}@NLOHMANN_JSON_PKGCONFIG_CFLAGS@
@@ -46,10 +46,9 @@ create_output: $(EXAMPLES:.cpp=.output)
 # check output of all stand-alone example files
 check_output: $(EXAMPLES:.cpp=.test)

-# check output of all stand-alone example files (exclude files whose output depends on the platform by nature:
-# library and compiler information, container size limits, and hash values)
+# check output of all stand-alone example files (exclude files with platform-dependent output.)
 # This target is used in the CI (ci_test_documentation).
-check_output_portable: $(filter-out mkdocs/docs/examples/meta.test mkdocs/docs/examples/max_size.test mkdocs/docs/examples/std_hash.test,$(EXAMPLES:.cpp=.test))
+check_output_portable: $(filter-out mkdocs/docs/examples/meta.test mkdocs/docs/examples/max_size.test mkdocs/docs/examples/std_hash.test mkdocs/docs/examples/basic_json__CompatibleType.test,$(EXAMPLES:.cpp=.test))

 clean:
 	rm -fr $(EXAMPLES:.cpp=)
@@ -10,16 +10,12 @@ INSERT INTO searchIndex(name, type, path) VALUES ('byte_container_with_subtype',
 INSERT INTO searchIndex(name, type, path) VALUES ('byte_container_with_subtype::byte_container_with_subtype', 'Constructor', 'api/byte_container_with_subtype/byte_container_with_subtype/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('byte_container_with_subtype::clear_subtype', 'Method', 'api/byte_container_with_subtype/clear_subtype/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('byte_container_with_subtype::has_subtype', 'Method', 'api/byte_container_with_subtype/has_subtype/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('byte_container_with_subtype::operator!=', 'Operator', 'api/byte_container_with_subtype/operator_ne/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('byte_container_with_subtype::operator==', 'Operator', 'api/byte_container_with_subtype/operator_eq/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('byte_container_with_subtype::set_subtype', 'Method', 'api/byte_container_with_subtype/set_subtype/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('byte_container_with_subtype::subtype', 'Method', 'api/byte_container_with_subtype/subtype/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json', 'Class', 'api/basic_json/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('format_as', 'Function', 'api/basic_json/format_as/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::accept', 'Function', 'api/basic_json/accept/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::array', 'Function', 'api/basic_json/array/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::array_t', 'Type', 'api/basic_json/array_t/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::as_base_class', 'Method', 'api/basic_json/as_base_class/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::at', 'Method', 'api/basic_json/at/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::back', 'Method', 'api/basic_json/back/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::basic_json', 'Constructor', 'api/basic_json/basic_json/index.html');
@@ -136,19 +132,15 @@ INSERT INTO searchIndex(name, type, path) VALUES ('json', 'Class', 'api/json/ind
 INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer', 'Class', 'api/json_pointer/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer::back', 'Method', 'api/json_pointer/back/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer::empty', 'Method', 'api/json_pointer/empty/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer::front', 'Method', 'api/json_pointer/front/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer::json_pointer', 'Constructor', 'api/json_pointer/json_pointer/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer::operator==', 'Operator', 'api/json_pointer/operator_eq/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer::operator!=', 'Operator', 'api/json_pointer/operator_ne/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer::operator/', 'Operator', 'api/json_pointer/operator_slash/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer::operator/=', 'Operator', 'api/json_pointer/operator_slasheq/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer::operator string_t', 'Operator', 'api/json_pointer/operator_string_t/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer::operator<=>', 'Operator', 'api/json_pointer/operator_spaceship/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer::parent_pointer', 'Method', 'api/json_pointer/parent_pointer/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer::pop_back', 'Method', 'api/json_pointer/pop_back/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer::pop_front', 'Method', 'api/json_pointer/pop_front/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer::push_back', 'Method', 'api/json_pointer/push_back/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer::push_front', 'Method', 'api/json_pointer/push_front/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer::string_t', 'Type', 'api/json_pointer/string_t/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer::to_string', 'Method', 'api/json_pointer/to_string/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_sax', 'Class', 'api/json_sax/index.html');
@@ -171,7 +163,6 @@ INSERT INTO searchIndex(name, type, path) VALUES ('operator<<', 'Operator', 'api
 INSERT INTO searchIndex(name, type, path) VALUES ('operator>>', 'Operator', 'api/operator_gtgt/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('ordered_json', 'Class', 'api/ordered_json/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('ordered_map', 'Class', 'api/ordered_map/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('std::formatter<basic_json>', 'Class', 'api/basic_json/std_formatter/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('std::hash<basic_json>', 'Class', 'api/basic_json/std_hash/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('std::swap<basic_json>', 'Function', 'api/basic_json/std_swap/index.html');

@@ -204,20 +195,17 @@ INSERT INTO searchIndex(name, type, path) VALUES ('nlohmann Namespace', 'Guide',
 INSERT INTO searchIndex(name, type, path) VALUES ('Types', 'Guide', 'features/types/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Types: Number Handling', 'Guide', 'features/types/number_handling/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Object Order', 'Guide', 'features/object_order/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('Performance', 'Guide', 'features/performance/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Parsing', 'Guide', 'features/parsing/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Parsing: JSON Lines', 'Guide', 'features/parsing/json_lines/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Parsing: Parser Callbacks', 'Guide', 'features/parsing/parser_callbacks/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Parsing: Parsing and Exceptions', 'Guide', 'features/parsing/parse_exceptions/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Parsing: SAX Interface', 'Guide', 'features/parsing/sax_interface/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('Parsing: Untrusted Input', 'Guide', 'features/parsing/untrusted_input/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Runtime Assertions', 'Guide', 'features/assertions/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Specializing enum conversion', 'Guide', 'features/enum_conversion/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Supported Macros', 'Guide', 'features/macros/index.html');

 -- Macros
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_ASSERT', 'Macro', 'api/macros/json_assert/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('JSON_BRACE_INIT_COPY_SEMANTICS', 'Macro', 'api/macros/json_brace_init_copy_semantics/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_CATCH_USER', 'Macro', 'api/macros/json_throw_user/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DIAGNOSTICS', 'Macro', 'api/macros/json_diagnostics/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DIAGNOSTIC_POSITIONS', 'Macro', 'api/macros/json_diagnostic_positions/index.html');
@@ -227,60 +215,34 @@ INSERT INTO searchIndex(name, type, path) VALUES ('JSON_HAS_CPP_11', 'Macro', 'a
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_HAS_CPP_14', 'Macro', 'api/macros/json_has_cpp_11/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_HAS_CPP_17', 'Macro', 'api/macros/json_has_cpp_11/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_HAS_CPP_20', 'Macro', 'api/macros/json_has_cpp_11/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('JSON_HAS_CPP_23', 'Macro', 'api/macros/json_has_cpp_11/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('JSON_HAS_CPP_26', 'Macro', 'api/macros/json_has_cpp_11/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_HAS_EXPERIMENTAL_FILESYSTEM', 'Macro', 'api/macros/json_has_filesystem/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_HAS_FILESYSTEM', 'Macro', 'api/macros/json_has_filesystem/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_HAS_RANGES', 'Macro', 'api/macros/json_has_ranges/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_HAS_STATIC_RTTI', 'Macro', 'api/macros/json_has_static_rtti/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('JSON_HAS_STD_FORMAT', 'Macro', 'api/macros/json_has_std_format/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_HAS_THREE_WAY_COMPARISON', 'Macro', 'api/macros/json_has_three_way_comparison/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_NOEXCEPTION', 'Macro', 'api/macros/json_noexception/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('JSON_NO_AUTOMATIC_UDLS', 'Macro', 'api/macros/json_no_automatic_udls/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_NO_IO', 'Macro', 'api/macros/json_no_io/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('JSON_NO_THREAD_LOCAL', 'Macro', 'api/macros/json_no_thread_local/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('JSON_PRECISE_STREAM_POSITION', 'Macro', 'api/macros/json_precise_stream_position/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_SKIP_LIBRARY_VERSION_CHECK', 'Macro', 'api/macros/json_skip_library_version_check/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_SKIP_UNSUPPORTED_COMPILER_CHECK', 'Macro', 'api/macros/json_skip_unsupported_compiler_check/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('JSON_STRICT_BINARY_UTF8', 'Macro', 'api/macros/json_strict_binary_utf8/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('JSON_STRICT_NUL_HANDLING', 'Macro', 'api/macros/json_strict_nul_handling/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_THROW_USER', 'Macro', 'api/macros/json_throw_user/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_TRY_USER', 'Macro', 'api/macros/json_throw_user/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_GLOBAL_UDLS', 'Macro', 'api/macros/json_use_global_udls/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_IMPLICIT_CONVERSIONS', 'Macro', 'api/macros/json_use_implicit_conversions/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON', 'Macro', 'api/macros/json_use_legacy_discarded_value_comparison/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_SIMDUTF', 'Macro', 'api/macros/json_use_simdutf/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Macros', 'Macro', 'api/macros/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE', 'Macro', 'api/macros/nlohmann_define_derived_type/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE', 'Macro', 'api/macros/nlohmann_define_derived_type/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE_WITH_NAMES', 'Macro', 'api/macros/nlohmann_define_type_with_names/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT', 'Macro', 'api/macros/nlohmann_define_derived_type/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT_WITH_NAMES', 'Macro', 'api/macros/nlohmann_define_type_with_names/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_NAMES', 'Macro', 'api/macros/nlohmann_define_type_with_names/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE', 'Macro', 'api/macros/nlohmann_define_derived_type/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE', 'Macro', 'api/macros/nlohmann_define_derived_type/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_WITH_NAMES', 'Macro', 'api/macros/nlohmann_define_type_with_names/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT', 'Macro', 'api/macros/nlohmann_define_derived_type/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT_WITH_NAMES', 'Macro', 'api/macros/nlohmann_define_type_with_names/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_NAMES', 'Macro', 'api/macros/nlohmann_define_type_with_names/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_TYPE_INTRUSIVE', 'Macro', 'api/macros/nlohmann_define_type_intrusive/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE', 'Macro', 'api/macros/nlohmann_define_type_intrusive/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE_WITH_NAMES', 'Macro', 'api/macros/nlohmann_define_type_with_names/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT', 'Macro', 'api/macros/nlohmann_define_type_intrusive/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT_WITH_NAMES', 'Macro', 'api/macros/nlohmann_define_type_with_names/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_NAMES', 'Macro', 'api/macros/nlohmann_define_type_with_names/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE', 'Macro', 'api/macros/nlohmann_define_type_non_intrusive/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE', 'Macro', 'api/macros/nlohmann_define_type_non_intrusive/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_WITH_NAMES', 'Macro', 'api/macros/nlohmann_define_type_with_names/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT', 'Macro', 'api/macros/nlohmann_define_type_non_intrusive/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT_WITH_NAMES', 'Macro', 'api/macros/nlohmann_define_type_with_names/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_NAMES', 'Macro', 'api/macros/nlohmann_define_type_with_names/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_JSON_NAMESPACE', 'Macro', 'api/macros/nlohmann_json_namespace/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_JSON_NAMESPACE_BEGIN', 'Macro', 'api/macros/nlohmann_json_namespace_begin/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_JSON_NAMESPACE_END', 'Macro', 'api/macros/nlohmann_json_namespace_begin/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_JSON_NAMESPACE_NO_VERSION', 'Macro', 'api/macros/nlohmann_json_namespace_no_version/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_JSON_SERIALIZE_ENUM', 'Macro', 'api/macros/nlohmann_json_serialize_enum/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_JSON_SERIALIZE_ENUM_STRICT', 'Macro', 'api/macros/nlohmann_json_serialize_enum_strict/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_JSON_VERSION_MAJOR', 'Macro', 'api/macros/nlohmann_json_version_major/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_JSON_VERSION_MINOR', 'Macro', 'api/macros/nlohmann_json_version_major/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_JSON_VERSION_PATCH', 'Macro', 'api/macros/nlohmann_json_version_major/index.html');
@@ -1,8 +1,3 @@
-# The MkDocs 2.0 banners of Material for MkDocs and ProperDocs (via mkdocs-redirects) are printed to stderr, not
-# logged, so they do not affect --strict; silence them anyway.
-export NO_MKDOCS_2_WARNING := true
-export DISABLE_MKDOCS_2_WARNING := true
-
 # serve the site locally
 serve: style_check
 	venv/bin/mkdocs serve
@@ -13,17 +8,11 @@ serve_dirty: style_check
 # This target is used in the CI (ci_test_build_documentation).
 # This target is used by the docset Makefile.
 build: style_check
-	venv/bin/mkdocs build --strict
+	venv/bin/mkdocs build

 style_check:
 	@cd docs ; ../venv/bin/python3 ../scripts/check_structure.py

-# check that all Mermaid diagrams parse (needs Node.js)
-# This target is used in the CI (ci_test_documentation_mermaid).
-check_mermaid:
-	npm ci --prefix scripts/mermaid --ignore-scripts --no-audit --no-fund
-	node scripts/mermaid/check_mermaid.mjs docs
-
 # check the links in the documentation files in docs/mkdocs
 link_check:
 	ENABLED_HTMLPROOFER=true venv/bin/mkdocs build
@@ -96,7 +96,7 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by

 ## Examples

-??? example "Example: (1) reading from a string"
+??? example

    The example below demonstrates the `accept()` function reading from a string.

@@ -110,21 +110,6 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
    --8<-- "examples/accept__string.output"
    ```

-??? example "Example: (2) reading from an iterator pair"
-
-    The example below demonstrates the `accept()` function reading from an iterator pair. Only the first call covers
-    exactly the JSON text; the second one also covers the trailing bytes and is therefore rejected.
-
-    ```cpp
-    --8<-- "examples/accept__iterator_pair.cpp"
-    ```
-
-    Output:
-
-    ```json
-    --8<-- "examples/accept__iterator_pair.output"
-    ```
-
 ## See also

 - [parse](parse.md) - deserialize from a compatible input
@@ -152,5 +137,3 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by

    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
    function.
-
-    See the [migration guide](../../integration/migration_guide.md#parsing) for how to update existing code.
@@ -25,7 +25,7 @@ To store objects in C++, a type is defined by the template parameters explained

 ## Notes

-### Default type
+#### Default type

 With the default values for `ArrayType` (`std::vector`) and `AllocatorType` (`std::allocator`), the default value for
 `array_t` is:
@@ -37,7 +37,7 @@ std::vector<
 >
 ```

-### Limits
+#### Limits

 [RFC 8259](https://tools.ietf.org/html/rfc8259) specifies:
 > An implementation may set limits on the maximum depth of nesting.
@@ -46,7 +46,7 @@ In this class, the array's limit of nesting is not explicitly constrained. Howev
 introduced by the compiler or runtime environment. A theoretical limit can be queried by calling the
 [`max_size`](max_size.md) function of a JSON array.

-### Storage
+#### Storage

 Arrays are stored as pointers in a `basic_json` type. That is, for any access to array values, a pointer of type
 `#!cpp array_t*` must be dereferenced.
@@ -67,13 +67,6 @@ Arrays are stored as pointers in a `basic_json` type. That is, for any access to
    --8<-- "examples/array_t.output"
    ```

-## See also
-
- [object_t](object_t.md) the type used to store JSON objects
- [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
- [max_size](max_size.md) returns the maximum possible number of elements
-
 ## Version history

 - Added in version 1.0.0.
@@ -1,53 +0,0 @@
-# <small>nlohmann::basic_json::</small>as_base_class
-
-```cpp
-json_base_class_t& as_base_class() noexcept;
-const json_base_class_t& as_base_class() const noexcept;
-```
-
-Returns a reference to this object as its custom base class [`json_base_class_t`](json_base_class_t.md). No copy is
-made.
-
-Since `basic_json` derives from `json_base_class_t`, a member of `basic_json` hides any member of the custom base class
-with the same name. This function makes such hidden members accessible again.
-
-## Return value
-
-reference to this object as [`json_base_class_t`](json_base_class_t.md)
-
-## Exception safety
-
-No-throw guarantee: this function never throws exceptions.
-
-## Complexity
-
-Constant.
-
-## Notes
-
-The function is equivalent to `static_cast<json_base_class_t&>(j)` (or `static_cast<const json_base_class_t&>(j)`).
-
-## Examples
-
-??? example
-
-    The example shows how to use `as_base_class` to access members of the custom base class that are hidden by members
-    of `basic_json`.
-    
-    ```cpp
-    --8<-- "examples/as_base_class.cpp"
-    ```
-    
-    Output:
-    
-    ```json
-    --8<-- "examples/as_base_class.output"
-    ```
-
-## See also
-
- [json_base_class_t](json_base_class_t.md) - type of the custom base class
-
-## Version history
-
- Added in version 3.13.0.
@@ -92,20 +92,6 @@ Strong exception safety: if an exception occurs, the original value stays intact
 3. Logarithmic in the size of the container.
 4. Logarithmic in the size of the container.

-## Notes
-
-!!! warning "Deprecation"
-
-    Overload (4) also accepts a [`json_pointer`](../json_pointer/index.md) whose template argument is a `basic_json`
-    specialization (e.g., `nlohmann::json_pointer<nlohmann::json>`) instead of a string type. This is deprecated since
-    version 3.11.0 and will be removed in a future major version; use `basic_json::json_pointer` (for `json`,
-    `nlohmann::json_pointer<std::string>`) instead.
-
-    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
-    function.
-
-    See the [migration guide](../../integration/migration_guide.md#json-pointers) for how to update existing code.
-
 ## Examples

 ??? example "Example: (1) access specified array element with bounds checking"
@@ -238,7 +224,5 @@ Strong exception safety: if an exception occurs, the original value stays intact

 1. Added in version 1.0.0.
 2. Added in version 1.0.0.
-3. Added in version 3.11.0. Fixed in version 3.13.0 to consistently accept `std::string_view`-convertible keys, as
-   already supported by [`operator[]`](operator[].md), [`value`](value.md), [`find`](find.md), and other lookup
-   functions.
+3. Added in version 3.11.0.
 4. Added in version 2.0.0.
@@ -99,25 +99,6 @@ basic_json(basic_json&& other) noexcept;
      elements of the pairs are treated as keys and the second elements are as values.
    3. In all other cases, an array is created.
    
-    The following flowchart also takes into account what happens when `type_deduction` is `#!cpp false`, in which case
-    `manual_type` decides between object and array, and an object can only be forced if `init` actually matches rule 2
-    (or is empty):
-
-    ```mermaid
-    flowchart TD
-        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 -->|"no"| D{"type_deduction"}
-        C -->|"true"| OBJ["create object"]
-        C -->|"false"| E{"manual_type"}
-        E -->|"object"| OBJ
-        E -->|"array"| ARR["create array"]
-        D -->|"true"| ARR
-        D -->|"false"| F{"manual_type"}
-        F -->|"array"| ARR
-        F -->|"object"| ERR["throw type_error.301"]
-    ```
-
    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.
@@ -190,8 +171,8 @@ basic_json(basic_json&& other) noexcept;
    - `BasicJsonType` has different template arguments than `basic_json_t`.
    
    **Note:** For cross-`basic_json` conversions to produce correct results, the target `basic_json`'s
-    [`object_t`](object_t.md)`::key_type` and [`string_t`](string_t.md) must be directly constructible from the source
-    `basic_json`'s corresponding types. See the description of overload (4) above for details on what happens when
+    `object_t::key_type` and `string_t` must be directly constructible from the source `basic_json`'s
+    corresponding types. See the description of overload (4) above for details on what happens when
    this requirement is not met.

 `U`:
@@ -293,15 +274,6 @@ basic_json(basic_json&& other) noexcept;
        When used without parentheses around an empty initializer list, `basic_json()` is called instead of this
        function, yielding the JSON `#!json null` value.

- Overload 4:
-
-    !!! info "Implicit conversion"
-
-        The conversion is implicit unless [`JSON_USE_IMPLICIT_CONVERSIONS`](../macros/json_use_implicit_conversions.md)
-        is defined to `0` and `BasicJsonType::string_t` differs from `string_t`. In that case, the constructor is
-        `explicit`, so a JSON value with a different string type is no longer silently converted, for example when it is
-        passed to a function taking `#!cpp const json&`. Write `#!cpp json(other)` or `#!cpp other.get<json>()` instead.
-
 - Overload 7:

    !!! info "Preconditions"
@@ -375,22 +347,6 @@ basic_json(basic_json&& other) noexcept;

    Note the output is platform-dependent.

-??? example "Example: (4) create a JSON value from another `basic_json` specialization"
-
-    The example below shows how a `json` value is converted to an `ordered_json` value and back using the converting
-    constructor. Note how the original insertion order of `oj` is not restored, because it was already given up when
-    converting to `json`, whose `object_t` sorts by key.
-
-    ```cpp
-    --8<-- "examples/basic_json__BasicJsonType.cpp"
-    ```
-
-    Output:
-
-    ```json
-    --8<-- "examples/basic_json__BasicJsonType.output"
-    ```
-
 ??? example "Example: (5) create a container (array or object) from an initializer list"

    The example below shows how JSON values are created from initializer lists.
@@ -461,22 +417,12 @@ basic_json(basic_json&& other) noexcept;
    --8<-- "examples/basic_json__moveconstructor.output"
    ```

-## See also
-
- [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
- [binary](binary.md) create a JSON binary array value
- [operator=](operator=.md) copy assignment operator
- [Creating JSON values](../../features/creating_values.md) - the article on creating JSON values
-
 ## Version history

 1. Since version 1.0.0.
 2. Since version 1.0.0.
 3. Since version 2.1.0.
-4. Since version 3.2.0. Explicit for different string types if `JSON_USE_IMPLICIT_CONVERSIONS` is `0` since
-   version 3.13.0.
+4. Since version 3.2.0.
 5. Since version 1.0.0.
 6. Since version 1.0.0.
 7. Since version 1.0.0. Fixed in version 3.13.0 to also check the iterator range for binary values; before, a range
@@ -37,14 +37,6 @@ Constant.
    --8<-- "examples/begin.output"
    ```

-## See also
-
- [end](end.md) returns an iterator to one past the last element
- [cbegin](cbegin.md) returns a const iterator to the first 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
- [Iterators](../../features/iterators.md) - the article on iterators
-
 ## Version history

 - Added in version 1.0.0.
@@ -7,9 +7,9 @@ static basic_json binary(typename binary_t::container_type&& init);

 // (2)
 static basic_json binary(const typename binary_t::container_type& init,
-                         typename binary_t::subtype_type subtype);
+                         std::uint8_t subtype);
 static basic_json binary(typename binary_t::container_type&& init,
-                         typename binary_t::subtype_type subtype);
+                         std::uint8_t subtype);
 ```

 1. Creates a JSON binary array value from a given binary container.
@@ -61,15 +61,6 @@ initialization of a binary array type, for backwards compatibility and so it doe
    --8<-- "examples/binary.output"
    ```

-## See also
-
- [binary_t](binary_t.md) type for binary values
- [get_binary](get_binary.md) get a reference to the stored binary value
- [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
- [Binary Values](../../features/binary_values.md) - the article on binary values
-
 ## Version history

 - Added in version 3.8.0.
- Changed the type of `subtype` from `std::uint8_t` to `binary_t::subtype_type` (`std::uint64_t`) in version 3.10.0.
@@ -48,16 +48,16 @@ represent a byte array in modern C++.

 ## Notes

-### Default type
+#### Default type

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

-### Supported byte types
+#### Supported byte types

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

-### Custom BinaryType behavior
+#### Custom BinaryType behavior

 When a custom `BinaryType` is configured (other than the default `#!cpp std::vector<std::uint8_t>`), you can assign
 values of that type directly to a `basic_json` instance, and they will automatically be recognized as binary values
@@ -89,12 +89,12 @@ assert(extracted == data);
 This automatic type detection is a convenience feature that only applies to custom (non-default) `BinaryType` configurations.
 The default `nlohmann::json` continues to treat `#!cpp std::vector<std::uint8_t>` as arrays for backward compatibility.

-### Storage
+#### Storage

 Binary Arrays are stored as pointers in a `basic_json` type. That is, for any access to array values, a pointer of the
 type `#!cpp binary_t*` must be dereferenced.

-### Notes on subtypes
+#### Notes on subtypes

 - CBOR
    - Binary values are represented as byte strings. Subtypes are written as tags.
@@ -21,11 +21,11 @@ To store boolean values in C++, a type is defined by the template parameter  `Bo

 ## Notes

-### Default type
+#### Default type

 With the default values for `BooleanType` (`#!cpp bool`), the default value for `boolean_t` is `#!cpp bool`.

-### Storage
+#### Storage

 Boolean values are stored directly inside a `basic_json` type.

@@ -45,10 +45,6 @@ Boolean values are stored directly inside a `basic_json` type.
    --8<-- "examples/boolean_t.output"
    ```

-## See also
-
- [is_boolean](is_boolean.md) checks whether the JSON value is a boolean
-
 ## Version history

 - Added in version 1.0.0.
@@ -36,13 +36,6 @@ Constant.
    --8<-- "examples/cbegin.output"
    ```

-## See also
-
- [begin](begin.md) returns an iterator to the first 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
- [Iterators](../../features/iterators.md) - the article on iterators
-
 ## Version history

 - Added in version 1.0.0.
@@ -38,12 +38,6 @@ store
    --8<-- "examples/cbor_tag_handler_t.output"
    ```

-## See also
-
- [from_cbor](from_cbor.md) deserializes a JSON value from CBOR
- [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

 - Added in version 3.9.0. Added value `store` in 3.10.0.
@@ -36,13 +36,6 @@ Constant.
    --8<-- "examples/cend.output"
    ```

-## See also
-
- [end](end.md) returns an iterator to one past the last 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
- [Iterators](../../features/iterators.md) - the article on iterators
-
 ## Version history

 - Added in version 1.0.0.
@@ -52,11 +52,6 @@ All iterators, pointers, and references related to this container are invalidate
    --8<-- "examples/clear.output"
    ```

-## See also
-
- [erase](erase.md) removes elements from a JSON value
- [empty](empty.md) checks whether the JSON value has no elements
-
 ## Version history

 - Added in version 1.0.0.
@@ -67,18 +67,6 @@ Logarithmic in the size of the JSON object.

    If `#!cpp j.contains(x)` returns `#!c true` for a key or JSON pointer `x`, then it is safe to call `j[x]`.

-!!! warning "Deprecation"
-
-    Overload (3) also accepts a [`json_pointer`](../json_pointer/index.md) whose template argument is a `basic_json`
-    specialization (e.g., `nlohmann::json_pointer<nlohmann::json>`) instead of a string type. This is deprecated since
-    version 3.11.0 and will be removed in a future major version; use `basic_json::json_pointer` (for `json`,
-    `nlohmann::json_pointer<std::string>`) instead.
-
-    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
-    function.
-
-    See the [migration guide](../../integration/migration_guide.md#json-pointers) for how to update existing code.
-
 ## Examples

 ??? example "Example: (1) check with key"
@@ -131,9 +119,7 @@ Logarithmic in the size of the JSON object.
 ## 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. Fixed in
-   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.
+2. Added in version 3.6.0. Extended template `KeyType` to support comparable types in version 3.11.0.
 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.
@@ -84,8 +84,6 @@ Logarithmic in the size of the JSON object.
 ## Version history

 1. Added in version 3.11.0.
-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
-   consistently accept `std::string_view`-convertible keys, as already supported by [`operator[]`](operator[].md),
-   [`at`](at.md), [`value`](value.md), and other lookup functions.
+2. Added in version 1.0.0. Changed parameter `key` type to `KeyType&&` in version 3.11.0.
 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.
@@ -36,13 +36,6 @@ Constant.
    --8<-- "examples/crbegin.output"
    ```

-## See also
-
- [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
- [cbegin](cbegin.md) returns a const iterator to the first element
- [Iterators](../../features/iterators.md) - the article on iterators
-
 ## Version history

 - Added in version 1.0.0.
@@ -37,13 +37,6 @@ Constant.
    --8<-- "examples/crend.output"
    ```

-## See also
-
- [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
- [cend](cend.md) returns a const iterator to one past the last element
- [Iterators](../../features/iterators.md) - the article on iterators
-
 ## Version history

 - Added in version 1.0.0.
@@ -30,11 +30,6 @@ The actual comparator used depends on [`object_t`](object_t.md) and can be obtai
    --8<-- "examples/default_object_comparator_t.output"
    ```

-## See also
-
- [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
-
 ## Version history

 - Added in version 3.11.0.
@@ -25,12 +25,10 @@ and `ensure_ascii` parameters.
    result consists of ASCII characters only.

 `error_handler` (in)
-:   how to react on decoding errors; there are four possible values (see [`error_handler_t`](error_handler_t.md):
+:   how to react on decoding errors; there are three possible values (see [`error_handler_t`](error_handler_t.md):
    `strict` (throws an exception in case a decoding error occurs; default), `replace` (replace invalid UTF-8 sequences
-    with U+FFFD), `ignore` (ignore invalid UTF-8 sequences during serialization; all valid bytes are copied to the
-    output unchanged, and invalid bytes are dropped), and `keep` (write the ill-formed bytes to the output as is,
-    without escaping them, even if `ensure_ascii` is `#!cpp true`; the result is then not valid UTF-8, but equals the
-    input bytes exactly, and well-formed characters around the ill-formed bytes are still escaped as usual)).
+    with U+FFFD), and `ignore` (ignore invalid UTF-8 sequences during serialization; all valid bytes are copied to the
+    output unchanged, and invalid bytes are dropped)).
    
 ## Return value

@@ -96,4 +94,3 @@ Binary values are serialized as an object containing two keys:
 - Indentation character `indent_char`, option `ensure_ascii` and exceptions added in version 3.0.0.
 - Error handlers added in version 3.4.0.
 - Serialization of binary values added in version 3.8.0.
- Error handler `keep` added in version 3.13.0.
@@ -31,8 +31,7 @@ a `#!cpp bool` denoting whether the insertion took place.

 ## Exception safety

-Strong guarantee: if an exception is thrown, there are no changes to any JSON value. As an exception, a `#!json null`
-value is converted to an empty object before the element is added and keeps that type if adding the element throws.
+Strong guarantee: if an exception is thrown, there are no changes to any JSON value.

 ## Exceptions

@@ -70,5 +69,3 @@ Logarithmic in the size of the container, O(log(`size()`)).
 ## Version history

 - 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`.
@@ -28,11 +28,6 @@ iterator is invalidated.

 reference to the inserted element

-## Exception safety
-
-Strong guarantee: if an exception is thrown, there are no changes to any JSON value. As an exception, a `#!json null`
-value is converted to an empty array before the element is added and keeps that type if adding the element throws.
-
 ## Exceptions

 Throws [`type_error.311`](../../home/exceptions.md#jsonexceptiontype_error311) when called on a type other than JSON
@@ -60,11 +60,6 @@ itself is empty which is `#!cpp false` in the case of a string.
    --8<-- "examples/empty.output"
    ```

-## See also
-
- [size](size.md) returns the number of elements
- [clear](clear.md) clears the content and resets the value to the default value
-
 ## Version history

 - Added in version 1.0.0.
@@ -37,13 +37,6 @@ Constant.
    --8<-- "examples/end.output"
    ```

-## See also
-
- [begin](begin.md) returns an iterator to the first 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
- [Iterators](../../features/iterators.md) - the article on iterators
-
 ## Version history

 - Added in version 1.0.0.
@@ -213,7 +213,5 @@ 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. Fixed in 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.
+4. Added in version 3.11.0.
 5. Added in version 1.0.0.
@@ -4,31 +4,15 @@
 enum class error_handler_t {
    strict,
    replace,
-    ignore,
-    keep
+    ignore
 };
 ```

-This enumeration is used to choose how to treat ill-formed UTF-8 in a string value or object key:
-
- [`dump`](dump.md) uses it while serializing a `basic_json` value to text.
- [`to_cbor`](to_cbor.md), [`to_msgpack`](to_msgpack.md), [`to_ubjson`](to_ubjson.md), [`to_bjdata`](to_bjdata.md),
-  and [`to_bson`](to_bson.md) use it while serializing a `basic_json` value to that binary format. Their default is
-  `keep`, as no binary writer checked before this parameter was added. CBOR, UBJSON, BJData, and BSON require valid
-  UTF-8, so for these four the default is `strict` if [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md)
-  is enabled; MessagePack's specification explicitly allows a string to contain ill-formed UTF-8, so `to_msgpack`
-  stays at `keep`. `to_bon8` does not take this parameter: BON8 always validates, since UTF-8 lead bytes are
-  structural to that format.
- [`from_cbor`](from_cbor.md), [`from_msgpack`](from_msgpack.md), [`from_ubjson`](from_ubjson.md),
-  [`from_bjdata`](from_bjdata.md), and [`from_bson`](from_bson.md) use it while parsing that binary format, to decide
-  whether to check a string value or object key for well-formed UTF-8 at all; by default (`keep`) they do not, as no
-  binary reader did before this parameter was added. `from_bon8` does not take this parameter, for the same reason
-  `to_bon8` does not.
-
-Four values are differentiated:
+This enumeration is used in the [`dump`](dump.md) function to choose how to treat decoding errors while serializing a
+`basic_json` value. Three values are differentiated:

 strict
-:   throw a `type_error`/`parse_error` exception in case of invalid UTF-8
+:   throw a `type_error` exception in case of invalid UTF-8

 replace
 :   replace invalid UTF-8 sequences with U+FFFD (� REPLACEMENT CHARACTER)
@@ -36,12 +20,6 @@ replace
 ignore
 :   ignore invalid UTF-8 sequences; all valid bytes are copied to the output unchanged, and invalid bytes are dropped

-keep
-:   keep invalid UTF-8 sequences unchanged; only meaningful for the binary formats mentioned above, since [`dump`]
-    (dump.md) itself must produce text, and `keep` there writes the ill-formed bytes to the output as is, so the
-    result is then not valid UTF-8 (but still equals the input bytes exactly, including around any well-formed
-    characters, which are still escaped as usual)
-
 ## Examples

 ??? example
@@ -59,13 +37,6 @@ keep
    --8<-- "examples/error_handler_t.output"
    ```

-## See also
-
- [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

 - Added in version 3.4.0.
- Added `keep`, and made this enumeration apply to the binary readers and writers in addition to `dump`, in version
-  3.13.0.
@@ -88,8 +88,6 @@ Logarithmic in the size of the JSON object.
 ## 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. Fixed in 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.
+2. Added in version 1.0.0. Changed to support comparable types in version 3.11.0.
 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.
@@ -27,7 +27,7 @@ Empty objects and arrays are flattened to `#!json null` and will not be reconstr

 ## Examples

-??? example "Example: flatten a JSON object"
+??? example

    The following code shows how a JSON object is flattened to an object whose keys consist of JSON pointers.
    
@@ -41,21 +41,6 @@ Empty objects and arrays are flattened to `#!json null` and will not be reconstr
    --8<-- "examples/flatten.output"
    ```

-??? example "Example: empty objects and arrays are flattened to `#!json null`"
-
-    The following code shows that an empty object and an empty array are both flattened to `#!json null`, and that
-    `unflatten()` restores them as `#!json null` rather than as empty containers.
-
-    ```cpp
-    --8<-- "examples/flatten__empty.cpp"
-    ```
-
-    Output:
-
-    ```json
-    --8<-- "examples/flatten__empty.output"
-    ```
-
 ## See also

 - [unflatten](unflatten.md) the reverse function
@@ -5,14 +5,12 @@
 template<typename InputType>
 static basic_json from_bjdata(InputType&& i,
                              const bool strict = true,
-                              const bool allow_exceptions = true,
-                              const error_handler_t error_handler = error_handler_t::keep);
+                              const bool allow_exceptions = true);
 // (2)
 template<typename IteratorType, typename SentinelType = IteratorType>
 static basic_json from_bjdata(IteratorType first, SentinelType last,
                              const bool strict = true,
-                              const bool allow_exceptions = true,
-                              const error_handler_t error_handler = error_handler_t::keep);
+                              const bool allow_exceptions = true);
 ```

 Deserializes a given input to a JSON value using the BJData (Binary JData) serialization format.
@@ -60,12 +58,6 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 `allow_exceptions` (in)
 :   whether to throw exceptions in case of a parse error (optional, `#!cpp true` by default)

-`error_handler` (in)
-:   how to treat a string value or object key that is not valid UTF-8; see [`error_handler_t`](error_handler_t.md).
-    BJData does not require a decoder to reject ill-formed UTF-8, so checking is opt-in: the default, `keep`, does not
-    check at all, as every binary reader did before this parameter was added; `strict` checks and throws;
-    `replace`/`ignore` sanitize the string the same way [`dump`](dump.md) would
-
 ## Return value

 deserialized JSON value; in case of a parse error and `allow_exceptions` set to `#!cpp false`, the return value will be
@@ -81,7 +73,7 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
  the end of the file was not reached when `strict` was set to true
 - 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`
+  successfully
 - Throws [out_of_range.408](../../home/exceptions.md#jsonexceptionout_of_range408) if the size of an optimized container
  or n-dimensional array cannot be represented by `std::size_t`

@@ -119,4 +111,3 @@ Linear in the size of the input.
 - Added in version 3.11.0.
 - Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.
 - Extended overload (2) to accept heterogeneous iterator+sentinel pairs (C++20 ranges support) in version 3.13.0.
- Added `error_handler` parameter in version 3.13.0.
@@ -5,14 +5,12 @@
 template<typename InputType>
 static basic_json from_bson(InputType&& i,
                            const bool strict = true,
-                            const bool allow_exceptions = true,
-                            const error_handler_t error_handler = error_handler_t::keep);
+                            const bool allow_exceptions = true);
 // (2)
 template<typename IteratorType, typename SentinelType = IteratorType>
 static basic_json from_bson(IteratorType first, SentinelType last,
                            const bool strict = true,
-                            const bool allow_exceptions = true,
-                            const error_handler_t error_handler = error_handler_t::keep);
+                            const bool allow_exceptions = true);
 ```

 Deserializes a given input to a JSON value using the BSON (Binary JSON) serialization format.
@@ -60,12 +58,6 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 `allow_exceptions` (in)
 :   whether to throw exceptions in case of a parse error (optional, `#!cpp true` by default)

-`error_handler` (in)
-:   how to treat a string value or object key that is not valid UTF-8; see [`error_handler_t`](error_handler_t.md).
-    BSON does not require a decoder to reject ill-formed UTF-8, so checking is opt-in: the default, `keep`, does not
-    check at all, as every binary reader did before this parameter was added; `strict` checks and throws;
-    `replace`/`ignore` sanitize the string the same way [`dump`](dump.md) would
-
 ## Return value

 deserialized JSON value; in case of a parse error and `allow_exceptions` set to `#!cpp false`, the return value will be
@@ -83,8 +75,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
  invalid string or byte array length)
 - 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
-  not valid UTF-8 and `error_handler` is `strict`

 ## Complexity

@@ -121,7 +111,6 @@ Linear in the size of the input.
 - Added in version 3.4.0.
 - Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.
 - Extended overload (2) to accept heterogeneous iterator+sentinel pairs (C++20 ranges support) in version 3.13.0.
- Added `error_handler` parameter in version 3.13.0.

 !!! warning "Deprecation"

@@ -134,5 +123,3 @@ Linear in the size of the input.

    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
    function.
-
-    See the [migration guide](../../integration/migration_guide.md#parsing) for how to update existing code.
@@ -6,16 +6,14 @@ template<typename InputType>
 static basic_json from_cbor(InputType&& i,
                            const bool strict = true,
                            const bool allow_exceptions = true,
-                            const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error,
-                            const error_handler_t error_handler = error_handler_t::keep);
+                            const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error);

 // (2)
 template<typename IteratorType, typename SentinelType = IteratorType>
 static basic_json from_cbor(IteratorType first, SentinelType last,
                            const bool strict = true,
                            const bool allow_exceptions = true,
-                            const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error,
-                            const error_handler_t error_handler = error_handler_t::keep);
+                            const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error);
 ```

 Deserializes a given input to a JSON value using the CBOR (Concise Binary Object Representation) serialization format.
@@ -67,12 +65,6 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 :   how to treat CBOR tags (optional, `error` by default); see [`cbor_tag_handler_t`](cbor_tag_handler_t.md) for more
    information

-`error_handler` (in)
-:   how to treat a string value or object key that is not valid UTF-8; see [`error_handler_t`](error_handler_t.md).
-    CBOR does not require a decoder to reject ill-formed UTF-8, so checking is opt-in: the default, `keep`, does not
-    check at all, as every binary reader did before this parameter was added; `strict` checks and throws;
-    `replace`/`ignore` sanitize the string the same way [`dump`](dump.md) would
-
 ## Return value

 deserialized JSON value; in case of a parse error and `allow_exceptions` set to `#!cpp false`, the return value will be
@@ -88,9 +80,8 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
  the end of the file was not reached when `strict` was set to true
 - 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), or if a string value or object key is not
-  valid UTF-8 and `error_handler` is `strict`
+- 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) or a string is malformed

 ## Complexity

@@ -130,7 +121,6 @@ Linear in the size of the input.
 - Added `tag_handler` parameter in version 3.9.0.
 - Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.
 - Extended overload (2) to accept heterogeneous iterator+sentinel pairs (C++20 ranges support) in version 3.13.0.
- Added `error_handler` parameter in version 3.13.0.

 !!! warning "Deprecation"

@@ -143,5 +133,3 @@ Linear in the size of the input.

    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
    function.
-
-    See the [migration guide](../../integration/migration_guide.md#parsing) for how to update existing code.
@@ -5,14 +5,12 @@
 template<typename InputType>
 static basic_json from_msgpack(InputType&& i,
                               const bool strict = true,
-                               const bool allow_exceptions = true,
-                               const error_handler_t error_handler = error_handler_t::keep);
+                               const bool allow_exceptions = true);
 // (2)
 template<typename IteratorType, typename SentinelType = IteratorType>
 static basic_json from_msgpack(IteratorType first, SentinelType last,
                               const bool strict = true,
-                               const bool allow_exceptions = true,
-                               const error_handler_t error_handler = error_handler_t::keep);
+                               const bool allow_exceptions = true);
 ```

 Deserializes a given input to a JSON value using the MessagePack serialization format.
@@ -60,12 +58,6 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 `allow_exceptions` (in)
 :   whether to throw exceptions in case of a parse error (optional, `#!cpp true` by default)

-`error_handler` (in)
-:   how to treat a string value or object key that is not valid UTF-8; see [`error_handler_t`](error_handler_t.md).
-    MessagePack's specification explicitly allows ill-formed UTF-8, so checking is opt-in: the default, `keep`, does
-    not check at all, as every binary reader did before this parameter was added; `strict` checks and throws;
-    `replace`/`ignore` sanitize the string the same way [`dump`](dump.md) would
-
 ## Return value

 deserialized JSON value; in case of a parse error and `allow_exceptions` set to `#!cpp false`, the return value will be
@@ -81,9 +73,8 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
  the end of the file was not reached when `strict` was set to true
 - Throws [parse_error.112](../../home/exceptions.md#jsonexceptionparse_error112) if unsupported features from
  MessagePack were used in the given input or if the input is not valid MessagePack
- 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), or if a string value or object key is not
-  valid UTF-8 and `error_handler` is `strict`
+- 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) or a string is malformed

 ## Complexity

@@ -122,7 +113,6 @@ Linear in the size of the input.
 - Added `allow_exceptions` parameter in version 3.2.0.
 - Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.
 - Extended overload (2) to accept heterogeneous iterator+sentinel pairs (C++20 ranges support) in version 3.13.0.
- Added `error_handler` parameter in version 3.13.0.

 !!! warning "Deprecation"

@@ -135,5 +125,3 @@ Linear in the size of the input.

    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
    function.
-
-    See the [migration guide](../../integration/migration_guide.md#parsing) for how to update existing code.
@@ -5,14 +5,12 @@
 template<typename InputType>
 static basic_json from_ubjson(InputType&& i,
                              const bool strict = true,
-                              const bool allow_exceptions = true,
-                              const error_handler_t error_handler = error_handler_t::keep);
+                              const bool allow_exceptions = true);
 // (2)
 template<typename IteratorType, typename SentinelType = IteratorType>
 static basic_json from_ubjson(IteratorType first, SentinelType last,
                              const bool strict = true,
-                              const bool allow_exceptions = true,
-                              const error_handler_t error_handler = error_handler_t::keep);
+                              const bool allow_exceptions = true);
 ```

 Deserializes a given input to a JSON value using the UBJSON (Universal Binary JSON) serialization format.
@@ -60,12 +58,6 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 `allow_exceptions` (in)
 :   whether to throw exceptions in case of a parse error (optional, `#!cpp true` by default)

-`error_handler` (in)
-:   how to treat a string value or object key that is not valid UTF-8; see [`error_handler_t`](error_handler_t.md).
-    UBJSON does not require a decoder to reject ill-formed UTF-8, so checking is opt-in: the default, `keep`, does not
-    check at all, as every binary reader did before this parameter was added; `strict` checks and throws;
-    `replace`/`ignore` sanitize the string the same way [`dump`](dump.md) would
-
 ## Return value

 deserialized JSON value; in case of a parse error and `allow_exceptions` set to `#!cpp false`, the return value will be
@@ -81,7 +73,7 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
  the end of the file was not reached when `strict` was set to true
 - 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`
+  successfully
 - Throws [out_of_range.408](../../home/exceptions.md#jsonexceptionout_of_range408) if the size of an optimized container
  or n-dimensional array cannot be represented by `std::size_t`

@@ -120,7 +112,6 @@ Linear in the size of the input.
 - Added `allow_exceptions` parameter in version 3.2.0.
 - Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.
 - Extended overload (2) to accept heterogeneous iterator+sentinel pairs (C++20 ranges support) in version 3.13.0.
- Added `error_handler` parameter in version 3.13.0.

 !!! warning "Deprecation"

@@ -133,5 +124,3 @@ Linear in the size of the input.

    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
    function.
-
-    See the [migration guide](../../integration/migration_guide.md#parsing) for how to update existing code.
@@ -13,16 +13,16 @@ BasicJsonType get() const;

 // (3)
 template<typename PointerType>
-PointerType get() noexcept;
+PointerType get_ptr();

 template<typename PointerType>
-const PointerType get() const noexcept;  // constexpr since C++14
+constexpr const PointerType get_ptr() const noexcept;
 ```

 1. Explicit type conversion between the JSON value and a compatible value which is
   [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible) and
   [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible). The value is converted by
-   calling the [`json_serializer<ValueType>`](json_serializer.md) `from_json()` method.
+   calling the `json_serializer<ValueType>` `from_json()` method.
   
    The function is equivalent to executing
    ```cpp
@@ -84,12 +84,6 @@ const PointerType get() const noexcept;  // constexpr since C++14
 3. pointer to the internally stored JSON value if the requested pointer type fits to the JSON value; `#!cpp nullptr`
   otherwise

-## Exception safety
-
-Depends on what `json_serializer<ValueType>` `from_json()` method throws for overloads (1) and (2); the JSON value
-itself is never modified, since `get()` is a `#!cpp const` member function. No-throw guarantee for overload (3): this
-function never throws exceptions.
-
 ## Exceptions

 Depends on what `json_serializer<ValueType>` `from_json()` method throws
@@ -129,13 +123,13 @@ overload (3).

 ## Examples

-??? example "Example: (1) explicit conversion to compatible types"
+??? example

    The example below shows several conversions from JSON values
    to other types. There a few things to note: (1) Floating-point numbers can
    be converted to integers, (2) A JSON array can be converted to a standard
    `std::vector<short>`, (3) A JSON object can be converted to C++
-    associative containers such as `std::map<std::string, json>`.
+    associative containers such as `std::unordered_map<std::string, json>`.
        
    ```cpp
    --8<-- "examples/get__ValueType_const.cpp"
@@ -147,21 +141,7 @@ overload (3).
    --8<-- "examples/get__ValueType_const.output"
    ```

-??? example "Example: (2) explicit conversion to another `basic_json` specialization"
-
-    The example below shows how a `json` value is converted to an `ordered_json` value using `get<BasicJsonType>()`.
-
-    ```cpp
-    --8<-- "examples/get__BasicJsonType.cpp"
-    ```
-
-    Output:
-
-    ```json
-    --8<-- "examples/get__BasicJsonType.output"
-    ```
-
-??? example "Example: (3) explicit pointer access to the stored value"
+??? example

    The example below shows how pointers to internal values of a JSON value can be requested. Note that no type
    conversions are made and a `#cpp nullptr` is returned if the value and the requested pointer type does not match.
@@ -10,14 +10,6 @@ Returns the allocator associated with the container.

 associated allocator

-## Exception safety
-
-Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
-
-## Complexity
-
-Constant.
-
 ## Examples

 ??? example
@@ -34,11 +26,6 @@ Constant.
    --8<-- "examples/get_allocator.output"
    ```

-## See also
-
- [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

 - Added in version 1.0.0.
@@ -8,7 +8,7 @@ ValueType& get_to(ValueType& v) const noexcept(
 ```

 Explicit type conversion between the JSON value and a compatible value. The value is filled into the input parameter by
-calling the [`json_serializer<ValueType>`](json_serializer.md) `from_json()` method.
+calling the `json_serializer<ValueType>` `from_json()` method.

 The function is equivalent to executing
 ```cpp
@@ -34,11 +34,6 @@ the compiler reports that no matching `get_to` was found.

 the input parameter, allowing chaining calls

-## Exception safety
-
-Depends on what `json_serializer<ValueType>` `from_json()` method throws; the JSON value itself is never modified,
-since `get_to()` is a `#!cpp const` member function.
-
 ## Exceptions

 Depends on what `json_serializer<ValueType>` `from_json()` method throws
@@ -54,7 +49,7 @@ Depends on the `json_serializer<ValueType>::from_json()` implementation.
    The example below shows several conversions from JSON values to other types. There a few things to note: (1)
    Floating-point numbers can be converted to integers, (2) A JSON array can be converted to a standard
    `#!cpp std::vector<short>`, (3) A JSON object can be converted to C++ associative containers such as
-    `#!cpp std::map<std::string, json>`.
+    `#cpp std::unordered_map<std::string, json>`.
        
    ```cpp
    --8<-- "examples/get_to.cpp"
@@ -200,7 +200,6 @@ Direct access to the stored value of a JSON value.
 - [**get_ref**](get_ref.md) - get a reference 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

 ### Element access

@@ -51,11 +51,6 @@ bon8
    --8<-- "examples/sax_parse__binary.output"
    ```

-## See also
-
- [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
-
 ## Version history

 - Added in version 3.2.0.
@@ -109,11 +109,11 @@ Strong exception safety: if an exception occurs, the original value stays intact
 2. Linear in `cnt` plus linear in the distance between `pos` and end of the container.
 3. Linear in `#!cpp std::distance(first, last)` plus linear in the distance between `pos` and end of the container.
 4. Linear in `ilist.size()` plus linear in the distance between `pos` and end of the container.
-5. `O(N*log(size() + N))`, where `N` is the number of elements to insert.
+5. Logarithmic: `O(N*log(size() + N))`, where `N` is the number of elements to insert.

 ## Examples

-??? example "Example: (1) insert element into array"
+??? example "Example (1): insert element into array"

    The example shows how `insert()` is used.
    
@@ -127,7 +127,7 @@ Strong exception safety: if an exception occurs, the original value stays intact
    --8<-- "examples/insert.output"
    ```

-??? example "Example: (2) insert copies of element into array"
+??? example "Example (2): insert copies of element into array"

    The example shows how `insert()` is used.
    
@@ -141,7 +141,7 @@ Strong exception safety: if an exception occurs, the original value stays intact
    --8<-- "examples/insert__count.output"
    ```

-??? example "Example: (3) insert a range of elements into an array"
+??? example "Example (3): insert a range of elements into an array"

    The example shows how `insert()` is used.
    
@@ -155,7 +155,7 @@ Strong exception safety: if an exception occurs, the original value stays intact
    --8<-- "examples/insert__range.output"
    ```

-??? example "Example: (4) insert elements from an initializer list into an array"
+??? example "Example (4): insert elements from an initializer list into an array"

    The example shows how `insert()` is used.
    
@@ -169,7 +169,7 @@ Strong exception safety: if an exception occurs, the original value stays intact
    --8<-- "examples/insert__ilist.output"
    ```

-??? example "Example: (5) insert a range of elements into an object"
+??? example "Example (5): insert a range of elements into an object"

    The example shows how `insert()` is used.
    
@@ -34,13 +34,6 @@ Constant.
    --8<-- "examples/is_array.output"
    ```

-## See also
-
- [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)
- [type](type.md) returns the type of the JSON value
- [array_t](array_t.md) the type used to store JSON arrays
-
 ## Version history

 - Added in version 1.0.0.
@@ -34,12 +34,6 @@ Constant.
    --8<-- "examples/is_binary.output"
    ```

-## See also
-
- [is_primitive](is_primitive.md) checks whether the JSON value is primitive
- [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
-
 ## Version history

 - Added in version 3.8.0.
@@ -34,11 +34,6 @@ Constant.
    --8<-- "examples/is_boolean.output"
    ```

-## See also
-
- [boolean_t](boolean_t.md) the type used to store JSON booleans
- [is_primitive](is_primitive.md) checks whether the JSON value is primitive
-
 ## Version history

 - Added in version 1.0.0.
@@ -55,7 +55,7 @@ with `allow_exceptions` set to `#!cpp false`: a parse error then yields a discar

 ## Examples

-??? example "Example: `is_discarded()` for ordinary JSON values"
+??? example

    The following code exemplifies `is_discarded()` for all JSON types.
    
@@ -69,22 +69,6 @@ with `allow_exceptions` set to `#!cpp false`: a parse error then yields a discar
    --8<-- "examples/is_discarded.output"
    ```

-??? example "Example: discarded values from parsing"
-
-    The following code shows the two situations in which a discarded value can be observed: parsing invalid JSON with
-    `allow_exceptions` set to `#!cpp false`, and a parser callback that discards the top-level value (which is replaced
-    by `#!json null` and therefore does *not* remain discarded).
-
-    ```cpp
-    --8<-- "examples/is_discarded__parse.cpp"
-    ```
-
-    Output:
-
-    ```json
-    --8<-- "examples/is_discarded__parse.output"
-    ```
-
 ## Version history

 - Added in version 1.0.0.
@@ -34,13 +34,6 @@ Constant.
    --8<-- "examples/is_null.output"
    ```

-## See also
-
- [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
- [type](type.md) returns the type of the JSON value
- [value_t](value_t.md) the enumeration of JSON types
-
 ## Version history

 - Added in version 1.0.0.
@@ -34,13 +34,6 @@ Constant.
    --8<-- "examples/is_object.output"
    ```

-## See also
-
- [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)
- [type](type.md) returns the type of the JSON value
- [object_t](object_t.md) the type used to store JSON objects
-
 ## Version history

 - Added in version 1.0.0.
@@ -34,12 +34,6 @@ Constant.
    --8<-- "examples/is_string.output"
    ```

-## See also
-
- [is_primitive](is_primitive.md) checks whether the JSON value is primitive
- [type](type.md) returns the type of the JSON value
- [string_t](string_t.md) the type used to store JSON strings
-
 ## Version history

 - Added in version 1.0.0.
@@ -114,5 +114,3 @@ When iterating over an array, `key()` will return the index of the element as st

    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
    function.
-
-    See the [migration guide](../../integration/migration_guide.md#miscellaneous-functions) for how to update existing code.
@@ -14,12 +14,12 @@ Examples of such functionality might be metadata, additional member functions (e

 ## Notes

-### Default type
+#### Default type

 The default value for `CustomBaseClass` is `void`. In this case, an
 [empty base class](https://en.cppreference.com/w/cpp/language/ebo) is used and no additional functionality is injected.

-### Limitations
+#### Limitations

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

-#### Name conflicts
-
-Since `basic_json` derives from `CustomBaseClass`, members of `basic_json` hide members of `CustomBaseClass` with the
-same name. Hidden members remain accessible via [`as_base_class`](as_base_class.md) or by casting the value to
-`json_base_class_t`.
-
-!!! warning "Avoid generic member names"
-
-    Future versions of the library may add members to `basic_json` that hide members of `CustomBaseClass` that are
-    accessible today. To reduce the risk of such conflicts, avoid generic names for the members of `CustomBaseClass`,
-    for instance by using a distinctive prefix.
-
 ## Examples

 ??? example
@@ -55,12 +43,6 @@ same name. Hidden members remain accessible via [`as_base_class`](as_base_class.
    --8<-- "examples/json_base_class_t.output"
    ```

-## See also
-
- [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

 - Added in version 3.12.0.
- Made a public member type in version 3.13.0; it was private before, so it could not be named outside the class.
@@ -15,11 +15,11 @@ using json_serializer = JSONSerializer<T, SFINAE>;

 ## Notes

-### Default type
+#### Default type

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

-### Requirements
+#### Requirements

 A custom serializer must provide `#!cpp static void to_json(basic_json&, T)` for every type it serializes, and either
 `#!cpp static void from_json(const basic_json&, T&)` or `#!cpp static T from_json(const basic_json&)` for every type it
@@ -42,13 +42,6 @@ deserializes. See [Template Parameter Requirements](../../features/types/templat
    --8<-- "examples/from_json__non_default_constructible.output"
    ```

-## See also
-
- [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_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
-
 ## Version history

 - Since version 2.0.0.
@@ -54,12 +54,6 @@ string elements the JSON value can store which is `1`.

    Note the output is platform-dependent.

-## See also
-
- [size](size.md) returns the number of elements
- [array_t](array_t.md) the type used to store JSON arrays
- [object_t](object_t.md) the type used to store JSON objects
-
 ## Version history

 - Added in version 1.0.0.
@@ -33,10 +33,6 @@ Thereby, `Target` is the current object; that is, the patch is applied to the cu
 `apply_patch` (in)
 :   the patch to apply

-## Exception safety
-
-Basic guarantee: if an exception is thrown during the operation, the JSON value may be partially modified.
-
 ## Complexity

 Linear in the lengths of `apply_patch`.
@@ -13,7 +13,7 @@ JSON object holding version information

 | key         | description                                                                                                                                                                                                                                                                    |
 |-------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `compiler`  | Information on the used compiler. It is an object with the following keys: `c++` (the used C++ standard), `family` (the compiler family; possible values are `clang`, `icc`, `gcc`, `hp`, `ilecpp`, `msvc`, `pgcpp`, `sunpro`, and `unknown`), and `version` (the compiler version). |
+| `compiler`  | Information on the used compiler. It is an object with the following keys: `c++` (the used C++ standard), `family` (the compiler family; possible values are `clang`, `icc`, `gcc`, `ilecpp`, `msvc`, `pgcpp`, `sunpro`, and `unknown`), and `version` (the compiler version). On HP aCC compilers, `compiler` is instead the plain string `hp`. |
 | `copyright` | The copyright line for the library as string.                                                                                                                                                                                                                                  |
 | `name`      | The name of the library as string.                                                                                                                                                                                                                                             |
 | `platform`  | The used platform as string. Possible values are `win32`, `linux`, `apple`, `unix`, and `unknown`.                                                                                                                                                                             |
@@ -32,18 +32,18 @@ type to use.

 ## Notes

-### Default type
+#### Default type

 With the default values for `NumberFloatType` (`double`), the default value for `number_float_t` is `#!cpp double`.

-### Default behavior
+#### Default behavior

 - The restrictions about leading zeros are not enforced in C++. Instead, leading zeros in floating-point literals will
  be ignored. Internally, the value will be stored as a decimal number. For instance, the C++ floating-point literal
  `01.2` will be serialized to `1.2`. During deserialization, leading zeros yield an error.
 - Not-a-number (NaN) values will be serialized to `null`.

-### Limits
+#### Limits

 [RFC 8259](https://tools.ietf.org/html/rfc8259) states:
 > This specification allows implementations to set limits on the range and precision of numbers accepted. Since software
@@ -55,7 +55,7 @@ This implementation does exactly follow this approach, as it uses double precisi
 smaller than `-1.79769313486232e+308` and values greater than `1.79769313486232e+308` will be stored as NaN internally
 and be serialized to `null`.

-### Storage
+#### Storage

 Floating-point number values are stored directly inside a `basic_json` type.

@@ -75,13 +75,6 @@ Floating-point number values are stored directly inside a `basic_json` type.
    --8<-- "examples/number_float_t.output"
    ```

-## See also
-
- [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
- [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
-
 ## Version history

 - Added in version 1.0.0.
@@ -29,18 +29,18 @@ to use.

 ## Notes

-### Default type
+#### Default type

 With the default values for `NumberIntegerType` (`std::int64_t`), the default value for `number_integer_t` is
 `#!cpp std::int64_t`.

-### Default behavior
+#### Default behavior

 - The restrictions about leading zeros are not enforced in C++. Instead, leading zeros in integer literals lead to an
  interpretation as an octal number. Internally, the value will be stored as a decimal number. For instance, the C++
  integer literal `010` will be serialized to `8`. During deserialization, leading zeros yield an error.

-### Limits
+#### Limits

 [RFC 8259](https://tools.ietf.org/html/rfc8259) specifies:
 > An implementation may set limits on the range and precision of numbers.
@@ -57,7 +57,7 @@ will automatically be stored as [`number_unsigned_t`](number_unsigned_t.md) or [
 As this range is a subrange of the exactly supported range [INT64_MIN, INT64_MAX], this class's integer type is
 interoperable.

-### Storage
+#### Storage

 Integer number values are stored directly inside a `basic_json` type.

@@ -77,13 +77,6 @@ Integer number values are stored directly inside a `basic_json` type.
    --8<-- "examples/number_integer_t.output"
    ```

-## See also
-
- [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
- [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
-
 ## Version history

 - Added in version 1.0.0.
@@ -30,18 +30,18 @@ the type to use.

 ## Notes

-### Default type
+#### Default type

 With the default values for `NumberUnsignedType` (`std::uint64_t`), the default value for `number_unsigned_t` is
 `#!cpp std::uint64_t`.

-### Default behavior
+#### Default behavior

 - The restrictions about leading zeros are not enforced in C++. Instead, leading zeros in integer literals lead to an
  interpretation as an octal number. Internally, the value will be stored as a decimal number. For instance, the C++
  integer  literal `010` will be serialized to `8`. During deserialization, leading zeros yield an error.

-### Limits
+#### Limits

 [RFC 8259](https://tools.ietf.org/html/rfc8259) specifies:
 > An implementation may set limits on the range and precision of numbers.
@@ -58,7 +58,7 @@ as [`number_integer_t`](number_integer_t.md) or [`number_float_t`](number_float_
 As this range is a subrange (when considered in conjunction with the `number_integer_t` type) of the exactly supported
 range [0, UINT64_MAX], this class's integer type is interoperable.

-### Storage
+#### Storage

 Integer number values are stored directly inside a `basic_json` type.

@@ -78,13 +78,6 @@ Integer number values are stored directly inside a `basic_json` type.
    --8<-- "examples/number_unsigned_t.output"
    ```

-## See also
-
- [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
- [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
-
 ## Version history

 - Added in version 2.0.0.
@@ -25,11 +25,6 @@ and [`default_object_comparator_t`](default_object_comparator_t.md) otherwise.
    --8<-- "examples/object_comparator_t.output"
    ```

-## See also
-
- [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
-
 ## Version history

 - Added in version 3.0.0.
@@ -33,7 +33,7 @@ To store objects in C++, a type is defined by the template parameters described

 ## Notes

-### Default type
+#### Default type

 With the default values for `ObjectType` (`std::map`), `StringType` (`std::string`), and `AllocatorType`
 (`std::allocator`), the default value for `object_t` is:
@@ -58,7 +58,7 @@ std::map<

 See [`default_object_comparator_t`](default_object_comparator_t.md) for more information.

-### Behavior
+#### Behavior

 The choice of `object_t` influences the behavior of the JSON class. With the default type, objects have the following
 behavior:
@@ -76,7 +76,7 @@ behavior:
  that they will not be affected by these differences. For instance, `#!json {"b": 1, "a": 2}` and
  `#!json {"a": 2, "b": 1}` will be treated as equal.

-### Limits
+#### Limits

 [RFC 8259](https://tools.ietf.org/html/rfc8259) specifies:
 > An implementation may set limits on the maximum depth of nesting.
@@ -85,12 +85,12 @@ In this class, the object's limit of nesting is not explicitly constrained. Howe
 introduced by the compiler or runtime environment. A theoretical limit can be queried by calling the
 [`max_size`](max_size.md) function of a JSON object.

-### Storage
+#### Storage

 Objects are stored as pointers in a `basic_json` type. That is, for any access to object values, a pointer of type
 `object_t*` must be dereferenced.

-### Object key order
+#### Object key order

 The order name/value pairs are added to the object are *not* preserved by the library. Therefore, iterating an object
 may return name/value pairs in a different order than they were originally stored. In fact, keys will be traversed in
@@ -98,10 +98,10 @@ alphabetical order as `std::map` with `std::less` is used by default. Please not
 [RFC 8259](https://tools.ietf.org/html/rfc8259), because any order implements the specified "unordered" nature of JSON
 objects.

-### Cross-`basic_json` conversion requirements
+#### Cross-`basic_json` conversion requirements

 When converting an object from one `basic_json` specialization to another via the
-[converting constructor](basic_json.md) (overload 4), the target `object_t`'s `key_type` must be
+[converting constructor](basic_json.md#overload-4), the target `object_t`'s `key_type` must be
 directly constructible from the source `basic_json`'s `string_t` type (or more generally, from the
 source object's key type). If this requirement is not met, the conversion does not fail; instead,
 the object is silently converted as an array of key-value pairs, which is incorrect. See
@@ -123,13 +123,6 @@ the object is silently converted as an array of key-value pairs, which is incorr
    --8<-- "examples/object_t.output"
    ```

-## See also
-
- [array_t](array_t.md) the type used to store JSON arrays
- [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 Order](../../features/object_order.md) - the article on object key ordering
-
 ## Version history

 - Added in version 1.0.0.
@@ -48,12 +48,6 @@ invalidates all iterators and all references.

 `#!cpp *this`

-## Exception safety
-
-Strong guarantee: if an exception is thrown, there are no changes to any JSON value. As an exception, a `#!json null`
-value is converted to an empty array or object before the element is added and keeps that type if adding the element
-throws.
-
 ## Exceptions

 1. Throws [`type_error.308`](../../home/exceptions.md#jsonexceptiontype_error308) when called on a type other than
@@ -89,9 +89,6 @@ Strong exception safety: if an exception occurs, the original value stays intact
    - Throws [`out_of_range.410`](../../home/exceptions.md#jsonexceptionout_of_range410) if an array index in the passed
      JSON pointer `ptr` exceeds the range of `size_type` (e.g., on 32-bit platforms).

-    For the **const** version, an object key or array index in `ptr` that does not exist is not reported by an
-    exception, but is undefined behavior (see the notes below). Use [`at`](at.md) for checked access.
-
 ## Complexity

 1. Constant if `idx` is in the range of the array. Otherwise, linear in `idx - size()`.
@@ -106,12 +103,9 @@ Strong exception safety: if an exception occurs, the original value stays intact
    The following cases apply to the **const** overloads; the non-const overloads instead insert the missing element
    (see the notes below).

-    1. If the element at index `idx` does not exist, the behavior is undefined and is **guarded by a
-       [runtime assertion](../../features/assertions.md)**!
+    1. If the element at index `idx` does not exist, the behavior is undefined.
    2. If the element with key `key` does not exist, the behavior is undefined and is **guarded by a
       [runtime assertion](../../features/assertions.md)**!
-    3. If the JSON pointer `ptr` refers to an object key or an array index that does not exist, the behavior is
-       undefined and is **guarded by a [runtime assertion](../../features/assertions.md)**!

 1. The non-const version may add values: If `idx` is beyond the range of the array (i.e., `idx >= size()`), then the
   array is silently filled up with `#!json null` values to make `idx` a valid reference to the last stored element. In
@@ -142,18 +136,6 @@ Strong exception safety: if an exception occurs, the original value stays intact
        while `/foo/one/one/one` creates nested objects. 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"
-
-    Overload (4) also accepts a [`json_pointer`](../json_pointer/index.md) whose template argument is a `basic_json`
-    specialization (e.g., `nlohmann::json_pointer<nlohmann::json>`) instead of a string type. This is deprecated since
-    version 3.11.0 and will be removed in a future major version; use `basic_json::json_pointer` (for `json`,
-    `nlohmann::json_pointer<std::string>`) instead.
-
-    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
-    function.
-
-    See the [migration guide](../../integration/migration_guide.md#json-pointers) for how to update existing code.
-
 ## Examples

 ??? example "Example: (1) access specified array element"
@@ -279,11 +261,9 @@ Strong exception safety: if an exception occurs, the original value stays intact
 ## 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.
+   accessing it out of bounds when `idx` equals the maximum value of `size_type`.
 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)
   in version 3.11.0.
 3. Added in version 3.11.0. Fixed in version 3.13.0 to consistently accept `std::string_view`-convertible keys, as
   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.
+4. Added in version 2.0.0.
@@ -17,11 +17,6 @@ Implicit type conversion between the JSON value and a compatible value. The call

 copy of the JSON value, converted to `ValueType`

-## Exception safety
-
-Depends on what `json_serializer<ValueType>` `from_json()` method throws; the JSON value itself is never modified,
-since `#!cpp operator ValueType()` is a `#!cpp const` member function that only calls [`get()`](get.md).
-
 ## Exceptions

 Depends on what `json_serializer<ValueType>` `from_json()` method throws
@@ -61,8 +56,6 @@ Linear in the size of the JSON value.
    [`JSON_USE_IMPLICIT_CONVERSIONS`](../macros/json_use_implicit_conversions.md) to `0` and replace any implicit
    conversions with calls to [`get`](../basic_json/get.md).

-    See the [migration guide](../../integration/migration_guide.md#replace-implicit-conversions) for how to update existing code.
-
 ## Examples

 ??? example
@@ -70,7 +63,7 @@ Linear in the size of the JSON value.
    The example below shows several conversions from JSON values to other types. There are a few things to note: (1)
    Floating-point numbers can be converted to integers, (2) A JSON array can be converted to a standard
    `std::vector<short>`, (3) A JSON object can be converted to C++ associative containers such as
-    `std::map<std::string, json>`.
+    `std::unordered_map<std::string, json>`.
        
    ```cpp
    --8<-- "examples/operator__ValueType.cpp"
@@ -5,17 +5,17 @@
 bool operator==(const_reference lhs, const_reference rhs) noexcept;   // (1)

 template<typename ScalarType>
-bool operator==(const_reference lhs, const ScalarType rhs) noexcept(/* see below */); // (2)
+bool operator==(const_reference lhs, const ScalarType rhs) noexcept;  // (2)

 template<typename ScalarType>
-bool operator==(ScalarType lhs, const const_reference rhs) noexcept(/* see below */); // (2)
+bool operator==(ScalarType lhs, const const_reference rhs) noexcept;  // (2)

 // since C++20
 class basic_json {
    bool operator==(const_reference rhs) const noexcept;              // (1)

    template<typename ScalarType>
-    bool operator==(ScalarType rhs) const noexcept(/* see below */); // (2)
+    bool operator==(ScalarType rhs) const noexcept;                   // (2)
 };
 ```

@@ -46,12 +46,7 @@ whether the values `lhs`/`*this` and `rhs` are equal

 ## Exception safety

-1. No-throw guarantee: this function never throws exceptions.
-2. No-throw guarantee if converting the scalar to a JSON value cannot throw, as for numbers, Booleans, and
-   `#!cpp nullptr`; the function is `#!cpp noexcept` exactly in that case. Otherwise, it throws what the conversion
-   throws, for example `std::bad_alloc` when converting a string, or
-   [`out_of_range.410`](../../home/exceptions.md#jsonexceptionout_of_range410) for an enum value not mapped by
-   [`NLOHMANN_JSON_SERIALIZE_ENUM_STRICT`](../macros/nlohmann_json_serialize_enum_strict.md).
+No-throw guarantee: this function never throws exceptions.

 ## Complexity

@@ -139,7 +134,7 @@ Linear.

 ## Examples

-??? example "Example: (1) compare JSON values"
+??? example

    The example demonstrates comparing several JSON types.
        
@@ -153,7 +148,7 @@ Linear.
    --8<-- "examples/operator__equal.output"
    ```

-??? example "Example: (2) compare JSON values with `#!cpp nullptr`"
+??? example

    The example demonstrates comparing several JSON types against the null pointer (JSON `#!json null`).
        
@@ -176,4 +171,3 @@ Linear.

 1. Added in version 1.0.0. Added C++20 member functions in version 3.11.0.
 2. Added in version 1.0.0. Added C++20 member functions in version 3.11.0.
-   Made conditionally `#!cpp noexcept` in version 3.13.0; before, a throwing conversion called `std::terminate`.
@@ -5,10 +5,10 @@
 bool operator>=(const_reference lhs, const_reference rhs) noexcept;   // (1)

 template<typename ScalarType>
-bool operator>=(const_reference lhs, const ScalarType rhs) noexcept(/* see below */); // (2)
+bool operator>=(const_reference lhs, const ScalarType rhs) noexcept;  // (2)

 template<typename ScalarType>
-bool operator>=(ScalarType lhs, const const_reference rhs) noexcept(/* see below */); // (2)
+bool operator>=(ScalarType lhs, const const_reference rhs) noexcept;  // (2)
 ```

 1. Compares whether one JSON value `lhs` is greater than or equal to another JSON value `rhs` according to the following
@@ -39,12 +39,7 @@ whether `lhs` is greater than or equal to `rhs`

 ## Exception safety

-1. No-throw guarantee: this function never throws exceptions.
-2. No-throw guarantee if converting the scalar to a JSON value cannot throw, as for numbers, Booleans, and
-   `#!cpp nullptr`; the function is `#!cpp noexcept` exactly in that case. Otherwise, it throws what the conversion
-   throws, for example `std::bad_alloc` when converting a string, or
-   [`out_of_range.410`](../../home/exceptions.md#jsonexceptionout_of_range410) for an enum value not mapped by
-   [`NLOHMANN_JSON_SERIALIZE_ENUM_STRICT`](../macros/nlohmann_json_serialize_enum_strict.md).
+No-throw guarantee: this function never throws exceptions.

 ## Complexity

@@ -65,16 +60,6 @@ Linear.
    Since C++20 overload resolution will consider the _rewritten candidate_ generated from
    [`operator<=>`](operator_spaceship.md).

-!!! warning "Deprecation"
-
-    If [`JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](../macros/json_use_legacy_discarded_value_comparison.md) is
-    defined to `1`, the library declares a member `#!cpp bool operator>=(const_reference rhs) const noexcept` in
-    C++20 mode to emulate the legacy comparison of discarded values. This member is deprecated since version 3.11.0,
-    together with the legacy comparison behavior.
-
-    See the [migration guide](../../integration/migration_guide.md#miscellaneous-functions) for how to update existing
-    code.
-
 ## Examples

 ??? example
@@ -99,4 +84,3 @@ Linear.

 1. Added in version 1.0.0. Conditionally removed since C++20 in version 3.11.0.
 2. Added in version 1.0.0. Conditionally removed since C++20 in version 3.11.0.
-   Made conditionally `#!cpp noexcept` in version 3.13.0; before, a throwing conversion called `std::terminate`.
@@ -5,10 +5,10 @@
 bool operator>(const_reference lhs, const_reference rhs) noexcept;   // (1)

 template<typename ScalarType>
-bool operator>(const_reference lhs, const ScalarType rhs) noexcept(/* see below */); // (2)
+bool operator>(const_reference lhs, const ScalarType rhs) noexcept;  // (2)

 template<typename ScalarType>
-bool operator>(ScalarType lhs, const const_reference rhs) noexcept(/* see below */); // (2)
+bool operator>(ScalarType lhs, const const_reference rhs) noexcept;  // (2)
 ```

 1. Compares whether one JSON value `lhs` is greater than another JSON value `rhs` according to the
@@ -39,12 +39,7 @@ whether `lhs` is greater than `rhs`

 ## Exception safety

-1. No-throw guarantee: this function never throws exceptions.
-2. No-throw guarantee if converting the scalar to a JSON value cannot throw, as for numbers, Booleans, and
-   `#!cpp nullptr`; the function is `#!cpp noexcept` exactly in that case. Otherwise, it throws what the conversion
-   throws, for example `std::bad_alloc` when converting a string, or
-   [`out_of_range.410`](../../home/exceptions.md#jsonexceptionout_of_range410) for an enum value not mapped by
-   [`NLOHMANN_JSON_SERIALIZE_ENUM_STRICT`](../macros/nlohmann_json_serialize_enum_strict.md).
+No-throw guarantee: this function never throws exceptions.

 ## Complexity

@@ -89,4 +84,3 @@ Linear.

 1. Added in version 1.0.0. Conditionally removed since C++20 in version 3.11.0.
 2. Added in version 1.0.0. Conditionally removed since C++20 in version 3.11.0.
-   Made conditionally `#!cpp noexcept` in version 3.13.0; before, a throwing conversion called `std::terminate`.
@@ -5,10 +5,10 @@
 bool operator<=(const_reference lhs, const_reference rhs) noexcept;   // (1)

 template<typename ScalarType>
-bool operator<=(const_reference lhs, const ScalarType rhs) noexcept(/* see below */); // (2)
+bool operator<=(const_reference lhs, const ScalarType rhs) noexcept;  // (2)

 template<typename ScalarType>
-bool operator<=(ScalarType lhs, const const_reference rhs) noexcept(/* see below */); // (2)
+bool operator<=(ScalarType lhs, const const_reference rhs) noexcept;  // (2)
 ```

 1. Compares whether one JSON value `lhs` is less than or equal to another JSON value `rhs`
@@ -40,12 +40,7 @@ whether `lhs` is less than or equal to `rhs`

 ## Exception safety

-1. No-throw guarantee: this function never throws exceptions.
-2. No-throw guarantee if converting the scalar to a JSON value cannot throw, as for numbers, Booleans, and
-   `#!cpp nullptr`; the function is `#!cpp noexcept` exactly in that case. Otherwise, it throws what the conversion
-   throws, for example `std::bad_alloc` when converting a string, or
-   [`out_of_range.410`](../../home/exceptions.md#jsonexceptionout_of_range410) for an enum value not mapped by
-   [`NLOHMANN_JSON_SERIALIZE_ENUM_STRICT`](../macros/nlohmann_json_serialize_enum_strict.md).
+No-throw guarantee: this function never throws exceptions.

 ## Complexity

@@ -66,16 +61,6 @@ Linear.
    Since C++20 overload resolution will consider the _rewritten candidate_ generated from
    [`operator<=>`](operator_spaceship.md).

-!!! warning "Deprecation"
-
-    If [`JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](../macros/json_use_legacy_discarded_value_comparison.md) is
-    defined to `1`, the library declares a member `#!cpp bool operator<=(const_reference rhs) const noexcept` in
-    C++20 mode to emulate the legacy comparison of discarded values. This member is deprecated since version 3.11.0,
-    together with the legacy comparison behavior.
-
-    See the [migration guide](../../integration/migration_guide.md#miscellaneous-functions) for how to update existing
-    code.
-
 ## Examples

 ??? example
@@ -100,4 +85,3 @@ Linear.

 1. Added in version 1.0.0. Conditionally removed since C++20 in version 3.11.0.
 2. Added in version 1.0.0. Conditionally removed since C++20 in version 3.11.0.
-   Made conditionally `#!cpp noexcept` in version 3.13.0; before, a throwing conversion called `std::terminate`.
@@ -5,10 +5,10 @@
 bool operator<(const_reference lhs, const_reference rhs) noexcept;   // (1)

 template<typename ScalarType>
-bool operator<(const_reference lhs, const ScalarType rhs) noexcept(/* see below */); // (2)
+bool operator<(const_reference lhs, const ScalarType rhs) noexcept;  // (2)

 template<typename ScalarType>
-bool operator<(ScalarType lhs, const const_reference rhs) noexcept(/* see below */); // (2)
+bool operator<(ScalarType lhs, const const_reference rhs) noexcept;  // (2)
 ```

 1. Compares whether one JSON value `lhs` is less than another JSON value `rhs` according to the
@@ -49,12 +49,7 @@ whether `lhs` is less than `rhs`

 ## Exception safety

-1. No-throw guarantee: this function never throws exceptions.
-2. No-throw guarantee if converting the scalar to a JSON value cannot throw, as for numbers, Booleans, and
-   `#!cpp nullptr`; the function is `#!cpp noexcept` exactly in that case. Otherwise, it throws what the conversion
-   throws, for example `std::bad_alloc` when converting a string, or
-   [`out_of_range.410`](../../home/exceptions.md#jsonexceptionout_of_range410) for an enum value not mapped by
-   [`NLOHMANN_JSON_SERIALIZE_ENUM_STRICT`](../macros/nlohmann_json_serialize_enum_strict.md).
+No-throw guarantee: this function never throws exceptions.

 ## Complexity

@@ -99,4 +94,3 @@ Linear.

 1. Added in version 1.0.0. Conditionally removed since C++20 in version 3.11.0.
 2. Added in version 1.0.0. Conditionally removed since C++20 in version 3.11.0.
-   Made conditionally `#!cpp noexcept` in version 3.13.0; before, a throwing conversion called `std::terminate`.
@@ -5,13 +5,21 @@
 bool operator!=(const_reference lhs, const_reference rhs) noexcept;   // (1)

 template<typename ScalarType>
-bool operator!=(const_reference lhs, const ScalarType rhs) noexcept(/* see below */); // (2)
+bool operator!=(const_reference lhs, const ScalarType rhs) noexcept;  // (2)

 template<typename ScalarType>
-bool operator!=(ScalarType lhs, const const_reference rhs) noexcept(/* see below */); // (2)
+bool operator!=(ScalarType lhs, const const_reference rhs) noexcept;  // (2)
+
+// since C++20
+class basic_json {
+    bool operator!=(const_reference rhs) const noexcept;              // (1)
+
+    template<typename ScalarType>
+    bool operator!=(ScalarType rhs) const noexcept;                   // (2)
+};
 ```

-1. Compares two JSON values for inequality. Returns `#!cpp !(lhs == rhs)`.
+1. Compares two JSON values for inequality. Returns `#!cpp !(lhs == rhs)` (until C++20) or `#!cpp !(*this == rhs)` (since C++20).
    - This means the comparison is simply the logical negation of `operator==`, including for special values like `NaN` and `discarded`.

 2. Compares a JSON value and a scalar or a scalar and a JSON value for inequality by converting the scalar to a JSON
@@ -36,12 +44,7 @@ whether the values `lhs`/`*this` and `rhs` are not equal

 ## Exception safety

-1. No-throw guarantee: this function never throws exceptions.
-2. No-throw guarantee if converting the scalar to a JSON value cannot throw, as for numbers, Booleans, and
-   `#!cpp nullptr`; the function is `#!cpp noexcept` exactly in that case. Otherwise, it throws what the conversion
-   throws, for example `std::bad_alloc` when converting a string, or
-   [`out_of_range.410`](../../home/exceptions.md#jsonexceptionout_of_range410) for an enum value not mapped by
-   [`NLOHMANN_JSON_SERIALIZE_ENUM_STRICT`](../macros/nlohmann_json_serialize_enum_strict.md).
+No-throw guarantee: this function never throws exceptions.

 ## Complexity

@@ -49,11 +52,6 @@ Linear.

 ## Notes

-!!! note "C++20"
-
-    Since C++20, `basic_json` declares no `operator!=`. The compiler rewrites `#!cpp a != b` as `#!cpp !(a == b)`
-    using [`operator==`](operator_eq.md), so the result is the same as described above.
-
 !!! note "Comparing `NaN` and `discarded`"

    Since `operator!=` is defined as `!(a == b)`, the behavior for special values follows that of `operator==`:
@@ -63,7 +61,7 @@ Linear.

 ## Examples

-??? example "Example: (1) compare JSON values"
+??? example

    The example demonstrates comparing several JSON types.
        
@@ -77,7 +75,7 @@ Linear.
    --8<-- "examples/operator__notequal.output"
    ```

-??? example "Example: (2) compare JSON values with `#!cpp nullptr`"
+??? example

    The example demonstrates comparing several JSON types against the null pointer (JSON `#!json null`).
        
@@ -91,16 +89,9 @@ Linear.
    --8<-- "examples/operator__notequal__nullptr_t.output"
    ```

-## See also
-
- [operator==](operator_eq.md) comparison: equal
- [operator<=>](operator_spaceship.md) comparison: 3-way (C++20)
-
 ## Version history

-1. Added in version 1.0.0. Added a C++20 member function in version 3.11.0. Changed in version 3.13.0 to remove
-   special-casing for `NaN` and `discarded` values; `operator!=` now consistently means `!(a == b)`. Removed the C++20
-   member function in version 3.13.0; since C++20, the compiler rewrites `a != b` using `operator==`.
-2. Added in version 1.0.0. Changed in version 3.13.0 to remove special-casing for `NaN` and `discarded` values;
-   `operator!=` now consistently means `!(a == b)`. Since C++20, the compiler rewrites `a != b` using `operator==`.
-   Made conditionally `#!cpp noexcept` in version 3.13.0; before, a throwing conversion called `std::terminate`.
+1. Added in version 1.0.0. Added C++20 member functions in version 3.11.0. Changed in version 3.13.0 to remove 
+   special-casing for `NaN` and `discarded` values; `operator!=` now consistently means `!(a == b)`.
+2. Added in version 1.0.0. Added C++20 member functions in version 3.11.0. Changed in version 3.13.0 to remove
+   special-casing for `NaN` and `discarded` values; `operator!=` now consistently means `!(a == b)`.
@@ -6,7 +6,7 @@ class basic_json {
    std::partial_ordering operator<=>(const_reference rhs) const noexcept;  // (1)

    template<typename ScalarType>
-    std::partial_ordering operator<=>(const ScalarType rhs) const noexcept(/* see below */); // (2)
+    std::partial_ordering operator<=>(const ScalarType rhs) const noexcept; // (2)
 };
 ```

@@ -39,12 +39,7 @@ the `std::partial_ordering` of the 3-way comparison of `*this` and `rhs`

 ## Exception safety

-1. No-throw guarantee: this function never throws exceptions.
-2. No-throw guarantee if converting the scalar to a JSON value cannot throw, as for numbers, Booleans, and
-   `#!cpp nullptr`; the function is `#!cpp noexcept` exactly in that case. Otherwise, it throws what the conversion
-   throws, for example `std::bad_alloc` when converting a string, or
-   [`out_of_range.410`](../../home/exceptions.md#jsonexceptionout_of_range410) for an enum value not mapped by
-   [`NLOHMANN_JSON_SERIALIZE_ENUM_STRICT`](../macros/nlohmann_json_serialize_enum_strict.md).
+No-throw guarantee: this function never throws exceptions.

 ## Complexity

@@ -103,4 +98,3 @@ Linear.

 1. Added in version 3.11.0.
 2. Added in version 3.11.0.
-   Made conditionally `#!cpp noexcept` in version 3.13.0; before, a throwing conversion called `std::terminate`.
@@ -47,11 +47,6 @@ Constant.
    --8<-- "examples/operator__value_t.output"
    ```

-## See also
-
- [type](type.md) named member function equivalent to this implicit conversion operator
- [value_t](value_t.md) the enumeration of JSON types
-
 ## Version history

 - Added in version 1.0.0.
@@ -114,7 +114,7 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by

 ## Examples

-??? example "Example: (1) parse from a character array"
+??? example "Parsing from a character array"

    The example below demonstrates the `parse()` function reading from an array.

@@ -128,7 +128,7 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
    --8<-- "examples/parse__array__parser_callback_t.output"
    ```

-??? example "Example: (1) parse from a string"
+??? example "Parsing from a string"

    The example below demonstrates the `parse()` function with and without callback function.

@@ -142,7 +142,7 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
    --8<-- "examples/parse__string__parser_callback_t.output"
    ```

-??? example "Example: (1) parse from an input stream"
+??? example "Parsing from an input stream"

    The example below demonstrates the `parse()` function with and without callback function.

@@ -156,7 +156,7 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
    --8<-- "examples/parse__istream__parser_callback_t.output"
    ```

-??? example "Example: (1) parse from a contiguous container"
+??? example "Parsing from a contiguous container"

    The example below demonstrates the `parse()` function reading from a contiguous container.

@@ -170,7 +170,7 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
    --8<-- "examples/parse__contiguouscontainer__parser_callback_t.output"
    ```

-??? example "Example: (2) parse from a non-null-terminated string"
+??? example "Parsing from a non-null-terminated string"

    The example below demonstrates the `parse()` function reading from a string that is not null-terminated.

@@ -184,7 +184,7 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
    --8<-- "examples/parse__pointers.output"
    ```

-??? example "Example: (2) parse from an iterator pair"
+??? example "Parsing from an iterator pair"

    The example below demonstrates the `parse()` function reading from an iterator pair.

@@ -198,7 +198,7 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
    --8<-- "examples/parse__iterator_pair.output"
    ```

-??? example "Example: effect of `allow_exceptions` parameter"
+??? example "Effect of `allow_exceptions` parameter"

    The example below demonstrates the effect of the `allow_exceptions` parameter in the `parse()` function.

@@ -212,7 +212,7 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
    --8<-- "examples/parse__allow_exceptions.output"
    ```

-??? example "Example: effect of `ignore_comments` parameter"
+??? example "Effect of `ignore_comments` parameter"

    The example below demonstrates the effect of the `ignore_comments` parameter in the `parse()` function.

@@ -226,7 +226,7 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
    --8<-- "examples/comments.output"
    ```

-??? example "Example: effect of `ignore_trailing_commas` parameter"
+??? example "Effect of `ignore_trailing_commas` parameter"

    The example below demonstrates the effect of the `ignore_trailing_commas` parameter in the `parse()` function.

@@ -270,5 +270,3 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by

    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
    function.
-
-    See the [migration guide](../../integration/migration_guide.md#parsing) for how to update existing code.
@@ -24,21 +24,6 @@ The parser callback distinguishes the following events:

 ![Example when certain parse events are triggered](../../images/callback_events.png)

-??? example
-
-    The following code parses a small JSON text with a parser callback that reports every event together with its
-    depth and keeps every value (by always returning `#!cpp true`).
-
-    ```cpp
-    --8<-- "examples/parse_event_t.cpp"
-    ```
-
-    Output:
-
-    ```json
-    --8<-- "examples/parse_event_t.output"
-    ```
-
 ## See also

 - [parser_callback_t](parser_callback_t.md) callback function type for the parser
@@ -60,7 +60,7 @@ the latter case, it is skipped completely, or replaced by `null` if it is the to

 ## Examples

-??? example "Example: skip an object key while parsing"
+??? example

    The example below demonstrates the `parse()` function with
    and without callback function.
@@ -75,7 +75,7 @@ the latter case, it is skipped completely, or replaced by `null` if it is the to
    --8<-- "examples/parse__string__parser_callback_t.output"
    ```

-??? example "Example: how discarded values are removed"
+??? example

    The example below shows where discarded values are removed. The array and the number are discarded in different
    ways, but in each case the parse result contains neither the value nor its key.
@@ -26,24 +26,10 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [`parse_error.104`](../../home/exceptions.md#jsonexceptionparse_error104) if the JSON patch does not consist of
  an array of objects.
 - Throws [`parse_error.105`](../../home/exceptions.md#jsonexceptionparse_error105) if the JSON patch is malformed (e.g.,
-  mandatory attributes are missing); example: `"operation 'add' must have member 'path'"`.
+  mandatory attributes are missing); example: `"operation add must have member path"`.
 - Throws [`out_of_range.401`](../../home/exceptions.md#jsonexceptionout_of_range401) if an array index is out of range.
- Throws [`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106) if an array index in a "path" or
-  "from" member begins with '0'; example: `"array index '01' must not begin with '0'"`.
- Throws [`parse_error.107`](../../home/exceptions.md#jsonexceptionparse_error107) if a "path" or "from" member is not
-  empty and does not begin with a slash (`/`); example: `"JSON pointer must be empty or begin with '/' - was: 'a'"`.
- Throws [`parse_error.108`](../../home/exceptions.md#jsonexceptionparse_error108) if a tilde (`~`) in a "path" or
-  "from" member is not followed by `0` or `1`; example: `"escape character '~' must be followed with '0' or '1'"`.
- Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) if an array index in a "path" or
-  "from" member is not a number; example: `"array index 'foo' is not a number"`.
- Throws [`out_of_range.402`](../../home/exceptions.md#jsonexceptionout_of_range402) if the array index `-` is used
-  where an existing element is required (the "path" of "replace", the "from" of "move" and "copy"); example:
-  `"array index '-' (3) is out of range"`.
 - Throws [`out_of_range.403`](../../home/exceptions.md#jsonexceptionout_of_range403) if a JSON pointer inside the patch
  could not be resolved successfully in the current JSON value; example: `"key baz not found"`.
- Throws [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) if a reference token of a JSON
-  pointer inside the patch cannot be resolved, e.g., `-` in a "remove" operation or `1a` for an array; example:
-  `"unresolved reference token '-'"`.
 - Throws [`out_of_range.405`](../../home/exceptions.md#jsonexceptionout_of_range405) if JSON pointer has no parent
  ("add", "remove", "move")
 - Throws [`out_of_range.411`](../../home/exceptions.md#jsonexceptionout_of_range411) if an "add" operation's target
@@ -67,7 +53,7 @@ is thrown. In any case, the original value is not changed: the patch is applied

 ## Examples

-??? example "Example: apply a JSON patch"
+??? example

    The following code shows how a JSON patch is applied to a value.
     
@@ -81,21 +67,6 @@ is thrown. In any case, the original value is not changed: the patch is applied
    --8<-- "examples/patch.output"
    ```

-??? example "Example: out_of_range.414 exception"
-
-    The following code shows how a "move" operation whose "from" location is a proper prefix of its "path" location is
-    rejected, and how the original document is left unchanged because the patch is applied to a copy.
-
-    ```cpp
-    --8<-- "examples/patch__exception.cpp"
-    ```
-
-    Output:
-
-    ```json
-    --8<-- "examples/patch__exception.output"
-    ```
-
 ## See also

 - [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
@@ -22,24 +22,10 @@ No guarantees, value may be corrupted by an unsuccessful patch operation.
 - Throws [`parse_error.104`](../../home/exceptions.md#jsonexceptionparse_error104) if the JSON patch does not consist of
  an array of objects.
 - Throws [`parse_error.105`](../../home/exceptions.md#jsonexceptionparse_error105) if the JSON patch is malformed (e.g.,
-  mandatory attributes are missing); example: `"operation 'add' must have member 'path'"`.
+  mandatory attributes are missing); example: `"operation add must have member path"`.
 - Throws [`out_of_range.401`](../../home/exceptions.md#jsonexceptionout_of_range401) if an array index is out of range.
- Throws [`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106) if an array index in a "path" or
-  "from" member begins with '0'; example: `"array index '01' must not begin with '0'"`.
- Throws [`parse_error.107`](../../home/exceptions.md#jsonexceptionparse_error107) if a "path" or "from" member is not
-  empty and does not begin with a slash (`/`); example: `"JSON pointer must be empty or begin with '/' - was: 'a'"`.
- Throws [`parse_error.108`](../../home/exceptions.md#jsonexceptionparse_error108) if a tilde (`~`) in a "path" or
-  "from" member is not followed by `0` or `1`; example: `"escape character '~' must be followed with '0' or '1'"`.
- Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) if an array index in a "path" or
-  "from" member is not a number; example: `"array index 'foo' is not a number"`.
- Throws [`out_of_range.402`](../../home/exceptions.md#jsonexceptionout_of_range402) if the array index `-` is used
-  where an existing element is required (the "path" of "replace", the "from" of "move" and "copy"); example:
-  `"array index '-' (3) is out of range"`.
 - Throws [`out_of_range.403`](../../home/exceptions.md#jsonexceptionout_of_range403) if a JSON pointer inside the patch
  could not be resolved successfully in the current JSON value; example: `"key baz not found"`.
- Throws [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) if a reference token of a JSON
-  pointer inside the patch cannot be resolved, e.g., `-` in a "remove" operation or `1a` for an array; example:
-  `"unresolved reference token '-'"`.
 - Throws [`out_of_range.405`](../../home/exceptions.md#jsonexceptionout_of_range405) if JSON pointer has no parent
  ("add", "remove", "move")
 - Throws [`out_of_range.411`](../../home/exceptions.md#jsonexceptionout_of_range411) if an "add" operation's target
@@ -64,7 +50,7 @@ function throws an exception.

 ## Examples

-??? example "Example: apply a JSON patch in place"
+??? example

    The following code shows how a JSON patch is applied to a value.
     
@@ -78,22 +64,6 @@ function throws an exception.
    --8<-- "examples/patch_inplace.output"
    ```

-??? example "Example: out_of_range.403 exception with a partially applied patch"
-
-    The following code shows a patch whose first operation succeeds and whose second operation fails. Because
-    `patch_inplace` applies each operation directly to the value, the first operation's effect is still visible after
-    the exception is caught, unlike [`patch`](patch.md).
-
-    ```cpp
-    --8<-- "examples/patch_inplace__exception.cpp"
-    ```
-
-    Output:
-
-    ```json
-    --8<-- "examples/patch_inplace__exception.output"
-    ```
-
 ## See also

 - [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
@@ -44,12 +44,6 @@ invalidates all iterators and all references.
 `init` (in)
 :   an initializer list

-## Exception safety
-
-Strong guarantee: if an exception is thrown, there are no changes to any JSON value. As an exception, a `#!json null`
-value is converted to an empty array or object before the element is added and keeps that type if adding the element
-throws.
-
 ## Exceptions

 1. Throws [`type_error.308`](../../home/exceptions.md#jsonexceptiontype_error308) when called on a type other than
@@ -37,13 +37,6 @@ Constant.
    --8<-- "examples/rbegin.output"
    ```

-## See also
-
- [rend](rend.md) returns a reverse iterator to one before the first element
- [crbegin](crbegin.md) returns a const reverse iterator to the last element
- [begin](begin.md) returns an iterator to the first element
- [Iterators](../../features/iterators.md) - the article on iterators
-
 ## Version history

 - Added in version 1.0.0.
@@ -38,13 +38,6 @@ Constant.
    --8<-- "examples/rend.output"
    ```

-## See also
-
- [rbegin](rbegin.md) returns a reverse iterator to the last element
- [crend](crend.md) returns a const reverse iterator to one before the first element
- [end](end.md) returns an iterator to one past the last element
- [Iterators](../../features/iterators.md) - the article on iterators
-
 ## Version history

 - Added in version 1.0.0.
@@ -147,5 +147,3 @@ A UTF-8 byte order mark is silently ignored.
    Overload (2) replaces calls to `sax_parse` with a pair of iterators as their first parameter which has been
    deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like
    `#!cpp sax_parse({ptr, ptr+len});` with `#!cpp sax_parse(ptr, ptr+len);`.
-
-    See the [migration guide](../../integration/migration_guide.md#parsing) for how to update existing code.
@@ -51,11 +51,6 @@ JSON value which is `1` in the case of a string.
    --8<-- "examples/size.output"
    ```

-## See also
-
- [empty](empty.md) checks whether the JSON value has no elements
- [max_size](max_size.md) returns the maximum possible number of elements
-
 ## Version history

 - Added in version 1.0.0.
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Niels Lohmann	168aa3723c	Remove accidentally committed Python bytecode Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-01 14:19:41 +02:00
Niels Lohmann	4289a38275	Check in CI that Meson and pkg-config offer the CMake options tools/check_build_options/check_build_options.py takes the compile definitions of the CMake target as the reference and checks that the CMake pkg-config block, meson_options.txt (name and default), meson.build, and the Meson section of the package manager docs have each option with the same definition and condition. It runs as make check_build_options in the ci_meson_install job, so a new CMake option cannot be forgotten in the Meson build again. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-01 14:19:32 +02:00
Niels Lohmann	73b8a6a9c8	Add DisableTupleReferenceConversion to Meson and the CMake pkg-config file JSON_DisableTupleReferenceConversion (#5598) came in with the develop merge. Meson gets the matching option, and both the Meson and the CMake pkg-config file carry JSON_DISABLE_TUPLE_REFERENCE_CONVERSION=1 when it is enabled. The ci_meson_install job checks it. Reported by @heitbaum in #5587. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-01 14:16:08 +02:00
Niels Lohmann	9df8de47a5	Merge branch 'develop' into claude/issue-3885-3dcafd Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-01 13:07:17 +02:00
Niels Lohmann	57371b0977	Avoid //include in Meson-generated CMake target for prefix / As CMake's generated targets file does, reset _IMPORT_PREFIX to an empty string when it resolves to "/". Reported by @heitbaum in #5587. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-01 13:07:17 +02:00
Niels Lohmann	2c65caa5bf	Merge branch 'develop' into claude/issue-3885-3dcafd Conflicts: - Makefile: include.zip lists both develop's $(AMALGAMATED_LITERALS_FILE) and this PR's meson_options.txt - meson.build: kept this PR's install_subdir(incdir / 'nlohmann'), which already installs develop's new json_literals.hpp in both header modes, in place of develop's per-file install_headers() lines Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 20:31:07 +02:00
Niels Lohmann	38528b4a38	Merge branch 'develop' into claude/issue-3885-3dcafd Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 20:58:21 +02:00
Niels Lohmann	9cbe62efb0	Fix the Meson CMake target for includedir or datadir outside the prefix nlohmann_jsonTargets.cmake always prepended the prefix computed from the file's location to includedir. With an absolute includedir outside the prefix (as Nix passes for packages with a separate dev output), this gave "<prefix>//abs/include"; with an absolute datadir outside the prefix, the number of ".." was derived from the absolute path and the prefix resolved to "/". In both cases find_package(nlohmann_json) failed with "Imported target includes non-existent path". Use the absolute include directory in these cases, as CMake's install(EXPORT) does, and check it in CI. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 18:23:27 +02:00
Niels Lohmann	471c7678cf	Merge branch 'develop' into claude/issue-3885-3dcafd Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 17:50:55 +02:00
Niels Lohmann	4fabfb27f7	Merge branch 'develop' into claude/issue-3885-3dcafd Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 16:07:30 +02:00
Niels Lohmann	71b4eaf743	Document the Meson options and check them in CI Describe the options of meson.build in FILES.md and in the Meson section of the package manager documentation, which so far said that a Meson installation always uses the default configuration. The ci_meson_install job now also installs with non-default options and checks that the headers of the multi-header version are installed, that the definitions reach the pkg-config file and the CMake target, and that find_package still works. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 14:51:27 +02:00
Niels Lohmann	2790175d79	Add the JSON_* definitions to the CMake pkg-config file The installed pkg-config file only had the include path, so a pkg-config user of a library installed with, for example, -DJSON_Diagnostics=ON compiled without JSON_DIAGNOSTICS=1, unlike users of the CMake target. Append the same definitions the target has. For the default options, the file is unchanged. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 14:50:39 +02:00
Niels Lohmann	cc9fafa0e1	Complete the Meson options and match CMake's compile definitions Finish the Meson changes from #4452: - Offer all eight options that change the CMake target, named like the CMake options without the JSON_ prefix. MultipleHeaders defaults to false so that existing Meson users keep the single header. - Add a compile definition only for an option that differs from its default, exactly as target_compile_definitions does. Before, the GlobalUDLs and ImplicitConversions definitions were inverted and were also added in the default configuration. - Keep the nlohmann_json_multiple_headers dependency that earlier versions of meson.build provided. - Put the definitions into the pkg-config file and the Meson-generated nlohmann_jsonTargets.cmake, and install the pkg-config file into <datadir>/pkgconfig like CMake does. - Ship meson_options.txt in include.zip, since meson.build now reads options and the zip is documented as a Meson subproject. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 14:50:10 +02:00
Dylan Baker	8d6d1264a7	Add meson information to FILES.md Signed-off-by: Dylan Baker <dylan@pnwbakers.com>	2026-09-27 14:47:12 +02:00
Dylan Baker	d75f9ab161	meson: add support for the ImplictConversions option Signed-off-by: Dylan Baker <dylan@pnwbakers.com>	2026-09-27 14:47:04 +02:00
Dylan Baker	c3774be4e2	meson: add support for the GlobalUDLs option Signed-off-by: Dylan Baker <dylan@pnwbakers.com>	2026-09-27 14:47:03 +02:00
Dylan Baker	91365ca3b2	meson: handle single header and multiheader the same way CMake does This uses a meson option (set in `meson_options.txt`) to control whether multi-header or single-header setup is wanted. Signed-off-by: Dylan Baker <dylan@pnwbakers.com>	2026-09-27 14:47:02 +02:00
Dylan Baker	605cc6c81d	meson: set the C++ standard to C++11 Matching the CMake as closely as possible, as Meson doesn't have C++11 feature checks like CMAke does. Signed-off-by: Dylan Baker <dylan@pnwbakers.com>	2026-09-27 14:47:01 +02:00
Dylan Baker	f012b85d06	meson: use `install_subdir` for headers This makes a single call to install the entire directory, and doesn't need an update if any new headers are added. It also will simplify bringing the Meson and CMake builds into allignment on how they handle the multi-header vs single-header setups. Signed-off-by: Dylan Baker <dylan@pnwbakers.com>	2026-09-27 14:46:56 +02:00
Dylan Baker	243b6e20e3	meson: use `override_dependency()` to set dependencies This simplifies the use of json as a subproject. Signed-off-by: Dylan Baker <dylan@pnwbakers.com>	2026-09-27 14:46:55 +02:00
Dylan Baker	0a0d5623be	meson: set a minimum Meson version Without a version set meson will give no developer warnings, including deprecations. 0.64 was selected as it's quite old, it's the newest version supported by muon (a pure C Meson implementation), and there's nothing complicated going on here. Signed-off-by: Dylan Baker <dylan@pnwbakers.com>	2026-09-27 14:46:55 +02:00
Dylan Baker	22c9ce3f21	meson: Indent code inside an if block for better readability Signed-off-by: Dylan Baker <dylan@pnwbakers.com>	2026-09-27 14:46:49 +02:00
Niels Lohmann	0d2240ad1e	Install CMake package config files with Meson A Meson installation only provided the headers and a pkg-config file, so consumers using find_package(nlohmann_json) could not find the library. Meson now also installs nlohmann_jsonConfig.cmake and nlohmann_jsonConfigVersion.cmake from the existing templates, plus a static nlohmann_jsonTargets.cmake that defines the header-only imported target with a relocatable include path. A new CI job installs with Meson and builds tests/cmake_import/project against the result. Closes #3885 Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 14:25:10 +02:00