Add JSON_DELETE_DEPRECATED_FUNCTIONS to delete the deprecated functions

Defining JSON_DELETE_DEPRECATED_FUNCTIONS to 1 (or the CMake option JSON_DeleteDeprecatedFunctions) declares every deprecated function as deleted instead of deprecated, so that code that is not ready for 4.0.0 no longer compiles. A deleted function still takes part in overload resolution, so from_*(ptr, len) cannot silently bind len to the strict parameter of from_*(InputType&&, bool); the roadmap now plans to keep these overloads deleted in 4.0.0 instead of removing them. The legacy discarded-value comparison is left to its own macro. Also update the 4.0 roadmap: add JSON_DISABLE_TUPLE_REFERENCE_CONVERSION and JSON_DELETE_DEPRECATED_FUNCTIONS to the macro table, add the from_bjdata/from_bon8 (ptr, len) overloads to the deprecated functions, document the macro in the migration guide, and fix the docs style check findings (example titles, missing docset entry for JSON_STRICT_BINARY_UTF8). Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Merge branch 'develop' into claude/from-bon8-bjdata-ptr-len-5648
2026-10-04 13:40:33 +00:00 · 2026-10-04 12:54:07 +02:00 · 2026-10-04 12:29:05 +02:00 · 2026-10-04 12:23:53 +02:00 · 2026-10-04 12:13:49 +02:00 · 2026-10-04 12:13:48 +02:00
408 changed files with 7516 additions and 34740 deletions
@@ -1,18 +1,9 @@
 # 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,
@@ -45,24 +45,6 @@ labels:
 - label: "aspect: binary formats"
  title: "(?i)(bson|cbor|msgpack|messagepack|ubjson|bjdata|bon8|binary format)"
 - label: "aspect: json_view"
  files:
    - "include/nlohmann/json_view\\.hpp"
    - "include/nlohmann/detail/view/.*"
    - "single_include/nlohmann/json_view\\.hpp"
    - "tests/src/unit-json_view.*"
    - "tests/src/fuzzer-(parse_json_view|json_view_image)\\.cpp"
    - "tests/benchmarks/json_view/.*"
    - "tools/amalgamate/config_json_view\\.json"
    - "docs/mkdocs/docs/features/json_view\\.md"
    - "docs/mkdocs/docs/api/basic_json_(document|view)/.*"
    - "docs/mkdocs/docs/api/(ordered_)?json_(editable_)?(document|view)\\.md"
    - "docs/mkdocs/docs/examples/(basic_json_(document|view)__|(ordered_)?json_(editable_)?(document|view)).*"
    - "tests/benchmarks/src/benchmarks_view\\.cpp"
 - label: "aspect: json_view"
  title: "(?i)(json_view|json_document|zero-copy)"
 - label: "python"
  files:
    - "\\.py$"
@@ -118,15 +118,12 @@ jobs:
          python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/config_json.json -s .
          python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/config_json_fwd.json -s .
          cp include/nlohmann/json_literals.hpp $INCLUDE_DIR/json_literals.hpp
          # the configuration of json_view.hpp comes with the pull request until
          # it is on develop; the tool itself is still develop's
          python3 $TOOL_DIR/amalgamate.py -c $MAIN_DIR/tools/amalgamate/config_json_view.json -s .
          # the header list of the Bazel "json" target must match the files in include/
          cmake -P cmake/scripts/gen_bazel_build_file.cmake
          ${{ github.workspace }}/venv/bin/astyle --project=tools/astyle/.astylerc --suffix=none --quiet \
-            $INCLUDE_DIR/json.hpp $INCLUDE_DIR/json_fwd.hpp $INCLUDE_DIR/json_view.hpp
+            $INCLUDE_DIR/json.hpp $INCLUDE_DIR/json_fwd.hpp
          # fail loudly if a directory is renamed or removed: find would only warn
          # about the missing path and silently drop its files from the check
@@ -1,78 +0,0 @@
 name: "json_view benchmarks"
 # On demand only: runs the comparison of json_view with yyjson, simdjson, and
 # Boost.JSON (tests/benchmarks/json_view/compare.py) on GitHub-hosted runners,
 # for numbers from x86-64 and AArch64 Linux. It runs when started by hand, or
 # when a pull request gets the label "benchmark" (on both architectures, with
 # GCC and the default settings). Shared runners are noisy: the results show
 # where json_view stands, but published numbers need a quiet machine (see
 # tests/benchmarks/json_view/README.md).
 on:
  pull_request:
    types: [labeled]
  workflow_dispatch:
    inputs:
      runner:
        description: "Runner image"
        type: choice
        options:
          - ubuntu-24.04
          - ubuntu-24.04-arm
        default: ubuntu-24.04
      compiler:
        description: "Compiler"
        type: choice
        options:
          - g++
          - clang++
        default: g++
      native:
        description: "Compile for the runner's CPU (-march=native)"
        type: boolean
        default: false
      rounds:
        description: "Rounds of bench_view"
        type: number
        default: 30
 permissions:
  contents: read
 jobs:
  compare:
    if: github.event_name == 'workflow_dispatch' || github.event.label.name == 'benchmark'
    strategy:
      matrix:
        runner: ${{ fromJSON(github.event_name == 'workflow_dispatch' && format('["{0}"]', inputs.runner) || '["ubuntu-24.04", "ubuntu-24.04-arm"]') }}
    runs-on: ${{ matrix.runner }}
    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: Download test data
        run: |
          cmake -S . -B build -DJSON_BuildTests=On
          cmake --build build --target download_test_data
      - name: Run the comparison
        env:
          CXX: ${{ inputs.compiler || 'g++' }}
          CC: ${{ inputs.compiler == 'clang++' && 'clang' || 'gcc' }}
          ROUNDS: ${{ inputs.rounds || 30 }}
          NATIVE: ${{ inputs.native && '--native' || '' }}
        run: python3 tests/benchmarks/json_view/compare.py --data build/test_files --download --rounds "$ROUNDS" $NATIVE
      - name: Summary
        run: cat tests/benchmarks/json_view/results/*.md >> "$GITHUB_STEP_SUMMARY"
      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: json_view-benchmarks-${{ matrix.runner }}-${{ inputs.compiler || 'g++' }}
          path: tests/benchmarks/json_view/results/
@@ -107,7 +107,7 @@ jobs:
    container: ubuntu:24.04
    strategy:
      matrix:
-        target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls, ci_test_disableenumserialization, ci_test_disabletuplereferenceconversion, ci_test_skiplibraryversioncheck, ci_test_simdutf, ci_test_strict_nul_handling, ci_test_no_thread_local]
+        target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls, ci_test_disableenumserialization, ci_test_disabletuplereferenceconversion, ci_test_skiplibraryversioncheck, ci_test_simdutf, ci_test_strict_nul_handling, ci_test_delete_deprecated_functions, ci_test_no_thread_local]
    steps:
      - name: Install build-essential
        run: apt-get update ; apt-get install -y build-essential unzip wget git
@@ -20,7 +20,6 @@ cc_library(
    hdrs = [
        "include/nlohmann/adl_serializer.hpp",
        "include/nlohmann/byte_container_with_subtype.hpp",
        "include/nlohmann/detail/abi_config.hpp",
        "include/nlohmann/detail/abi_macros.hpp",
        "include/nlohmann/detail/bit_ops.hpp",
        "include/nlohmann/detail/conversions/from_json.hpp",
@@ -54,7 +53,6 @@ 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",
@@ -66,32 +64,9 @@ cc_library(
        "include/nlohmann/detail/string_escape.hpp",
        "include/nlohmann/detail/string_utils.hpp",
        "include/nlohmann/detail/value_t.hpp",
        "include/nlohmann/detail/view/builder.hpp",
        "include/nlohmann/detail/view/compare.hpp",
        "include/nlohmann/detail/view/document_data.hpp",
        "include/nlohmann/detail/view/edit.hpp",
        "include/nlohmann/detail/view/edit_storage.hpp",
        "include/nlohmann/detail/view/errors.hpp",
        "include/nlohmann/detail/view/image.hpp",
        "include/nlohmann/detail/view/input.hpp",
        "include/nlohmann/detail/view/iterator.hpp",
        "include/nlohmann/detail/view/lookup.hpp",
        "include/nlohmann/detail/view/macro_scope.hpp",
        "include/nlohmann/detail/view/macro_unscope.hpp",
        "include/nlohmann/detail/view/materialize.hpp",
        "include/nlohmann/detail/view/node.hpp",
        "include/nlohmann/detail/view/number.hpp",
        "include/nlohmann/detail/view/object_index.hpp",
        "include/nlohmann/detail/view/pointer.hpp",
        "include/nlohmann/detail/view/scan.hpp",
        "include/nlohmann/detail/view/serializer.hpp",
        "include/nlohmann/detail/view/simd.hpp",
        "include/nlohmann/detail/view/string_ref.hpp",
        "include/nlohmann/detail/view/value.hpp",
        "include/nlohmann/json.hpp",
        "include/nlohmann/json_fwd.hpp",
        "include/nlohmann/json_literals.hpp",
        "include/nlohmann/json_view.hpp",
        "include/nlohmann/ordered_map.hpp",
        "include/nlohmann/thirdparty/hedley/hedley.hpp",
        "include/nlohmann/thirdparty/hedley/hedley_undef.hpp",
@@ -104,7 +79,6 @@ cc_library(
    name = "singleheader-json",
    hdrs = [
        "single_include/nlohmann/json.hpp",
        "single_include/nlohmann/json_view.hpp",
    ],
    includes = ["single_include"],
    visibility = ["//visibility:public"],
@@ -61,6 +61,8 @@ 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)
 option(JSON_DeleteDeprecatedFunctions      "Delete the deprecated functions instead of only deprecating them." OFF)
 if (JSON_CI)
    include(ci)
@@ -118,6 +120,14 @@ 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_DeleteDeprecatedFunctions)
    message(STATUS "Deprecated functions are deleted (JSON_DELETE_DEPRECATED_FUNCTIONS=1)")
 endif()
 if (JSON_Diagnostic_Positions)
    message(STATUS "Diagnostic positions enabled (JSON_DIAGNOSTIC_POSITIONS=1)")
 endif()
@@ -153,6 +163,8 @@ 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>
    $<$<BOOL:${JSON_DeleteDeprecatedFunctions}>:JSON_DELETE_DEPRECATED_FUNCTIONS=1>
 )
 target_include_directories(
@@ -23,7 +23,6 @@ AMALGAMATED_FILE=single_include/nlohmann/json.hpp
 AMALGAMATED_FWD_FILE=single_include/nlohmann/json_fwd.hpp
 # json_literals.hpp only includes <nlohmann/json.hpp>, so it is copied verbatim
 AMALGAMATED_LITERALS_FILE=single_include/nlohmann/json_literals.hpp
 AMALGAMATED_VIEW_FILE=single_include/nlohmann/json_view.hpp
 # the header with the argument-counting macros generated by tools/macro_builder
 MACRO_SCOPE_HPP=include/nlohmann/detail/macro_scope.hpp
@@ -35,7 +34,7 @@ MACRO_SCOPE_HPP=include/nlohmann/detail/macro_scope.hpp
 # main target
 all:
-	@echo "amalgamate - amalgamate files single_include/nlohmann/json{,_fwd,_literals,_view}.hpp from the include/nlohmann sources"
+	@echo "amalgamate - amalgamate files single_include/nlohmann/json{,_fwd,_literals}.hpp from the include/nlohmann sources"
 	@echo "BUILD.bazel - regenerate the Bazel BUILD file from the include/nlohmann sources"
 	@echo "ChangeLog.md - generate ChangeLog file"
 	@echo "check-amalgamation - check whether sources have been amalgamated and BUILD.bazel is up to date"
@@ -88,10 +87,10 @@ install_astyle:
 # call the Artistic Style pretty printer on all source files
 pretty: install_astyle
-	$(ASTYLE) --project=tools/astyle/.astylerc $(SRCS) $(TESTS_SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) $(AMALGAMATED_VIEW_FILE) docs/mkdocs/docs/examples/*.cpp docs/mkdocs/docs/examples/*.hpp
+	$(ASTYLE) --project=tools/astyle/.astylerc $(SRCS) $(TESTS_SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) docs/mkdocs/docs/examples/*.cpp docs/mkdocs/docs/examples/*.hpp
 # create single header files and pretty print
-amalgamate: $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) $(AMALGAMATED_VIEW_FILE)
+amalgamate: $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE)
 	$(MAKE) pretty
 # call the amalgamation tool for json.hpp
@@ -106,9 +105,6 @@ $(AMALGAMATED_FWD_FILE): $(SRCS)
 $(AMALGAMATED_LITERALS_FILE): include/nlohmann/json_literals.hpp
 	cp include/nlohmann/json_literals.hpp $(AMALGAMATED_LITERALS_FILE)
 # call the amalgamation tool for json_view.hpp (keeps including json.hpp)
 $(AMALGAMATED_VIEW_FILE): $(SRCS)
 	tools/amalgamate/amalgamate.py -c tools/amalgamate/config_json_view.json -s . --verbose=yes
 # regenerate nlohmann_json.natvis from the ABI tags and version in include/nlohmann/detail/abi_macros.hpp
 natvis:
 	python3 tools/generate_natvis/generate_natvis.py .
@@ -133,16 +129,13 @@ check-amalgamation:
 	@mv $(AMALGAMATED_FILE) $(AMALGAMATED_FILE)~
 	@mv $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_FWD_FILE)~
 	@mv $(AMALGAMATED_LITERALS_FILE) $(AMALGAMATED_LITERALS_FILE)~
 	@mv $(AMALGAMATED_VIEW_FILE) $(AMALGAMATED_VIEW_FILE)~
 	@$(MAKE) amalgamate
 	@diff $(AMALGAMATED_FILE) $(AMALGAMATED_FILE)~ || (echo "===================================================================\n  Amalgamation required! Please read the contribution guidelines\n  in file .github/CONTRIBUTING.md.\n===================================================================" ; mv $(AMALGAMATED_FILE)~ $(AMALGAMATED_FILE) ; false)
 	@diff $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_FWD_FILE)~ || (echo "===================================================================\n  Amalgamation required! Please read the contribution guidelines\n  in file .github/CONTRIBUTING.md.\n===================================================================" ; mv $(AMALGAMATED_FWD_FILE)~ $(AMALGAMATED_FWD_FILE) ; false)
 	@diff $(AMALGAMATED_LITERALS_FILE) $(AMALGAMATED_LITERALS_FILE)~ || (echo "===================================================================\n  Amalgamation required! Please read the contribution guidelines\n  in file .github/CONTRIBUTING.md.\n===================================================================" ; mv $(AMALGAMATED_LITERALS_FILE)~ $(AMALGAMATED_LITERALS_FILE) ; false)
 	@diff $(AMALGAMATED_VIEW_FILE) $(AMALGAMATED_VIEW_FILE)~ || (echo "===================================================================\n  Amalgamation required! Please read the contribution guidelines\n  in file .github/CONTRIBUTING.md.\n===================================================================" ; mv $(AMALGAMATED_VIEW_FILE)~ $(AMALGAMATED_VIEW_FILE) ; false)
 	@mv $(AMALGAMATED_FILE)~ $(AMALGAMATED_FILE)
 	@mv $(AMALGAMATED_FWD_FILE)~ $(AMALGAMATED_FWD_FILE)
 	@mv $(AMALGAMATED_LITERALS_FILE)~ $(AMALGAMATED_LITERALS_FILE)
 	@mv $(AMALGAMATED_VIEW_FILE)~ $(AMALGAMATED_VIEW_FILE)
 	@mv BUILD.bazel BUILD.bazel~
 	@$(MAKE) BUILD.bazel
 	@diff BUILD.bazel BUILD.bazel~ || (echo "===================================================================\n  BUILD.bazel is out of date! Please run 'make BUILD.bazel'.\n===================================================================" ; mv BUILD.bazel~ BUILD.bazel ; false)
@@ -188,7 +181,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) $(AMALGAMATED_VIEW_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 LICENSE.MIT
 # Create the files for a release and add signatures and hashes.
 release: include.zip json.tar.xz
@@ -198,13 +191,11 @@ release: include.zip json.tar.xz
 	gpg --armor --detach-sig $(AMALGAMATED_FILE)
 	gpg --armor --detach-sig $(AMALGAMATED_FWD_FILE)
 	gpg --armor --detach-sig $(AMALGAMATED_LITERALS_FILE)
 	gpg --armor --detach-sig $(AMALGAMATED_VIEW_FILE)
 	gpg --armor --detach-sig json.tar.xz
 	cp $(AMALGAMATED_FILE) release_files
 	cp $(AMALGAMATED_FWD_FILE) release_files
 	cp $(AMALGAMATED_LITERALS_FILE) release_files
-	cp $(AMALGAMATED_VIEW_FILE) release_files
+	mv $(AMALGAMATED_FILE).asc $(AMALGAMATED_FWD_FILE).asc $(AMALGAMATED_LITERALS_FILE).asc json.tar.xz json.tar.xz.asc include.zip include.zip.asc release_files
 	mv $(AMALGAMATED_FILE).asc $(AMALGAMATED_FWD_FILE).asc $(AMALGAMATED_LITERALS_FILE).asc $(AMALGAMATED_VIEW_FILE).asc json.tar.xz json.tar.xz.asc include.zip include.zip.asc release_files
 	cd release_files ; shasum -a 256 $$(find . -type f -not -name '*.asc' | sed 's|^\./||' | sort) > hashes.txt
@@ -1187,14 +1187,6 @@ binary.set_subtype(0x10);
 auto cbor = json::to_msgpack(j); // 0xD5 (fixext2), 0x10, 0xCA, 0xFE
 ```
 ### Zero-copy views
 Header `<nlohmann/json_view.hpp>` adds `json_document`/`json_view`, a read-only, non-owning way to look at a parsed
 JSON text: parsing builds a flat index (16 bytes per value) instead of a tree, strings and numbers stay in the source
 text, and `materialize()` builds a `json` value for a subtree only when you actually need one. See
 [Zero-copy JSON views](https://json.nlohmann.me/features/json_view/) for the details, including which inputs are
 borrowed and which are copied.
 ## Customers
 The library is used in multiple projects, applications, operating systems, etc. The list below is not exhaustive, but the result of an internet search. If you know further customers of the library, please let me know, see [contact](#contact).
@@ -1401,9 +1393,7 @@ THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR I
 - The class contains a slightly modified version of the Grisu2 algorithm from Florian Loitsch which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright &copy; 2009 [Florian Loitsch](https://florian.loitsch.com/)
 - The class contains a copy of [Hedley](https://nemequ.github.io/hedley/) from Evan Nemerson which is licensed as [CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/).
 - The class contains parts of [Google Abseil](https://github.com/abseil/abseil-cpp) which is licensed under the [Apache 2.0 License](https://opensource.org/licenses/Apache-2.0).
- The class contains an adapted version of the Eisel-Lemire algorithm, its table of powers of five, and its digit comparison for long numbers from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright &copy; 2021 The fast_float authors
+- The class contains an adapted version of the Eisel-Lemire algorithm and its table of powers of five from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright &copy; 2021 The fast_float authors
 - The view's parser (`<nlohmann/json_view.hpp>`) contains techniques and code adapted from [yyjson](https://github.com/ibireme/yyjson) by YaoYuan, which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above): table-driven decoding of `\u` escapes and fixed-offset unrolled checks.
 - The view's parser (`<nlohmann/json_view.hpp>`) validates non-ASCII strings with the vector UTF-8 check of [simdjson](https://github.com/simdjson/simdjson) by Daniel Lemire, Geoff Langdale, John Keiser, and contributors (its "lookup4" algorithm and tables, after J. Keiser and D. Lemire, "Validating UTF-8 In Less Than One Instruction Per Byte", 2021), which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here) and the Apache 2.0 License. Copyright &copy; 2018-2025 The simdjson authors
 <img align="right" src="https://git.fsfe.org/reuse/reuse-ci/raw/branch/master/reuse-horizontal.png" alt="REUSE Software">
@@ -249,6 +249,20 @@ add_custom_target(ci_test_strict_nul_handling
    COMMENT "Compile and test with strict NUL-byte handling enabled"
 )
 ###############################################################################
 # Delete the deprecated functions.
 ###############################################################################
 add_custom_target(ci_test_delete_deprecated_functions
    COMMAND ${CMAKE_COMMAND}
    -DCMAKE_BUILD_TYPE=Debug -GNinja
    -DJSON_BuildTests=ON -DJSON_FastTests=ON -DJSON_DeleteDeprecatedFunctions=ON
    -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_delete_deprecated_functions
    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_delete_deprecated_functions
    COMMAND cd ${PROJECT_BINARY_DIR}/build_delete_deprecated_functions && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
    COMMENT "Compile and test with the deprecated functions deleted"
 )
 ###############################################################################
 # Disable global UDLs.
 ###############################################################################
@@ -396,11 +410,10 @@ list(FILTER INDENT_FILES EXCLUDE REGEX "/tests/thirdparty/|/tests/abi/include/nl
 set(include_dir ${PROJECT_SOURCE_DIR}/single_include/nlohmann)
 set(tool_dir ${PROJECT_SOURCE_DIR}/tools/amalgamate)
 add_custom_target(ci_test_amalgamation
-    COMMAND rm -fr ${include_dir}/json.hpp~ ${include_dir}/json_fwd.hpp~ ${include_dir}/json_literals.hpp~ ${include_dir}/json_view.hpp~
+    COMMAND rm -fr ${include_dir}/json.hpp~ ${include_dir}/json_fwd.hpp~ ${include_dir}/json_literals.hpp~
    COMMAND cp ${include_dir}/json.hpp ${include_dir}/json.hpp~
    COMMAND cp ${include_dir}/json_fwd.hpp ${include_dir}/json_fwd.hpp~
    COMMAND cp ${include_dir}/json_literals.hpp ${include_dir}/json_literals.hpp~
    COMMAND cp ${include_dir}/json_view.hpp ${include_dir}/json_view.hpp~
    COMMAND cp ${PROJECT_SOURCE_DIR}/BUILD.bazel ${PROJECT_SOURCE_DIR}/BUILD.bazel~
    COMMAND ${Python3_EXECUTABLE} -mvenv venv_astyle
@@ -410,14 +423,12 @@ add_custom_target(ci_test_amalgamation
    COMMAND ${Python3_EXECUTABLE} ${tool_dir}/amalgamate.py -c ${tool_dir}/config_json.json -s .
    COMMAND ${Python3_EXECUTABLE} ${tool_dir}/amalgamate.py -c ${tool_dir}/config_json_fwd.json -s .
    COMMAND cp ${PROJECT_SOURCE_DIR}/include/nlohmann/json_literals.hpp ${include_dir}/json_literals.hpp
-    COMMAND ${Python3_EXECUTABLE} ${tool_dir}/amalgamate.py -c ${tool_dir}/config_json_view.json -s .
+    COMMAND venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=none ${include_dir}/json.hpp ${include_dir}/json_fwd.hpp
    COMMAND venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=none ${include_dir}/json.hpp ${include_dir}/json_fwd.hpp ${include_dir}/json_view.hpp
    COMMAND ${CMAKE_COMMAND} -P ${PROJECT_SOURCE_DIR}/cmake/scripts/gen_bazel_build_file.cmake
    COMMAND diff ${include_dir}/json.hpp~ ${include_dir}/json.hpp
    COMMAND diff ${include_dir}/json_fwd.hpp~ ${include_dir}/json_fwd.hpp
    COMMAND diff ${include_dir}/json_literals.hpp~ ${include_dir}/json_literals.hpp
    COMMAND diff ${include_dir}/json_view.hpp~ ${include_dir}/json_view.hpp
    COMMAND diff ${PROJECT_SOURCE_DIR}/BUILD.bazel~ ${PROJECT_SOURCE_DIR}/BUILD.bazel
    COMMAND venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=orig ${INDENT_FILES}
@@ -704,7 +715,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_StrictNulHandling JSON_StrictBinaryUTF8 JSON_DeleteDeprecatedFunctions)
 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})
@@ -48,7 +48,6 @@ cc_library(
    name = "singleheader-json",
    hdrs = [
        "single_include/nlohmann/json.hpp",
        "single_include/nlohmann/json_view.hpp",
    ],
    includes = ["single_include"],
    visibility = ["//visibility:public"],
@@ -19,6 +19,7 @@ INSERT INTO searchIndex(name, type, path) VALUES ('format_as', 'Function', 'api/
 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');
@@ -131,74 +132,7 @@ INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::to_ubjson', 'Func
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::value', 'Method', 'api/basic_json/value/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::value_t', 'Enum', 'api/basic_json/value_t/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::~basic_json', 'Method', 'api/basic_json/~basic_json/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document', 'Class', 'api/basic_json_document/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::basic_json_document', 'Constructor', 'api/basic_json_document/basic_json_document/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::accept', 'Function', 'api/basic_json_document/accept/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::erase', 'Method', 'api/basic_json_document/erase/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::insert', 'Method', 'api/basic_json_document/insert/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::is_discarded', 'Method', 'api/basic_json_document/is_discarded/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::load', 'Function', 'api/basic_json_document/load/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::memory_usage', 'Method', 'api/basic_json_document/memory_usage/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::node_count', 'Method', 'api/basic_json_document/node_count/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::owns_source', 'Method', 'api/basic_json_document/owns_source/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::parse', 'Function', 'api/basic_json_document/parse/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::parse_copy', 'Function', 'api/basic_json_document/parse_copy/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::push_back', 'Method', 'api/basic_json_document/push_back/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::read', 'Method', 'api/basic_json_document/read/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::root', 'Method', 'api/basic_json_document/root/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::save', 'Method', 'api/basic_json_document/save/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::set', 'Method', 'api/basic_json_document/set/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::shrink_to_fit', 'Method', 'api/basic_json_document/shrink_to_fit/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::source', 'Method', 'api/basic_json_document/source/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view', 'Class', 'api/basic_json_view/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::basic_json_view', 'Constructor', 'api/basic_json_view/basic_json_view/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::at', 'Method', 'api/basic_json_view/at/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::back', 'Method', 'api/basic_json_view/back/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::begin', 'Method', 'api/basic_json_view/begin/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::cbegin', 'Method', 'api/basic_json_view/cbegin/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::cend', 'Method', 'api/basic_json_view/cend/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::contains', 'Method', 'api/basic_json_view/contains/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::count', 'Method', 'api/basic_json_view/count/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::dump', 'Method', 'api/basic_json_view/dump/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::empty', 'Method', 'api/basic_json_view/empty/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::end', 'Method', 'api/basic_json_view/end/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::find', 'Method', 'api/basic_json_view/find/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::front', 'Method', 'api/basic_json_view/front/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::get', 'Method', 'api/basic_json_view/get/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::get_string', 'Method', 'api/basic_json_view/get_string/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::get_to', 'Method', 'api/basic_json_view/get_to/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_array', 'Method', 'api/basic_json_view/is_array/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_binary', 'Method', 'api/basic_json_view/is_binary/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_boolean', 'Method', 'api/basic_json_view/is_boolean/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_discarded', 'Method', 'api/basic_json_view/is_discarded/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_null', 'Method', 'api/basic_json_view/is_null/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_number', 'Method', 'api/basic_json_view/is_number/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_number_float', 'Method', 'api/basic_json_view/is_number_float/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_number_integer', 'Method', 'api/basic_json_view/is_number_integer/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_number_unsigned', 'Method', 'api/basic_json_view/is_number_unsigned/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_object', 'Method', 'api/basic_json_view/is_object/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_primitive', 'Method', 'api/basic_json_view/is_primitive/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_string', 'Method', 'api/basic_json_view/is_string/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_structured', 'Method', 'api/basic_json_view/is_structured/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::items', 'Method', 'api/basic_json_view/items/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::materialize', 'Method', 'api/basic_json_view/materialize/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::number_format', 'Enum', 'api/basic_json_view/number_format/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::number_token', 'Method', 'api/basic_json_view/number_token/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator bool', 'Method', 'api/basic_json_view/operator_bool/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator<<', 'Operator', 'api/basic_json_view/operator_ltlt/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator[]', 'Operator', 'api/basic_json_view/operator[]/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator==', 'Operator', 'api/basic_json_view/operator_eq/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator!=', 'Operator', 'api/basic_json_view/operator_ne/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::size', 'Method', 'api/basic_json_view/size/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::source_offset', 'Method', 'api/basic_json_view/source_offset/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::type', 'Method', 'api/basic_json_view/type/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::type_name', 'Method', 'api/basic_json_view/type_name/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::value', 'Method', 'api/basic_json_view/value/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json', 'Class', 'api/json/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_document', 'Class', 'api/json_document/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_editable_document', 'Class', 'api/json_editable_document/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_editable_view', 'Class', 'api/json_editable_view/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_view', 'Class', 'api/json_view/index.html');
 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');
@@ -236,10 +170,6 @@ INSERT INTO searchIndex(name, type, path) VALUES ('operator""_json_pointer', 'Li
 INSERT INTO searchIndex(name, type, path) VALUES ('operator<<', 'Operator', 'api/operator_ltlt/index.html');
 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_json_document', 'Class', 'api/ordered_json_document/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('ordered_json_editable_document', 'Class', 'api/ordered_json_editable_document/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('ordered_json_editable_view', 'Class', 'api/ordered_json_editable_view/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('ordered_json_view', 'Class', 'api/ordered_json_view/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');
@@ -270,7 +200,6 @@ INSERT INTO searchIndex(name, type, path) VALUES ('Iterators', 'Guide', 'feature
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON Merge Patch', 'Guide', 'features/merge_patch/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON Patch and Diff', 'Guide', 'features/json_patch/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON Pointer', 'Guide', 'features/json_pointer/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Zero-copy JSON views', 'Guide', 'features/json_view/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('nlohmann Namespace', 'Guide', 'features/namespace/index.html');
 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');
@@ -290,6 +219,7 @@ INSERT INTO searchIndex(name, type, path) VALUES ('Supported Macros', 'Guide', '
 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_DELETE_DEPRECATED_FUNCTIONS', 'Macro', 'api/macros/json_delete_deprecated_functions/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');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DISABLE_ENUM_SERIALIZATION', 'Macro', 'api/macros/json_disable_enum_serialization/index.html');
@@ -313,6 +243,7 @@ INSERT INTO searchIndex(name, type, path) VALUES ('JSON_NO_THREAD_LOCAL', 'Macro
 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');
@@ -354,5 +285,3 @@ INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_JSON_SERIALIZE_ENUM_
 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');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_VIEW_NO_SIMD', 'Macro', 'api/macros/json_view_no_simd/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_VIEW_USE_SSSE3', 'Macro', 'api/macros/json_view_use_ssse3/index.html');
@@ -0,0 +1,53 @@
 # <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.
@@ -233,11 +233,12 @@ Strong exception safety: if an exception occurs, the original value stays intact
 - documentation on [checked access](../../features/element_access/checked_access.md)
 - [`operator[]`](operator%5B%5D.md) for unchecked access by reference
 - [`value`](value.md) for access with default value
 - [basic_json_view::at](../basic_json_view/at.md) - the same access on a zero-copy view
 ## Version history
 1. Added in version 1.0.0.
 2. Added in version 1.0.0.
-3. Added 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 [`operator[]`](operator[].md), [`value`](value.md), [`find`](find.md), and other lookup
   functions.
 4. Added in version 2.0.0.
@@ -58,7 +58,6 @@ Constant.
 ## See also
 - [front](front.md) to access the first element
 - [basic_json_view::back](../basic_json_view/back.md) - the same access on a zero-copy view
 ## Version history
@@ -293,6 +293,15 @@ 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"
@@ -466,7 +475,8 @@ basic_json(basic_json&& other) noexcept;
 1. Since version 1.0.0.
 2. Since version 1.0.0.
 3. Since version 2.1.0.
-4. Since version 3.2.0.
+4. Since version 3.2.0. Explicit for different string types if `JSON_USE_IMPLICIT_CONVERSIONS` is `0` since
   version 3.13.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
@@ -44,8 +44,6 @@ Constant.
 - [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
 - [basic_json_view::begin](../basic_json_view/begin.md) - the same iteration on a zero-copy view (in document order,
  not sorted by key)
 ## Version history
@@ -42,7 +42,6 @@ Constant.
 - [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
 - [basic_json_view::cbegin](../basic_json_view/cbegin.md) - the same iteration on a zero-copy view
 ## Version history
@@ -42,7 +42,6 @@ Constant.
 - [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
 - [basic_json_view::cend](../basic_json_view/cend.md) - the same iteration on a zero-copy view
 ## Version history
@@ -127,12 +127,13 @@ Logarithmic in the size of the JSON object.
 - [find](find.md) find a value in an object
 - [count](count.md) returns the number of occurrences of a key
 - [basic_json_view::contains](../basic_json_view/contains.md) - the same check on a zero-copy view
 ## 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.
+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.
 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.
@@ -80,11 +80,12 @@ Logarithmic in the size of the JSON object.
 - [find](find.md) find a value in an object
 - [contains](contains.md) checks whether a key exists
 - [basic_json_view::count](../basic_json_view/count.md) - the same check on a zero-copy view
 ## 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.
+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.
 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.
@@ -25,10 +25,12 @@ and `ensure_ascii` parameters.
    result consists of ASCII characters only.
 `error_handler` (in)
-:   how to react on decoding errors; there are three possible values (see [`error_handler_t`](error_handler_t.md):
+:   how to react on decoding errors; there are four 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), and `ignore` (ignore invalid UTF-8 sequences during serialization; all valid bytes are copied to the
+    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)).
+    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)).
 ## Return value
@@ -86,8 +88,6 @@ Binary values are serialized as an object containing two keys:
 - [to_string](to_string.md) returns a string representation of a JSON value
 - [operator<<](../operator_ltlt.md) serialize to stream
 - [`basic_json_view::dump`](../basic_json_view/dump.md) the corresponding function of `basic_json_view`, serializing
  directly from a flat index without building a `basic_json` value
 - [Serialization](../../features/serialization.md) - the serialization article
 ## Version history
@@ -96,3 +96,4 @@ 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.
@@ -70,3 +70,5 @@ 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`.
@@ -64,7 +64,6 @@ itself is empty which is `#!cpp false` in the case of a string.
 - [size](size.md) returns the number of elements
 - [clear](clear.md) clears the content and resets the value to the default value
 - [basic_json_view::empty](../basic_json_view/empty.md) - the same check on a zero-copy view
 ## Version history
@@ -43,7 +43,6 @@ Constant.
 - [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
 - [basic_json_view::end](../basic_json_view/end.md) - the same iteration on a zero-copy view
 ## Version history
@@ -213,5 +213,7 @@ Strong exception safety: if an exception occurs, the original value stays intact
 1. Added in version 1.0.0. Added support for binary types in version 3.8.0.
 2. Added in version 1.0.0. Added support for binary types in version 3.8.0.
 3. Added in version 1.0.0.
-4. Added in version 3.11.0.
+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.
 5. Added in version 1.0.0.
@@ -4,15 +4,31 @@
 enum class error_handler_t {
    strict,
    replace,
-    ignore
+    ignore,
    keep
 };
 ```
-This enumeration is used in the [`dump`](dump.md) function to choose how to treat decoding errors while serializing a
+This enumeration is used to choose how to treat ill-formed UTF-8 in a string value or object key:
-`basic_json` value. Three values are differentiated:
+
 - [`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:
 strict
-:   throw a `type_error` exception in case of invalid UTF-8
+:   throw a `type_error`/`parse_error` exception in case of invalid UTF-8
 replace
 :   replace invalid UTF-8 sequences with U+FFFD (� REPLACEMENT CHARACTER)
@@ -20,6 +36,12 @@ 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
@@ -45,3 +67,5 @@ ignore
 ## 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.
@@ -84,11 +84,12 @@ Logarithmic in the size of the JSON object.
 - [count](count.md) returns the number of occurrences of a key
 - [contains](contains.md) checks whether a key exists
 - [basic_json_view::find](../basic_json_view/find.md) - the same lookup on a zero-copy view
 ## 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.
+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.
 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.
@@ -5,12 +5,14 @@
 template<typename InputType>
 static basic_json from_bjdata(InputType&& i,
                              const bool strict = true,
-                              const bool allow_exceptions = true);
+                              const bool allow_exceptions = true,
                              const error_handler_t error_handler = error_handler_t::keep);
 // (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 bool allow_exceptions = true,
                              const error_handler_t error_handler = error_handler_t::keep);
 ```
 Deserializes a given input to a JSON value using the BJData (Binary JData) serialization format.
@@ -58,6 +60,12 @@ 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
@@ -73,7 +81,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
+  successfully, or if a string value or object key is not valid UTF-8 and `error_handler` is `strict`
 - Throws [out_of_range.408](../../home/exceptions.md#jsonexceptionout_of_range408) if the size of an optimized container
  or n-dimensional array cannot be represented by `std::size_t`
@@ -111,3 +119,13 @@ 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.
 !!! warning "Deprecation"
    - Overload (2) replaces calls to `from_bjdata` with a pointer and a length as first two parameters, which has been
      deprecated in version 3.13.0. This overload will be removed in version 4.0.0. Please replace all calls like
      `#!cpp from_bjdata(ptr, len, ...);` with `#!cpp from_bjdata(ptr, ptr+len, ...);`.
    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
    function.
@@ -106,3 +106,12 @@ Linear in the size of the input.
 ## Version history
 - Added in version 3.13.0.
 !!! warning "Deprecation"
    - Overload (2) replaces calls to `from_bon8` with a pointer and a length as first two parameters, which has been
      deprecated in version 3.13.0. This overload will be removed in version 4.0.0. Please replace all calls like
      `#!cpp from_bon8(ptr, len, ...);` with `#!cpp from_bon8(ptr, ptr+len, ...);`.
    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
    function.
@@ -5,12 +5,14 @@
 template<typename InputType>
 static basic_json from_bson(InputType&& i,
                            const bool strict = true,
-                            const bool allow_exceptions = true);
+                            const bool allow_exceptions = true,
                            const error_handler_t error_handler = error_handler_t::keep);
 // (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 bool allow_exceptions = true,
                            const error_handler_t error_handler = error_handler_t::keep);
 ```
 Deserializes a given input to a JSON value using the BSON (Binary JSON) serialization format.
@@ -58,6 +60,12 @@ 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
@@ -75,6 +83,8 @@ 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
@@ -111,6 +121,7 @@ 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"
@@ -6,14 +6,16 @@ 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 cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error,
                            const error_handler_t error_handler = error_handler_t::keep);
 // (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 cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error,
                            const error_handler_t error_handler = error_handler_t::keep);
 ```
 Deserializes a given input to a JSON value using the CBOR (Concise Binary Object Representation) serialization format.
@@ -65,6 +67,12 @@ 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
@@ -80,8 +88,9 @@ 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
+- Throws [parse_error.113](../../home/exceptions.md#jsonexceptionparse_error113) if a map key is not a string (keys of
-  types are not supported, as JSON object keys are always strings) or a string is malformed
+  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`
 ## Complexity
@@ -121,6 +130,7 @@ 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"
@@ -5,12 +5,14 @@
 template<typename InputType>
 static basic_json from_msgpack(InputType&& i,
                               const bool strict = true,
-                               const bool allow_exceptions = true);
+                               const bool allow_exceptions = true,
                               const error_handler_t error_handler = error_handler_t::keep);
 // (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 bool allow_exceptions = true,
                               const error_handler_t error_handler = error_handler_t::keep);
 ```
 Deserializes a given input to a JSON value using the MessagePack serialization format.
@@ -58,6 +60,12 @@ 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
@@ -73,8 +81,9 @@ 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
+- Throws [parse_error.113](../../home/exceptions.md#jsonexceptionparse_error113) if a map key is not a string (keys of
-  types are not supported, as JSON object keys are always strings) or a string is malformed
+  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`
 ## Complexity
@@ -113,6 +122,7 @@ 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"
@@ -5,12 +5,14 @@
 template<typename InputType>
 static basic_json from_ubjson(InputType&& i,
                              const bool strict = true,
-                              const bool allow_exceptions = true);
+                              const bool allow_exceptions = true,
                              const error_handler_t error_handler = error_handler_t::keep);
 // (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 bool allow_exceptions = true,
                              const error_handler_t error_handler = error_handler_t::keep);
 ```
 Deserializes a given input to a JSON value using the UBJSON (Universal Binary JSON) serialization format.
@@ -58,6 +60,12 @@ 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
@@ -73,7 +81,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
+  successfully, or if a string value or object key is not valid UTF-8 and `error_handler` is `strict`
 - Throws [out_of_range.408](../../home/exceptions.md#jsonexceptionout_of_range408) if the size of an optimized container
  or n-dimensional array cannot be represented by `std::size_t`
@@ -112,6 +120,7 @@ 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"
@@ -51,7 +51,6 @@ Constant.
 ## See also
 - [back](back.md) to access the last element
 - [basic_json_view::front](../basic_json_view/front.md) - the same access on a zero-copy view
 ## Version history
@@ -183,8 +183,6 @@ overload (3).
 - [get_ref](get_ref.md) get a reference to the stored value
 - [operator ValueType](operator_ValueType.md) get a value via implicit conversion
 - [Converting values](../../features/conversions.md) - the type conversions article
 - [basic_json_view::get](../basic_json_view/get.md) - the same conversion on a zero-copy view (many types are
  converted without ever building a `basic_json` value)
 ## Version history
@@ -61,8 +61,6 @@ Constant.
 ## See also
 - [get_ptr()](get_ptr.md) get a pointer value
 - [basic_json_view::get_string](../basic_json_view/get_string.md) - the closest counterpart on a zero-copy view: a
  string without a copy, but as a view rather than a reference to a value that must already exist
 ## Version history
@@ -72,7 +72,6 @@ Depends on the `json_serializer<ValueType>::from_json()` implementation.
 - [get_ref](get_ref.md) get a reference to the stored value
 - [get_ptr](get_ptr.md) get a pointer to the stored value
 - [Converting values](../../features/conversions.md) - the type conversions article
 - [basic_json_view::get_to](../basic_json_view/get_to.md) - the same conversion on a zero-copy view
 ## Version history
@@ -200,6 +200,7 @@ 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
@@ -40,7 +40,6 @@ Constant.
 - [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
 - [basic_json_view::is_array](../basic_json_view/is_array.md) - the same check on a zero-copy view
 ## Version history
@@ -39,7 +39,6 @@ Constant.
 - [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
 - [basic_json_view::is_binary](../basic_json_view/is_binary.md) - the same check on a zero-copy view
 ## Version history
@@ -38,7 +38,6 @@ Constant.
 - [boolean_t](boolean_t.md) the type used to store JSON booleans
 - [is_primitive](is_primitive.md) checks whether the JSON value is primitive
 - [basic_json_view::is_boolean](../basic_json_view/is_boolean.md) - the same check on a zero-copy view
 ## Version history
@@ -85,11 +85,6 @@ with `allow_exceptions` set to `#!cpp false`: a parse error then yields a discar
    --8<-- "examples/is_discarded__parse.output"
    ```
 ## See also
 - [basic_json_view::is_discarded](../basic_json_view/is_discarded.md) - the corresponding check on a zero-copy view,
  which is `#!cpp true` if the view refers to no value
 ## Version history
 - Added in version 1.0.0.
@@ -40,7 +40,6 @@ Constant.
 - [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
 - [basic_json_view::is_null](../basic_json_view/is_null.md) - the same check on a zero-copy view
 ## Version history
@@ -49,7 +49,6 @@ constexpr bool is_number() const noexcept
 - [is_number_integer()](is_number_integer.md) check if the value is an integer or unsigned integer number
 - [is_number_unsigned()](is_number_unsigned.md) check if the value is an unsigned integer number
 - [is_number_float()](is_number_float.md) check if the value is a floating-point number
 - [basic_json_view::is_number](../basic_json_view/is_number.md) - the same check on a zero-copy view
 ## Version history
@@ -40,7 +40,6 @@ Constant.
 - [is_number()](is_number.md) check if the value is a number
 - [is_number_integer()](is_number_integer.md) check if the value is an integer or unsigned integer number
 - [is_number_unsigned()](is_number_unsigned.md) check if the value is an unsigned integer number
 - [basic_json_view::is_number_float](../basic_json_view/is_number_float.md) - the same check on a zero-copy view
 ## Version history
@@ -40,7 +40,6 @@ Constant.
 - [is_number()](is_number.md) check if the value is a number
 - [is_number_unsigned()](is_number_unsigned.md) check if the value is an unsigned integer number
 - [is_number_float()](is_number_float.md) check if the value is a floating-point number
 - [basic_json_view::is_number_integer](../basic_json_view/is_number_integer.md) - the same check on a zero-copy view
 ## Version history
@@ -40,7 +40,6 @@ Constant.
 - [is_number()](is_number.md) check if the value is a number
 - [is_number_integer()](is_number_integer.md) check if the value is an integer or unsigned integer number
 - [is_number_float()](is_number_float.md) check if the value is a floating-point number
 - [basic_json_view::is_number_unsigned](../basic_json_view/is_number_unsigned.md) - the same check on a zero-copy view
 ## Version history
@@ -40,7 +40,6 @@ Constant.
 - [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
 - [basic_json_view::is_object](../basic_json_view/is_object.md) - the same check on a zero-copy view
 ## Version history
@@ -62,7 +62,6 @@ This library extends primitive types to binary types, because binary types are r
 - [is_boolean()](is_boolean.md) returns whether the JSON value is a boolean
 - [is_number()](is_number.md) returns whether the JSON value is a number
 - [is_binary()](is_binary.md) returns whether the JSON value is a binary array
 - [basic_json_view::is_primitive](../basic_json_view/is_primitive.md) - the same check on a zero-copy view
 ## Version history
@@ -39,7 +39,6 @@ Constant.
 - [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
 - [basic_json_view::is_string](../basic_json_view/is_string.md) - the same check on a zero-copy view
 ## Version history
@@ -57,7 +57,6 @@ Note that though strings are containers in C++, they are treated as primitive va
 - [is_primitive()](is_primitive.md) returns whether JSON value is primitive
 - [is_array()](is_array.md) returns whether the value is an array
 - [is_object()](is_object.md) returns whether the value is an object
 - [basic_json_view::is_structured](../basic_json_view/is_structured.md) - the same check on a zero-copy view
 ## Version history
@@ -99,8 +99,6 @@ When iterating over an array, `key()` will return the index of the element as st
 - [begin](begin.md) returns an iterator to the first element
 - [end](end.md) returns an iterator to one past the last element
 - [basic_json_view::items](../basic_json_view/items.md) - the same range on a zero-copy view (`#!cpp const auto`,
  not `#!cpp const auto&`: items are produced on the fly)
 ## Version history
@@ -27,6 +27,18 @@ 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
@@ -45,8 +57,10 @@ A `CustomBaseClass` with non-static data members forfeits `basic_json`'s
 ## 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.
@@ -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`, `ilecpp`, `msvc`, `pgcpp`, `sunpro`, and `unknown`), and `version` (the compiler version). On HP aCC compilers, `compiler` is instead the plain string `hp`. |
+| `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). |
 | `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`.                                                                                                                                                                             |
@@ -23,10 +23,9 @@ type to use.
 ## Template parameters
 `NumberFloatType`
-:   the type to store floating-point numbers. The parser converts `#!cpp float`, `#!cpp double`, and a
+:   the type to store floating-point numbers. Parsing and serialization are implemented in terms of
-    `#!cpp long double` that is IEEE 754 binary64 itself and other `#!cpp long double` formats with
+    `#!cpp std::strtof`/`#!cpp std::strtod`/`#!cpp std::strtold` and `#!cpp std::snprintf`, so the type must be
-    `#!cpp std::from_chars` or `#!cpp std::strtold`, and serialization falls back to `#!cpp std::snprintf`, so the
+    `#!cpp float`, `#!cpp double`, or `#!cpp long double`. The
    type must be `#!cpp float`, `#!cpp double`, or `#!cpp long double`. The
    [binary formats](../../features/binary_formats/index.md) additionally require `#!cpp float` or `#!cpp double`,
    because they have no encoding for `#!cpp long double`. See
    [Template Parameter Requirements](../../features/types/template_parameters.md#numberfloattype).
@@ -89,6 +89,9 @@ 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()`.
@@ -103,9 +106,12 @@ 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.
+    1. If the element at index `idx` does not exist, the behavior is undefined and is **guarded by a
       [runtime assertion](../../features/assertions.md)**!
    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
@@ -269,15 +275,15 @@ Strong exception safety: if an exception occurs, the original value stays intact
 - documentation on [runtime assertions](../../features/assertions.md)
 - see [`at`](at.md) for access by reference with range checking
 - see [`value`](value.md) for access with default value
 - [basic_json_view::operator[]](../basic_json_view/operator%5B%5D.md) - the same access on a zero-copy view (always
  returns a discarded view instead of assuming undefined behavior)
 ## 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`.
+   accessing it out of bounds when `idx` equals the maximum value of `size_type`. A missing index in the const version
   is guarded by a runtime assertion since version 3.13.0.
 2. Added in version 1.0.0. Added overloads for `T* key` in version 1.1.0. 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.
+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.
@@ -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;  // (2)
+bool operator==(const_reference lhs, const ScalarType rhs) noexcept(/* see below */); // (2)
 template<typename ScalarType>
-bool operator==(ScalarType lhs, const const_reference rhs) noexcept;  // (2)
+bool operator==(ScalarType lhs, const const_reference rhs) noexcept(/* see below */); // (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)
+    bool operator==(ScalarType rhs) const noexcept(/* see below */); // (2)
 };
 ```
@@ -46,7 +46,12 @@ whether the values `lhs`/`*this` and `rhs` are equal
 ## Exception safety
-No-throw guarantee: this function never throws exceptions.
+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).
 ## Complexity
@@ -166,10 +171,9 @@ Linear.
 - [operator!=](operator_ne.md) compare for inequality
 - [operator<=>](operator_spaceship.md) comparison: 3-way (C++20)
 - [basic_json_view::operator==](../basic_json_view/operator_eq.md) - the same comparison on a zero-copy view, without
  building a `basic_json` value for it
 ## Version history
 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;  // (2)
+bool operator>=(const_reference lhs, const ScalarType rhs) noexcept(/* see below */); // (2)
 template<typename ScalarType>
-bool operator>=(ScalarType lhs, const const_reference rhs) noexcept;  // (2)
+bool operator>=(ScalarType lhs, const const_reference rhs) noexcept(/* see below */); // (2)
 ```
 1. Compares whether one JSON value `lhs` is greater than or equal to another JSON value `rhs` according to the following
@@ -39,7 +39,12 @@ whether `lhs` is greater than or equal to `rhs`
 ## Exception safety
-No-throw guarantee: this function never throws exceptions.
+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).
 ## Complexity
@@ -94,3 +99,4 @@ 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;  // (2)
+bool operator>(const_reference lhs, const ScalarType rhs) noexcept(/* see below */); // (2)
 template<typename ScalarType>
-bool operator>(ScalarType lhs, const const_reference rhs) noexcept;  // (2)
+bool operator>(ScalarType lhs, const const_reference rhs) noexcept(/* see below */); // (2)
 ```
 1. Compares whether one JSON value `lhs` is greater than another JSON value `rhs` according to the
@@ -39,7 +39,12 @@ whether `lhs` is greater than `rhs`
 ## Exception safety
-No-throw guarantee: this function never throws exceptions.
+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).
 ## Complexity
@@ -84,3 +89,4 @@ 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;  // (2)
+bool operator<=(const_reference lhs, const ScalarType rhs) noexcept(/* see below */); // (2)
 template<typename ScalarType>
-bool operator<=(ScalarType lhs, const const_reference rhs) noexcept;  // (2)
+bool operator<=(ScalarType lhs, const const_reference rhs) noexcept(/* see below */); // (2)
 ```
 1. Compares whether one JSON value `lhs` is less than or equal to another JSON value `rhs`
@@ -40,7 +40,12 @@ whether `lhs` is less than or equal to `rhs`
 ## Exception safety
-No-throw guarantee: this function never throws exceptions.
+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).
 ## Complexity
@@ -95,3 +100,4 @@ 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;  // (2)
+bool operator<(const_reference lhs, const ScalarType rhs) noexcept(/* see below */); // (2)
 template<typename ScalarType>
-bool operator<(ScalarType lhs, const const_reference rhs) noexcept;  // (2)
+bool operator<(ScalarType lhs, const const_reference rhs) noexcept(/* see below */); // (2)
 ```
 1. Compares whether one JSON value `lhs` is less than another JSON value `rhs` according to the
@@ -49,7 +49,12 @@ whether `lhs` is less than `rhs`
 ## Exception safety
-No-throw guarantee: this function never throws exceptions.
+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).
 ## Complexity
@@ -94,3 +99,4 @@ 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;  // (2)
+bool operator!=(const_reference lhs, const ScalarType rhs) noexcept(/* see below */); // (2)
 template<typename ScalarType>
-bool operator!=(ScalarType lhs, const const_reference rhs) noexcept;  // (2)
+bool operator!=(ScalarType lhs, const const_reference rhs) noexcept(/* see below */); // (2)
 ```
 1. Compares two JSON values for inequality. Returns `#!cpp !(lhs == rhs)`.
@@ -36,7 +36,12 @@ whether the values `lhs`/`*this` and `rhs` are not equal
 ## Exception safety
-No-throw guarantee: this function never throws exceptions.
+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).
 ## Complexity
@@ -90,8 +95,6 @@ Linear.
 - [operator==](operator_eq.md) comparison: equal
 - [operator<=>](operator_spaceship.md) comparison: 3-way (C++20)
 - [basic_json_view::operator!=](../basic_json_view/operator_ne.md) - the same comparison on a zero-copy view, without
  building a `basic_json` value for it
 ## Version history
@@ -100,3 +103,4 @@ Linear.
   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`.
@@ -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; // (2)
+    std::partial_ordering operator<=>(const ScalarType rhs) const noexcept(/* see below */); // (2)
 };
 ```
@@ -39,7 +39,12 @@ the `std::partial_ordering` of the 3-way comparison of `*this` and `rhs`
 ## Exception safety
-No-throw guarantee: this function never throws exceptions.
+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).
 ## Complexity
@@ -98,3 +103,4 @@ 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`.
@@ -55,7 +55,6 @@ JSON value which is `1` in the case of a string.
 - [empty](empty.md) checks whether the JSON value has no elements
 - [max_size](max_size.md) returns the maximum possible number of elements
 - [basic_json_view::size](../basic_json_view/size.md) - the same function on a zero-copy view
 ## Version history
@@ -5,15 +5,18 @@
 static std::vector<std::uint8_t> to_bjdata(const basic_json& j,
                                           const bool use_size = false,
                                           const bool use_type = false,
-                                           const bjdata_version_t version = bjdata_version_t::draft2);
+                                           const bjdata_version_t version = bjdata_version_t::draft2,
                                           const error_handler_t error_handler = error_handler_t::keep);
 // (2)
 static void to_bjdata(const basic_json& j, detail::output_adapter<std::uint8_t> o,
                      const bool use_size = false, const bool use_type = false,
-                      const bjdata_version_t version = bjdata_version_t::draft2);
+                      const bjdata_version_t version = bjdata_version_t::draft2,
                      const error_handler_t error_handler = error_handler_t::keep);
 static void to_bjdata(const basic_json& j, detail::output_adapter<char> o,
                      const bool use_size = false, const bool use_type = false,
-                      const bjdata_version_t version = bjdata_version_t::draft2);
+                      const bjdata_version_t version = bjdata_version_t::draft2,
                      const error_handler_t error_handler = error_handler_t::keep);
 ```
 Serializes a given JSON value `j` to a byte vector using the BJData (Binary JData) serialization format. BJData aims to
@@ -43,6 +46,12 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 :   which version of BJData to use (see note on "Binary values" on [BJData](../../features/binary_formats/bjdata.md));
 optional, `#!cpp bjdata_version_t::draft2` by default.
 `error_handler` (in)
 :   how to treat a string or object key in `j` that is not valid UTF-8; see [`error_handler_t`](error_handler_t.md).
    The default, `keep`, writes the ill-formed bytes to the output as is, as every version of `to_bjdata` did before
    this parameter was added; `strict` throws; `replace`/`ignore` sanitize it the same way [`dump`](dump.md) would.
    If [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled, the default is `strict` instead.
 ## Return value
 1. BJData serialization as byte vector
@@ -56,6 +65,9 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [`other_error.502`](../../home/exceptions.md#jsonexceptionother_error502) if `use_type` is true and `use_size`
  is false, and `j` contains a non-empty array, object, or binary value.
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
  not valid UTF-8 and `error_handler` is `strict` (the default only if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
 ## Complexity
@@ -104,4 +116,7 @@ Linear in the size of the JSON value `j`.
 ## Version history
 - Added in version 3.11.0.
- BJData version parameter (for draft3 binary encoding) added in version 3.12.0.
+- BJData version parameter (for draft3 binary encoding) added in version 3.12.0.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
  that is not valid UTF-8 unchanged, as before; `strict` (the default if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
@@ -2,11 +2,14 @@
 ```cpp
 // (1)
-static std::vector<std::uint8_t> to_bson(const basic_json& j);
+static std::vector<std::uint8_t> to_bson(const basic_json& j,
                                         const error_handler_t error_handler = error_handler_t::keep);
 // (2)
-static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o);
+static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o,
-static void to_bson(const basic_json& j, detail::output_adapter<char> o);
+                    const error_handler_t error_handler = error_handler_t::keep);
 static void to_bson(const basic_json& j, detail::output_adapter<char> o,
                    const error_handler_t error_handler = error_handler_t::keep);
 ```
 BSON (Binary JSON) is a binary format in which zero or more ordered key/value pairs are stored as a single entity (a
@@ -25,6 +28,12 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 `o` (in)
 :   output adapter to write serialization to
 `error_handler` (in)
 :   how to treat a string or object key in `j` that is not valid UTF-8; see [`error_handler_t`](error_handler_t.md).
    The default, `keep`, writes the ill-formed bytes to the output as is, as every version of `to_bson` did before
    this parameter was added; `strict` throws; `replace`/`ignore` sanitize it the same way [`dump`](dump.md) would.
    If [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled, the default is `strict` instead.
 ## Return value
 1. BSON serialization as a byte vector
@@ -46,6 +55,9 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [`out_of_range.415`](../../home/exceptions.md#jsonexceptionout_of_range415) if the subtype of a binary value
  exceeds 255, the maximum of the BSON binary subtype; example:
  `"subtype 70000 is too large for the BSON binary subtype (max 255)"`
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key is
  not valid UTF-8 and `error_handler` is `strict` (the default only if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
 ## Complexity
@@ -98,3 +110,7 @@ pass before anything is written.
 - Throws `out_of_range.412` and `out_of_range.415` since version 3.13.0.
 - Linear in the size of `j`, and no longer limited by the call stack for deeply nested values, since version 3.13.0.
 - `out_of_range.415` is now detected before anything is written, like the other exceptions above, since version 3.13.0.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
  that is not valid UTF-8 unchanged, as before; `strict` (the default if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316` before anything
  is written.
@@ -2,11 +2,14 @@
 ```cpp
 // (1)
-static std::vector<std::uint8_t> to_cbor(const basic_json& j);
+static std::vector<std::uint8_t> to_cbor(const basic_json& j,
                                          const error_handler_t error_handler = error_handler_t::keep);
 // (2)
-static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o);
+static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o,
-static void to_cbor(const basic_json& j, detail::output_adapter<char> o);
+                     const error_handler_t error_handler = error_handler_t::keep);
 static void to_cbor(const basic_json& j, detail::output_adapter<char> o,
                     const error_handler_t error_handler = error_handler_t::keep);
 ```
 Serializes a given JSON value `j` to a byte vector using the CBOR (Concise Binary Object Representation) serialization
@@ -26,6 +29,12 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 `o` (in)
 :   output adapter to write serialization to
 `error_handler` (in)
 :   how to treat a string or object key in `j` that is not valid UTF-8; see [`error_handler_t`](error_handler_t.md).
    The default, `keep`, writes the ill-formed bytes to the output as is, as every version of `to_cbor` did before
    this parameter was added; `strict` throws; `replace`/`ignore` sanitize it the same way [`dump`](dump.md) would.
    If [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled, the default is `strict` instead.
 ## Return value
 1. CBOR serialization as a byte vector
@@ -35,6 +44,12 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
 ## Exceptions
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
  not valid UTF-8 and `error_handler` is `strict` (the default only if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
 ## Complexity
 Linear in the size of the JSON value `j`.
@@ -68,3 +83,6 @@ Linear in the size of the JSON value `j`.
 - Added in version 2.0.9.
 - Compact representation of floating-point numbers added in version 3.8.0.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
  that is not valid UTF-8 unchanged, as before; `strict` (the default if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
@@ -2,11 +2,14 @@
 ```cpp
 // (1)
-static std::vector<std::uint8_t> to_msgpack(const basic_json& j);
+static std::vector<std::uint8_t> to_msgpack(const basic_json& j,
                                            const error_handler_t error_handler = error_handler_t::keep);
 // (2)
-static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o);
+static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o,
-static void to_msgpack(const basic_json& j, detail::output_adapter<char> o);
+                       const error_handler_t error_handler = error_handler_t::keep);
 static void to_msgpack(const basic_json& j, detail::output_adapter<char> o,
                       const error_handler_t error_handler = error_handler_t::keep);
 ```
 Serializes a given JSON value `j` to a byte vector using the MessagePack serialization format. MessagePack is a binary
@@ -25,6 +28,13 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 `o` (in)
 :   output adapter to write serialization to
 `error_handler` (in)
 :   how to treat a string or object key in `j` that is not valid UTF-8; see [`error_handler_t`](error_handler_t.md).
    The default, `keep`, writes the ill-formed bytes to the output as is, as every version of `to_msgpack` did before
    this parameter was added and as the MessagePack specification allows; `strict` throws; `replace`/`ignore` sanitize
    it the same way [`dump`](dump.md) would. Unlike the other binary writers, the default stays `keep` even if
    [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled.
 ## Return value
 1. MessagePack serialization as a byte vector
@@ -42,6 +52,8 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [`out_of_range.415`](../../home/exceptions.md#jsonexceptionout_of_range415) if the subtype of a binary value
  exceeds 255, the maximum of the MessagePack ext type; example:
  `"subtype 70000 is too large for the MessagePack ext type (max 255)"`
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
  not valid UTF-8 and `error_handler` is `strict`
 ## Complexity
@@ -91,6 +103,8 @@ Linear in the size of the JSON value `j`.
 - Added in version 2.0.9.
 - Throws `out_of_range.412` and `out_of_range.415` since version 3.13.0.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
  that is not valid UTF-8 unchanged, as before.
 - Fixed in version 3.13.0 to serialize `number_integer_t`/`number_unsigned_t` pairs of different width correctly;
  before, integers could be serialized with the wrong value if `number_integer_t` was narrower than
  `number_unsigned_t`.
@@ -4,13 +4,16 @@
 // (1)
 static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
                                           const bool use_size = false,
-                                           const bool use_type = false);
+                                           const bool use_type = false,
                                           const error_handler_t error_handler = error_handler_t::keep);
 // (2)
 static void to_ubjson(const basic_json& j, detail::output_adapter<std::uint8_t> o,
-                      const bool use_size = false, const bool use_type = false);
+                      const bool use_size = false, const bool use_type = false,
                      const error_handler_t error_handler = error_handler_t::keep);
 static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
-                      const bool use_size = false, const bool use_type = false);
+                      const bool use_size = false, const bool use_type = false,
                      const error_handler_t error_handler = error_handler_t::keep);
 ```
 Serializes a given JSON value `j` to a byte vector using the UBJSON (Universal Binary JSON) serialization format. UBJSON
@@ -36,6 +39,12 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 :   whether to add type annotations to container types (must be combined with `#!cpp use_size = true`); optional,
    `#!cpp false` by default.
 `error_handler` (in)
 :   how to treat a string or object key in `j` that is not valid UTF-8; see [`error_handler_t`](error_handler_t.md).
    The default, `keep`, writes the ill-formed bytes to the output as is, as every version of `to_ubjson` did before
    this parameter was added; `strict` throws; `replace`/`ignore` sanitize it the same way [`dump`](dump.md) would.
    If [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled, the default is `strict` instead.
 ## Return value
 1. UBJSON serialization as a byte vector
@@ -49,6 +58,9 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [`other_error.502`](../../home/exceptions.md#jsonexceptionother_error502) if `use_type` is true and `use_size`
  is false, and `j` contains a non-empty array, object, or binary value.
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
  not valid UTF-8 and `error_handler` is `strict` (the default only if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
 ## Complexity
@@ -97,3 +109,6 @@ Linear in the size of the JSON value `j`.
 ## Version history
 - Added in version 3.1.0.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
  that is not valid UTF-8 unchanged, as before; `strict` (the default if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
@@ -52,7 +52,6 @@ Constant.
 - [operator value_t](operator_value_t.md) implicit conversion operator equivalent to this named member function
 - [type_name](type_name.md) returns the type as a string, for use in error messages
 - [value_t](value_t.md) the enumeration of JSON types
 - [basic_json_view::type](../basic_json_view/type.md) - the same function on a zero-copy view
 ## Version history
@@ -56,7 +56,6 @@ Constant.
 - [type](type.md) returns the type of the JSON value
 - [value_t](value_t.md) the enumeration of JSON types
 - [basic_json_view::type_name](../basic_json_view/type_name.md) - the same function on a zero-copy view
 ## Version history
@@ -216,14 +216,15 @@ changes to any JSON value.
 - see [`at`](at.md) for access by reference with range checking
 - see [`operator[]`](operator%5B%5D.md) for unchecked access by reference
 - [basic_json_view::value](../basic_json_view/value.md) - the same access on a zero-copy view
 ## Version history
 1. Added in version 1.0.0. Changed parameter `default_value` type from `const ValueType&` to `ValueType&&` in version
   3.11.0. 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.
-2. Added in version 3.11.0. Made `ValueType` the first template parameter in version 3.11.2.
+2. Added in version 3.11.0. Made `ValueType` the first template parameter in version 3.11.2. Fixed in version 3.13.0
   to consistently accept `std::string_view`-convertible keys, as already supported by
   [`operator[]`](operator[].md), [`at`](at.md), [`find`](find.md), and other lookup functions.
 3. Added in version 2.0.2. Extended to work with arrays in version 3.13.0, including fixing an issue where resolving
   `ptr` through an array unexpectedly threw `out_of_range` instead of returning the resolved element (or
   `default_value`, as documented).
@@ -1,67 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>accept
 ```cpp
 template<typename InputType>
 static bool accept(InputType&& input,
                   const bool ignore_comments = false,
                   const bool ignore_trailing_commas = false);
 ```
 Checks whether the input is valid JSON, accepting and rejecting exactly what
 [`BasicJsonType::accept()`](../basic_json/accept.md) does, with the same options. Unlike [`parse()`](parse.md), this
 function never throws an exception for invalid input, and the returned `#!cpp bool` is the only result -- no document
 is returned.
 ## Template parameters
 `InputType`
 :   A compatible input; see [`parse`](parse.md#template-parameters).
 ## Parameters
 `input` (in)
 :   Input to check.
 `ignore_comments` (in)
 :   whether comments should be ignored and treated like whitespace (`#!cpp true`) or yield a parse error
    (`#!cpp false`); (optional, `#!cpp false` by default)
 `ignore_trailing_commas` (in)
 :   whether trailing commas in arrays or objects should be ignored and treated like whitespace (`#!cpp true`) or
    yield a parse error (`#!cpp false`); (optional, `#!cpp false` by default)
 ## Return value
 Whether the input is valid JSON.
 ## Exception safety
 Strong guarantee: this function itself never throws for an invalid input; it can only throw what allocating the
 input's own copy (for inputs that are always read into a buffer) throws.
 ## Complexity
 Linear in the length of the input.
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__accept.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__accept.output"
    ```
 ## See also
 - [parse](parse.md) - deserialize from a compatible input
 - [`BasicJsonType::accept`](../basic_json/accept.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,58 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>basic_json_document
 ```cpp
 // (1)
 basic_json_document() = default;
 // (2)
 basic_json_document(basic_json_document&& other) noexcept = default;
 // (3)
 basic_json_document(const basic_json_document&) = delete;
 ```
 1. Creates an empty (discarded) document: [`root()`](root.md) returns a discarded view, and
   [`is_discarded()`](is_discarded.md) is `#!cpp true`.
 2. Move constructor. Takes over `other`'s index and, if owned, its text; `other` is left as an empty document. Views
   taken from `other` before the move remain valid, because the index is heap-allocated independently of the
   `basic_json_document` object.
 3. `basic_json_document` is move-only. Copying is disabled because it would either duplicate a potentially large index
   and text, or leave two documents claiming to borrow the same buffer.
 ## Parameters
 `other` (in)
 :   another document to move the index and text from
 ## Exception safety
 No-throw guarantee: the default and move constructors never throw exceptions.
 ## Complexity
 Constant, for the default and move constructors.
 ## Examples
 ??? example
    The example below shows the default constructor and demonstrates that `basic_json_document` is move-only.
    ```cpp
    --8<-- "examples/basic_json_document__basic_json_document.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__basic_json_document.output"
    ```
 ## See also
 - [parse](parse.md) - deserialize from a compatible input
 - [is_discarded](is_discarded.md) - return whether the last parse failed
 ## Version history
 - Added in version 3.13.0.
@@ -1,128 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>erase
 ```cpp
 // (1)
 std::size_t erase(view_type object, string_view_t key);
 // (2)
 template<typename I>
 void erase(view_type array, I idx);
 // (3)
 std::size_t erase(const json_pointer& ptr);
 ```
 Only an **editable** document (`#!cpp Editable == true`, e.g. [`json_editable_document`](../json_editable_document.md))
 has `erase`; calling it on a read-only `basic_json_document` fails to compile (`#!cpp static_assert`).
 1. Removes every member of `object` whose key is `key` (see [Notes](#notes) on duplicate keys) and returns how many
   were removed; `#!cpp 0` if `object` has no member with this key.
 2. Removes the element at index `idx` of `array`, which must already exist (`#!cpp idx < array.size()`).
 3. Removes the value the JSON pointer `ptr` refers to, relative to [`root()`](root.md), and returns how many values
   were removed: the *parent* of the target must already exist, and the target itself is removed as in 1. (an object
   member; `#!cpp 0` or more) or 2. (an array element; always `#!cpp 1`). `ptr` must not be empty -- [`root()`](root.md)
   itself cannot be erased.
 ## Template parameters
 `I`
 :   an integral type other than `#!cpp bool`, deduced (overloads taking a `#!cpp bool` or a non-integral type for
    `idx` do not participate in overload resolution).
 ## Parameters
 `object` (in)
 :   the object to remove a member of
 `array` (in)
 :   the array to remove an element of
 `key` (in)
 :   the key of the member(s) to remove
 `idx` (in)
 :   the index of the element to remove; a negative value throws (see [Exceptions](#exceptions))
 `ptr` (in)
 :   a JSON pointer to the value to remove, relative to `root()`
 ## Return value
 1. the number of removed members (`#!cpp 0` if `object` had none with this `key`)
 2. (nothing)
 3. the number of removed values (`#!cpp 0` or more for an object member, always `#!cpp 1` for an array element)
 ## Exceptions
 1. Throws [`type_error.307`](../../home/exceptions.md#jsonexceptiontype_error307) if `object` is not an object -- the
   same message [`BasicJsonType::erase`](../basic_json/erase.md) throws for the same type.
 2. Throws `type_error.307` if `array` is not an array. Throws
   [`out_of_range.401`](../../home/exceptions.md#jsonexceptionout_of_range401) if `idx` is negative, or if
   `#!cpp idx >= array.size()`.
 3. Throws [`out_of_range.405`](../../home/exceptions.md#jsonexceptionout_of_range405) ("JSON pointer has no parent")
   if `ptr` is empty. Throws what [`at`](../basic_json_view/at.md) throws (overload 3) for resolving `ptr`'s parent.
   For the last reference token itself: if the parent is an array, throws what 2. throws for an index that is out of
   range, or, for a token that is not a valid array index,
   [`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106) (a leading `#!cpp '0'`),
   [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) (not a number),
   [`out_of_range.410`](../../home/exceptions.md#jsonexceptionout_of_range410) (too large for `size_type`), or
   [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) (an empty token); otherwise (an
   object, or a primitive value the pointer's parent resolves to) throws what 1. throws.
 Every overload also throws [`invalid_iterator.202`](../../home/exceptions.md#jsonexceptioninvalid_iterator202) ("view
 does not belong to this document") if `object`/`array` is a [discarded](../basic_json_view/is_discarded.md) view or a
 view of a *different* document (overloads 1-2 only; overload 3 always starts from this document's own
 [`root()`](root.md)).
 ## Complexity
 1. Linear in the number of members of `object`.
 2. Linear in the number of elements of `array` at or after `idx` (they move one slot over).
 3. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
   that level or the index into the array (as [`at`](../basic_json_view/at.md)), plus the complexity of 1. or 2. for
   the last token.
 ## Notes
 !!! info "Duplicate keys"
    Overload 1. removes *every* member with `key`, not just the first -- unlike [`set`](set.md), which assigns the
    first occurrence and drops the rest. This is why it returns a count rather than a single view: there may be
    more than one member removed, or none.
 Like [`set`](set.md) and [`push_back`](push_back.md), `erase` never moves an element's *value*: a view still
 referring to a removed member or element keeps showing what it last held (see [Edits](index.md#edits)) -- it just no
 longer appears when `array`/`object` is read, dumped, or iterated. Removing an element of `array` (2.) does shift the
 *links* to the elements after it, the same way `insert`, `set`, or `push_back` on the same array would; any iterator
 already taken over `array`/`object` is invalidated by an erase, since it was walking the old layout.
 ## Examples
 ??? example
    The example below drops a deprecated field and a decommissioned entry from a configuration document -- using all
    three overloads -- and shows what stays intact that would not with a plain `json`/`ordered_json` value: the order
    of the fields around the ones removed, and the exact spelling of a number that was never touched.
    ```cpp
    --8<-- "examples/basic_json_document__erase.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__erase.output"
    ```
 ## See also
 - [insert](insert.md) - insert an element into an array
 - [set](set.md) - replace a value, or set an object member, an array element, or the value a JSON pointer refers to
 - [push_back](push_back.md) - append to an array
 - [root](root.md) - the view of the root value, the starting point of overload 3
 - [`BasicJsonType::erase`](../basic_json/erase.md) - the corresponding function of `basic_json`
 - [Edits](index.md#edits) - what an edit guarantees, for every overload
 ## Version history
 - Added in version 3.13.0.
@@ -1,118 +0,0 @@
 # <small>nlohmann::</small>basic_json_document
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
 template<typename BasicJsonType, bool Editable = false>
 class basic_json_document;
 ```
 A parsed JSON text, held as a flat index of its values
 ([16 bytes per value](../../home/architecture.md#node-index-of-json-views)) instead of a tree of `BasicJsonType` values.
 Strings and numbers stay in the source text; only strings that contain escapes are decoded, into one buffer owned by
 the document. [`basic_json_view`](../basic_json_view/index.md) is a read-only handle to one value of a
 `basic_json_document`; [`materialize()`](../basic_json_view/materialize.md) turns a subtree back into the
 `BasicJsonType` value that [`BasicJsonType::parse()`](../basic_json/parse.md) would have produced for it.
 A document may **borrow** the text it was parsed from (the caller's buffer must then outlive the document) or **own**
 it (a copy, or an rvalue `#!cpp std::string` that was moved in); see [`owns_source`](owns_source.md). `basic_json_document`
 is move-only: copying a document would either duplicate a potentially large index and text, or leave two documents
 claiming to borrow the same buffer, so it is disabled.
 With `#!cpp Editable == true`, the document also offers [`set`](set.md), [`push_back`](push_back.md),
 [`insert`](insert.md), and [`erase`](erase.md) to change values in place, see [Edits](#edits) below. The source text
 itself is never written; a read-only document (`#!cpp Editable == false`, the default) does not carry any of the
 bookkeeping edits need, and calling any of them on one fails to compile (`#!cpp static_assert`).
 ## Template parameters
 `BasicJsonType`
 :   a specialization of [`basic_json`](../basic_json/index.md), for instance [`json`](../json.md) or
    [`ordered_json`](../ordered_json.md). Only 64-bit `number_integer_t`/`number_unsigned_t` types are supported; this
    is checked with a `static_assert`.
 `Editable`
 :   whether the document supports [`set`](set.md), [`push_back`](push_back.md), [`insert`](insert.md), and
    [`erase`](erase.md) (optional, `#!cpp false` by default). See [Edits](#edits) below.
 ## Specializations
 - [**json_document**](../json_document.md) - read-only documents of the default specialization [`json`](../json.md)
 - [**ordered_json_document**](../ordered_json_document.md) - read-only documents of
  [`ordered_json`](../ordered_json.md)
 - [**json_editable_document**](../json_editable_document.md) - editable documents of [`json`](../json.md)
 - [**ordered_json_editable_document**](../ordered_json_editable_document.md) - editable documents of
  [`ordered_json`](../ordered_json.md)
 ## Member types
 - **view_type** - the type of view returned by [`root()`](root.md) (`#!cpp basic_json_view<BasicJsonType, Editable>`)
 - **value_t** - the JSON type enumeration, see [`basic_json::value_t`](../basic_json/value_t.md)
 ## Member functions
 - [(constructor)](basic_json_document.md)
 ### Parsing
 - [**parse**](parse.md) (_static_) - deserialize from a compatible input, borrowing or owning it as appropriate
 - [**parse_copy**](parse_copy.md) (_static_) - deserialize a copy of a compatible input
 - [**accept**](accept.md) (_static_) - check whether the input is valid JSON
 - [**read**](read.md) - (re-)parse into this document, reusing its memory
 ### Access
 - [**root**](root.md) - the view of the root value
 - [**is_discarded**](is_discarded.md) - return whether the last parse failed
 - [**source**](source.md) - the parsed text
 - [**owns_source**](owns_source.md) - return whether the document holds its own copy of the text
 - [**node_count**](node_count.md) - the number of index entries (values plus object keys)
 - [**memory_usage**](memory_usage.md) - the number of bytes held by the document
 - [**shrink_to_fit**](shrink_to_fit.md) - release unused index capacity
 ### Images
 - [**save**](save.md) - the document as an image that `load()` reads without parsing
 - [**load**](load.md) (_static_) - read an image written by `save()`
 ### Edits
 - [**set**](set.md) - replace a value, or set an object member, an array element, or the value a JSON pointer refers
  to (`#!cpp Editable` documents only)
 - [**push_back**](push_back.md) - append to an array (`#!cpp Editable` documents only)
 - [**insert**](insert.md) - insert an element into an array before a given position (`#!cpp Editable` documents only)
 - [**erase**](erase.md) - remove an object member, an array element, or the value a JSON pointer refers to
  (`#!cpp Editable` documents only)
 ## Edits
 An editable document (`#!cpp Editable == true`) can be changed after parsing, with [`set`](set.md),
 [`push_back`](push_back.md), [`insert`](insert.md), and [`erase`](erase.md);
 [`json_editable_document`](../json_editable_document.md) and
 [`ordered_json_editable_document`](../ordered_json_editable_document.md) are the corresponding specializations. A few
 points apply to every edit:
 - **The source text is never written**, and the parsed index never moves: every value keeps the node it was parsed
  into, so [views](../basic_json_view/index.md) taken before an edit stay valid, including
  [`root()`](root.md). New values (and the element sequences of an edited array/object) go to storage owned by the
  document, allocated on demand.
 - **A view keeps referring to the same value.** After [`set`](set.md) replaces the value a view refers to, that view
  sees the new value; a view of a value that a later edit replaces or drops keeps showing what it last held. An edit
  of an array or object, however, **invalidates the iterators taken over it** (its members may now live in a
  different sequence), and a string obtained with [`get_string()`](../basic_json_view/get_string.md) stays valid even
  as further edits happen (earlier buffers of edited text are kept alive, not overwritten).
 - **Values are accepted three ways:** a [`basic_json_view`](../basic_json_view/index.md) of *any* document
  (read-only or editable; it is copied, nothing is shared with the source document), a `BasicJsonType` value, or
  anything `BasicJsonType` can be constructed from (numbers, strings, `#!cpp bool`, `#!cpp nullptr`, containers, ...).
 - [`dump()`](../basic_json_view/dump.md) writes an edited document with members in document order, new members at
  the end, and, with [`number_format::source`](../basic_json_view/number_format.md), keeps the spelling of every
  number that was not itself edited -- see [Editing a document](../../features/json_view.md#editing-a-document) for
  why this matters.
 - [`read()`](read.md) discards all edits, [`shrink_to_fit()`](shrink_to_fit.md) does not move the node index once
  there are edits, and [`memory_usage()`](memory_usage.md) includes the memory edits use.
  [`source_offset()`](../basic_json_view/source_offset.md) of a value introduced by an edit is
  `#!cpp static_cast<std::size_t>(-1)`, the same value it reports for a decoded string.
 ## Version history
 - Added in version 3.13.0.
@@ -1,114 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>insert
 ```cpp
 template<typename I, typename V>
 view_type insert(view_type array, I idx, V&& value);
 ```
 Only an **editable** document (`#!cpp Editable == true`, e.g. [`json_editable_document`](../json_editable_document.md))
 has `insert`; calling it on a read-only `basic_json_document` fails to compile (`#!cpp static_assert`).
 Inserts `value` into `array` as a new element before position `idx`, which must not be past the end
 (`#!cpp idx <= array.size()`; `#!cpp idx == array.size()` appends, like [`push_back`](push_back.md)). Unlike
 [`push_back`](push_back.md), a [null](../basic_json_view/is_null.md) `array` does *not* first become an empty array:
 `array` must already be an array.
 `value` is accepted three ways: a [`basic_json_view`](../basic_json_view/index.md) of *any* document -- read-only or
 editable, and it does not have to be `array`'s own document -- which is copied so that nothing is shared with the
 source document afterward; a `BasicJsonType` value; or anything `BasicJsonType` can be constructed from (numbers,
 strings, `#!cpp bool`, `#!cpp nullptr`, containers, ...).
 ## Template parameters
 `I`
 :   an integral type other than `#!cpp bool`, deduced (overloads taking a `#!cpp bool` or a non-integral type for
    `idx` do not participate in overload resolution).
 `V`
 :   the type of `value`, deduced; see above for what is accepted.
 ## Parameters
 `array` (in)
 :   the array to insert into
 `idx` (in)
 :   the position to insert `value` before; a negative value throws (see [Exceptions](#exceptions))
 `value` (in)
 :   the value to insert
 ## Return value
 a view of the new element, now holding `value`
 ## Exception safety
 Basic exception safety: `value` is fully encoded -- including the checks below -- into storage owned by the document
 before anything already reachable from [`root()`](root.md) is touched, so a failure while encoding `value` (an
 invalid argument, or `#!cpp std::bad_alloc`) leaves the document completely unchanged, other than memory allocated
 for the encoding that is not reclaimed. A failure of a later allocation -- while `array` switches from its parsed
 layout to a growable block, or while that block grows, see [Notes](#notes) -- can still leave `array` already
 switched to that layout even though `value` itself was not inserted.
 ## Exceptions
 Throws [`type_error.309`](../../home/exceptions.md#jsonexceptiontype_error309) if `array` is not an array -- the same
 message [`BasicJsonType::insert`](../basic_json/insert.md) throws for the same type; a null `array` throws this too
 (see above). Throws [`out_of_range.401`](../../home/exceptions.md#jsonexceptionout_of_range401) if `idx` is negative,
 or if `#!cpp idx > array.size()`. Throws
 [`invalid_iterator.202`](../../home/exceptions.md#jsonexceptioninvalid_iterator202) ("view does not belong to this
 document") if `array` is a [discarded](../basic_json_view/is_discarded.md) view or a view of a *different* document.
 Throws [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) if `value` is a
 [discarded](../basic_json_view/is_discarded.md) view or a [discarded](../basic_json/is_discarded.md) `BasicJsonType`
 value, and [`type_error.319`](../../home/exceptions.md#jsonexceptiontype_error319) if `value` is (or contains) a
 binary value -- `BasicJsonType` can hold one, but a `json_document` cannot. Throws
 [`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316) if `value` is (or contains) a string that is
 not valid UTF-8, with the same message [`BasicJsonType::dump()`](../basic_json/dump.md) gives for that string.
 ## Complexity
 Linear in the number of elements of `array` at or after `idx` (they move one slot over), plus time linear in the
 size of `value` to encode it into the document's storage (constant for a scalar, linear in the number of nested
 values for an array or object): like [`push_back`](push_back.md), the elements of `array` move to a growable block
 of links the first time it is inserted into (or [`set`](set.md)/[`push_back`](push_back.md) on), and that block
 grows in amortized constant time; inserting before the end within that block still shifts every later element.
 ## Notes
 Like [`set`](set.md) on a member or an element, `insert` never moves an existing *element's value* -- only where
 `array`'s *links* to its elements live -- so a view of an existing element of `array` stays valid across an
 `insert`, and keeps referring to the same element even though its index shifts. Any iterator already taken over
 `array` is invalidated, since it was walking the old layout. See [Edits](index.md#edits) for what stays valid across
 an edit in general.
 ## Examples
 ??? example
    The example below inserts a step into the middle of a deployment plan, without touching the steps that come
    after it, and shows that a view taken before the insert keeps referring to the same element even though its
    index shifts -- something a plain `json`/`ordered_json` array, or its `std::vector`-based storage, has no
    equivalent for.
    ```cpp
    --8<-- "examples/basic_json_document__insert.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__insert.output"
    ```
 ## See also
 - [push_back](push_back.md) - append to an array
 - [erase](erase.md) - remove an object member, an array element, or the value a JSON pointer refers to
 - [set](set.md) - replace a value, or set an object member, an array element, or the value a JSON pointer refers to
 - [`BasicJsonType::insert`](../basic_json/insert.md) - the corresponding function of `basic_json`
 - [Edits](index.md#edits) - what an edit guarantees, for every overload
 ## Version history
 - Added in version 3.13.0.
@@ -1,49 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>is_discarded
 ```cpp
 bool is_discarded() const noexcept;
 ```
 Returns whether the document holds no value, either because it was default-constructed or because the last call to
 [`parse()`](parse.md), [`parse_copy()`](parse_copy.md), or [`read()`](read.md) failed with `allow_exceptions` set to
 `#!cpp false`.
 ## Return value
 `#!cpp true` if the document is discarded, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 When the document is discarded, [`root()`](root.md) returns a discarded view (its
 [`is_discarded()`](../basic_json_view/is_discarded.md) is also `#!cpp true`).
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__is_discarded.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__is_discarded.output"
    ```
 ## See also
 - [parse](parse.md) - deserialize from a compatible input
 - [is_discarded (basic_json_view)](../basic_json_view/is_discarded.md) - return whether a view is invalid
 ## Version history
 - Added in version 3.13.0.
@@ -1,169 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>load
 ```cpp
 // (1)
 static basic_json_document load(const std::uint8_t* image, std::size_t size,
                                 const image_check check = image_check::full);
 // (2)
 static basic_json_document load(const std::vector<std::uint8_t>& image,
                                 const image_check check = image_check::full);
 // (3)
 static basic_json_document load(std::vector<std::uint8_t>&& image,
                                 const image_check check = image_check::full);
 ```
 1. Reads an image [`save()`](save.md) wrote, from a pointer and a byte count. The image is **borrowed**: `image`
   must stay alive and unchanged for as long as the returned document, and any view taken from it, is used.
 2. Reads an image from a `#!cpp std::vector`. Also **borrowed** -- equivalent to overload 1 called with
   `#!cpp image.data()` and `#!cpp image.size()`.
 3. Reads an image, keeping the vector instead of copying it: `image` is moved into the document (no copy), which
   then owns it for as long as it needs the text and the decoded strings. [`owns_source()`](owns_source.md) is
   `#!cpp true` afterward.
 In every overload, the node index is copied into storage the document itself owns -- so that it is properly aligned,
 and, for an [editable](index.md#edits) document, can be edited -- while the text and the decoded strings stay in
 `image`. The hash indexes [large objects](../../features/json_view.md) use for lookup are rebuilt, exactly as after
 parsing.
 ## Parameters
 `image` (in)
 :   the image [`save()`](save.md) wrote (overloads 1 and 2), or one to take ownership of (overload 3)
 `size` (in)
 :   the number of bytes at `image` (overload 1)
 `check` (in)
 :   how thoroughly to validate `image` before trusting it; see [`image_check`](#image_check) below (optional,
    `#!cpp image_check::full` by default)
 ## Return value
 The document read from the image.
 ## Exception safety
 Overloads 1 and 2 give the strong guarantee: `image` is only read, never written, so a thrown exception leaves the
 caller's buffer untouched.
 Overload 3 moves `image` into the document *before* validating it, so that a good image is kept without a copy. If
 loading then fails, the partially built document -- and the vector now inside it -- is discarded along with the
 exception, and `image` itself is left **empty**, not restored to what was passed in. Move a copy in instead, or
 validate with overload 2 first, if the original vector must survive a failed load.
 ## Exceptions
 On a big-endian target, throws [`type_error.320`](../../home/exceptions.md#jsonexceptiontype_error320) -- the same
 exception [`save()`](save.md#exceptions) throws there, since the image format is little-endian only.
 Otherwise throws [`parse_error.116`](../../home/exceptions.md#jsonexceptionparse_error116) if `image` is not one
 `save()` could have written, or fails the requested `check`:
 | message               | when                                                                                                |
 |------------------------|------------------------------------------------------------------------------------------------------|
 | `too short`            | `image` is `#!cpp nullptr`, or `size` is smaller than the 64-byte header                             |
 | `unknown format`       | the header's magic bytes or version do not match, or a reserved header field is not zero             |
 | `sizes out of range`   | the node count, text size, or decoded-string size the header describes does not fit `size`, or the `#!cpp '\0'` after the text or after the decoded strings is missing |
 | `the check failed`     | `check` is not `#!cpp image_check::none`, and the image fails it -- see [`image_check`](#image_check) |
 !!! failure "Example messages"
    ```
    [json.exception.parse_error.116] parse error: invalid json_document image: too short
    ```
    ```
    [json.exception.parse_error.116] parse error: invalid json_document image: unknown format
    ```
    ```
    [json.exception.parse_error.116] parse error: invalid json_document image: sizes out of range
    ```
    ```
    [json.exception.parse_error.116] parse error: invalid json_document image: the check failed
    ```
 ## Complexity
 Linear in the number of nodes, which are always copied into the document. With `#!cpp check == image_check::full`,
 additionally linear in the combined length of the text and the decoded strings; `#!cpp image_check::bounds` and
 `#!cpp image_check::none` do not read them.
 ## Notes
 **The `image_check` modes.**
 ```cpp
 using image_check = detail::view::image_check;
 enum class image_check
 {
    full,
    bounds,
    none
 };
 ```
 How thoroughly `load()` validates `image` before trusting it.
 | value    | checks                                                                                                    | guarantees |
 |----------|--------------------------------------------------------------------------------------------------------------|------------|
 | `full`   | everything the parser itself guarantees: structure and bounds; that every string is valid UTF-8 (and, for a string still in the source text, that it contains no quote, backslash, or control character); and that every number token is well-formed and matches the value stored for it | reading and serializing a checked image is safe and always produces valid JSON, exactly as for a parsed document |
 | `bounds` | structure and bounds only -- that every offset and count in the node index stays inside the image            | reading and serializing stay memory-safe, but a crafted image can hold strings that are not valid UTF-8 or that serialize to invalid JSON ([`dump()`](../basic_json_view/dump.md) writes them unchanged or throws [`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316)), and numbers whose values differ from their text |
 | `none`   | nothing                                                                                                       | images from a trusted source only -- reading a damaged image is undefined behavior |
 `full` is the default and the right choice for an image from anything you do not fully control -- a file, a cache
 shared with other processes, a peer on the network. `bounds` skips scanning the text and the decoded strings, so it
 fits a cache your own process just wrote and reads straight back, where damage would mean a bug or a hardware fault
 rather than adversarial input; it still cannot crash or read out of bounds. `none` skips validation entirely and
 should only be used for an image you trust as much as your own memory.
 **Lifetime.** Overloads 1 and 2 borrow `image`: it must stay alive and byte-for-byte unchanged for as long as the
 returned document, and any [view](../basic_json_view/index.md) taken from it, is used -- exactly like a document
 [`parse()`](parse.md) borrowed its input for. Overload 3 avoids this by keeping the vector itself; see
 [`owns_source`](owns_source.md).
 !!! warning "Experimental"
    The image format is versioned but not yet stable, and may change in an incompatible way before it is declared
    stable; `load()` already rejects an image written by a different format version with `parse_error.116`
    ("unknown format"). Use images to cache a document within one build of the library, or to hand one to another
    process running the *same* build on the *same* (little-endian) machine -- not as a long-term storage format.
 **What `image_check::bounds` does not guarantee.** A bounds-checked image can never make `load()`,
 [`root()`](root.md), element access, or [`materialize()`](../basic_json_view/materialize.md) read outside the image,
 so those stay safe on a damaged one. It does *not* guarantee that the image describes valid JSON: a string
 that a `full` check would have rejected can make [`dump()`](../basic_json_view/dump.md) write invalid UTF-8 or invalid
 JSON, or throw `type_error.316`, and a number can read back with a value that does not match how it is spelled.
 Reserve `bounds` for images you already trust to be well-formed, and use it only to skip the extra scan.
 ## Examples
 ??? example "Caching a document, ownership, and a rejected image"
    The example below saves a parsed document as an image, checks that `load()` reproduces the original
    [`dump()`](../basic_json_view/dump.md) without parsing, and shows the difference between
    `load(std::move(image))` (owned) and `load(image)` (borrowed). It then damages one byte of the image and shows
    `image_check::full` rejecting it with `parse_error.116`, while `image_check::bounds` -- meant for a cache the
    process already trusts -- still reads it without going out of bounds.
    ```cpp
    --8<-- "examples/basic_json_document__load.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__load.output"
    ```
 ## See also
 - [save](save.md) - write the document as an image
 - [owns_source](owns_source.md) - return whether the document holds its own copy of the text
 - [parse](parse.md) - deserialize from JSON text instead of an image
 - [Images](../../features/json_view.md#images) - why and when to use images
 ## Version history
 - Added in version 3.13.0.
@@ -1,50 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>memory_usage
 ```cpp
 std::size_t memory_usage() const noexcept;
 ```
 Returns the number of bytes held by the document: the node index, the decoded-string buffer (for strings that
 contain escapes), and, for an owned document, its copy of the source text.
 ## Return value
 The number of bytes the document holds, `0` for a [discarded](is_discarded.md) document.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 The exact value depends on the platform, the allocator, and the library's own layout, and may change between
 versions; do not rely on it being a specific number, and do not compare it across different builds or platforms.
 Compare it for the same document over time, or between documents built with the same binary, instead -- for instance
 to observe the effect of [`shrink_to_fit()`](shrink_to_fit.md).
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__memory_usage.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__memory_usage.output"
    ```
 ## See also
 - [node_count](node_count.md) - the number of index entries
 - [shrink_to_fit](shrink_to_fit.md) - release unused index capacity
 ## Version history
 - Added in version 3.13.0.
@@ -1,49 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>node_count
 ```cpp
 std::size_t node_count() const noexcept;
 ```
 Returns the number of entries in the document's flat index.
 ## Return value
 The number of index entries: one per value (of any type, at any nesting depth) plus one per object key. `0` for a
 [discarded](is_discarded.md) document.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 Each index entry is [16 bytes](../../home/architecture.md#node-index-of-json-views), so `#!cpp node_count() * 16` is
 the size of the index itself (part, but not all, of [`memory_usage()`](memory_usage.md), which also counts decoded
 strings and, for an owned document, the text).
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__node_count.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__node_count.output"
    ```
 ## See also
 - [memory_usage](memory_usage.md) - the number of bytes held by the document
 - [shrink_to_fit](shrink_to_fit.md) - release unused index capacity
 ## Version history
 - Added in version 3.13.0.
@@ -1,49 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>owns_source
 ```cpp
 bool owns_source() const noexcept;
 ```
 Returns whether the document holds its own copy of the parsed text, as opposed to borrowing the caller's buffer.
 ## Return value
 `#!cpp true` if the document owns the text returned by [`source()`](source.md), `#!cpp false` if it borrows it (or if
 the document is [discarded](is_discarded.md)).
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 See the ownership table on [`parse`](parse.md#notes) for which inputs are borrowed and which are owned. A borrowed
 document (`#!cpp owns_source() == false`) is only valid while the buffer it was parsed from is still alive.
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__owns_source.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__owns_source.output"
    ```
 ## See also
 - [parse](parse.md) - deserialize from a compatible input
 - [parse_copy](parse_copy.md) - deserialize a copy of a compatible input, always owned
 - [source](source.md) - the parsed text
 ## Version history
 - Added in version 3.13.0.
@@ -1,140 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>parse
 ```cpp
 // (1)
 template<typename InputType>
 static basic_json_document parse(InputType&& input,
                                 const bool allow_exceptions = true,
                                 const bool ignore_comments = false,
                                 const bool ignore_trailing_commas = false);
 // (2)
 template<typename IteratorType>
 static basic_json_document parse(IteratorType first, IteratorType last,
                                 const bool allow_exceptions = true,
                                 const bool ignore_comments = false,
                                 const bool ignore_trailing_commas = false);
 ```
 1. Deserialize from a compatible input, borrowing or owning it depending on its value category and type (see Notes).
 2. Deserialize from a pair of input iterators.
 Both overloads accept exactly what [`BasicJsonType::parse()`](../basic_json/parse.md) accepts, with the same
 `ignore_comments`/`ignore_trailing_commas` options, but build a [`basic_json_document`](index.md) (a flat index into
 the input) instead of a tree of `BasicJsonType` values.
 ## Template parameters
 `InputType`
 :   A compatible input, for instance:
    - a `#!cpp std::string`, `#!cpp std::string_view`, or a C-style array of characters
    - a pointer to a null-terminated string of single byte characters
    - a container for which `#!cpp obj.data()` and `#!cpp obj.size()` give contiguous single-byte access, e.g.
      `#!cpp std::vector<char>` or `#!cpp std::vector<std::uint8_t>`
    - an `#!cpp std::istream` object, or anything else [`BasicJsonType::parse()`](../basic_json/parse.md) accepts
 `IteratorType`
 :   a compatible iterator type, for instance a pair of pointers such as `ptr` and `ptr + len`, or a pair of
    `#!cpp std::string::iterator`
 ## Parameters
 `input` (in)
 :   Input to parse from.
 `allow_exceptions` (in)
 :   whether to throw exceptions in case of a parse error (optional, `#!cpp true` by default)
 `ignore_comments` (in)
 :   whether comments should be ignored and treated like whitespace (`#!cpp true`) or yield a parse error
    (`#!cpp false`); (optional, `#!cpp false` by default)
 `ignore_trailing_commas` (in)
 :   whether trailing commas in arrays or objects should be ignored and treated like whitespace (`#!cpp true`) or
    yield a parse error (`#!cpp false`); (optional, `#!cpp false` by default)
 `first` (in)
 :   iterator to the start of a character range
 `last` (in)
 :   iterator to the end of a character range
 ## Return value
 The parsed document. If `allow_exceptions` is `#!cpp false` and the input is not valid JSON, the returned document is
 discarded; see [`is_discarded`](is_discarded.md).
 ## Exceptions
 Throws the same exception [`BasicJsonType::parse()`](../basic_json/parse.md) throws for the same input and options --
 the same exception id, message, and position -- because on a failing input the library's own parser is run on the
 same bytes to produce the diagnostic. Additionally throws
 [`out_of_range.416`](../../home/exceptions.md#jsonexceptionout_of_range416) if the input is 4 GiB or larger, a size
 [`BasicJsonType::parse()`](../basic_json/parse.md) does not reject.
 ## Complexity
 Linear in the length of the input.
 ## Notes
 **Ownership.** Whether the document borrows `input` or owns a copy of it depends on its value category and type:
 | `input`                                                                             | ownership                                                    |
 |--------------------------------------------------------------------------------------|--------------------------------------------------------------|
 | lvalue byte container (`std::string`, `std::vector<char>`, ...), `std::string_view`, C string, character array | **borrowed** -- `input` must outlive the document |
 | rvalue `#!cpp std::string`                                                            | **owned**, moved in without a copy                            |
 | rvalue byte container other than `#!cpp std::string`                                  | **owned**, copied                                             |
 | stream, wide string, or anything else read through the general input adapter          | **owned**, read into a buffer (a stream is read to its end)   |
 For overload (2), a pair of pointers to single-byte integers (e.g. `#!cpp const char*`, `#!cpp std::uint8_t*`) is
 borrowed. From C++20 on, so is any other contiguous iterator over single bytes, such as
 `#!cpp std::vector<char>::iterator` or `#!cpp std::string::const_iterator`. Before C++20 these iterators cannot be
 told apart from other class-type iterators, so their range is read into an owned buffer, as is any non-contiguous
 range (e.g. of a `#!cpp std::list<char>`).
 See [`owns_source`](owns_source.md) to check which happened after a call, and the
 [feature page](../../features/json_view.md) for the reasoning.
 **Numbers.** As for [`BasicJsonType::parse()`](../basic_json/parse.md), an integer literal too large for the 64-bit
 integer type becomes a floating-point value.
 ## Examples
 ??? example "Example: (1) borrowed vs. owned input, and errors identical to `BasicJsonType::parse()`"
    ```cpp
    --8<-- "examples/basic_json_document__parse.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__parse.output"
    ```
 ??? example "Example: (2) parse an iterator range (no NUL terminator required)"
    ```cpp
    --8<-- "examples/basic_json_document__parse_iterator_pair.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__parse_iterator_pair.output"
    ```
 ## See also
 - [parse_copy](parse_copy.md) - deserialize a copy of a compatible input
 - [accept](accept.md) - check whether the input is valid JSON
 - [read](read.md) - (re-)parse into this document, reusing its memory
 - [owns_source](owns_source.md) - return whether the document holds its own copy of the text
 - [load](load.md) - read a document from an image instead of parsing JSON text
 - [`BasicJsonType::parse`](../basic_json/parse.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,77 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>parse_copy
 ```cpp
 template<typename InputType>
 static basic_json_document parse_copy(InputType&& input,
                                      const bool allow_exceptions = true,
                                      const bool ignore_comments = false,
                                      const bool ignore_trailing_commas = false);
 ```
 Deserialize from a compatible input, always taking the document's own copy of it, regardless of the value category or
 type of `input`. Unlike [`parse()`](parse.md), the returned document never depends on `input` staying alive.
 ## Template parameters
 `InputType`
 :   A compatible input; see [`parse`](parse.md#template-parameters).
 ## Parameters
 `input` (in)
 :   Input to parse from.
 `allow_exceptions` (in)
 :   whether to throw exceptions in case of a parse error (optional, `#!cpp true` by default)
 `ignore_comments` (in)
 :   whether comments should be ignored and treated like whitespace (`#!cpp true`) or yield a parse error
    (`#!cpp false`); (optional, `#!cpp false` by default)
 `ignore_trailing_commas` (in)
 :   whether trailing commas in arrays or objects should be ignored and treated like whitespace (`#!cpp true`) or
    yield a parse error (`#!cpp false`); (optional, `#!cpp false` by default)
 ## Return value
 The parsed document, with [`owns_source()`](owns_source.md) `#!cpp true`. If `allow_exceptions` is `#!cpp false` and
 the input is not valid JSON, the returned document is discarded; see [`is_discarded`](is_discarded.md).
 ## Exceptions
 Same as [`parse`](parse.md#exceptions).
 ## Complexity
 Linear in the length of the input.
 ## Notes
 `parse_copy()` accepts and rejects exactly what [`parse()`](parse.md) does, and classifies numbers the same way; it
 only differs in that the input is always copied rather than sometimes borrowed. Prefer [`parse()`](parse.md) when the
 input's lifetime already covers the document's, since it avoids the copy for borrowed inputs.
 ## Examples
 ??? example
    The example below returns a document from a function whose local buffer would otherwise not outlive it.
    ```cpp
    --8<-- "examples/basic_json_document__parse_copy.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__parse_copy.output"
    ```
 ## See also
 - [parse](parse.md) - deserialize from a compatible input, borrowing it where possible
 - [owns_source](owns_source.md) - return whether the document holds its own copy of the text
 ## Version history
 - Added in version 3.13.0.
@@ -1,102 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>push_back
 ```cpp
 template<typename V>
 view_type push_back(view_type array, V&& value);
 ```
 Appends `value` as a new last element of `array`. A [null](../basic_json_view/is_null.md) `array` first becomes an
 empty array, the same way [`set`](set.md) turns a null `object` into an empty object.
 `value` is accepted three ways: a [`basic_json_view`](../basic_json_view/index.md) of *any* document -- read-only or
 editable, and it does not have to be `array`'s own document -- which is copied so that nothing is shared with the
 source document afterward; a `BasicJsonType` value; or anything `BasicJsonType` can be constructed from (numbers,
 strings, `#!cpp bool`, `#!cpp nullptr`, containers, ...).
 Only an **editable** document (`#!cpp Editable == true`, e.g. [`json_editable_document`](../json_editable_document.md))
 has `push_back`; calling it on a read-only `basic_json_document` fails to compile (`#!cpp static_assert`).
 ## Template parameters
 `V`
 :   the type of `value`, deduced; see above for what is accepted.
 ## Parameters
 `array` (in)
 :   the array (or null value) to append to
 `value` (in)
 :   the value to append
 ## Return value
 a view of the new last element of `array`, now holding `value`
 ## Exception safety
 Basic exception safety: `value` is fully encoded -- including the checks below -- into storage owned by the document
 before anything already reachable from [`root()`](root.md) is touched, so a failure while encoding `value` (an
 invalid argument, or `#!cpp std::bad_alloc`) leaves the document completely unchanged, other than memory allocated
 for the encoding that is not reclaimed. A failure of a later allocation -- while `array` switches from its parsed
 layout to a growable block, or while that block grows, see [Notes](#notes) -- can still leave a partial effect, such
 as a null `array` argument already turned into an empty array even though `value` itself was not appended.
 ## Exceptions
 Throws [`type_error.308`](../../home/exceptions.md#jsonexceptiontype_error308) if `array` is neither an array nor
 null -- the same message [`BasicJsonType::push_back`](../basic_json/push_back.md) throws for the same type. Throws
 [`invalid_iterator.202`](../../home/exceptions.md#jsonexceptioninvalid_iterator202) ("view does not belong to this
 document") if `array` is a [discarded](../basic_json_view/is_discarded.md) view or a view of a *different* document.
 Throws [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) if `value` is a
 [discarded](../basic_json_view/is_discarded.md) view or a [discarded](../basic_json/is_discarded.md) `BasicJsonType`
 value, and [`type_error.319`](../../home/exceptions.md#jsonexceptiontype_error319) if `value` is (or contains) a
 binary value -- `BasicJsonType` can hold one, but a `json_document` cannot. Throws
 [`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316) if `value` is (or contains) a string that is
 not valid UTF-8, with the same message [`BasicJsonType::dump()`](../basic_json/dump.md) gives for that string.
 ## Complexity
 Amortized constant, plus time linear in the size of `value` to encode it into the document's storage (constant for
 a scalar, linear in the number of nested values for an array or object): the elements of `array` move to a growable
 block of links the first time it is appended to (or [`set`](set.md) on), and that block itself grows -- doubling its
 capacity, so the cost of growing it amortizes to constant per element -- only once it runs out of room. See
 [Notes](#notes).
 ## Notes
 Like [`set`](set.md) on a member or an element, `push_back` never moves an existing element itself -- only where
 `array`'s *links* to its elements live -- so a view of an existing element of `array` stays valid across a
 `push_back`, but any iterator already taken over `array` is invalidated, since it was walking the old layout. See
 [Edits](index.md#edits) for what stays valid across an edit in general.
 ## Examples
 ??? example
    The example below appends records to an array one at a time, as they might arrive from a stream of events,
    without ever building a `BasicJsonType` value for the array or for the records already in it, and shows that a
    view taken from an earlier `push_back` still refers to the same element once later ones have run.
    ```cpp
    --8<-- "examples/basic_json_document__push_back.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__push_back.output"
    ```
 ## See also
 - [set](set.md) - replace a value, or set an object member, an array element, or the value a JSON pointer refers to
 - [insert](insert.md) - insert an element into an array before a given position
 - [erase](erase.md) - remove an object member, an array element, or the value a JSON pointer refers to
 - [root](root.md) - the view of the root value
 - [`BasicJsonType::push_back`](../basic_json/push_back.md) - the corresponding function of `basic_json`
 - [Edits](index.md#edits) - what an edit guarantees, for every overload
 ## Version history
 - Added in version 3.13.0.
@@ -1,77 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>read
 ```cpp
 template<typename InputType>
 void read(InputType&& input,
         const bool allow_exceptions = true,
         const bool ignore_comments = false,
         const bool ignore_trailing_commas = false);
 ```
 (Re-)parses `input` into `#!cpp *this`, discarding the document's previous value and reusing its memory (the node
 index, the decoded-string buffer, and, if applicable, the owned copy of the text) rather than allocating a fresh
 document. [`parse()`](parse.md) is implemented in terms of this function, applied to a default-constructed document.
 ## Template parameters
 `InputType`
 :   A compatible input; see [`parse`](parse.md#template-parameters).
 ## Parameters
 `input` (in)
 :   Input to parse from.
 `allow_exceptions` (in)
 :   whether to throw exceptions in case of a parse error (optional, `#!cpp true` by default)
 `ignore_comments` (in)
 :   whether comments should be ignored and treated like whitespace (`#!cpp true`) or yield a parse error
    (`#!cpp false`); (optional, `#!cpp false` by default)
 `ignore_trailing_commas` (in)
 :   whether trailing commas in arrays or objects should be ignored and treated like whitespace (`#!cpp true`) or
    yield a parse error (`#!cpp false`); (optional, `#!cpp false` by default)
 ## Exceptions
 Same as [`parse`](parse.md#exceptions).
 ## Complexity
 Linear in the length of the input.
 ## Notes
 Every view taken from `#!cpp *this` before the call -- including the previous [`root()`](root.md) -- is invalidated,
 whether or not the new parse succeeds; take fresh views from [`root()`](root.md) afterward.
 `input` is borrowed or owned by the same rules as [`parse()`](parse.md#notes); a document can borrow on one call and
 own on the next, since ownership is decided freshly each time.
 ## Examples
 ??? example
    The example below parses a sequence of messages into the same document, reusing its memory instead of allocating
    a new document for each one.
    ```cpp
    --8<-- "examples/basic_json_document__read.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__read.output"
    ```
 ## See also
 - [parse](parse.md) - deserialize from a compatible input
 - [root](root.md) - the view of the root value
 - [load](load.md) - read a document from an image instead of parsing JSON text
 ## Version history
 - Added in version 3.13.0.
@@ -1,50 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>root
 ```cpp
 view_type root() const noexcept;
 ```
 Returns a view of the root value of the document.
 ## Return value
 A [`view_type`](index.md#member-types) (i.e. `#!cpp basic_json_view<BasicJsonType>`) for the root value, or a
 discarded view if the document is [discarded](is_discarded.md).
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 `root()` is a cheap handle into the document's index, not a copy of anything; call it as often as needed. The
 returned view is valid under the same conditions as any other view of the document -- see
 [Object inspection](../basic_json_view/index.md) -- in particular, it is invalidated by the next
 [`read()`](read.md) or [`shrink_to_fit()`](shrink_to_fit.md) on this document.
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__root.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__root.output"
    ```
 ## See also
 - [is_discarded](is_discarded.md) - return whether the last parse failed
 - [materialize](../basic_json_view/materialize.md) - build the `BasicJsonType` value of a subtree
 ## Version history
 - Added in version 3.13.0.
@@ -1,104 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>save
 ```cpp
 std::vector<std::uint8_t> save() const;
 ```
 Writes the document as an *image*: a byte buffer that [`load`](load.md) reads back without parsing. The image holds
 the node index, the source text (plus, for an edited document, the number tokens edits wrote), and the decoded
 strings (plus the strings edits wrote) -- everything [`root()`](root.md) needs, with nothing left to parse.
 An edited document is written in its *current* state, with its values in document order, the way the library's own
 parser would have produced them for that JSON text: a member [`set`](set.md) added goes at the end, an
 [`erase`](erase.md)d member leaves no trace, and a float that is not finite (NaN or positive/negative infinity)
 becomes null, the same substitution [`dump()`](../basic_json_view/dump.md) makes. The same document always saves to
 the same bytes -- also across `BasicJsonType` and `#!cpp Editable`, since the image reflects document order and
 values only, not which specialization produced them.
 ## Return value
 The image, as a `#!cpp std::vector<std::uint8_t>`. Pass it, or a pointer to its data together with its size, to
 [`load`](load.md) to read the document back.
 ## Exception safety
 Strong guarantee: `save()` does not modify `#!cpp *this` (it is `#!cpp const`), so if it throws, the document is left
 exactly as it was, and the partially built image is discarded with the exception.
 ## Exceptions
 Throws [`type_error.320`](../../home/exceptions.md#jsonexceptiontype_error320) if the document is
 [discarded](is_discarded.md) -- a default-constructed document, or one a failed [`parse()`](parse.md)/
 [`read()`](read.md) with `allow_exceptions == false` left discarded.
 On a big-endian target, throws `type_error.320` with a different message instead: the image format is little-endian
 only (see [Notes](#notes)).
 Throws [`out_of_range.416`](../../home/exceptions.md#jsonexceptionout_of_range416) if the node count, the text, or
 the decoded strings of the image would individually reach 4 GiB -- the same 32-bit offsets
 [`parse()`](parse.md#exceptions) and, for edits, [`set`](set.md)/[`push_back`](push_back.md) are already limited to.
 !!! failure "Example messages"
    ```
    [json.exception.type_error.320] cannot save a discarded json_document
    ```
    ```
    [json.exception.type_error.320] json_document images need a little-endian target
    ```
    ```
    [json.exception.out_of_range.416] images of 4 GiB or more are not supported by json_document
    ```
 ## Complexity
 Linear in the size of the document: the number of nodes, plus the length of the text and the decoded strings that end
 up in the image.
 ## Notes
 **Format.** The image begins with a 64-byte header (the magic bytes `#!cpp "NJVI"`, a version number, the node count,
 and the sizes of the text and the decoded strings, all little-endian), followed by the nodes
 ([16 bytes each](../../home/architecture.md#node-index-of-json-views)), the text and a `#!cpp '\0'`, and the decoded
 strings and a `#!cpp '\0'`. [`load`](load.md) checks the header, and the sizes it describes, before reading anything
 else -- see [`load`'s Exceptions](load.md#exceptions).
 !!! warning "Experimental"
    The image format is versioned but not yet stable: it may change in an incompatible way before it is declared
    stable. Use images to cache a document within one build of the library, or to hand one to another process running
    the *same* build on the *same* (little-endian) machine -- not as a long-term storage format. Keep the original
    JSON text if you need to read a saved document back with a future library version.
 **Little-endian only.** The image is written as raw little-endian bytes, with no byte-swapping. `save()` (and
 [`load`](load.md)) throw `type_error.320` on a big-endian target rather than silently produce bytes a big-endian
 reader could not interpret correctly.
 ## Examples
 ??? example "Caching a parsed document as an image"
    The example below saves a parsed configuration as an image -- the way a service might cache one to answer later
    requests without parsing the text again -- and confirms that loading it back gives exactly the same result as
    parsing did, and that saving is deterministic.
    ```cpp
    --8<-- "examples/basic_json_document__save.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__save.output"
    ```
 ## See also
 - [load](load.md) - read an image written by `save()`
 - [owns_source](owns_source.md) - return whether the document holds its own copy of the text
 - [`basic_json_view::dump`](../basic_json_view/dump.md) - serialize the document to JSON text instead of an image
 - [Images](../../features/json_view.md#images) - why and when to use images
 ## Version history
 - Added in version 3.13.0.
@@ -1,194 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>set
 ```cpp
 // (1)
 template<typename V>
 view_type set(view_type target, V&& value);
 // (2)
 template<typename V>
 view_type set(view_type object, string_view_t key, V&& value);
 // (3)
 template<typename I, typename V>
 view_type set(view_type array, I idx, V&& value);
 // (4)
 template<typename V>
 view_type set(const json_pointer& ptr, V&& value);
 ```
 Only an **editable** document (`#!cpp Editable == true`, e.g. [`json_editable_document`](../json_editable_document.md))
 has `set`; calling it on a read-only `basic_json_document` fails to compile (`#!cpp static_assert`).
 1. Replaces the value `target` refers to with `value`.
 2. Sets the member `key` of the object `object` to `value`: assigns it if `object` already has a member with this
   key -- the first one, should the key occur more than once, and the later duplicates are then dropped (see the
   [Notes](#notes) below) -- or appends a new member at the end otherwise. A [null](../basic_json_view/is_null.md)
   `object` first becomes an empty object.
 3. Assigns `value` to the element at index `idx` of the array `array`, which must already exist (`#!cpp idx <
   array.size()`).
 4. Sets the value the JSON pointer `ptr` refers to, relative to [`root()`](root.md), to `value`. The *parent* of the
   target must already exist: an object member is set as in 2. (added if it does not exist yet), an array element is
   assigned as in 3., and a last reference token of `#!cpp "-"`, or equal to the size of the array, appends `value`
   instead, exactly as [`push_back`](push_back.md) would. An empty `ptr` sets [`root()`](root.md) itself, as in 1.
 In every overload, `value` is accepted three ways: a [`basic_json_view`](../basic_json_view/index.md) of *any*
 document -- read-only or editable, and it does not have to be `target`'s/`object`'s/`array`'s own document -- which
 is copied so that nothing is shared with the source document afterward; a `BasicJsonType` value; or anything
 `BasicJsonType` can be constructed from (numbers, strings, `#!cpp bool`, `#!cpp nullptr`, containers, ...).
 ## Template parameters
 `V`
 :   the type of `value`, deduced; see above for what is accepted.
 `I`
 :   an integral type other than `#!cpp bool`, deduced (overloads taking a `#!cpp bool` or a non-integral type for
    `idx` do not participate in overload resolution).
 ## Parameters
 `target` (in)
 :   the value to replace
 `object` (in)
 :   the object (or null value) whose member to set
 `array` (in)
 :   the array whose element to assign
 `key` (in)
 :   the key of the member to set
 `idx` (in)
 :   the index of the element to assign; a negative value throws (see [Exceptions](#exceptions))
 `ptr` (in)
 :   a JSON pointer to the value to set, relative to `root()`
 `value` (in)
 :   the new value
 ## Return value
 1. a view of `target`, now holding `value`
 2. a view of the member `key` of `object`, now holding `value`
 3. a view of the element `idx` of `array`, now holding `value`
 4. a view of the value `ptr` refers to, now holding `value`
 ## Exception safety
 Basic exception safety: `value` is fully encoded -- including the checks below -- into storage owned by the document
 before anything already reachable from [`root()`](root.md) is touched, so a failure while encoding `value` (an
 invalid argument, or `#!cpp std::bad_alloc`) leaves the document completely unchanged, other than memory allocated
 for the encoding that is not reclaimed. A failure of a later allocation -- while an edited array or object switches
 from its parsed layout to a growable block, see [Notes](#notes) -- can still leave a partial effect, such as a
 [null](../basic_json_view/is_null.md) `object`/`array` argument already turned into an empty object/array even
 though `value` itself was not linked in.
 ## Exceptions
 1. Throws [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) if `value` is a
   [discarded](../basic_json_view/is_discarded.md) view, or a [discarded](../basic_json/is_discarded.md)
   `BasicJsonType` value (e.g. `#!cpp BasicJsonType(value_t::discarded)`) -- an object or array `value`, of either
   kind, is fine and is encoded as a whole subtree.
 2. Throws [`type_error.305`](../../home/exceptions.md#jsonexceptiontype_error305) if `object` is neither an object
   nor null -- the same message [`operator[]`](../basic_json_view/operator%5B%5D.md) throws for a string argument on
   such a value. Throws [`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316) if `key` is not
   valid UTF-8, with the same message [`BasicJsonType::dump()`](../basic_json/dump.md) gives for that string.
   Also throws what 1. throws for `value`.
 3. Throws `type_error.305` if `array` is not an array -- the same message `operator[]` throws for a numeric argument
   on such a value. Throws [`out_of_range.401`](../../home/exceptions.md#jsonexceptionout_of_range401) if `idx` is
   negative, or if `#!cpp idx >= array.size()`. Also throws what 1. throws for `value`.
 4. Throws what [`at`](../basic_json_view/at.md) throws (overload 3) for resolving `ptr`'s parent, except that a
   missing object member or an array index equal to the array's size at the very last reference token is not an
   error there (it becomes a new member or an appended element) instead of
   [`out_of_range.403`](../../home/exceptions.md#jsonexceptionout_of_range403)/[`out_of_range.402`](../../home/exceptions.md#jsonexceptionout_of_range402).
   For the last reference token itself: if the parent is an object (or a primitive value, where it throws
   `type_error.305`), throws what 2. throws; if the parent is an array, throws what 3. throws for an index that is
   out of range, or, for a token that is not a valid array index,
   [`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106) (a leading `#!cpp '0'`),
   [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) (not a number),
   [`out_of_range.410`](../../home/exceptions.md#jsonexceptionout_of_range410) (too large for `size_type`), or
   [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) (an empty token). Also throws what 1.
   throws for `value`.
 Every overload also throws [`type_error.319`](../../home/exceptions.md#jsonexceptiontype_error319) if `value` is (or
 contains) a binary value -- `BasicJsonType` can hold one, but a `json_document` cannot -- and
 [`invalid_iterator.202`](../../home/exceptions.md#jsonexceptioninvalid_iterator202) ("view does not belong to this
 document") if `target`/`object`/`array` is a [discarded](../basic_json_view/is_discarded.md) view or a view of a
 *different* document (overloads 1-3 only; overload 4 always starts from this document's own [`root()`](root.md)).
 ## Complexity
 1. Linear in the size of `value` (encoding it into the document's storage): constant for a scalar, linear in the
   number of nested values for an array or object. If `target` is itself an array or object that spans more than one
   node in its parent's original, unedited layout, and `value` is a scalar, replacing it additionally costs time
   linear in the number of elements of that parent, the *first* time -- see [Notes](#notes).
 2. Linear in the number of members of `object`, to find an existing member with `key`, plus the complexity of 1. for
   `value`.
 3. Constant, plus the complexity of 1. for `value`.
 4. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
   that level or the index into the array (as [`at`](../basic_json_view/at.md)), plus the complexity of 2. or 3. for
   the last token.
 ## Notes
 !!! info "Duplicate keys"
    If `object` already has more than one member with `key` (2.), the *first* one is assigned `value` and every
    later member with the same key is removed -- so that a lookup, an iteration, and
    [`materialize()`](../basic_json_view/materialize.md) of `object` afterward all agree on a single value for
    `key`, the same way [`operator[]`](../basic_json_view/operator%5B%5D.md) already picks the first occurrence of a
    duplicate key for reading. See the [Notes on duplicate keys](../basic_json_view/operator%5B%5D.md#notes) of
    `operator[]`.
 Setting a member (2.) or an element (3., through 4.) of an array or object whose elements have not been edited
 before switches it from its parsed layout to a growable block holding links to its elements; a later
 [`push_back`](push_back.md) or `set` on the same container reuses that block, growing it (amortized constant time)
 only once it runs out of room. This never moves an element itself -- only where the container's *links* to its
 elements live -- so a view of an element stays valid, but any iterator already taken over the container is
 invalidated, since it was walking the old layout. See [Edits](index.md#edits) for what stays valid across an edit in
 general.
 The same switch happens, for the same reason, when overload 1. replaces a multi-node array/object value with a
 scalar: the *parent's* element sequence is what has to switch to links, not `target` itself, because the parent
 originally stepped over `target`'s whole subtree by its node count, which no longer applies once `target` is a
 one-node scalar.
 ## Examples
 ??? example "Example: (1)/(2)/(3)/(4) replace a value, set a member, assign an element, set via a JSON pointer"
    The example below edits a small configuration document -- replacing a value, adding an object member, assigning
    an array element, and reaching a field through a JSON pointer -- and shows what
    [`dump()`](../basic_json_view/dump.md) preserves that is lost once the same edits are made on a `BasicJsonType`
    value instead: the order object members were written in, and the exact spelling of a number that was never
    touched.
    ```cpp
    --8<-- "examples/basic_json_document__set.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__set.output"
    ```
 ## See also
 - [push_back](push_back.md) - append to an array
 - [insert](insert.md) - insert an element into an array
 - [erase](erase.md) - remove an object member, an array element, or the value a JSON pointer refers to
 - [root](root.md) - the view of the root value, the starting point of overload 4
 - [`basic_json_view::dump`](../basic_json_view/dump.md) - serialize the document, keeping an untouched number's
  spelling with `#!cpp number_format::source`
 - [Edits](index.md#edits) - what an edit guarantees, for every overload
 - [Editing a document](../../features/json_view.md#editing-a-document) - why editable documents keep the source
  text's order and number spelling
 ## Version history
 - Added in version 3.13.0.
@@ -1,58 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>shrink_to_fit
 ```cpp
 void shrink_to_fit();
 ```
 Releases capacity that is no longer needed, both of the node index and of the buffer for decoded strings (strings that
 contained escape sequences), e.g. after [`read()`](read.md) replaced a large document with a much smaller one. Like
 `#!cpp std::vector::shrink_to_fit()`, this is a non-binding request: the library may keep more capacity than strictly
 necessary.
 ## Exception safety
 Strong guarantee: if an exception is thrown, there are no changes to the document.
 ## Exceptions
 May throw `#!cpp std::bad_alloc` if the reallocation fails; on exception, the document is unchanged.
 ## Complexity
 Linear in [`node_count()`](node_count.md) plus the length of the decoded strings.
 ## Notes
 !!! warning "Invalidates views"
    Unlike moving the document, `shrink_to_fit()` **invalidates every view taken from this document before the
    call**, including a previously obtained [`root()`](root.md): the node index is moved into a new, smaller
    allocation, and the old one is freed. Take a fresh view from [`root()`](root.md) after calling this function.
 This is unlike `#!cpp std::vector::shrink_to_fit()`, which promises nothing about validity but in practice often
 leaves iterators alone when it did not need to reallocate; here, an implementation that avoids a reallocation when
 possible would be an internal optimization only, not a guarantee to rely on.
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__shrink_to_fit.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__shrink_to_fit.output"
    ```
 ## See also
 - [node_count](node_count.md) - the number of index entries
 - [memory_usage](memory_usage.md) - the number of bytes held by the document
 - [root](root.md) - the view of the root value
 ## Version history
 - Added in version 3.13.0.
@@ -1,48 +0,0 @@
 # <small>nlohmann::basic_json_document::</small>source
 ```cpp
 view_type::string_view_t source() const noexcept;
 ```
 Returns the parsed text, whether it is borrowed from the caller or owned by the document.
 ## Return value
 A `#!cpp string_view_t` (`#!cpp std::string_view` on C++17 and newer) over the parsed text, or an empty one if the
 document is [discarded](is_discarded.md).
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 For a borrowed document, `source()` points directly into the caller's buffer, so it is only valid while that buffer
 is; see [`owns_source`](owns_source.md).
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_document__source.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_document__source.output"
    ```
 ## See also
 - [owns_source](owns_source.md) - return whether the document holds its own copy of the text
 - [source_offset](../basic_json_view/source_offset.md) - byte offset of a value in the source text
 ## Version history
 - Added in version 3.13.0.
@@ -1,134 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>at
 ```cpp
 // (1)
 basic_json_view at(string_view_t key) const;
 basic_json_view at(const char* key) const;
 basic_json_view at(const string_t& key) const;
 // (2)
 basic_json_view at(size_type idx) const;
 basic_json_view at(int idx) const;
 // (3)
 basic_json_view at(const json_pointer& ptr) const;
 ```
 1. Returns the value of the object member with key `key` -- the first one, should the key occur more than once (see
   [Notes on duplicate keys](operator[].md#notes)).
 2. Returns the array element at index `idx`.
 3. Returns the value a JSON pointer `ptr` refers to, starting at this value.
 ## Parameters
 `key` (in)
 :   object key of the element to access
 `idx` (in)
 :   index of the element to access
 `ptr` (in)
 :   JSON pointer to the element to access
 ## Return value
 1. the value of the first member with key `key`
 2. the element at index `idx`
 3. the value `ptr` resolves to, starting at this value
 ## Exception safety
 Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
 ## Exceptions
 1. The function can throw the following exceptions, both with the same message as the corresponding call to
   [`BasicJsonType::at`](../basic_json/at.md):
    - Throws [`type_error.304`](../../home/exceptions.md#jsonexceptiontype_error304) if the value is not an object.
    - Throws [`out_of_range.403`](../../home/exceptions.md#jsonexceptionout_of_range403) if no member has key `key`.
 2. The function can throw the following exceptions, both with the same message as the corresponding call to
   [`BasicJsonType::at`](../basic_json/at.md):
    - Throws [`type_error.304`](../../home/exceptions.md#jsonexceptiontype_error304) if the value is not an array.
    - Throws [`out_of_range.401`](../../home/exceptions.md#jsonexceptionout_of_range401) if `#!cpp idx >= size()`.
 3. The function can throw the following exceptions, all with the same message as the corresponding call to
   [`BasicJsonType::at`](../basic_json/at.md):
    - Throws [`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106) if an array index in `ptr`
      begins with `#!cpp '0'`.
    - Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) if an array index in `ptr` is
      not a number.
    - Throws [`out_of_range.401`](../../home/exceptions.md#jsonexceptionout_of_range401) if an array index in `ptr`
      is out of range.
    - Throws [`out_of_range.402`](../../home/exceptions.md#jsonexceptionout_of_range402) if a reference token is
      `#!cpp "-"` at an array -- `at` never inserts an element, so `#!cpp "-"` is always invalid.
    - Throws [`out_of_range.403`](../../home/exceptions.md#jsonexceptionout_of_range403) if a reference token names
      an object member that does not exist.
    - Throws [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) if `ptr` cannot be resolved
      because a reference token is used on a primitive value.
 None of these exceptions carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no
 `BasicJsonType` value to point at, so the exception is created without one, even if `BasicJsonType` was built with
 `JSON_DIAGNOSTICS` enabled.
 ## Complexity
 1. Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
   another, in document order, stopping at the first match. Each comparison first checks the key's length --
   already known from the index, without reading the key bytes -- before comparing its content.
   Objects with 128 or more members get a hash index while parsing, so that a lookup in them takes constant time
   on average.
 2. Linear in `idx`: elements are skipped one at a time from the first one, since they are not a fixed size in the
   index (unlike `BasicJsonType`'s array, which is random-access).
 3. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
   that level (as 1.) or the index into the array (as 2.).
 ## Notes
 Unlike [`operator[]`](operator[].md), which returns a [discarded](is_discarded.md) view for a missing key or an
 out-of-range index, `at` always throws -- exactly as `BasicJsonType::at` does, and with the same messages, so
 existing error handling written against `BasicJsonType::at` keeps working unchanged when switched to a view. This
 also holds for overload 3: unlike [`operator[]`](operator[].md) with a JSON pointer, which returns a discarded view
 for a missing key or an out-of-range index, `at` throws for those too (`out_of_range.403`/`out_of_range.401`).
 ## Examples
 ??? example "Example: (1)/(2) access specified element with bounds checking"
    The example below reads required fields out of a service configuration with `at`, and shows that the exceptions
    it throws -- for a wrong type and for a missing key -- carry the same messages
    [`BasicJsonType::at`](../basic_json/at.md) would produce for the same JSON text.
    ```cpp
    --8<-- "examples/basic_json_view__at.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__at.output"
    ```
 ??? example "Example: (3) access specified element via JSON pointer with bounds checking"
    The example below shows that `at` with a JSON pointer throws exactly the exceptions, with exactly the messages,
    that [`BasicJsonType::at`](../basic_json/at.md) throws for the same pointer and the same document.
    ```cpp
    --8<-- "examples/basic_json_view__at_json_pointer.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__at_json_pointer.output"
    ```
 ## See also
 - [operator[]](operator[].md) - access specified element (returns a discarded view instead of throwing)
 - [front](front.md), [back](back.md) - access the first or last element
 - [`BasicJsonType::at`](../basic_json/at.md) - the corresponding function of `basic_json`
 - [`json_pointer`](../json_pointer/index.md) - JSON pointer type used by overload 3
 ## Version history
 - Added in version 3.13.0.
@@ -1,64 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>back
 ```cpp
 basic_json_view back() const;
 ```
 Returns the last element of an array, the last member value of an object, or the value itself if it is primitive
 (as for [`BasicJsonType::back()`](../basic_json/back.md), a primitive value is a range of one element).
 ## Return value
 The last element or member value. For a primitive value (number, string, boolean), the value itself.
 ## Exception safety
 Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
 ## Exceptions
 Throws [`invalid_iterator.214`](../../home/exceptions.md#jsonexceptioninvalid_iterator214) if the view is
 [null](is_null.md) or [discarded](is_discarded.md), or if it is an empty array or object.
 This exception does not carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no
 `BasicJsonType` value to point at, so the exception is created without one, even if `BasicJsonType` was built with
 `JSON_DIAGNOSTICS` enabled.
 ## Complexity
 Linear in the size of the array or object: unlike [`front()`](front.md), which only ever looks at the first
 element, `back()` has to walk every element to find where they end, since elements are not a fixed size in the
 index.
 ## Notes
 Unlike [`BasicJsonType::back()`](../basic_json/back.md), which has undefined behavior for an empty array or object,
 `back()` throws `invalid_iterator.214` in that case -- the same way it already does for `#!json null` and for a
 discarded view, where `BasicJsonType::back()` also throws.
 ## Examples
 ??? example
    The example below reads only the final status of a build log with `back()`. Even though `back()` is linear in
    the number of events (unlike [`front()`](front.md), which is constant), it still avoids building a
    `BasicJsonType` value for the events that are not needed.
    ```cpp
    --8<-- "examples/basic_json_view__back.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__back.output"
    ```
 ## See also
 - [front](front.md) - access the first element
 - [`BasicJsonType::back`](../basic_json/back.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,52 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>basic_json_view
 ```cpp
 basic_json_view() noexcept = default;
 ```
 Creates an invalid (discarded) view: [`type()`](type.md) is `#!cpp value_t::discarded`,
 [`is_discarded()`](is_discarded.md) is `#!cpp true`, and `#!cpp explicit operator bool()` is `#!cpp false`.
 This is the only constructor a caller can use directly. Every other view is obtained from a
 [`basic_json_document`](../basic_json_document/index.md), via [`root()`](../basic_json_document/root.md) or by
 navigating into a container with [`operator[]`](operator[].md), [`at`](at.md), [`front`](front.md), [`back`](back.md),
 [`find`](find.md), or iteration.
 ## Exception safety
 No-throw guarantee: this constructor never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 `basic_json_view` is trivially copyable (it holds two pointers), so a default-constructed view can be used as a
 placeholder for "no value yet" and later be assigned a real view.
 ## Examples
 ??? example
    The example below shows the default constructor and that a `basic_json_view` is a small, copyable handle.
    ```cpp
    --8<-- "examples/basic_json_view__basic_json_view.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__basic_json_view.output"
    ```
 ## See also
 - [is_discarded](is_discarded.md) - return whether the view is invalid
 - [operator bool](operator_bool.md) - return whether the view refers to a value
 - [root](../basic_json_document/root.md) - the view of a document's root value
 ## Version history
 - Added in version 3.13.0.
@@ -1,61 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>begin
 ```cpp
 iterator begin() const noexcept;
 ```
 Returns an iterator to the first element of an array, or the first member value of an object, in **document order**
 -- the order the values appear in the source text, not sorted by key. A primitive value iterates as a range of one
 element (itself); `#!json null` and a [discarded](is_discarded.md) view iterate as an empty range.
 ## Return value
 Iterator to the first element.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 For an object, iteration visits **every** member, including all occurrences of a duplicate key -- unlike
 [`operator[]`](operator[].md), [`at`](at.md), [`find`](find.md), [`contains`](contains.md), and [`count`](count.md),
 which all resolve to the *first* member with a given key. See the
 [Notes on duplicate keys](operator[].md#notes) of `operator[]`.
 Because objects are iterated in document order rather than sorted by key, the order seen here can differ from what
 iterating the [`materialize()`](materialize.md)d `BasicJsonType` value would produce: a `#!cpp basic_json` object
 (`std::map`-backed by default) sorts its keys, while a view does not.
 ## Examples
 ??? example
    The example below iterates a log record's members with `begin()`/[`end()`](end.md) and prints them in the order
    they were written. Materializing the record into a `BasicJsonType` object and iterating that would instead print
    the members sorted by key.
    ```cpp
    --8<-- "examples/basic_json_view__begin.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__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
 - [items](items.md) - access iterator member functions in range-based for
 - [`BasicJsonType::begin`](../basic_json/begin.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,49 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>cbegin
 ```cpp
 iterator cbegin() const noexcept;
 ```
 Returns an iterator to the first element, in [document order](begin.md). Equivalent to [`begin()`](begin.md): a view
 is always read-only, so `#!cpp const_iterator` and `#!cpp iterator` are the same type, and `cbegin()` exists only so
 that generic code that expects a `cbegin()`/`cend()` pair works with a view too.
 ## Return value
 Iterator to the first element; identical to what [`begin()`](begin.md) returns.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below sums many measurements with `std::accumulate`, using `cbegin()`/[`cend()`](cend.md) as the
    range -- the same way it would for any standard container -- without ever materializing the whole array into a
    `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__cbegin.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__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
 - [`BasicJsonType::cbegin`](../basic_json/cbegin.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,49 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>cend
 ```cpp
 iterator cend() const noexcept;
 ```
 Returns an iterator to one past the last element, in [document order](begin.md). Equivalent to [`end()`](end.md): a
 view is always read-only, so `#!cpp const_iterator` and `#!cpp iterator` are the same type, and `cend()` exists only
 so that generic code that expects a `cbegin()`/`cend()` pair works with a view too.
 ## Return value
 Iterator one past the last element; identical to what [`end()`](end.md) returns.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below checks that every record of a batch is an object with `std::all_of`, using
    [`cbegin()`](cbegin.md)/`cend()` as the range -- the same way it would for any standard container -- before
    materializing any record of the batch.
    ```cpp
    --8<-- "examples/basic_json_view__cend.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__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
 - [`BasicJsonType::cend`](../basic_json/cend.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,103 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>contains
 ```cpp
 // (1)
 bool contains(string_view_t key) const;
 bool contains(const char* key) const;
 bool contains(const string_t& key) const;
 // (2)
 bool contains(const json_pointer& ptr) const;
 ```
 1. Checks whether the value is an object with a member with key `key`.
 2. Checks whether a JSON pointer `ptr` can be resolved, starting at this value.
 ## Parameters
 `key` (in)
 :   key value to check its existence
 `ptr` (in)
 :   JSON pointer to check its existence
 ## Return value
 1. `#!cpp true` if the value is an object and has a member with key `key`, `#!cpp false` otherwise
 2. `#!cpp true` if `ptr` can be resolved to a value starting at this view, `#!cpp false` otherwise
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 1. Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
   another, in document order, stopping at the first match. Each comparison first checks the key's length -- already
   known from the index, without reading the key bytes -- before comparing its content.
   Objects with 128 or more members get a hash index while parsing, so that a lookup in them takes constant time
   on average.
 2. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
   that level or the index into the array -- as for [`operator[]`](operator[].md#complexity) and
   [`at`](at.md#complexity) with a JSON pointer.
 ## Notes
 Overload 1 always returns `#!cpp false` when the value is not an object -- including a [discarded](is_discarded.md)
 view.
 !!! info "Postconditions"
    If `#!cpp v.contains(key)` returns `#!cpp true`, then `#!cpp v[key]` is not [discarded](is_discarded.md). If
    `#!cpp v.contains(ptr)` returns `#!cpp true`, then `#!cpp v[ptr]` is not discarded and `#!cpp v.at(ptr)` does not
    throw.
 !!! info "Overload 2 never throws"
    Unlike [`BasicJsonType::contains(const json_pointer&)`](../basic_json/contains.md), which can throw for certain
    malformed pointers (for instance an empty array-index reference token), overload 2 never throws: a missing key,
    an out-of-range or malformed array index, a `#!cpp "-"` index, or a reference token used on a primitive all
    simply make it return `#!cpp false`.
 ## Examples
 ??? example "Example: (1) check with key"
    The example below counts how many of a batch of records carry an optional `retry_of` field, using `contains()`
    to check without ever materializing a single record of the batch.
    ```cpp
    --8<-- "examples/basic_json_view__contains.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__contains.output"
    ```
 ??? example "Example: (2) check with JSON pointer"
    The example below checks an optional, nested field with a JSON pointer, and shows two pointers that
    `#!cpp contains()` resolves to `#!cpp false` without throwing.
    ```cpp
    --8<-- "examples/basic_json_view__contains_json_pointer.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__contains_json_pointer.output"
    ```
 ## See also
 - [find](find.md) - find a value in an object
 - [count](count.md) - returns the number of occurrences of a key
 - [at](at.md), [operator[]](operator[].md) - resolve a JSON pointer and throw, or return a discarded view
 - [`BasicJsonType::contains`](../basic_json/contains.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,68 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>count
 ```cpp
 size_type count(string_view_t key) const;
 size_type count(const char* key) const;
 size_type count(const string_t& key) const;
 ```
 Returns `#!cpp 1` if the value is an object with a member with key `key`, `#!cpp 0` otherwise.
 ## Parameters
 `key` (in)
 :   key value of the element to count
 ## Return value
 `#!cpp 1` if the value is an object and has a member with key `key`, `#!cpp 0` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
 another, in document order, stopping at the first match. Each comparison first checks the key's length -- already
 known from the index, without reading the key bytes -- before comparing its content.
 Objects with 128 or more members get a hash index while parsing, so that a lookup in them takes constant time on
 average.
 ## Notes
 This method always returns `#!cpp 0` when the value is not an object -- including a [discarded](is_discarded.md)
 view.
 Unlike [`BasicJsonType::count()`](../basic_json/count.md), whose return value can in principle exceed `#!cpp 1` for
 an `ObjectType` that allows multiple entries per key, `count()` here never does: it is exactly
 [`contains()`](contains.md) as `#!cpp 0`/`#!cpp 1`. This holds even if the source text has a duplicate key -- see the
 [Notes on duplicate keys](operator[].md#notes) of `operator[]` -- because a `#!cpp count() > 1` result would require
 counting every member with a matching key, not just finding the first one.
 ## Examples
 ??? example
    The example below validates that every transaction of a batch carries a mandatory `amount` field, using
    `count()` before deciding whether to materialize a transaction at all.
    ```cpp
    --8<-- "examples/basic_json_view__count.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__count.output"
    ```
 ## See also
 - [find](find.md) - find a value in an object
 - [contains](contains.md) - checks whether a key exists
 - [`BasicJsonType::count`](../basic_json/count.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
--- a/Show More
+++ b/Show More