Build the update()/merge_patch() diagnostics test values instead of parsing them

Parsed values carry byte positions under JSON_DIAGNOSTIC_POSITIONS, which the expected messages do not include. Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Use the shared recursion limit in update() and merge_patch()
2026-10-01 04:00:31 +00:00 · 2026-09-24 17:11:39 +02:00 · 2026-09-24 17:11:39 +02:00 · 2026-09-24 17:11:39 +02:00 · 2026-09-24 17:11:38 +02:00 · 2026-09-24 17:11:38 +02:00
307 changed files with 2204 additions and 30563 deletions
@@ -2,7 +2,6 @@
 - [ ] The changes are described in detail, both the what and why.
 - [ ] If applicable, an [existing issue](https://github.com/nlohmann/json/issues) is referenced.
 - [ ] If applicable, a fixed [OSS-Fuzz](https://issues.oss-fuzz.com) issue is referenced as `OSS-Fuzz: <id>` (see [fuzz testing](https://github.com/nlohmann/json/blob/develop/tests/fuzzing.md#handling-oss-fuzz-reports)).
 - [ ] The [Code coverage](https://coveralls.io/github/nlohmann/json) remained at 100%. A test case for every new line of code.
 - [ ] If applicable, the [documentation](https://json.nlohmann.me) is updated.
 - [ ] The source code is amalgamated by running `make amalgamate`.
@@ -9,23 +9,12 @@ identified a security vulnerability in this repository, please use the GitHub Se
 Until it is published, this draft security advisory will only be visible to the maintainers of this project. Other
 users and teams may be added once the advisory is created.
-We will send a first response within 14 days, indicating the next steps in handling your report. After the initial
+We will send a response indicating the next steps in handling your report. After the initial reply to your report, we
-reply to your report, we will keep you informed of the progress towards a fix and full announcement and may ask for
+will keep you informed of the progress towards a fix and full announcement and may ask for additional information or
-additional information or guidance.
+guidance.
 For vulnerabilities in third-party dependencies or modules, please report them directly to the respective maintainers.
 ## Disclosure and credit
 Once a fix is released, we publish the security advisory and list the fixed vulnerability in the release notes. We
 credit the reporter in both, unless they ask not to be named.
 ## Supported versions
 Security fixes are made on the `develop` branch and shipped with the next release. Only the latest release receives
 security fixes; they are not backported to older releases. A release stops receiving security fixes when the next
 release is published, so please update to the latest release to get them.
 ## Unofficial packages
 This project does not publish an official npm package. The npm package
@@ -37,30 +37,13 @@ labels:
  files:
    - "include/nlohmann/detail/input/binary_reader\\.hpp"
    - "include/nlohmann/detail/output/binary_writer\\.hpp"
-    - "tests/src/unit-(bson|cbor|msgpack|ubjson|bjdata|bon8|binary_formats)"
+    - "tests/src/unit-(bson|cbor|msgpack|ubjson|bjdata|binary_formats)"
-    - "tests/src/fuzzer-parse_(bson|cbor|msgpack|ubjson|bjdata|bon8)"
+    - "tests/src/fuzzer-parse_(bson|cbor|msgpack|ubjson|bjdata)"
    - "docs/mkdocs/docs/features/binary_formats/"
-    - "docs/mkdocs/docs/(api/basic_json|examples)/(to|from)_(bson|cbor|msgpack|ubjson|bjdata|bon8)"
+    - "docs/mkdocs/docs/(api/basic_json|examples)/(to|from)_(bson|cbor|msgpack|ubjson|bjdata)"
 - label: "aspect: binary formats"
-  title: "(?i)(bson|cbor|msgpack|messagepack|ubjson|bjdata|bon8|binary format)"
+  title: "(?i)(bson|cbor|msgpack|messagepack|ubjson|bjdata|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\\.cpp"
    - "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_(document|view)\\.md"
    - "docs/mkdocs/docs/examples/(basic_json_(document|view)__|(ordered_)?json_(document|view)).*"
    - "tests/benchmarks/src/benchmarks_view\\.cpp"
 - label: "aspect: json_view"
  title: "(?i)(json_view|json_document|zero-copy)"
 - label: "python"
  files:
@@ -3,10 +3,6 @@ name: "Check amalgamation"
 on:
  pull_request:
 concurrency:
  group: ${{ github.workflow }}-${{ github.ref || github.run_id }}
  cancel-in-progress: true
 permissions:
  contents: read
@@ -67,16 +63,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,10 +1,6 @@
 name: CIFuzz
 on: [pull_request]
 concurrency:
  group: ${{ github.workflow }}-${{ github.ref || github.run_id }}
  cancel-in-progress: true
 permissions:
  contents: read
@@ -38,14 +38,14 @@ jobs:
    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
-      uses: github/codeql-action/init@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
+      uses: github/codeql-action/init@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
      with:
        languages: c-cpp
    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
    # If this step fails, then you should remove it and run the build manually (see below)
    - name: Autobuild
-      uses: github/codeql-action/autobuild@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
+      uses: github/codeql-action/autobuild@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
+      uses: github/codeql-action/analyze@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
@@ -9,10 +9,6 @@
 name: 'Dependency Review'
 on: [pull_request]
 concurrency:
  group: ${{ github.workflow }}-${{ github.ref || github.run_id }}
  cancel-in-progress: true
 permissions:
  contents: read
@@ -5,10 +5,6 @@
 name: flawfinder
 concurrency:
  group: ${{ github.workflow }}-${{ github.ref || github.run_id }}
  cancel-in-progress: true
 permissions:
  contents: read
@@ -47,6 +43,6 @@ jobs:
          output: 'flawfinder_results.sarif'
      - name: Upload analysis results to GitHub Security tab
-        uses: github/codeql-action/upload-sarif@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
+        uses: github/codeql-action/upload-sarif@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
        with:
          sarif_file: ${{github.workspace}}/flawfinder_results.sarif
@@ -4,12 +4,6 @@ on:
  pull_request_target:
    types: [opened, synchronize]
 # pull_request_target runs on the base branch, so github.ref would put all pull
 # requests into one group; group by pull request number instead
 concurrency:
  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_id }}
  cancel-in-progress: true
 permissions:
  contents: read
@@ -14,10 +14,6 @@ on:
  push:
    branches: ["develop"]
 concurrency:
  group: ${{ github.workflow }}-${{ github.ref || github.run_id }}
  cancel-in-progress: true
 permissions:
  contents: read
@@ -80,6 +76,6 @@ jobs:
      # Upload the results to GitHub's code scanning dashboard.
      - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
+        uses: github/codeql-action/upload-sarif@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
        with:
          sarif_file: results.sarif
@@ -19,10 +19,6 @@ on:
  schedule:
    - cron: '23 2 * * 4'
 concurrency:
  group: ${{ github.workflow }}-${{ github.ref || github.run_id }}
  cancel-in-progress: true
 permissions:
  contents: read
@@ -65,7 +61,7 @@ jobs:
      # Upload SARIF file generated in previous step
      - name: Upload SARIF file
-        uses: github/codeql-action/upload-sarif@1c5b675653bb5c22dbe9b12b556ec555138e09fd # v4.38.1
+        uses: github/codeql-action/upload-sarif@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
        with:
          sarif_file: semgrep.sarif
        if: always()
@@ -124,11 +124,11 @@ jobs:
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
      - name: Run CMake (Release)
-        run: cmake -S . -B build -G "Visual Studio 18 2026" -A ARM64 -DJSON_BuildTests=On -DCMAKE_CXX_FLAGS="/W4 /WX"
+        run: cmake -S . -B build -G "Visual Studio 17 2022" -A ARM64 -DJSON_BuildTests=On -DCMAKE_CXX_FLAGS="/W4 /WX"
        if: matrix.build_type == 'Release'
        shell: pwsh
      - name: Run CMake (Debug)
-        run: cmake -S . -B build -G "Visual Studio 18 2026" -A ARM64 -DJSON_BuildTests=On -DJSON_FastTests=ON -DCMAKE_CXX_FLAGS="/W4 /WX"
+        run: cmake -S . -B build -G "Visual Studio 17 2022" -A ARM64 -DJSON_BuildTests=On -DJSON_FastTests=ON -DCMAKE_CXX_FLAGS="/W4 /WX"
        if: matrix.build_type == 'Debug'
        shell: pwsh
      - name: Build
@@ -20,9 +20,7 @@ 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",
        "include/nlohmann/detail/conversions/to_chars.hpp",
        "include/nlohmann/detail/conversions/to_json.hpp",
@@ -35,7 +33,6 @@ cc_library(
        "include/nlohmann/detail/input/number_parse.hpp",
        "include/nlohmann/detail/input/parser.hpp",
        "include/nlohmann/detail/input/position_t.hpp",
        "include/nlohmann/detail/input/pow5_table.hpp",
        "include/nlohmann/detail/input/string_scan.hpp",
        "include/nlohmann/detail/iterators/internal_iterator.hpp",
        "include/nlohmann/detail/iterators/iter_impl.hpp",
@@ -66,34 +63,21 @@ 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/document_data.hpp",
        "include/nlohmann/detail/view/errors.hpp",
        "include/nlohmann/detail/view/input.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/scan.hpp",
        "include/nlohmann/detail/view/string_ref.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",
    ],
    includes = ["include"],
    visibility = ["//visibility:public"],
    alwayslink = True,
 )
 cc_library(
    name = "singleheader-json",
    hdrs = [
        "single_include/nlohmann/json.hpp",
        "single_include/nlohmann/json_view.hpp",
    ],
    includes = ["single_include"],
    visibility = ["//visibility:public"],
@@ -21,9 +21,6 @@ TESTS_SRCS=$(shell find tests -type f \( -name '*.hpp' -o -name '*.cpp' -o -name
 # the single headers (amalgamated from the source files)
 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
 ##########################################################################
@@ -32,17 +29,15 @@ AMALGAMATED_VIEW_FILE=single_include/nlohmann/json_view.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}.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"
 	@echo "clean - remove built files"
 	@echo "doctest - compile example files and check their output"
 	@echo "fuzz_testing - prepare fuzz testing of the JSON parser"
 	@echo "fuzz_testing_bon8 - prepare fuzz testing of the BON8 parser"
 	@echo "fuzz_testing_bson - prepare fuzz testing of the BSON parser"
 	@echo "fuzz_testing_cbor - prepare fuzz testing of the CBOR parser"
 	@echo "fuzz_testing_json_view - prepare fuzz testing of the json_document/json_view parser"
 	@echo "fuzz_testing_msgpack - prepare fuzz testing of the MessagePack parser"
 	@echo "fuzz_testing_ubjson - prepare fuzz testing of the UBJSON parser"
 	@echo "pretty - beautify code with Artistic Style"
@@ -76,14 +71,6 @@ fuzz_testing:
 	find tests/data/json_tests -size -5k -name *json | xargs -I{} cp "{}" fuzz-testing/testcases
 	@echo "Execute: afl-fuzz -i fuzz-testing/testcases -o fuzz-testing/out fuzz-testing/fuzzer"
 fuzz_testing_bon8:
 	rm -fr fuzz-testing
 	mkdir -p fuzz-testing fuzz-testing/testcases fuzz-testing/out
 	$(MAKE) parse_bon8_fuzzer -C tests CXX=afl-clang++
 	mv tests/parse_bon8_fuzzer fuzz-testing/fuzzer
 	find tests/data -size -5k -name *.bon8 | xargs -I{} cp "{}" fuzz-testing/testcases
 	@echo "Execute: afl-fuzz -i fuzz-testing/testcases -o fuzz-testing/out fuzz-testing/fuzzer"
 fuzz_testing_bson:
 	rm -fr fuzz-testing
 	mkdir -p fuzz-testing fuzz-testing/testcases fuzz-testing/out
@@ -100,14 +87,6 @@ fuzz_testing_cbor:
 	find tests/data -size -5k -name *.cbor | xargs -I{} cp "{}" fuzz-testing/testcases
 	@echo "Execute: afl-fuzz -i fuzz-testing/testcases -o fuzz-testing/out fuzz-testing/fuzzer"
 fuzz_testing_json_view:
 	rm -fr fuzz-testing
 	mkdir -p fuzz-testing fuzz-testing/testcases fuzz-testing/out
 	$(MAKE) parse_json_view_fuzzer -C tests CXX=afl-clang++
 	mv tests/parse_json_view_fuzzer fuzz-testing/fuzzer
 	find tests/data/json_tests -size -5k -name *json | xargs -I{} cp "{}" fuzz-testing/testcases
 	@echo "Execute: afl-fuzz -i fuzz-testing/testcases -o fuzz-testing/out fuzz-testing/fuzzer"
 fuzz_testing_msgpack:
 	rm -fr fuzz-testing
 	mkdir -p fuzz-testing fuzz-testing/testcases fuzz-testing/out
@@ -166,14 +145,14 @@ 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
+	$(ASTYLE) --project=tools/astyle/.astylerc $(SRCS) $(TESTS_SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) docs/mkdocs/docs/examples/*.cpp
 # call the Clang-Format on all source files
 pretty_format:
 	for FILE in $(SRCS) $(TESTS_SRCS) $(AMALGAMATED_FILE) docs/mkdocs/docs/examples/*.cpp; do echo $$FILE; clang-format -i $$FILE; done
 # 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)
 	$(MAKE) pretty
 # call the amalgamation tool for json.hpp
@@ -184,30 +163,16 @@ $(AMALGAMATED_FILE): $(SRCS)
 $(AMALGAMATED_FWD_FILE): $(SRCS)
 	tools/amalgamate/amalgamate.py -c tools/amalgamate/config_json_fwd.json -s . --verbose=yes
 # copy json_literals.hpp
 $(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
 # check if file single_include/nlohmann/json.hpp has been amalgamated from the nlohmann sources
 # Note: this target is called by Travis
 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)
@@ -248,7 +213,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) 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
@@ -257,15 +222,11 @@ release: include.zip json.tar.xz
 	gpg --armor --detach-sig include.zip
 	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
+	mv $(AMALGAMATED_FILE).asc $(AMALGAMATED_FWD_FILE).asc json.tar.xz json.tar.xz.asc include.zip include.zip.asc release_files
-	cp $(AMALGAMATED_VIEW_FILE) release_files
+	cd release_files ; shasum -a 256 json.hpp include.zip json.tar.xz > hashes.txt
 	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 json.hpp json_view.hpp include.zip json.tar.xz > hashes.txt
 ##########################################################################
@@ -17,7 +17,7 @@
 [![GitHub Downloads](https://img.shields.io/github/downloads/nlohmann/json/total)](https://github.com/nlohmann/json/releases)
 [![GitHub Issues](https://img.shields.io/github/issues/nlohmann/json.svg)](https://github.com/nlohmann/json/issues)
 [![Average time to resolve an issue](https://isitmaintained.com/badge/resolution/nlohmann/json.svg)](https://isitmaintained.com/project/nlohmann/json "Average time to resolve an issue")
-[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/289/badge)](https://www.bestpractices.dev/projects/289)
+[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/289/badge)](https://bestpractices.coreinfrastructure.org/projects/289)
 [![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/nlohmann/json/badge)](https://scorecard.dev/viewer/?uri=github.com/nlohmann/json)
 [![Backup Status](https://app.cloudback.it/badge/nlohmann/json)](https://cloudback.it)
 [![GitHub Sponsors](https://img.shields.io/badge/GitHub-Sponsors-ff69b4)](https://github.com/sponsors/nlohmann)
@@ -40,7 +40,7 @@
  - [Implicit conversions](#implicit-conversions)
  - [Conversions to/from arbitrary types](#arbitrary-types-conversions)
  - [Specializing enum conversion](#specializing-enum-conversion)
-  - [Binary formats (BSON, CBOR, MessagePack, UBJSON, BJData, and BON8)](#binary-formats-bson-cbor-messagepack-ubjson-bjdata-and-bon8)
+  - [Binary formats (BSON, CBOR, MessagePack, UBJSON, and BJData)](#binary-formats-bson-cbor-messagepack-ubjson-and-bjdata)
 - [Customers](#customers)
 - [Ecosystem](#ecosystem)
 - [Supported compilers](#supported-compilers)
@@ -63,7 +63,7 @@ There are myriads of [JSON](https://json.org) libraries out there, and each may
 - **Trivial integration**. Our whole code consists of a single header file [`json.hpp`](https://github.com/nlohmann/json/blob/develop/single_include/nlohmann/json.hpp). That's it. No library, no subproject, no dependencies, no complex build system. The class is written in vanilla C++11. All in all, everything should require no adjustment of your compiler flags or project settings. The library is also included in all popular [package managers](https://json.nlohmann.me/integration/package_managers/).
- **Serious testing**. Our code is heavily [unit-tested](https://github.com/nlohmann/json/tree/develop/tests/src) and covers [100%](https://coveralls.io/r/nlohmann/json) of the code, including all exceptional behavior. Furthermore, we checked with [Valgrind](https://valgrind.org) and the [Clang Sanitizers](https://clang.llvm.org/docs/index.html) that there are no memory leaks. [Google OSS-Fuzz](https://github.com/google/oss-fuzz/tree/master/projects/json) additionally runs fuzz tests against all parsers 24/7, effectively executing billions of tests so far. To maintain high quality, the project is following the [OpenSSF Best Practices](https://www.bestpractices.dev/projects/289). See the [quality assurance](https://json.nlohmann.me/community/quality_assurance) overview documentation.
+- **Serious testing**. Our code is heavily [unit-tested](https://github.com/nlohmann/json/tree/develop/tests/src) and covers [100%](https://coveralls.io/r/nlohmann/json) of the code, including all exceptional behavior. Furthermore, we checked with [Valgrind](https://valgrind.org) and the [Clang Sanitizers](https://clang.llvm.org/docs/index.html) that there are no memory leaks. [Google OSS-Fuzz](https://github.com/google/oss-fuzz/tree/master/projects/json) additionally runs fuzz tests against all parsers 24/7, effectively executing billions of tests so far. To maintain high quality, the project is following the [Core Infrastructure Initiative (CII) best practices](https://bestpractices.coreinfrastructure.org/projects/289). See the [quality assurance](https://json.nlohmann.me/community/quality_assurance) overview documentation.
 Other aspects were not so important to us:
@@ -128,7 +128,7 @@ There is also a [**docset**](https://github.com/Kapeli/Dash-User-Contributions/t
 - **JSON Pointer functions**: [flatten](https://json.nlohmann.me/api/basic_json/flatten), [unflatten](https://json.nlohmann.me/api/basic_json/unflatten)
 - **JSON Patch functions**: [patch](https://json.nlohmann.me/api/basic_json/patch), [patch_inplace](https://json.nlohmann.me/api/basic_json/patch_inplace), [diff](https://json.nlohmann.me/api/basic_json/diff), [merge_patch](https://json.nlohmann.me/api/basic_json/merge_patch)
 - **Static functions**: [meta](https://json.nlohmann.me/api/basic_json/meta), [get_allocator](https://json.nlohmann.me/api/basic_json/get_allocator)
- **Binary formats**: [from_bjdata](https://json.nlohmann.me/api/basic_json/from_bjdata), [from_bon8](https://json.nlohmann.me/api/basic_json/from_bon8), [from_bson](https://json.nlohmann.me/api/basic_json/from_bson), [from_cbor](https://json.nlohmann.me/api/basic_json/from_cbor), [from_msgpack](https://json.nlohmann.me/api/basic_json/from_msgpack), [from_ubjson](https://json.nlohmann.me/api/basic_json/from_ubjson), [to_bjdata](https://json.nlohmann.me/api/basic_json/to_bjdata), [to_bon8](https://json.nlohmann.me/api/basic_json/to_bon8), [to_bson](https://json.nlohmann.me/api/basic_json/to_bson), [to_cbor](https://json.nlohmann.me/api/basic_json/to_cbor), [to_msgpack](https://json.nlohmann.me/api/basic_json/to_msgpack), [to_ubjson](https://json.nlohmann.me/api/basic_json/to_ubjson)
+- **Binary formats**: [from_bjdata](https://json.nlohmann.me/api/basic_json/from_bjdata), [from_bson](https://json.nlohmann.me/api/basic_json/from_bson), [from_cbor](https://json.nlohmann.me/api/basic_json/from_cbor), [from_msgpack](https://json.nlohmann.me/api/basic_json/from_msgpack), [from_ubjson](https://json.nlohmann.me/api/basic_json/from_ubjson), [to_bjdata](https://json.nlohmann.me/api/basic_json/to_bjdata), [to_bson](https://json.nlohmann.me/api/basic_json/to_bson), [to_cbor](https://json.nlohmann.me/api/basic_json/to_cbor), [to_msgpack](https://json.nlohmann.me/api/basic_json/to_msgpack), [to_ubjson](https://json.nlohmann.me/api/basic_json/to_ubjson)
 - **Non-member functions**: [operator<<](https://json.nlohmann.me/api/operator_ltlt/), [operator>>](https://json.nlohmann.me/api/operator_gtgt/), [to_string](https://json.nlohmann.me/api/basic_json/to_string)
 - **Literals**: [operator""_json](https://json.nlohmann.me/api/operator_literal_json)
 - **Helper classes**: [std::hash&lt;basic_json&gt;](https://json.nlohmann.me/api/basic_json/std_hash), [std::swap&lt;basic_json&gt;](https://json.nlohmann.me/api/basic_json/std_swap)
@@ -1110,9 +1110,9 @@ Other Important points:
 - When using `get<ENUM_TYPE>()`, undefined JSON values will default to the first pair specified in your map. Select this default pair carefully. If you desire an exception in this circumstance use `NLOHMANN_JSON_SERIALIZE_ENUM_STRICT()` which behaves identically except for throwing an exception on unrecognized values.
 - If an enum or JSON value is specified more than once in your map, the first matching occurrence from the top of the map will be returned when converting to or from JSON.
-### Binary formats (BSON, CBOR, MessagePack, UBJSON, BJData, and BON8)
+### Binary formats (BSON, CBOR, MessagePack, UBJSON, and BJData)
-Though JSON is a ubiquitous data format, it is not a very compact format suitable for data exchange, for instance over a network. Hence, the library supports [BSON](https://bsonspec.org) (Binary JSON), [CBOR](https://cbor.io) (Concise Binary Object Representation), [MessagePack](https://msgpack.org), [UBJSON](https://ubjson.org) (Universal Binary JSON Specification), [BJData](https://neurojson.org/bjdata) (Binary JData), and [BON8](https://github.com/hikoworks/hikogui/blob/main/docs/BON8.md) (Binary Object Notation 8) to efficiently encode JSON values to byte vectors and to decode such vectors.
+Though JSON is a ubiquitous data format, it is not a very compact format suitable for data exchange, for instance over a network. Hence, the library supports [BSON](https://bsonspec.org) (Binary JSON), [CBOR](https://cbor.io) (Concise Binary Object Representation), [MessagePack](https://msgpack.org), [UBJSON](https://ubjson.org) (Universal Binary JSON Specification) and [BJData](https://neurojson.org/bjdata) (Binary JData) to efficiently encode JSON values to byte vectors and to decode such vectors.
 ```cpp
 // create a JSON value
@@ -1149,14 +1149,6 @@ std::vector<std::uint8_t> v_ubjson = json::to_ubjson(j);
 // roundtrip
 json j_from_ubjson = json::from_ubjson(v_ubjson);
 // serialize to BON8
 std::vector<std::uint8_t> v_bon8 = json::to_bon8(j);
 // 0x88, 0x63, 0x6F, 0x6D, 0x70, 0x61, 0x63, 0x74, 0xF9, 0x73, 0x63, 0x68, 0x65, 0x6D, 0x61, 0x90
 // roundtrip
 json j_from_bon8 = json::from_bon8(v_bon8);
 ```
 The library also supports binary types from BSON, CBOR (byte strings), and MessagePack (bin, ext, fixext). They are stored by default as `std::vector<std::uint8_t>` to be processed outside the library.
@@ -1189,14 +1181,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).
@@ -1403,8 +1387,6 @@ 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 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.
 <img align="right" src="https://git.fsfe.org/reuse/reuse-ci/raw/branch/master/reuse-horizontal.png" alt="REUSE Software">
@@ -300,10 +300,10 @@ add_custom_target(ci_test_skiplibraryversioncheck
 # Disable thread-local storage.
 ###############################################################################
-# Without thread-local storage, copying and comparing cannot bound their
+# Without thread-local storage, the copy constructor cannot bound its descent
-# descent and handle every object and array without the call stack. Those paths
+# and copies every object and array without the call stack. That path is
-# are otherwise only reached by values nested deeper than the bound, so this
+# otherwise only reached by values nested deeper than the bound, so this target
-# target is what runs the whole test suite through them.
+# is what runs the whole test suite through it.
 add_custom_target(ci_test_no_thread_local
    COMMAND ${CMAKE_COMMAND}
    -DCMAKE_BUILD_TYPE=Debug -GNinja
@@ -373,11 +373,9 @@ file(GLOB_RECURSE INDENT_FILES
 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~
    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 ${Python3_EXECUTABLE} -mvenv venv_astyle
    COMMAND venv_astyle/bin/pip3 --quiet install -r ${CMAKE_SOURCE_DIR}/tools/astyle/requirements.txt
@@ -385,14 +383,10 @@ 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 venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=none ${include_dir}/json.hpp ${include_dir}/json_fwd.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 ${include_dir}/json_view.hpp
    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 venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=orig ${INDENT_FILES}
    COMMAND for FILE in `find . -name '*.orig'`\; do false \; done
@@ -548,7 +542,7 @@ add_custom_target(ci_infer
 add_custom_target(ci_offline_testdata
    COMMAND mkdir -p ${PROJECT_BINARY_DIR}/build_offline_testdata/test_data
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_offline_testdata/test_data && ${GIT_TOOL} clone -c advice.detachedHead=false --branch v3.2.0 https://github.com/nlohmann/json_test_data.git --quiet --depth 1
+    COMMAND cd ${PROJECT_BINARY_DIR}/build_offline_testdata/test_data && ${GIT_TOOL} clone -c advice.detachedHead=false --branch v3.1.0 https://github.com/nlohmann/json_test_data.git --quiet --depth 1
    COMMAND ${CMAKE_COMMAND}
        -DCMAKE_BUILD_TYPE=Debug -GNinja
        -DJSON_BuildTests=ON -DJSON_FastTests=ON -DJSON_TestDataDirectory=${PROJECT_BINARY_DIR}/build_offline_testdata/test_data/json_test_data
@@ -625,7 +619,7 @@ add_custom_target(ci_single_binaries
 add_custom_target(ci_benchmarks
    COMMAND ${CMAKE_COMMAND}
        -DCMAKE_BUILD_TYPE=Release -GNinja
-        -S${PROJECT_SOURCE_DIR}/tests/benchmarks -B${PROJECT_BINARY_DIR}/build_benchmarks
+        -S${PROJECT_SOURCE_DIR}/benchmarks -B${PROJECT_BINARY_DIR}/build_benchmarks
    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_benchmarks --target json_benchmarks
    COMMAND cd ${PROJECT_BINARY_DIR}/build_benchmarks && ./json_benchmarks
    COMMENT "Run benchmarks"
@@ -1,5 +1,5 @@
 set(JSON_TEST_DATA_URL     https://github.com/nlohmann/json_test_data)
-set(JSON_TEST_DATA_VERSION 3.2.0)
+set(JSON_TEST_DATA_VERSION 3.1.0)
 include(ExternalProject)
@@ -77,7 +77,7 @@ if(CMAKE_CROSSCOMPILING)
 endif()
 if(NOT DEFINED LIBCPP_VERSION_OUTPUT_CACHED)
    try_run(RUN_RESULT_VAR COMPILE_RESULT_VAR
-        "${CMAKE_BINARY_DIR}" SOURCES "${CMAKE_CURRENT_LIST_DIR}/detect_libcpp_version.cpp"
+        "${CMAKE_BINARY_DIR}" SOURCES "${CMAKE_SOURCE_DIR}/cmake/detect_libcpp_version.cpp"
        RUN_OUTPUT_VARIABLE LIBCPP_VERSION_OUTPUT
        COMPILE_OUTPUT_VARIABLE LIBCPP_VERSION_COMPILE_OUTPUT
    )
@@ -42,13 +42,13 @@ string(APPEND CONTENT [=[
    ],
    includes = ["include"],
    visibility = ["//visibility:public"],
    alwayslink = True,
 )
 cc_library(
    name = "singleheader-json",
    hdrs = [
        "single_include/nlohmann/json.hpp",
        "single_include/nlohmann/json_view.hpp",
    ],
    includes = ["single_include"],
    visibility = ["//visibility:public"],
@@ -48,7 +48,6 @@ INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::from_bjdata', 'Fu
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::from_bson', 'Function', 'api/basic_json/from_bson/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::from_cbor', 'Function', 'api/basic_json/from_cbor/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::from_msgpack', 'Function', 'api/basic_json/from_msgpack/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::from_bon8', 'Function', 'api/basic_json/from_bon8/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::from_ubjson', 'Function', 'api/basic_json/from_ubjson/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::front', 'Method', 'api/basic_json/front/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::get', 'Method', 'api/basic_json/get/index.html');
@@ -122,49 +121,12 @@ INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::to_bjdata', 'Func
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::to_bson', 'Function', 'api/basic_json/to_bson/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::to_cbor', 'Function', 'api/basic_json/to_cbor/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::to_msgpack', 'Function', 'api/basic_json/to_msgpack/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::to_bon8', 'Function', 'api/basic_json/to_bon8/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::to_string', 'Method', 'api/basic_json/to_string/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::to_ubjson', 'Function', 'api/basic_json/to_ubjson/index.html');
 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::is_discarded', 'Method', 'api/basic_json_document/is_discarded/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::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::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::empty', 'Method', 'api/basic_json_view/empty/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::materialize', 'Method', 'api/basic_json_view/materialize/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::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 ('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_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');
@@ -198,8 +160,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_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::hash<basic_json>', 'Class', 'api/basic_json/std_hash/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('std::swap<basic_json>', 'Function', 'api/basic_json/std_swap/index.html');
@@ -211,7 +171,6 @@ INSERT INTO searchIndex(name, type, path) VALUES ('Binary Formats: BJData', 'Gui
 INSERT INTO searchIndex(name, type, path) VALUES ('Binary Formats: BSON', 'Guide', 'features/binary_formats/bson/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Binary Formats: CBOR', 'Guide', 'features/binary_formats/cbor/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Binary Formats: MessagePack', 'Guide', 'features/binary_formats/messagepack/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Binary Formats: BON8', 'Guide', 'features/binary_formats/bon8/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Binary Formats: UBJSON', 'Guide', 'features/binary_formats/ubjson/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Binary Values', 'Guide', 'features/binary_values/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Comments', 'Guide', 'features/comments/index.html');
@@ -229,7 +188,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');
@@ -139,8 +139,8 @@ basic_json(basic_json&& other) noexcept;
    - In case of a `#!json null` type, [invalid_iterator.206](../../home/exceptions.md#jsonexceptioninvalid_iterator206)
      is thrown.
-    - In case of other primitive types (number, boolean, string, or binary), `first` must be `begin()` and `last`
+    - In case of other primitive types (number, boolean, or string), `first` must be `begin()` and `last` must be
-      must be `end()`. In this case, the value is copied. Otherwise,
+      `end()`. In this case, the value is copied. Otherwise,
      [`invalid_iterator.204`](../../home/exceptions.md#jsonexceptioninvalid_iterator204) is thrown.
    - In case of structured types (array, object), the constructor behaves as similar versions for `std::vector` or
      `std::map`; that is, a JSON array or object is constructed from the values in the range.
@@ -242,8 +242,8 @@ basic_json(basic_json&& other) noexcept;
      and `last` are not compatible (i.e., do not belong to the same JSON value). In this case, the range
      `[first, last)` is undefined.
    - Throws [`invalid_iterator.204`](../../home/exceptions.md#jsonexceptioninvalid_iterator204) if iterators `first`
-      and `last` belong to a primitive type (number, boolean, string, or binary), but `first` does not point to the
+      and `last` belong to a primitive type (number, boolean, or string), but `first` does not point to the first
-      first element anymore. In this case, the range `[first, last)` is undefined. See the example code below.
+      element anymore. In this case, the range `[first, last)` is undefined. See the example code below.
    - Throws [`invalid_iterator.206`](../../home/exceptions.md#jsonexceptioninvalid_iterator206) if iterators `first`
      and `last` belong to a `#!json null` value. In this case, the range `[first, last)` is undefined.
 8. (none)
@@ -423,8 +423,6 @@ basic_json(basic_json&& other) noexcept;
 4. Since version 3.2.0.
 5. Since version 1.0.0.
 6. Since version 1.0.0.
-7. Since version 1.0.0. Fixed in version 3.13.0 to also check the iterator range for binary values; before, a range
+7. Since version 1.0.0.
   that did not cover the whole value (such as `(end(), end())`) was accepted and the whole binary value was copied,
   unlike the other primitive types.
 8. Since version 1.0.0.
 9. Since version 1.0.0.
@@ -18,8 +18,7 @@ ignore
 :   ignore tags
 store
-:   store tagged byte strings (for bytes 0xd8..0xdb) as binary values with the tag as subtype; other tagged values are
+:   store tagged values as binary container with subtype (for bytes 0xd8..0xdb)
    read as if the tag were ignored. If several tags precede a byte string, only the innermost one is stored.
 ## Examples
@@ -7,15 +7,15 @@ void clear() noexcept;
 Clears the content of a JSON value and resets it to the default value as if [`basic_json(value_t)`](basic_json.md) would
 have been called with the current value type from [`type()`](type.md):
-| Value type | initial value                           |
+| Value type | initial value        |
-|------------|-----------------------------------------|
+|------------|----------------------|
-| null       | `null`                                  |
+| null       | `null`               |
-| boolean    | `false`                                 |
+| boolean    | `false`              |
-| string     | `""`                                    |
+| string     | `""`                 |
-| number     | `0`                                     |
+| number     | `0`                  |
-| binary     | An empty byte vector with no subtype    |
+| binary     | An empty byte vector |
-| object     | `{}`                                    |
+| object     | `{}`                 |
-| array      | `[]`                                    |
+| array      | `[]`                 |
 Has the same effect as calling
@@ -56,4 +56,3 @@ All iterators, pointers, and references related to this container are invalidate
 - Added in version 1.0.0.
 - Added support for binary types in version 3.8.0.
 - Fixed in version 3.13.0 to also clear the subtype of a binary value; before, the subtype was left unchanged.
@@ -58,10 +58,6 @@ Logarithmic in the size of the JSON object.
 - This method always returns `#!cpp false` when executed on a JSON type that is not an object.
 - This method can be executed on any JSON value type.
 - Calling this function with an integer argument (for example, `#!cpp contains(0)`) does not compile: such an argument
  would otherwise implicitly convert to a null `#!cpp const char*` and, from there, cause undefined behavior when
  constructing a `#!cpp std::string` for the object key. To check for an array element instead, use [`at`](at.md),
  [`operator[]`](operator%5B%5D.md), or compare against [`size`](size.md).
 !!! info "Postconditions"
@@ -121,5 +117,3 @@ Logarithmic in the size of the JSON object.
 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.
 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.
@@ -40,11 +40,7 @@ Logarithmic in the size of the JSON object.
 ## Notes
- This method always returns `0` when executed on a JSON type that is not an object.
+This method always returns `0` when executed on a JSON type that is not an object.
 - Calling this function with an integer argument (for example, `#!cpp count(0)`) does not compile: such an argument
  would otherwise implicitly convert to a null `#!cpp const char*` and, from there, cause undefined behavior when
  constructing a `#!cpp std::string` for the object key. To check for an array element instead, use [`at`](at.md),
  [`operator[]`](operator%5B%5D.md), or compare against [`size`](size.md).
 ## Examples
@@ -85,5 +81,3 @@ Logarithmic in the size of the JSON object.
 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.
 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.
@@ -60,10 +60,6 @@ itself is empty which is `#!cpp false` in the case of a string.
    --8<-- "examples/empty.output"
    ```
 ## See also
 - [basic_json_view::empty](../basic_json_view/empty.md) - the same check on a zero-copy view
 ## Version history
 - Added in version 1.0.0.
@@ -44,11 +44,7 @@ Logarithmic in the size of the JSON object.
 ## Notes
- This method always returns `end()` when executed on a JSON type that is not an object.
+This method always returns `end()` when executed on a JSON type that is not an object.
 - Calling this function with an integer argument (for example, `#!cpp find(0)`) does not compile: such an argument
  would otherwise implicitly convert to a null `#!cpp const char*` and, from there, cause undefined behavior when
  constructing a `#!cpp std::string` for the object key. To access an array element instead, use [`at`](at.md),
  [`operator[]`](operator%5B%5D.md), or compare against [`size`](size.md).
 ## Examples
@@ -89,5 +85,3 @@ Logarithmic in the size of the JSON object.
 1. Added in version 3.11.0.
 2. Added in version 1.0.0. Changed to support comparable types in version 3.11.0.
 3. Deleted overloads for integral key types added in version 3.13.0 to reject such calls at compile time instead of
   causing undefined behavior at runtime.
@@ -104,7 +104,6 @@ Linear in the size of the input.
 - [from_msgpack](from_msgpack.md) create a JSON value from an input in MessagePack format
 - [from_bson](from_bson.md) create a JSON value from an input in BSON format
 - [from_ubjson](from_ubjson.md) create a JSON value from an input in UBJSON format
 - [from_bon8](from_bon8.md) create a JSON value from an input in BON8 format
 ## Version history
@@ -1,108 +0,0 @@
 # <small>nlohmann::basic_json::</small>from_bon8
 ```cpp
 // (1)
 template<typename InputType>
 static basic_json from_bon8(InputType&& i,
                            const bool strict = true,
                            const bool allow_exceptions = true);
 // (2)
 template<typename IteratorType, typename SentinelType = IteratorType>
 static basic_json from_bon8(IteratorType first, SentinelType last,
                            const bool strict = true,
                            const bool allow_exceptions = true);
 ```
 Deserializes a given input to a JSON value using the BON8 (Binary Object Notation 8) serialization format.
 1. Reads from a compatible input.
 2. Reads from an iterator range, or an iterator and a sentinel of a different type (C++20 ranges support).
 The exact mapping and its limitations are described on a [dedicated page](../../features/binary_formats/bon8.md).
 ## Template parameters
 `InputType`
 :   A compatible input, for instance:
    - an `std::istream` object
    - a `FILE` pointer
    - a C-style array of characters
    - a pointer to a null-terminated string of single byte characters
    - a container `obj` for which `begin(obj)` and `end(obj)` produce a valid pair of iterators
      (as found via ADL or member functions, with semantics compatible to `std::begin` and `std::end`)
 `IteratorType`
 :   a compatible iterator type
 `SentinelType`
 :   defaults to `IteratorType`; may be a different type comparable to `IteratorType` via `operator!=`, for instance.
    - a custom sentinel type for C++20 ranges
    - `std::default_sentinel_t`, when `IteratorType` is `std::counted_iterator`
 ## Parameters
 `i` (in)
 :   an input in BON8 format convertible to an input adapter
 `first` (in)
 :   iterator to the start of the input
 `last` (in)
 :   iterator to the end of the input, or a sentinel value that compares equal to the end iterator with `operator!=`
 `strict` (in)
 :   whether to expect the input to be consumed until EOF (`#!cpp true` by default)
 `allow_exceptions` (in)
 :   whether to throw exceptions in case of a parse error (optional, `#!cpp true` by default)
 ## Return value
 deserialized JSON value; in case of a parse error and `allow_exceptions` set to `#!cpp false`, the return value will be
 `value_t::discarded`. The latter can be checked with [`is_discarded`](is_discarded.md).
 ## Exception safety
 Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
 ## Exceptions
 - Throws [parse_error.110](../../home/exceptions.md#jsonexceptionparse_error110) if the given input ends prematurely or
  the end of the file was not reached when `strict` was set to true
 - Throws [parse_error.112](../../home/exceptions.md#jsonexceptionparse_error112) if a parse error occurs, for instance
  an invalid byte, a string that is not valid UTF-8, or an object key that is not a string
 ## Complexity
 Linear in the size of the input.
 ## Examples
 ??? example
    The example shows the deserialization of a byte vector in BON8 format to a JSON value.
    ```cpp
    --8<-- "examples/from_bon8.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/from_bon8.output"
    ```
 ## See also
 - [to_bon8](to_bon8.md) create a BON8 serialization of a JSON value
 - [from_cbor](from_cbor.md) create a JSON value from an input in CBOR format
 - [from_msgpack](from_msgpack.md) create a JSON value from an input in MessagePack format
 - [from_bson](from_bson.md) create a JSON value from an input in BSON format
 - [from_ubjson](from_ubjson.md) create a JSON value from an input in UBJSON format
 - [from_bjdata](from_bjdata.md) create a JSON value from an input in BJData format
 ## Version history
 - Added in version 3.13.0.
@@ -104,7 +104,6 @@ Linear in the size of the input.
 - [from_msgpack](from_msgpack.md) for the related MessagePack format
 - [from_ubjson](from_ubjson.md) for the related UBJSON format
 - [from_bjdata](from_bjdata.md) for the related BJData format
 - [from_bon8](from_bon8.md) for the related BON8 format
 ## Version history
@@ -80,8 +80,8 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
  the end of the file was not reached when `strict` was set to true
 - Throws [parse_error.112](../../home/exceptions.md#jsonexceptionparse_error112) if unsupported features from CBOR were
  used in the given input or if the input is not valid CBOR
- Throws [parse_error.113](../../home/exceptions.md#jsonexceptionparse_error113) if a map key is not a string (keys of other
+- Throws [parse_error.113](../../home/exceptions.md#jsonexceptionparse_error113) if a string was expected as a map key,
-  types are not supported, as JSON object keys are always strings) or a string is malformed
+  but not found
 ## Complexity
@@ -110,7 +110,6 @@ Linear in the size of the input.
 - [from_bson](from_bson.md) create a JSON value from an input in BSON format
 - [from_ubjson](from_ubjson.md) create a JSON value from an input in UBJSON format
 - [from_bjdata](from_bjdata.md) create a JSON value from an input in BJData format
 - [from_bon8](from_bon8.md) create a JSON value from an input in BON8 format
 ## Version history
@@ -73,8 +73,8 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
  the end of the file was not reached when `strict` was set to true
 - Throws [parse_error.112](../../home/exceptions.md#jsonexceptionparse_error112) if unsupported features from
  MessagePack were used in the given input or if the input is not valid MessagePack
- Throws [parse_error.113](../../home/exceptions.md#jsonexceptionparse_error113) if a map key is not a string (keys of other
+- Throws [parse_error.113](../../home/exceptions.md#jsonexceptionparse_error113) if a string was expected as a map key,
-  types are not supported, as JSON object keys are always strings) or a string is malformed
+  but not found
 ## Complexity
@@ -103,7 +103,6 @@ Linear in the size of the input.
 - [from_bson](from_bson.md) create a JSON value from an input in BSON format
 - [from_ubjson](from_ubjson.md) create a JSON value from an input in UBJSON format
 - [from_bjdata](from_bjdata.md) create a JSON value from an input in BJData format
 - [from_bon8](from_bon8.md) create a JSON value from an input in BON8 format
 ## Version history
@@ -104,7 +104,6 @@ Linear in the size of the input.
 - [from_msgpack](from_msgpack.md) create a JSON value from an input in MessagePack format
 - [from_bson](from_bson.md) create a JSON value from an input in BSON format
 - [from_bjdata](from_bjdata.md) create a JSON value from an input in BJData format
 - [from_bon8](from_bon8.md) create a JSON value from an input in BON8 format
 ## Version history
@@ -21,10 +21,6 @@ This overload is chosen if:
 - `ValueType` is not `basic_json`,
 - `json_serializer<ValueType>` has a `from_json()` method of the form `void from_json(const basic_json&, ValueType&)`
 `v` must not be `const`. Passing a `const` object is a compile-time error. For types such as arithmetic types, enums,
 and C arrays, the error is a `static_assert` that names the problem. For other types, the overload is not viable, and
 the compiler reports that no matching `get_to` was found.
 ## Template parameters
 `ValueType`
@@ -71,4 +67,3 @@ Depends on the `json_serializer<ValueType>::from_json()` implementation.
 ## Version history
 - Since version 3.3.0.
 - Added a `static_assert` with a clear message for `const` arguments in version 3.13.0.
@@ -290,13 +290,11 @@ Access to the JSON value
 ### Binary formats
 - [**from_bjdata**](from_bjdata.md) (_static_) - create a JSON value from an input in BJData format
 - [**from_bon8**](from_bon8.md) (_static_) - create a JSON value from an input in BON8 format
 - [**from_bson**](from_bson.md) (_static_) - create a JSON value from an input in BSON format
 - [**from_cbor**](from_cbor.md) (_static_) - create a JSON value from an input in CBOR format
 - [**from_msgpack**](from_msgpack.md) (_static_) - create a JSON value from an input in MessagePack format
 - [**from_ubjson**](from_ubjson.md) (_static_) - create a JSON value from an input in UBJSON format
 - [**to_bjdata**](to_bjdata.md) (_static_) - create a BJData serialization of a given JSON value
 - [**to_bon8**](to_bon8.md) (_static_) - create a BON8 serialization of a given JSON value
 - [**to_bson**](to_bson.md) (_static_) - create a BSON serialization of a given JSON value
 - [**to_cbor**](to_cbor.md) (_static_) - create a CBOR serialization of a given JSON value
 - [**to_msgpack**](to_msgpack.md) (_static_) - create a MessagePack serialization of a given JSON value
@@ -7,8 +7,7 @@ enum class input_format_t {
    msgpack,
    ubjson,
    bson,
-    bjdata,
+    bjdata
    bon8
 };
 ```
@@ -32,9 +31,6 @@ bson
 bjdata
 :   BJData (Binary JData)
 bon8
 :   BON8 (Binary Object Notation 8)
 ## Examples
 ??? example
@@ -195,7 +195,5 @@ Strong exception safety: if an exception occurs, the original value stays intact
 1. Added in version 1.0.0.
 2. Added in version 1.0.0.
 3. Added in version 1.0.0.
-4. Added in version 1.0.0. Fixed in version 3.13.0 to copy the values before inserting; before, an `ilist` that
+4. Added in version 1.0.0.
   referred to elements of the array being inserted into could insert wrong values, because the range insert could
   move from or shift an element before it was copied.
 5. Added in version 3.0.0.
@@ -34,10 +34,6 @@ Constant.
    --8<-- "examples/is_array.output"
    ```
 ## See also
 - [basic_json_view::is_array](../basic_json_view/is_array.md) - the same check on a zero-copy view
 ## Version history
 - Added in version 1.0.0.
@@ -34,10 +34,6 @@ Constant.
    --8<-- "examples/is_binary.output"
    ```
 ## See also
 - [basic_json_view::is_binary](../basic_json_view/is_binary.md) - the same check on a zero-copy view
 ## Version history
 - Added in version 3.8.0.
@@ -34,10 +34,6 @@ Constant.
    --8<-- "examples/is_boolean.output"
    ```
 ## See also
 - [basic_json_view::is_boolean](../basic_json_view/is_boolean.md) - the same check on a zero-copy view
 ## Version history
 - Added in version 1.0.0.
@@ -69,11 +69,6 @@ with `allow_exceptions` set to `#!cpp false`: a parse error then yields a discar
    --8<-- "examples/is_discarded.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.
@@ -34,10 +34,6 @@ Constant.
    --8<-- "examples/is_null.output"
    ```
 ## See also
 - [basic_json_view::is_null](../basic_json_view/is_null.md) - the same check on a zero-copy view
 ## Version history
 - Added in version 1.0.0.
@@ -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
@@ -34,10 +34,6 @@ Constant.
    --8<-- "examples/is_object.output"
    ```
 ## See also
 - [basic_json_view::is_object](../basic_json_view/is_object.md) - the same check on a zero-copy view
 ## Version history
 - Added in version 1.0.0.
@@ -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
@@ -34,10 +34,6 @@ Constant.
    --8<-- "examples/is_string.output"
    ```
 ## See also
 - [basic_json_view::is_string](../basic_json_view/is_string.md) - the same check on a zero-copy view
 ## Version history
 - Added in version 1.0.0.
@@ -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
@@ -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).
@@ -70,9 +70,6 @@ Strong exception safety: if an exception occurs, the original value stays intact
 1. The function can throw the following exceptions:
    - Throws [`type_error.305`](../../home/exceptions.md#jsonexceptiontype_error305) if the JSON value is not an array
      or null; in that case, using the `[]` operator with an index makes no sense.
    - Throws `#!cpp std::length_error` if `idx` equals the maximum value of `size_type`; the array is left unchanged.
      (This is the one index for which growing the array to hold it cannot be expressed as a `size_type` size, the same
      way an oversized [`resize`](https://en.cppreference.com/w/cpp/container/vector/resize) throws.)
 2. The function can throw the following exceptions:
    - Throws [`type_error.305`](../../home/exceptions.md#jsonexceptiontype_error305) if the JSON value is not an object
      or null; in that case, using the `[]` operator with a key makes no sense.
@@ -260,8 +257,7 @@ Strong exception safety: if an exception occurs, the original value stays intact
 ## Version history
-1. Added in version 1.0.0. Fixed in version 3.13.0 to throw `#!cpp std::length_error` instead of emptying the array and
+1. Added in version 1.0.0.
   accessing it out of bounds when `idx` equals the maximum value of `size_type`.
 2. Added in version 1.0.0. Added overloads for `T* key` in version 1.1.0. Removed overloads for `T* key` (replaced by 3)
   in version 3.11.0.
 3. Added in version 3.11.0. Fixed in version 3.13.0 to consistently accept `std::string_view`-convertible keys, as
@@ -88,12 +88,7 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 ## Exceptions
 - Throws [`parse_error.101`](../../home/exceptions.md#jsonexceptionparse_error101) in case of an unexpected token, or
-  empty input like a null `FILE*` or `char*` pointer, or an `std::istream` without a stream buffer
+  empty input like a null `FILE*` or `char*` pointer.
  (`#!cpp i.rdbuf() == nullptr`, for instance `#!cpp std::istream(nullptr)`).
 - If reading from an `std::istream` reaches the end of the input and `eofbit` is part of the stream's
  [`exceptions()`](https://en.cppreference.com/w/cpp/io/basic_ios/exceptions) mask, the `std::ios_base::failure`
  thrown by the stream itself propagates instead of a `parse_error`, the same as it would for the standard library's
  own extraction operators.
 ## Complexity
@@ -259,8 +254,6 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
 - Extended overload (2) to accept heterogeneous iterator+sentinel pairs (C++20 ranges support) in version 3.13.0.
 - `JSON_STRICT_NUL_HANDLING` added in version 3.13.0 to optionally reject a NUL byte in the input instead of treating
  it as end of input; planned to become the default in version 4.0.0.
 - Extended empty-input detection to also cover an `std::istream` without a stream buffer, and fixed a crash
  (`std::terminate`) when parsing from an `std::istream` with `eofbit` in its exception mask, in version 3.13.0.
 !!! warning "Deprecation"
@@ -5,7 +5,7 @@ class parse_error : public exception;
 ```
 The library throws this exception when a parse error occurs. Parse errors can occur during the deserialization of
-JSON text, BJData, BON8, BSON, CBOR, MessagePack, UBJSON, as well as when using JSON Patch.
+JSON text, BSON, CBOR, MessagePack, UBJSON, as well as when using JSON Patch.
 Member `byte` holds the byte index of the last read character in the input file (see note below).
@@ -100,6 +100,3 @@ the latter case, it is skipped completely, or replaced by `null` if it is the to
 - Added in version 1.0.0.
 - Fixed in version 3.13.0 to also remove discarded values from a parent object; before, discarding an array or a value
  stored under an object key left a discarded member behind, which made the parse result serialize to invalid JSON.
 - Fixed in version 3.13.0 so that discarding an array or object at its start event also hides its content from the
  callback, as documented above; before, the callback was still called for the content, and the key of every member of
  a discarded object was kept in memory until the parse ended.
@@ -65,14 +65,11 @@ The SAX event lister must follow the interface of [`json_sax`](../json_sax/index
 :   SAX event listener (must not be null)
 `format` (in)
-:    the format to parse (JSON, BJData, BON8, BSON, CBOR, MessagePack, or UBJSON) (optional, `input_format_t::json` by
+:    the format to parse (JSON, CBOR, MessagePack, or UBJSON) (optional, `input_format_t::json` by default), see
     default), see
     [`input_format_t`](input_format_t.md) for more information
 `strict` (in)
-:   whether the input has to be consumed completely (optional, `#!cpp true` by default); when `#!cpp false` and the
+:   whether the input has to be consumed completely (optional, `#!cpp true` by default)
    input is a `#!cpp std::istream`, the character that terminates a number is consumed unless
    [`JSON_PRECISE_STREAM_POSITION`](../macros/json_precise_stream_position.md) is defined to `1`; see [`operator>>`](../operator_gtgt.md#notes)
 `ignore_comments` (in)
 :   whether comments should be ignored and treated like whitespace (`#!cpp true`) or yield a parse error
@@ -139,8 +136,6 @@ A UTF-8 byte order mark is silently ignored.
 - Added `ignore_trailing_commas` in version 3.13.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.
 - `JSON_PRECISE_STREAM_POSITION` added in version 3.13.0 to optionally leave a `#!cpp std::istream` positioned right
  after the parsed value when `strict` is `#!cpp false`.
 !!! warning "Deprecation"
@@ -51,10 +51,6 @@ JSON value which is `1` in the case of a string.
    --8<-- "examples/size.output"
    ```
 ## See also
 - [basic_json_view::size](../basic_json_view/size.md) - the same function on a zero-copy view
 ## Version history
 - Added in version 1.0.0.
@@ -6,9 +6,7 @@ void swap(reference other) noexcept (
    std::is_nothrow_move_constructible<value_t>::value &&
    std::is_nothrow_move_assignable<value_t>::value &&
    std::is_nothrow_move_constructible<json_value>::value &&
-    std::is_nothrow_move_assignable<json_value>::value &&
+    std::is_nothrow_move_assignable<json_value>::value
    std::is_nothrow_move_constructible<json_base_class_t>::value &&
    std::is_nothrow_move_assignable<json_base_class_t>::value
 );
 // (2)
@@ -16,9 +14,7 @@ friend void swap(reference left, reference right) noexcept (
    std::is_nothrow_move_constructible<value_t>::value &&
    std::is_nothrow_move_assignable<value_t>::value &&
    std::is_nothrow_move_constructible<json_value>::value &&
-    std::is_nothrow_move_assignable<json_value>::value &&
+    std::is_nothrow_move_assignable<json_value>::value
    std::is_nothrow_move_constructible<json_base_class_t>::value &&
    std::is_nothrow_move_assignable<json_base_class_t>::value
 );
 // (3)
@@ -41,15 +37,11 @@ void swap(typename binary_t::container_type& other);
   individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated. If macro
   [`JSON_DIAGNOSTIC_POSITIONS`](../macros/json_diagnostic_positions.md) is defined to `#!cpp 1`, the
   [`start_pos()`](start_pos.md)/[`end_pos()`](end_pos.md) diagnostic positions are exchanged along with the value.
   The [`json_base_class_t`](json_base_class_t.md) subobject is exchanged along with the value as well, the same way it
   is copied or moved by the copy/move constructors and assignment operators.
 2. Exchanges the contents of the JSON value from `left` with those of `right`. Does not invoke any move, copy, or swap
   operations on individual elements. All iterators and references remain valid. The past-the-end iterator is
   invalidated. Implemented as a friend function callable via ADL. If macro
   [`JSON_DIAGNOSTIC_POSITIONS`](../macros/json_diagnostic_positions.md) is defined to `#!cpp 1`, the
   [`start_pos()`](start_pos.md)/[`end_pos()`](end_pos.md) diagnostic positions are exchanged along with the value.
   The [`json_base_class_t`](json_base_class_t.md) subobject is exchanged along with the value as well, the same way it
   is copied or moved by the copy/move constructors and assignment operators.
 3. Exchanges the contents of a JSON array with those of `other`. Does not invoke any move, copy, or swap operations on
   individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated. 
 4. Exchanges the contents of a JSON object with those of `other`. Does not invoke any move, copy, or swap operations on
@@ -172,8 +164,8 @@ Constant.
 ## Version history
-1. Since version 1.0.0. Exchanges the `json_base_class_t` subobject along with the value since version 3.13.0.
+1. Since version 1.0.0.
-2. Since version 1.0.0. Exchanges the `json_base_class_t` subobject along with the value since version 3.13.0.
+2. Since version 1.0.0.
 3. Since version 1.0.0.
 4. Since version 1.0.0.
 5. Since version 1.0.0.
@@ -84,7 +84,6 @@ Linear in the size of the JSON value `j`.
 - [to_msgpack](to_msgpack.md) create a MessagePack serialization of a JSON value
 - [to_bson](to_bson.md) create a BSON serialization of a JSON value
 - [to_ubjson](to_ubjson.md) create a UBJSON serialization of a JSON value
 - [to_bon8](to_bon8.md) create a BON8 serialization of a JSON value
 ## Version history
@@ -1,76 +0,0 @@
 # <small>nlohmann::basic_json::</small>to_bon8
 ```cpp
 // (1)
 static std::vector<std::uint8_t> to_bon8(const basic_json& j);
 // (2)
 static void to_bon8(const basic_json& j, detail::output_adapter<std::uint8_t> o);
 static void to_bon8(const basic_json& j, detail::output_adapter<char> o);
 ```
 Serializes a given JSON value `j` to a byte vector using the BON8 (Binary Object Notation 8) serialization format. BON8
 is a compact binary serialization format that stores strings as UTF-8 without a length prefix.
 1. Returns a byte vector containing the BON8 serialization.
 2. Writes the BON8 serialization to an output adapter.
 The exact mapping and its limitations are described on a [dedicated page](../../features/binary_formats/bon8.md).
 ## Parameters
 `j` (in)
 :   JSON value to serialize
 `o` (in)
 :   output adapter to write serialization to
 ## Return value
 1. BON8 serialization as a byte vector
 2. (none)
 ## Exception safety
 Strong guarantee: if an exception is thrown, there are no changes in the JSON value `j`, which is never modified.
 With (2), the bytes written before the exception remain in the output adapter.
 ## Exceptions
 - Throws [out_of_range.407](../../home/exceptions.md#jsonexceptionout_of_range407) if `j` contains an unsigned integer
  above 9223372036854775807, which BON8 cannot represent
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if `j` contains a string that is not
  valid UTF-8
 ## Complexity
 Linear in the size of the JSON value `j`.
 ## Examples
 ??? example
    The example shows the serialization of a JSON value to a byte vector in BON8 format.
    ```cpp
    --8<-- "examples/to_bon8.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/to_bon8.output"
    ```
 ## See also
 - [from_bon8](from_bon8.md) create a JSON value from an input in BON8 format
 - [to_cbor](to_cbor.md) create a CBOR serialization of a JSON value
 - [to_msgpack](to_msgpack.md) create a MessagePack serialization of a JSON value
 - [to_bson](to_bson.md) create a BSON serialization of a JSON value
 - [to_ubjson](to_ubjson.md) create a UBJSON serialization of a JSON value
 - [to_bjdata](to_bjdata.md) create a BJData serialization of a JSON value
 ## Version history
 - Added in version 3.13.0.
@@ -43,14 +43,12 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [`out_of_range.412`](../../home/exceptions.md#jsonexceptionout_of_range412) if the length of a document, array,
  string, or binary value exceeds the range of the 32-bit BSON length field; example:
  `"BSON length 2147483661 exceeds maximum of 2147483647"`
 - 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)"`
 ## Complexity
-Linear in the size of the JSON value `j`. The length prefixes of all nested documents and arrays are computed in one
+Proportional to the size of the JSON value `j` multiplied by its maximum nesting
-pass before anything is written.
+depth, `O(n × d)`. BSON length prefixes are computed recursively before nested
 values are written.
 ## Examples
@@ -75,10 +73,7 @@ pass before anything is written.
 - [to_msgpack](to_msgpack.md) create a MessagePack serialization of a JSON value
 - [to_ubjson](to_ubjson.md) create a UBJSON serialization of a JSON value
 - [to_bjdata](to_bjdata.md) create a BJData serialization of a JSON value
 - [to_bon8](to_bon8.md) create a BON8 serialization of a JSON value
 ## Version history
 - Added in version 3.4.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.
@@ -62,7 +62,6 @@ Linear in the size of the JSON value `j`.
 - [to_bson](to_bson.md) create a BSON serialization of a JSON value
 - [to_ubjson](to_ubjson.md) create a UBJSON serialization of a JSON value
 - [to_bjdata](to_bjdata.md) create a BJData serialization of a JSON value
 - [to_bon8](to_bon8.md) create a BON8 serialization of a JSON value
 ## Version history
@@ -34,15 +34,6 @@ The exact mapping and its limitations are described on a [dedicated page](../../
 Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
 ## Exceptions
 - Throws [`out_of_range.412`](../../home/exceptions.md#jsonexceptionout_of_range412) if the length of a string, binary
  value, array, or object exceeds 4294967295, the maximum MessagePack can store; example:
  `"MessagePack length 4294967296 exceeds maximum of 4294967295"`
 - 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)"`
 ## Complexity
 Linear in the size of the JSON value `j`.
@@ -70,12 +61,7 @@ Linear in the size of the JSON value `j`.
 - [to_bson](to_bson.md) create a BSON serialization of a JSON value
 - [to_ubjson](to_ubjson.md) create a UBJSON serialization of a JSON value
 - [to_bjdata](to_bjdata.md) create a BJData serialization of a JSON value
 - [to_bon8](to_bon8.md) create a BON8 serialization of a JSON value
 ## Version history
 - Added in version 2.0.9.
 - Throws `out_of_range.412` and `out_of_range.415` since version 3.13.0.
 - 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`.
@@ -77,7 +77,6 @@ Linear in the size of the JSON value `j`.
 - [to_msgpack](to_msgpack.md) create a MessagePack serialization of a JSON value
 - [to_bson](to_bson.md) create a BSON serialization of a JSON value
 - [to_bjdata](to_bjdata.md) create a BJData serialization of a JSON value
 - [to_bon8](to_bon8.md) create a BON8 serialization of a JSON value
 ## Version history
@@ -47,10 +47,6 @@ Constant.
    --8<-- "examples/type.output"
    ```
 ## See also
 - [basic_json_view::type](../basic_json_view/type.md) - the same function on a zero-copy view
 ## Version history
 - Added in version 1.0.0.
@@ -52,14 +52,6 @@ This is equivalent to Python's `dict.get(key, default)`.
    - Unlike [`operator[]`](operator[].md), this function does not implicitly add an element to the position defined by
     `key`/`ptr` key. This function is furthermore also applicable to const objects.
 !!! note "Integer keys"
    Calling this function with an integer `key` argument (for example, `#!cpp value(0, 1)`) does not compile in
    C++11, where `object_comparator_t` is not transparent: such an argument would otherwise implicitly convert to a
    null `#!cpp const char*` and, from there, cause undefined behavior when constructing a `#!cpp std::string` for the
    object key. To access an array element with a default value, use [`at`](at.md) together with a `#!cpp try`/`#!cpp
    catch` block, or compare against [`size`](size.md) instead.
 ## Template parameters
 `KeyType`
@@ -192,9 +184,7 @@ changes to any JSON value.
 ## Version history
-1. Added in version 1.0.0. Changed parameter `default_value` type from `const ValueType&` to `ValueType&&` in version
+1. Added in version 1.0.0. Changed parameter `default_value` type from `const ValueType&` to `ValueType&&` in version 3.11.0.
   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.
 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
@@ -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,56 +0,0 @@
 # <small>nlohmann::</small>basic_json_document
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
 template<typename BasicJsonType>
 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.
 ## 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`.
 ## Specializations
 - [**json_document**](../json_document.md) - documents of the default specialization [`json`](../json.md)
 - [**ordered_json_document**](../ordered_json_document.md) - 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>`)
 - **value_t** - the JSON type enumeration, see [`basic_json::value_t`](../basic_json/value_t.md)
 ## Member functions
 - [(constructor)](basic_json_document.md)
 - [**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
 - [**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
 ## 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,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,139 +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
 - [`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,76 +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
 ## 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,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,51 +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 (once
 element access is added) from navigating into a container.
 ## 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>empty
 ```cpp
 bool empty() const noexcept;
 ```
 Checks whether [`size()`](size.md) is `0`, as [`BasicJsonType::empty()`](../basic_json/empty.md) would for the same
 value.
 ## Return value
 The return value depends on the type and is defined as follows:
 | Value type          | return value    |
 |----------------------|-----------------|
 | null                  | `#!cpp true`     |
 | discarded             | `#!cpp true`     |
 | boolean               | `#!cpp false`    |
 | string                | `#!cpp false`    |
 | number                | `#!cpp false`    |
 | object                | `#!cpp object_t::empty()` |
 | array                 | `#!cpp array_t::empty()`  |
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 As for [`BasicJsonType::empty()`](../basic_json/empty.md), this does not return whether a string value is empty -- it
 is `#!cpp false` for any string, regardless of its length.
 ## Examples
 ??? example
    The example below uses [`size()`](size.md) and `empty()` to decide whether a parsed message is worth acting on,
    without materializing it into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__size_empty.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__size_empty.output"
    ```
 ## See also
 - [size](size.md) - return the number of elements
 - [`BasicJsonType::empty`](../basic_json/empty.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,82 +0,0 @@
 # <small>nlohmann::</small>basic_json_view
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
 template<typename BasicJsonType>
 class basic_json_view;
 ```
 A read-only handle to one value of a [`basic_json_document`](../basic_json_document/index.md): two pointers (a pointer
 to the document and a pointer into its index), trivially copyable. A view is valid as long as
 - the document is alive,
 - the document has not been re-parsed with [`read()`](../basic_json_document/read.md) (or
  [`parse()`](../basic_json_document/parse.md) into it) or shrunk with
  [`shrink_to_fit()`](../basic_json_document/shrink_to_fit.md) since the view was taken, and
 - if the document borrows its source text, that text is still alive.
 Moving the document itself does not invalidate its views: the index is heap-allocated independently of the
 `basic_json_document` object.
 `basic_json_view` provides the read-only part of the `BasicJsonType` interface: the type-inspection functions, and
 [`materialize()`](materialize.md) to build the `BasicJsonType` value of a subtree on demand. It does not (yet) provide
 element access, iteration, `get<T>()`, JSON Pointer support, `dump()`, or comparison.
 ## Template parameters
 `BasicJsonType`
 :   a specialization of [`basic_json`](../basic_json/index.md), matching the
    [`basic_json_document`](../basic_json_document/index.md) the view was taken from.
 ## Specializations
 - [**json_view**](../json_view.md) - views of a [`json_document`](../json_document.md)
 - [**ordered_json_view**](../ordered_json_view.md) - views of an [`ordered_json_document`](../ordered_json_document.md)
 ## Member types
 - **value_t** - the JSON type enumeration, see [`basic_json::value_t`](../basic_json/value_t.md)
 - **string_t**, **number_integer_t**, **number_unsigned_t**, **number_float_t**, **json_pointer** - the corresponding
  member types of `BasicJsonType`
 - **size_type** - `#!cpp std::size_t`
 - **string_view_t** - `#!cpp std::string_view` on C++17 and newer, a minimal internal substitute otherwise
 ## Member functions
 - [(constructor)](basic_json_view.md)
 ### Object inspection
 - [**type**](type.md) - return the type of the value
 - [**is_null**](is_null.md) - return whether the value is null
 - [**is_boolean**](is_boolean.md) - return whether the value is a boolean
 - [**is_number**](is_number.md) - return whether the value is a number
 - [**is_number_integer**](is_number_integer.md) - return whether the value is an integer number
 - [**is_number_unsigned**](is_number_unsigned.md) - return whether the value is an unsigned integer number
 - [**is_number_float**](is_number_float.md) - return whether the value is a floating-point number
 - [**is_string**](is_string.md) - return whether the value is a string
 - [**is_array**](is_array.md) - return whether the value is an array
 - [**is_object**](is_object.md) - return whether the value is an object
 - [**is_binary**](is_binary.md) - return whether the value is a binary array (always `#!cpp false`)
 - [**is_primitive**](is_primitive.md) - return whether the type is primitive
 - [**is_structured**](is_structured.md) - return whether the type is structured
 - [**is_discarded**](is_discarded.md) - return whether the view is invalid
 - [**operator bool**](operator_bool.md) - return whether the view refers to a value
 ### Capacity
 - [**size**](size.md) - return the number of elements
 - [**empty**](empty.md) - return whether the value has no elements
 ### Conversion
 - [**materialize**](materialize.md) - build the `BasicJsonType` value of this subtree
 ### Source access
 - [**source_offset**](source_offset.md) - byte offset of this value in the document's source text
 ## Version history
 - Added in version 3.13.0.
@@ -1,46 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_array
 ```cpp
 bool is_array() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is an array.
 ## Return value
 `#!cpp true` if the type is an array, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_structured](is_structured.md) - return whether the type is structured
 - [size](size.md), [empty](empty.md) - the number of elements, and whether there are none
 - [`BasicJsonType::is_array`](../basic_json/is_array.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,46 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_binary
 ```cpp
 bool is_binary() const noexcept;
 ```
 This function always returns `#!cpp false`: a JSON text has no binary values, so a view can never refer to one. The
 function exists for interface parity with [`BasicJsonType::is_binary`](../basic_json/is_binary.md).
 ## Return value
 `#!cpp false`, always.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [type](type.md) - return the type of the value
 - [`BasicJsonType::is_binary`](../basic_json/is_binary.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,45 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_boolean
 ```cpp
 bool is_boolean() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is a boolean.
 ## Return value
 `#!cpp true` if the type is a boolean, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [type](type.md) - return the type of the value
 - [`BasicJsonType::is_boolean`](../basic_json/is_boolean.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,55 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_discarded
 ```cpp
 bool is_discarded() const noexcept;
 ```
 Returns whether this view is invalid, i.e. does not refer to a value. This is the case for a default-constructed
 view (see [(constructor)](basic_json_view.md)), and for [`root()`](../basic_json_document/root.md) of a document
 that is itself [discarded](../basic_json_document/is_discarded.md) -- in particular, the root of a failed
 [`parse()`](../basic_json_document/parse.md) with `allow_exceptions` set to `#!cpp false`.
 ## Return value
 `#!cpp true` if the view is discarded, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 `#!cpp v.is_discarded()` and `#!cpp !static_cast<bool>(v)` are equivalent; use whichever reads better at the call
 site.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [operator bool](operator_bool.md) - return whether the view refers to a value
 - [(constructor)](basic_json_view.md) - the default constructor creates a discarded view
 - [is_discarded (basic_json_document)](../basic_json_document/is_discarded.md) - return whether the last parse failed
 - [`BasicJsonType::is_discarded`](../basic_json/is_discarded.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,45 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_null
 ```cpp
 bool is_null() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is `#!json null`.
 ## Return value
 `#!cpp true` if the type is `#!json null`, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [type](type.md) - return the type of the value
 - [`BasicJsonType::is_null`](../basic_json/is_null.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,47 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_number
 ```cpp
 bool is_number() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is a number, i.e. an integer, unsigned integer, or floating-point value. It is defined as `#!cpp is_number_integer() || is_number_float()`.
 ## Return value
 `#!cpp true` if the type is a number, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_number_integer](is_number_integer.md) - return whether the value is an integer or unsigned integer number
 - [is_number_unsigned](is_number_unsigned.md) - return whether the value is an unsigned integer number
 - [is_number_float](is_number_float.md) - return whether the value is a floating-point number
 - [`BasicJsonType::is_number`](../basic_json/is_number.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,51 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_number_float
 ```cpp
 bool is_number_float() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is a floating-point number.
 ## Return value
 `#!cpp true` if the type is `#!cpp value_t::number_float`, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 As for [`BasicJsonType::parse`](../basic_json/parse.md), an integer literal that does not fit into the 64-bit
 integer type is classified as a floating-point number, so `is_number_float()` can be `#!cpp true` even for an
 integer-looking token in the source text.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_number](is_number.md) - return whether the value is a number
 - [`BasicJsonType::is_number_float`](../basic_json/is_number_float.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,51 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_number_integer
 ```cpp
 bool is_number_integer() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is an integer or unsigned integer number.
 ## Return value
 `#!cpp true` if the type is `#!cpp value_t::number_integer` or `#!cpp value_t::number_unsigned`, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 As for [`BasicJsonType::is_number_integer`](../basic_json/is_number_integer.md), this includes unsigned integer
 values; use [`is_number_unsigned`](is_number_unsigned.md) to test for those specifically.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_number](is_number.md) - return whether the value is a number
 - [is_number_unsigned](is_number_unsigned.md) - return whether the value is an unsigned integer number
 - [`BasicJsonType::is_number_integer`](../basic_json/is_number_integer.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,45 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_number_unsigned
 ```cpp
 bool is_number_unsigned() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is an unsigned integer number.
 ## Return value
 `#!cpp true` if the type is `#!cpp value_t::number_unsigned`, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_number_integer](is_number_integer.md) - return whether the value is an integer or unsigned integer number
 - [`BasicJsonType::is_number_unsigned`](../basic_json/is_number_unsigned.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,46 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_object
 ```cpp
 bool is_object() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is an object.
 ## Return value
 `#!cpp true` if the type is an object, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_structured](is_structured.md) - return whether the type is structured
 - [size](size.md), [empty](empty.md) - the number of elements, and whether there are none
 - [`BasicJsonType::is_object`](../basic_json/is_object.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,46 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_primitive
 ```cpp
 bool is_primitive() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is primitive, i.e. `#!json null`, a boolean, a number, or a string. It is defined as `#!cpp is_null() || is_string() || is_boolean() || is_number()`.
 ## Return value
 `#!cpp true` if the type is primitive, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_structured](is_structured.md) - return whether the type is structured (the complement of this function, for a
  non-discarded view)
 - [`BasicJsonType::is_primitive`](../basic_json/is_primitive.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,45 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_string
 ```cpp
 bool is_string() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is a string.
 ## Return value
 `#!cpp true` if the type is a string, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [source_offset](source_offset.md) - byte offset of this value in the document's source text
 - [`BasicJsonType::is_string`](../basic_json/is_string.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,46 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>is_structured
 ```cpp
 bool is_structured() const noexcept;
 ```
 This function returns `#!cpp true` if and only if the value is structured, i.e. an array or an object. It is defined as `#!cpp is_array() || is_object()`.
 ## Return value
 `#!cpp true` if the type is structured, `#!cpp false` otherwise.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_primitive](is_primitive.md) - return whether the type is primitive
 - [size](size.md), [empty](empty.md) - the number of elements, and whether there are none
 - [`BasicJsonType::is_structured`](../basic_json/is_structured.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,69 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>materialize
 ```cpp
 BasicJsonType materialize() const;
 ```
 Builds the `BasicJsonType` value of this subtree: the value [`BasicJsonType::parse()`](../basic_json/parse.md) would
 have produced for the same source text, allocated for the first time by this call.
 ## Return value
 The `BasicJsonType` value of this subtree, or a discarded `BasicJsonType` value (`#!cpp BasicJsonType(value_t::discarded)`)
 if the view is [discarded](is_discarded.md).
 ## Exception safety
 Strong guarantee: if an exception is thrown, there are no changes to the view or the document it refers to (nothing
 about either is mutated by this function).
 ## Exceptions
 May throw `#!cpp std::bad_alloc` (via `BasicJsonType`'s allocator) if constructing the result fails.
 ## Complexity
 Linear in the size of the subtree.
 ## Notes
 `materialize()` replays the subtree through the same SAX builder [`BasicJsonType::parse()`](../basic_json/parse.md)
 uses internally, so the result matches it exactly -- including, for an object, that a repeated key keeps only its
 last value. The replay is iterative, so it is not limited by the call stack the way a naive recursive conversion
 would be; the JSON nesting depth is limited only by available memory, as for `BasicJsonType::parse()` itself.
 Unlike parsing with [`JSON_DIAGNOSTIC_POSITIONS`](../macros/json_diagnostic_positions.md) enabled, the values
 produced by `materialize()` do not carry source positions: there is no lexer run during the replay to record them.
 Calling `materialize()` on the same view repeatedly builds a new, independent `BasicJsonType` value each time; it
 never caches the result.
 ## Examples
 ??? example
    The example below skips messages that are not useful -- a discarded value, or an empty array -- using only
    [`is_array()`](is_array.md) and [`empty()`](empty.md), and calls `materialize()` only for the messages that are
    actually used, so no `BasicJsonType` value (and none of its per-element allocations) is ever built for the
    skipped ones.
    ```cpp
    --8<-- "examples/basic_json_view__materialize.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__materialize.output"
    ```
 ## See also
 - [root](../basic_json_document/root.md) - the view of a document's root value
 - [`BasicJsonType::parse`](../basic_json/parse.md) - build a `BasicJsonType` value directly from a JSON text
 - [`JSON_DIAGNOSTIC_POSITIONS`](../macros/json_diagnostic_positions.md) - source positions on parsed values (not
  produced by `materialize()`)
 ## Version history
 - Added in version 3.13.0.
@@ -1,46 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>operator bool
 ```cpp
 explicit operator bool() const noexcept;
 ```
 Returns whether this view refers to a value, i.e. the negation of [`is_discarded()`](is_discarded.md). Being
 `#!cpp explicit`, this conversion is only considered in a boolean context (`#!cpp if (v)`, `#!cpp !v`, `#!cpp v &&
 ...`), not for implicit conversions to other types.
 ## Return value
 `#!cpp true` if the view refers to a value, `#!cpp false` if it is [discarded](is_discarded.md).
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_discarded](is_discarded.md) - return whether the view is invalid
 ## Version history
 - Added in version 3.13.0.
@@ -1,60 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>size
 ```cpp
 size_type size() const noexcept;
 ```
 Returns the number of elements, as [`BasicJsonType::size()`](../basic_json/size.md) would for the same value.
 ## Return value
 The return value depends on the type and is defined as follows:
 | Value type          | return value                |
 |----------------------|-----------------------------|
 | null                  | `0`                          |
 | discarded             | `0`                          |
 | boolean               | `1`                          |
 | string                | `1`                          |
 | number                | `1`                          |
 | object                | number of key/value pairs    |
 | array                 | number of elements           |
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant: for an object or array, the element count is stored in the index, not counted on demand.
 ## Notes
 As for [`BasicJsonType::size()`](../basic_json/size.md), this does not return the length of a string value -- it is
 `1` for a string, regardless of its length.
 ## Examples
 ??? example
    The example below uses `size()` and [`empty()`](empty.md) to decide whether a parsed message is worth acting on,
    without materializing it into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__size_empty.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__size_empty.output"
    ```
 ## See also
 - [empty](empty.md) - return whether the value has no elements
 - [`BasicJsonType::size`](../basic_json/size.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,55 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>source_offset
 ```cpp
 std::size_t source_offset() const noexcept;
 ```
 Returns the byte offset of this value in the document's [`source()`](../basic_json_document/source.md) text, without
 materializing anything.
 ## Return value
 - For a string with no escapes, a number, `#!json true`/`#!json false`/`#!json null`, an array, or an object: the
  byte offset of the first byte of the value's token (for a string: the first byte after the opening quote) in
  [`source()`](../basic_json_document/source.md).
 - `#!cpp static_cast<std::size_t>(-1)` for a [discarded](is_discarded.md) view, and for a string that contains
  escapes -- such a string was decoded once into the document's own buffer, so there is no single byte range in
  `source()` left to point at.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 This is a raw offset, not a length: the API does not (yet) expose how many bytes the token occupies in the source
 text, so `source_offset()` alone is enough to report *where* a value came from (for an error message, for syntax
 highlighting, ...) but not to slice its exact text back out of [`source()`](../basic_json_document/source.md) for a
 string, whose token length is not the same as its decoded [`size()`](size.md).
 ## Examples
 ??? example
    ```cpp
    --8<-- "examples/basic_json_view__source_offset.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__source_offset.output"
    ```
 ## See also
 - [source](../basic_json_document/source.md) - the parsed text
 - [is_string](is_string.md) - return whether the value is a string
 ## Version history
 - Added in version 3.13.0.
@@ -1,53 +0,0 @@
 # <small>nlohmann::basic_json_view::</small>type
 ```cpp
 value_t type() const noexcept;
 ```
 Returns the type of the value this view refers to, as a value from the [`value_t`](../basic_json/value_t.md)
 enumeration -- the same enumeration [`BasicJsonType::type()`](../basic_json/type.md) uses.
 ## Return value
 The type of the value; `#!cpp value_t::discarded` for a [discarded](is_discarded.md) view.
 ## Exception safety
 No-throw guarantee: this function never throws exceptions.
 ## Complexity
 Constant.
 ## Notes
 Unlike [`BasicJsonType::type()`](../basic_json/type.md), this function can never return `#!cpp value_t::binary`: a
 JSON text has no binary values, so `type()` only distinguishes the eight ordinary JSON value types (plus
 `#!cpp discarded`).
 ## Examples
 ??? example
    The example below classifies several parsed documents by the type of their root value, without materializing any
    of them into a `BasicJsonType` value.
    ```cpp
    --8<-- "examples/basic_json_view__type_predicates.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/basic_json_view__type_predicates.output"
    ```
 ## See also
 - [is_null](is_null.md), [is_boolean](is_boolean.md), [is_number](is_number.md), [is_string](is_string.md),
  [is_array](is_array.md), [is_object](is_object.md) - type-specific predicates built on `type()`
 - [`BasicJsonType::type`](../basic_json/type.md) - the corresponding function of `basic_json`
 ## Version history
 - Added in version 3.13.0.
@@ -1,35 +0,0 @@
 # <small>nlohmann::</small>json_document
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
 using json_document = basic_json_document<json>;
 ```
 This type is a [`basic_json_document`](basic_json_document/index.md) of the default [`json`](json.md)
 specialization.
 ## Examples
 ??? example
    The example below demonstrates how to use the type `nlohmann::json_document`.
    ```cpp
    --8<-- "examples/json_document.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/json_document.output"
    ```
 ## See also
 - [json_view](json_view.md) - a view of a value of a `json_document`
 - [ordered_json_document](ordered_json_document.md) - the corresponding document for `ordered_json`
 ## Version history
 Since version 3.13.0.
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Niels Lohmann	6f971ae520	Build the update()/merge_patch() diagnostics test values instead of parsing them Parsed values carry byte positions under JSON_DIAGNOSTIC_POSITIONS, which the expected messages do not include. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-24 17:11:39 +02:00
Niels Lohmann	3395089b5f	Use the shared recursion limit in update() and merge_patch() merge_depth_limit() is gone in favor of detail::recursion_depth_limit(). The two identical function-local frame structs become one member struct, merge_frame, with a constructor, so both loops emplace_back() their frames. merge_patch_iteratively() copies the frame it works on out of the stack and changes it only through stack.back(). Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-24 17:11:39 +02:00
Niels Lohmann	519094151e	Merge deeply nested objects without recursing per nesting level merge_patch() and update(j, true) merged a nested object by calling themselves on it, once per nesting level. A value nested deeply enough - 50,000 levels of objects on an 8 MiB stack - exhausted the call stack and terminated the process, although parse() accepts such values without complaint. Bound the descent the same way dump() does. The recursion now carries the nesting level, and once merge_depth_limit() (128) levels have been entered, update_members_iteratively() and merge_patch_iteratively() finish the merge on an explicit stack. They still merge a nested object completely before the next member, and in the same order, so the results, including the parents JSON_DIAGNOSTICS reports paths from, are unchanged. Values nested less deeply than the bound run the same code as before, so the common case does not pay for the stack: merging only on it cost 10-14% in a first version. The public signatures are unchanged. The recursive worker behind merge_patch() has its own name rather than being a private overload, so that &basic_json::merge_patch stays unambiguous. Tests check every depth up to 300 against recursive reference implementations of both operations, check the diagnostic paths past the bound, and merge objects nested 100,000 levels deep. Fixes #5545 for update(j, true), and #5393 for merge_patch(). Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-24 17:11:39 +02:00
Niels Lohmann	e9af5cbd11	Parenthesize multiplications in the hash test for clang-tidy Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-24 17:11:38 +02:00
Niels Lohmann	21c626c641	Share one recursion depth limit, and copy the hash frame out of the stack dump() and hash() each defined their own limit on how many nesting levels they recurse into, and the operations still to come would have added more, free to diverge over time. They now all use detail::recursion_depth_limit(), in a header of its own; serializer::dump_depth_limit() and hash_depth_limit() are gone. hash_iteratively() now copies the frame it works on out of the stack and changes the frame only through stack.back(), so nothing can refer into the stack after entering an element has grown it. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-24 17:11:38 +02:00
Niels Lohmann	00bfe6808b	Declare hash_frame's constructor noexcept GCC's -Wnoexcept (an error in CI) flags the emplace_back() into the hash stack under C++26: the constructor cannot throw, since cbegin() is noexcept, but it did not say so. dump_frame's constructor is noexcept for the same reason. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-24 17:11:38 +02:00
Niels Lohmann	9be5018748	Hash deeply nested values without recursing per nesting level std::hash<basic_json> hashed an array or object by hashing each element, which called detail::hash again once per nesting level. A value nested deeply enough - 50,000 levels of objects on an 8 MiB stack - exhausted the call stack and terminated the process. parse() accepts such values without complaint, since the parser is iterative, and a parsed value is hashed wherever it is used as a key in an unordered container. Bound the descent the same way dump() does: detail::hash takes the nesting level, and once hash_depth_limit() (128) levels have been entered, hash_iteratively() hashes what is left on an explicit stack. It combines the seeds in exactly the same order, so hash values are unchanged. A value nested less deeply than the bound is hashed by the same code as before, without allocating, and is as fast as before. Tests check that every depth up to twice the bound hashes exactly like the recursive definition of the hash, and that values nested 100,000 levels deep hash without crashing. Fixes #5545 for std::hash. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-24 17:11:38 +02:00