Add element access, iteration, values, and JSON pointers to json_view

Give basic_json_view the read-only access functions of basic_json:
operator[] and at() with keys and indices, front()/back(), find(),
contains(), count(), begin()/end() and cbegin()/cend(), items()
with structured bindings from C++17 on, and type_name().

Exceptions have the ids and messages of the const functions of
basic_json. Where basic_json has undefined behavior the view
answers safely: operator[] with a missing key or an out-of-range
index returns a discarded view, and front()/back() of an empty
container throw invalid_iterator.214. Objects are iterated in
document order, and all members are visited; duplicate-key lookups
find the first member (as yyjson and simdjson do), while parse(),
materialize(), and the map conversions keep the last value, as
parse() does. Keys of up to 16 bytes are compared with two
overlapping loads.

Add value conversions: get<T>()/get_to() for arithmetic types,
bool, nullptr_t, strings (std::basic_string copied,
string_view_t without a copy), BasicJsonType, views, std::vector,
and maps with string keys; get_string() for the string without a
copy; number_token() for the number exactly as written in the
source; value() with keys and JSON pointers; and operator[]/at()/
contains() with JSON pointers. Everything else, including types
with from_json(), goes through materialize() of that subtree.
get<T>() of arithmetic types is inlined down to the conversion, so
reading an integer needs no call.

detail::json_pointer_access exposes a pointer's reference tokens
to code outside basic_json.

Signed-off-by: Niels Lohmann <mail@nlohmann.me>

.github/CONTRIBUTING.md

@@ -205,6 +205,9 @@ API of the 3.x.y version is broken. This includes:
 - Changing access specifiers.
 - Changing default arguments.
 
+What is and is not covered by this guarantee is described in the
+[roadmap](https://json.nlohmann.me/community/roadmap/#api-stability).
+
 Although these guidelines may seem restrictive, they are essential for maintaining the library’s utility.
 
 Breaking changes may be introduced when they are guarded with a feature macro such as

.github/external_ci/appveyor.yml

@@ -16,6 +16,9 @@ only_commits:
 
 environment:
   matrix:
+    # The Visual Studio 2017 jobs compile everything with /std:c++17, so they
+    # only build the C++17 variant of each test, split into two jobs each to
+    # stay below AppVeyor's 60-minute limit per job.
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       configuration: Debug
       platform: x86
@@ -34,7 +37,13 @@ environment:
       configuration: Release
       platform: x86
       CXX_FLAGS: "/permissive- /std:c++17 /utf-8 /W4 /WX"
-      CMAKE_OPTIONS: ""
+      CMAKE_OPTIONS: "-DJSON_TestStandards=17 -DJSON_TestShard=0/2"
+      GENERATOR: Visual Studio 15 2017
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      configuration: Release
+      platform: x86
+      CXX_FLAGS: "/permissive- /std:c++17 /utf-8 /W4 /WX"
+      CMAKE_OPTIONS: "-DJSON_TestStandards=17 -DJSON_TestShard=1/2"
       GENERATOR: Visual Studio 15 2017
 
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
@@ -55,7 +64,13 @@ environment:
       configuration: Release
       platform: x64
       CXX_FLAGS: "/permissive- /std:c++17 /Zc:__cplusplus /utf-8 /W4 /WX"
-      CMAKE_OPTIONS: ""
+      CMAKE_OPTIONS: "-DJSON_TestStandards=17 -DJSON_TestShard=0/2"
+      GENERATOR: Visual Studio 15 2017
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      configuration: Release
+      platform: x64
+      CXX_FLAGS: "/permissive- /std:c++17 /Zc:__cplusplus /utf-8 /W4 /WX"
+      CMAKE_OPTIONS: "-DJSON_TestStandards=17 -DJSON_TestShard=1/2"
       GENERATOR: Visual Studio 15 2017
 
 init:
@@ -66,15 +81,10 @@ install:
   - if "%platform%"=="x86"    set GENERATOR_PLATFORM=Win32
 
 before_build:
-  - cmake . -G "%GENERATOR%" -A "%GENERATOR_PLATFORM%" -DCMAKE_CXX_FLAGS="%CXX_FLAGS%" -DCMAKE_IGNORE_PATH="C:/Program Files/Git/usr/bin" -DJSON_BuildTests=On "%CMAKE_OPTIONS%"
+  - cmake . -G "%GENERATOR%" -A "%GENERATOR_PLATFORM%" -DCMAKE_CXX_FLAGS="%CXX_FLAGS%" -DCMAKE_IGNORE_PATH="C:/Program Files/Git/usr/bin" -DJSON_BuildTests=On %CMAKE_OPTIONS%
 
 build_script:
   - cmake --build . --config "%configuration%" --parallel 2
 
 test_script:
-  - if "%configuration%"=="Release" ctest -C "%configuration%" --parallel 2 --output-on-failure
+  - ctest -C "%configuration%" --parallel 2 --output-on-failure
-  # On Debug builds, skip test-unicode_all
-  # as it is extremely slow to run and cause
-  # occasional timeouts on AppVeyor.
-  # More info: https://github.com/nlohmann/json/pull/1570
-  - if "%configuration%"=="Debug" ctest --exclude-regex "test-unicode" -C "%configuration%" --parallel 2 --output-on-failure

.github/labeler.yml

@@ -45,6 +45,23 @@ labels:
 - label: "aspect: binary formats"
   title: "(?i)(bson|cbor|msgpack|messagepack|ubjson|bjdata|bon8|binary format)"
 
+- label: "aspect: json_view"
+  files:
+    - "include/nlohmann/json_view\\.hpp"
+    - "include/nlohmann/detail/view/.*"
+    - "single_include/nlohmann/json_view\\.hpp"
+    - "tests/src/unit-json_view.*"
+    - "tests/src/fuzzer-parse_json_view\\.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:
     - "\\.py$"

.github/workflows/check_amalgamation.yml

@@ -118,12 +118,15 @@ 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.hpp $INCLUDE_DIR/json_fwd.hpp $INCLUDE_DIR/json_view.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

.github/workflows/macos.yml

@@ -17,11 +17,11 @@ permissions:
   contents: read
 
 jobs:
-  macos-14:
+  macos-15:
-    runs-on: macos-14 # https://github.com/actions/runner-images/blob/main/images/macos/macos-14-Readme.md
+    runs-on: macos-15 # https://github.com/actions/runner-images/blob/main/images/macos/macos-15-Readme.md
     strategy:
       matrix:
-        xcode: ['15.0.1', '15.1', '15.2', '15.3', '15.4']
+        xcode: ['16.0', '16.1', '16.2', '16.3', '16.4', '26.0.1', '26.1.1', '26.2', '26.3']
     env:
       DEVELOPER_DIR: /Applications/Xcode_${{ matrix.xcode }}.app/Contents/Developer
 
@@ -36,11 +36,11 @@ jobs:
       - name: Test
         run: cd build ; ctest -j 10 --output-on-failure
 
-  macos-15:
+  macos-26:
-    runs-on: macos-15 # https://github.com/actions/runner-images/blob/main/images/macos/macos-15-Readme.md
+    runs-on: macos-26 # https://github.com/actions/runner-images/blob/main/images/macos/macos-26-arm64-Readme.md
     strategy:
       matrix:
-        xcode: ['16.0', '16.1', '16.2', '16.3', '16.4', '26.0.1']
+        xcode: ['26.4.1', '26.5', '26.6']
     env:
       DEVELOPER_DIR: /Applications/Xcode_${{ matrix.xcode }}.app/Contents/Developer
 
@@ -71,3 +71,38 @@ jobs:
         run: cmake --build build --parallel 10
       - name: Test
         run: cd build ; ctest -j 10 --output-on-failure
+
+  swiftpm:
+    runs-on: macos-15
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+      - name: Check that Package.swift resolves without a deprecation warning
+        run: swift package dump-package
+      - name: Build the SwiftPM documentation example against this checkout
+        run: |
+          mkdir -p /tmp/json-swiftpm-consumer/Sources/MyLibrary
+          cp docs/mkdocs/docs/integration/swift/example.cpp /tmp/json-swiftpm-consumer/Sources/MyLibrary/example.cpp
+          cat > /tmp/json-swiftpm-consumer/Package.swift << EOF
+          // swift-tools-version: 5.9
+          import PackageDescription
+
+          let package = Package(
+              name: "MyPackage",
+              dependencies: [
+                  .package(path: "${{ github.workspace }}")
+              ],
+              targets: [
+                  .target(
+                      name: "MyLibrary",
+                      dependencies: [
+                          .product(name: "json", package: "json")
+                      ],
+                      publicHeadersPath: "."
+                  )
+              ]
+          )
+          EOF
+          cd /tmp/json-swiftpm-consumer
+          swift build

.github/workflows/ubuntu.yml

@@ -107,7 +107,7 @@ jobs:
     container: ubuntu:24.04
     strategy:
       matrix:
-        target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls, ci_test_disableenumserialization, ci_test_disabletuplereferenceconversion, ci_test_skiplibraryversioncheck, ci_test_simdutf, ci_test_strict_nul_handling, ci_test_no_thread_local]
+        target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls, ci_test_disableenumserialization, ci_test_disabletuplereferenceconversion, ci_test_skiplibraryversioncheck, ci_test_simdutf, ci_test_strict_nul_handling, ci_test_delete_deprecated_functions, ci_test_no_thread_local]
     steps:
       - name: Install build-essential
         run: apt-get update ; apt-get install -y build-essential unzip wget git
@@ -209,7 +209,7 @@ jobs:
     strategy:
       matrix:
         # older GCC docker images (4, 5, 6) fail to check out code
-        compiler: ['7', '8', '9', '10', '11', '12', '13', '14', '15', 'latest']
+        compiler: ['7', '8', '9', '10', '11', '12', '13', '14', '15', '16', 'latest']
     container: gcc:${{ matrix.compiler }}
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1

.github/workflows/windows.yml

@@ -178,7 +178,7 @@ jobs:
       - name: Build
         run: cmake --build build --parallel 10
       - name: Test
-        run: cd build ; ctest -j 10 -C Debug --exclude-regex "test-unicode" --output-on-failure
+        run: cd build ; ctest -j 10 -C Debug --output-on-failure
 
   clang-cl-12:
     runs-on: windows-2022
@@ -195,7 +195,7 @@ jobs:
       - name: Build
         run: cmake --build build --config Debug --parallel 10
       - name: Test
-        run: cd build ; ctest -j 10 -C Debug --exclude-regex "test-unicode" --output-on-failure
+        run: cd build ; ctest -j 10 -C Debug --output-on-failure
 
   ci_module_cpp20:
     runs-on: windows-2022

.inferconfig

@@ -1,5 +1,7 @@
 {
   "_comment": "Used by the ci_infer CMake target (#5715 item 4b). fail-on-issue makes CI fail on Infer findings; disable-issue-type is a type-level baseline for the ~174 pre-existing findings (all PULSE_UNNECESSARY_COPY*/PULSE_RESOURCE_LEAK/PULSE_CONST_REFABLE, mostly in test code) triaged in run https://github.com/nlohmann/json/actions/runs/35829411620 on commit 1054b2097, so CI fails only on a NEW issue type. Remove an entry here once its findings have been fixed or explicitly accepted.",
+  "_comment_pulse": "Pulse stops exploring paths after pulse-max-disjuncts (default 20). With the default, basic_json::replace_value() (destroy + assert_invariant) exceeds the limit, Pulse loses the stored type, and reports false NULLPTR_DEREFERENCE findings for get_ptr() results in tests/src/unit-pointer_access.cpp.",
+  "pulse-max-disjuncts": 40,
   "fail-on-issue": true,
   "disable-issue-type": [
     "PULSE_UNNECESSARY_COPY_ASSIGNMENT",

.reuse/dep5

@@ -1,36 +0,0 @@
-Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
-Upstream-Name: json
-Upstream-Contact: Niels Lohmann <mail@nlohmann.me>
-Source: https://github.com/nlohmann/json
-
-Files: *
-Copyright: 2013-2026 Niels Lohmann <https://nlohmann.me>
-License: MIT
-
-Files: include/nlohmann/thirdparty/hedley.hpp
-Copyright: 2016-2021 Evan Nemerson <evan@nemerson.com>
-License: CC0
-
-Files: include/nlohmann/detail/meta/cpp_future.hpp
-Copyright: 2013-2026 Niels Lohmann <https://nlohmann.me> and 2018 The Abseil Authors
-License: MIT AND Apache-2.0
-
-Files: tests/thirdparty/doctest/*
-Copyright: 2016-2023 Viktor Kirilov
-License: MIT
-
-Files: tests/thirdparty/fifo_map/*
-Copyright: 2015-2017 Niels Lohmann
-License: MIT
-
-Files: tests/thirdparty/imapdl/*
-Copyright: 2017 Georg Sauthoff <mail@gms.tf>
-License: GPL-3.0-only
-
-Files: tools/amalgamate/*
-Copyright: 2012 Erik Edlund <erik.edlund@32767.se>
-License: BSD-3-Clause
-
-Files: tools/gdb_pretty_printer/*
-Copyright: 2020 Hannes Domani <https://github.com/ssbssa>
-License: MIT

BUILD.bazel

@@ -20,11 +20,13 @@ 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",
+        "include/nlohmann/detail/conversions/zmij.hpp",
         "include/nlohmann/detail/exceptions.hpp",
         "include/nlohmann/detail/hash.hpp",
         "include/nlohmann/detail/input/binary_reader.hpp",
@@ -65,9 +67,25 @@ 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/iterator.hpp",
+        "include/nlohmann/detail/view/lookup.hpp",
+        "include/nlohmann/detail/view/macro_scope.hpp",
+        "include/nlohmann/detail/view/macro_unscope.hpp",
+        "include/nlohmann/detail/view/materialize.hpp",
+        "include/nlohmann/detail/view/node.hpp",
+        "include/nlohmann/detail/view/number.hpp",
+        "include/nlohmann/detail/view/pointer.hpp",
+        "include/nlohmann/detail/view/scan.hpp",
+        "include/nlohmann/detail/view/string_ref.hpp",
+        "include/nlohmann/detail/view/value.hpp",
         "include/nlohmann/json.hpp",
         "include/nlohmann/json_fwd.hpp",
         "include/nlohmann/json_literals.hpp",
+        "include/nlohmann/json_view.hpp",
         "include/nlohmann/ordered_map.hpp",
         "include/nlohmann/thirdparty/hedley/hedley.hpp",
         "include/nlohmann/thirdparty/hedley/hedley_undef.hpp",
@@ -80,6 +98,8 @@ cc_library(
     name = "singleheader-json",
     hdrs = [
         "single_include/nlohmann/json.hpp",
+        "single_include/nlohmann/json_fwd.hpp",
+        "single_include/nlohmann/json_view.hpp",
     ],
     includes = ["single_include"],
     visibility = ["//visibility:public"],

CITATION.cff

@@ -10,5 +10,5 @@ title: "JSON for Modern C++"
 version: 3.12.0
 date-released: 2025-04-07
 license: MIT
-repository-code: "https://github.com/nlohmann"
+repository-code: "https://github.com/nlohmann/json"
 url: https://json.nlohmann.me

CMakeLists.txt

@@ -42,8 +42,11 @@ endif()
 ## OPTIONS
 ##
 
+# Build the tests by default only for the main project and only if the tests
+# directory exists (the release archive json.tar.xz does not contain it).
 # VERSION_GREATER_EQUAL is not available in older CMake (< 3.7)
-if(${MAIN_PROJECT} AND (${CMAKE_VERSION} VERSION_EQUAL 3.13 OR ${CMAKE_VERSION} VERSION_GREATER 3.13))
+if(${MAIN_PROJECT} AND (${CMAKE_VERSION} VERSION_EQUAL 3.13 OR ${CMAKE_VERSION} VERSION_GREATER 3.13)
+   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/tests/CMakeLists.txt")
     set(JSON_BuildTests_INIT ON)
 else()
     set(JSON_BuildTests_INIT OFF)
@@ -62,6 +65,7 @@ option(JSON_MultipleHeaders                "Use non-amalgamated version of the l
 option(JSON_SystemInclude                  "Include as system headers (skip for clang-tidy)." OFF)
 option(JSON_StrictNulHandling              "Build with strict NUL-byte handling enabled." OFF)
 option(JSON_StrictBinaryUTF8               "Build with UTF-8 checks in the CBOR, UBJSON, BJData, and BSON writers enabled." OFF)
+option(JSON_DeleteDeprecatedFunctions      "Delete the deprecated functions instead of only deprecating them." OFF)
 
 if (JSON_CI)
     include(ci)
@@ -123,6 +127,10 @@ if (JSON_StrictBinaryUTF8)
     message(STATUS "Strict UTF-8 checks in binary writers enabled (JSON_STRICT_BINARY_UTF8=1)")
 endif()
 
+if (JSON_DeleteDeprecatedFunctions)
+    message(STATUS "Deprecated functions are deleted (JSON_DELETE_DEPRECATED_FUNCTIONS=1)")
+endif()
+
 if (JSON_Diagnostic_Positions)
     message(STATUS "Diagnostic positions enabled (JSON_DIAGNOSTIC_POSITIONS=1)")
 endif()
@@ -159,6 +167,7 @@ target_compile_definitions(
     $<$<BOOL:${JSON_LegacyDiscardedValueComparison}>:JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1>
     $<$<BOOL:${JSON_StrictNulHandling}>:JSON_STRICT_NUL_HANDLING=1>
     $<$<BOOL:${JSON_StrictBinaryUTF8}>:JSON_STRICT_BINARY_UTF8=1>
+    $<$<BOOL:${JSON_DeleteDeprecatedFunctions}>:JSON_DELETE_DEPRECATED_FUNCTIONS=1>
 )
 
 target_include_directories(

FILES.md

@@ -196,19 +196,19 @@ Further documentation:
 
 ## REUSE
 
-### `.reuse/dep5`
+### `REUSE.toml`
 
 The file defines the licenses of certain third-party components in the repository. The root `Makefile` contains a target `reuse` that checks for compliance.
 
 Further documentation:
 
-- [DEP5](https://reuse.software/spec-3.2/#dep5-deprecated)
+- [REUSE.toml](https://reuse.software/spec-3.3/#reusetoml)
 - [reuse command-line tool](https://pypi.org/project/reuse/)
 - [documentation of linting](https://reuse.readthedocs.io/en/stable/man/reuse-lint.html)
 - [REUSE](http://reuse.software)
 
 > [!IMPORTANT]
-> The filename `.reuse/dep5` is predetermined by REUSE. Alternatively, a `REUSE.toml` file can be used.
+> The filename `REUSE.toml` is predetermined by REUSE. Alternatively, a `.reuse/dep5` file (deprecated) can be used.
 
 ### `.reuse/templates`
 

Makefile

@@ -7,6 +7,9 @@
 # find GNU sed to use `-i` parameter
 SED:=$(shell command -v gsed || which sed)
 
+# find GNU tar to use `--sort` and `--pax-option` parameters
+TAR:=$(shell command -v gtar || which tar)
+
 
 ##########################################################################
 # source files
@@ -23,6 +26,7 @@ AMALGAMATED_FILE=single_include/nlohmann/json.hpp
 AMALGAMATED_FWD_FILE=single_include/nlohmann/json_fwd.hpp
 # json_literals.hpp only includes <nlohmann/json.hpp>, so it is copied verbatim
 AMALGAMATED_LITERALS_FILE=single_include/nlohmann/json_literals.hpp
+AMALGAMATED_VIEW_FILE=single_include/nlohmann/json_view.hpp
 
 # the header with the argument-counting macros generated by tools/macro_builder
 MACRO_SCOPE_HPP=include/nlohmann/detail/macro_scope.hpp
@@ -34,7 +38,7 @@ MACRO_SCOPE_HPP=include/nlohmann/detail/macro_scope.hpp
 
 # main target
 all:
-	@echo "amalgamate - amalgamate files single_include/nlohmann/json{,_fwd,_literals}.hpp from the include/nlohmann sources"
+	@echo "amalgamate - amalgamate files single_include/nlohmann/json{,_fwd,_literals,_view}.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"
@@ -87,10 +91,10 @@ install_astyle:
 
 # call the Artistic Style pretty printer on all source files
 pretty: install_astyle
-	$(ASTYLE) --project=tools/astyle/.astylerc $(SRCS) $(TESTS_SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) docs/mkdocs/docs/examples/*.cpp docs/mkdocs/docs/examples/*.hpp
+	$(ASTYLE) --project=tools/astyle/.astylerc $(SRCS) $(TESTS_SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) $(AMALGAMATED_VIEW_FILE) docs/mkdocs/docs/examples/*.cpp docs/mkdocs/docs/examples/*.hpp
 
 # create single header files and pretty print
-amalgamate: $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE)
+amalgamate: $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) $(AMALGAMATED_VIEW_FILE)
 	$(MAKE) pretty
 
 # call the amalgamation tool for json.hpp
@@ -105,6 +109,9 @@ $(AMALGAMATED_FWD_FILE): $(SRCS)
 $(AMALGAMATED_LITERALS_FILE): include/nlohmann/json_literals.hpp
 	cp include/nlohmann/json_literals.hpp $(AMALGAMATED_LITERALS_FILE)
 
+# call the amalgamation tool for json_view.hpp (keeps including json.hpp)
+$(AMALGAMATED_VIEW_FILE): $(SRCS)
+	tools/amalgamate/amalgamate.py -c tools/amalgamate/config_json_view.json -s . --verbose=yes
 # regenerate nlohmann_json.natvis from the ABI tags and version in include/nlohmann/detail/abi_macros.hpp
 natvis:
 	python3 tools/generate_natvis/generate_natvis.py .
@@ -129,13 +136,16 @@ 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)
@@ -174,14 +184,14 @@ ChangeLog.md:
 # archive is created according to the advices of <https://reproducible-builds.org/docs/archives/>.
 json.tar.xz:
 	mkdir json
-	rsync -R $(shell find LICENSE.MIT nlohmann_json.natvis CMakeLists.txt cmake/*.in include single_include -type f) json
+	rsync -R $(shell find LICENSE.MIT nlohmann_json.natvis CMakeLists.txt cmake/*.in include single_include src/modules -type f) json
-	gtar --sort=name --mtime="@$(shell git log -1 --pretty=%ct)" --owner=0 --group=0 --numeric-owner --pax-option=exthdr.name=%d/PaxHeaders/%f,delete=atime,delete=ctime --create --file - json | xz --compress -9e --threads=2 - > json.tar.xz
+	$(TAR) --sort=name --mtime="@$(shell git log -1 --pretty=%ct)" --owner=0 --group=0 --numeric-owner --pax-option=exthdr.name=%d/PaxHeaders/%f,delete=atime,delete=ctime --create --file - json | xz --compress -9e --threads=2 - > json.tar.xz
 	rm -fr json
 
 # We use `-X` to make the resulting ZIP file reproducible, see
 # <https://content.pivotal.io/blog/barriers-to-deterministic-reproducible-zip-files>.
 include.zip: BUILD.bazel
-	zip -9 --recurse-paths -X include.zip $(SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) BUILD.bazel MODULE.bazel meson.build LICENSE.MIT
+	zip -9 --recurse-paths -X include.zip $(SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) $(AMALGAMATED_VIEW_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
@@ -191,11 +201,13 @@ release: include.zip json.tar.xz
 	gpg --armor --detach-sig $(AMALGAMATED_FILE)
 	gpg --armor --detach-sig $(AMALGAMATED_FWD_FILE)
 	gpg --armor --detach-sig $(AMALGAMATED_LITERALS_FILE)
+	gpg --armor --detach-sig $(AMALGAMATED_VIEW_FILE)
 	gpg --armor --detach-sig json.tar.xz
 	cp $(AMALGAMATED_FILE) release_files
 	cp $(AMALGAMATED_FWD_FILE) release_files
 	cp $(AMALGAMATED_LITERALS_FILE) release_files
-	mv $(AMALGAMATED_FILE).asc $(AMALGAMATED_FWD_FILE).asc $(AMALGAMATED_LITERALS_FILE).asc json.tar.xz json.tar.xz.asc include.zip include.zip.asc release_files
+	cp $(AMALGAMATED_VIEW_FILE) release_files
+	mv $(AMALGAMATED_FILE).asc $(AMALGAMATED_FWD_FILE).asc $(AMALGAMATED_LITERALS_FILE).asc $(AMALGAMATED_VIEW_FILE).asc json.tar.xz json.tar.xz.asc include.zip include.zip.asc release_files
 	cd release_files ; shasum -a 256 $$(find . -type f -not -name '*.asc' | sed 's|^\./||' | sort) > hashes.txt
 
 

Package.swift

@@ -6,7 +6,7 @@ import PackageDescription
 let package = Package(
     name: "nlohmann-json",
      platforms: [
-        .iOS(.v12), .macOS(.v10_13), .tvOS(.v12), .watchOS(.v4), .visionOS(.v1)
+        .iOS(.v12), .macOS(.v10_13), .tvOS(.v12), .watchOS(.v9), .visionOS(.v1)
     ],
     products: [
         .library(name: "json", targets: ["json"])

README.md

@@ -7,7 +7,7 @@
 [![Coverage Status](https://coveralls.io/repos/github/nlohmann/json/badge.svg?branch=develop)](https://coveralls.io/github/nlohmann/json?branch=develop)
 [![Coverity Scan Build Status](https://scan.coverity.com/projects/5550/badge.svg)](https://scan.coverity.com/projects/nlohmann-json)
 [![Codacy Badge](https://app.codacy.com/project/badge/Grade/e0d1a9d5d6fd46fcb655c4cb930bb3e8)](https://app.codacy.com/gh/nlohmann/json/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
-[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/json.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:json)
+[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/json.svg)](https://issues.oss-fuzz.com/issues?q=project:json)
 [![Try online](https://img.shields.io/badge/try-online-blue.svg)](https://wandbox.org/permlink/1mp10JbaANo6FUc7)
 [![Documentation](https://img.shields.io/badge/docs-mkdocs-blue.svg)](https://json.nlohmann.me)
 [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/nlohmann/json/develop/LICENSE.MIT)
@@ -1187,6 +1187,14 @@ 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).
@@ -1202,15 +1210,18 @@ language bindings, format converters, and the like. See the curated [Ecosystem](
 
 Though it's 2026 already, the support for C++11 is still a bit sparse. Currently, the following compilers are known to work:
 
-- GCC 4.8 - 14.2 (and possibly later)
+- GCC 4.8 - 16.2 (and possibly later)
-- Clang 3.4 - 21.0 (and possibly later)
+- Clang 3.4 - 22.1 (and possibly later)
-- Apple Clang 9.1 - 16.0 (and possibly later)
+- Apple Clang 15.0 - 21.0 (and possibly later)
-- Intel C++ Compiler 17.0.2 (and possibly later)
+- Intel C++ Compiler Classic (icpc) 2021.10
-- Nvidia CUDA Compiler 11.0.221 (and possibly later)
+- Intel oneAPI DPC++/C++ Compiler (icpx) 2025.3 (and possibly later)
-- Microsoft Visual C++ 2015 / Build Tools 14.0.25123.0 (and possibly later)
+- NVIDIA CUDA Compiler (nvcc) 11.8 - 12.6 (and possibly later)
-- Microsoft Visual C++ 2017 / Build Tools 15.5.180.51428 (and possibly later)
+- NVIDIA HPC SDK C++ Compiler (nvc++) 25.5 (and possibly later)
-- Microsoft Visual C++ 2019 / Build Tools 16.3.1+1def00d3d (and possibly later)
+- Microsoft Visual C++ 2015 / MSVC 19.0 (and possibly later)
-- Microsoft Visual C++ 2022 / Build Tools 19.30.30709.0 (and possibly later)
+- Microsoft Visual C++ 2017 / MSVC 19.16 (and possibly later)
+- Microsoft Visual C++ 2019 / MSVC 19.29 (and possibly later)
+- Microsoft Visual C++ 2022 / MSVC 19.44 (and possibly later)
+- Microsoft Visual C++ 2026 / MSVC 19.51 (and possibly later)
 
 I would be happy to learn about other compilers/versions.
 
@@ -1391,9 +1402,11 @@ THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR I
 
 - The class contains the UTF-8 Decoder from Bjoern Hoehrmann which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright &copy; 2008-2009 [Björn Hoehrmann](https://bjoern.hoehrmann.de/) <bjoern@hoehrmann.de>
 - 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 port of the shortest double-to-decimal conversion of [Żmij](https://github.com/vitaut/zmij) by Victor Zverovich, which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright &copy; 2025 [Victor Zverovich](https://github.com/vitaut)
 - 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 and its table of powers of five from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright &copy; 2021 The fast_float authors
+- The 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">
 
@@ -1401,7 +1414,7 @@ The library is compliant to version 3.3 of the [**REUSE specification**](https:/
 
 - Every source file contains an SPDX copyright header.
 - The full text of all licenses used in the repository can be found in the `LICENSES` folder.
-- File `.reuse/dep5` contains an overview of all files' copyrights and licenses.
+- File `REUSE.toml` contains an overview of all files' copyrights and licenses.
 - Run `pipx run reuse lint` to verify the project's REUSE compliance and `pipx run reuse spdx` to generate a SPDX SBOM.
 
 ## Contact

REUSE.toml

@@ -0,0 +1,52 @@
+version = 1
+SPDX-PackageName = "json"
+SPDX-PackageSupplier = "Niels Lohmann <mail@nlohmann.me>"
+SPDX-PackageDownloadLocation = "https://github.com/nlohmann/json"
+
+[[annotations]]
+path = "**"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "2013-2026 Niels Lohmann <https://nlohmann.me>"
+SPDX-License-Identifier = "MIT"
+
+[[annotations]]
+path = "include/nlohmann/thirdparty/hedley.hpp"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "2016-2021 Evan Nemerson <evan@nemerson.com>"
+SPDX-License-Identifier = "CC0"
+
+[[annotations]]
+path = "include/nlohmann/detail/meta/cpp_future.hpp"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "2013-2026 Niels Lohmann <https://nlohmann.me> and 2018 The Abseil Authors"
+SPDX-License-Identifier = "MIT AND Apache-2.0"
+
+[[annotations]]
+path = "tests/thirdparty/doctest/**"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "2016-2023 Viktor Kirilov"
+SPDX-License-Identifier = "MIT"
+
+[[annotations]]
+path = "tests/thirdparty/fifo_map/**"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "2015-2017 Niels Lohmann"
+SPDX-License-Identifier = "MIT"
+
+[[annotations]]
+path = "tests/thirdparty/imapdl/**"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "2017 Georg Sauthoff <mail@gms.tf>"
+SPDX-License-Identifier = "GPL-3.0-only"
+
+[[annotations]]
+path = "tools/amalgamate/**"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "2012 Erik Edlund <erik.edlund@32767.se>"
+SPDX-License-Identifier = "BSD-3-Clause"
+
+[[annotations]]
+path = "tools/gdb_pretty_printer/**"
+precedence = "aggregate"
+SPDX-FileCopyrightText = "2020 Hannes Domani <https://github.com/ssbssa>"
+SPDX-License-Identifier = "MIT"

cmake/ci.cmake

@@ -249,6 +249,20 @@ add_custom_target(ci_test_strict_nul_handling
     COMMENT "Compile and test with strict NUL-byte handling enabled"
 )
 
+###############################################################################
+# Delete the deprecated functions.
+###############################################################################
+
+add_custom_target(ci_test_delete_deprecated_functions
+    COMMAND ${CMAKE_COMMAND}
+    -DCMAKE_BUILD_TYPE=Debug -GNinja
+    -DJSON_BuildTests=ON -DJSON_FastTests=ON -DJSON_DeleteDeprecatedFunctions=ON
+    -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_delete_deprecated_functions
+    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_delete_deprecated_functions
+    COMMAND cd ${PROJECT_BINARY_DIR}/build_delete_deprecated_functions && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
+    COMMENT "Compile and test with the deprecated functions deleted"
+)
+
 ###############################################################################
 # Disable global UDLs.
 ###############################################################################
@@ -362,7 +376,7 @@ add_custom_target(ci_test_coverage
 # Sanitizers.
 ###############################################################################
 
-set(CLANG_CXX_FLAGS_SANITIZER "-g -O1 -fsanitize=address -fsanitize=undefined -fsanitize=integer -fsanitize=nullability -fno-omit-frame-pointer -fno-sanitize-recover=all -fno-sanitize=unsigned-integer-overflow -fno-sanitize=unsigned-shift-base")
+set(CLANG_CXX_FLAGS_SANITIZER "-g -O1 -fsanitize=address -fsanitize=undefined -fsanitize=integer -fsanitize=nullability -fno-omit-frame-pointer -fno-sanitize-recover=all -fno-sanitize=unsigned-integer-overflow -fno-sanitize=unsigned-shift-base -fsanitize-ignorelist=${PROJECT_SOURCE_DIR}/cmake/clang_sanitizer_ignorelist.txt")
 
 add_custom_target(ci_test_clang_sanitizer
     COMMAND CXX=${CLANG_TOOL} CXXFLAGS=${CLANG_CXX_FLAGS_SANITIZER} ${CMAKE_COMMAND}
@@ -396,10 +410,11 @@ list(FILTER INDENT_FILES EXCLUDE REGEX "/tests/thirdparty/|/tests/abi/include/nl
 set(include_dir ${PROJECT_SOURCE_DIR}/single_include/nlohmann)
 set(tool_dir ${PROJECT_SOURCE_DIR}/tools/amalgamate)
 add_custom_target(ci_test_amalgamation
-    COMMAND rm -fr ${include_dir}/json.hpp~ ${include_dir}/json_fwd.hpp~ ${include_dir}/json_literals.hpp~
+    COMMAND rm -fr ${include_dir}/json.hpp~ ${include_dir}/json_fwd.hpp~ ${include_dir}/json_literals.hpp~ ${include_dir}/json_view.hpp~
     COMMAND cp ${include_dir}/json.hpp ${include_dir}/json.hpp~
     COMMAND cp ${include_dir}/json_fwd.hpp ${include_dir}/json_fwd.hpp~
     COMMAND cp ${include_dir}/json_literals.hpp ${include_dir}/json_literals.hpp~
+    COMMAND cp ${include_dir}/json_view.hpp ${include_dir}/json_view.hpp~
     COMMAND cp ${PROJECT_SOURCE_DIR}/BUILD.bazel ${PROJECT_SOURCE_DIR}/BUILD.bazel~
 
     COMMAND ${Python3_EXECUTABLE} -mvenv venv_astyle
@@ -409,12 +424,14 @@ 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 ${CMAKE_COMMAND} -P ${PROJECT_SOURCE_DIR}/cmake/scripts/gen_bazel_build_file.cmake
 
     COMMAND diff ${include_dir}/json.hpp~ ${include_dir}/json.hpp
     COMMAND diff ${include_dir}/json_fwd.hpp~ ${include_dir}/json_fwd.hpp
     COMMAND diff ${include_dir}/json_literals.hpp~ ${include_dir}/json_literals.hpp
+    COMMAND diff ${include_dir}/json_view.hpp~ ${include_dir}/json_view.hpp
     COMMAND diff ${PROJECT_SOURCE_DIR}/BUILD.bazel~ ${PROJECT_SOURCE_DIR}/BUILD.bazel
 
     COMMAND venv_astyle/bin/astyle --project=tools/astyle/.astylerc --suffix=orig ${INDENT_FILES}
@@ -442,13 +459,14 @@ add_custom_target(ci_test_single_header
 # Valgrind.
 ###############################################################################
 
+# The Unicode test (~17M assertions) is too slow under Valgrind.
 add_custom_target(ci_test_valgrind
     COMMAND CXX=${GCC_TOOL} ${CMAKE_COMMAND}
         -DCMAKE_BUILD_TYPE=Debug -GNinja
         -DJSON_BuildTests=ON -DJSON_Valgrind=ON
         -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_valgrind
     COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_valgrind
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_valgrind && ${CMAKE_CTEST_COMMAND} -L valgrind --parallel ${N} --output-on-failure
+    COMMAND cd ${PROJECT_BINARY_DIR}/build_valgrind && ${CMAKE_CTEST_COMMAND} -L valgrind --exclude-regex "test-unicode" --parallel ${N} --output-on-failure
     COMMENT "Compile and test with Valgrind"
 )
 
@@ -705,7 +723,7 @@ ci_get_cmake(4.0.0  CMAKE_4_0_0_BINARY)
 # the tests require CMake 3.13 or later, so they are excluded for CMake 3.5.0
 set(JSON_CMAKE_FLAGS_3_5_0 JSON_Diagnostics JSON_Diagnostic_Positions JSON_GlobalUDLs JSON_ImplicitConversions JSON_DisableEnumSerialization
     JSON_LegacyDiscardedValueComparison JSON_Install JSON_MultipleHeaders JSON_SystemInclude JSON_Valgrind
-    JSON_StrictNulHandling JSON_StrictBinaryUTF8)
+    JSON_StrictNulHandling JSON_StrictBinaryUTF8 JSON_DeleteDeprecatedFunctions)
 set(JSON_CMAKE_FLAGS_3_31_6 JSON_BuildTests ${JSON_CMAKE_FLAGS_3_5_0})
 set(JSON_CMAKE_FLAGS_4_0_0 JSON_BuildTests ${JSON_CMAKE_FLAGS_3_5_0})
 
@@ -773,7 +791,7 @@ foreach(COMPILER g++-4.8 g++-4.9 g++-5 g++-6 g++-7 g++-8 g++-9 g++-10 g++-11 cla
                 -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_compiler_${COMPILER}
                 ${ADDITIONAL_FLAGS}
             COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_compiler_${COMPILER}
-            COMMAND cd ${PROJECT_BINARY_DIR}/build_compiler_${COMPILER} && ${CMAKE_CTEST_COMMAND} --parallel ${N} --exclude-regex "test-unicode" --output-on-failure
+            COMMAND cd ${PROJECT_BINARY_DIR}/build_compiler_${COMPILER} && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
             COMMENT "Compile and test with ${COMPILER}"
         )
     endif()
@@ -787,7 +805,7 @@ add_custom_target(ci_test_compiler_default
         -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_compiler_default
         ${ADDITIONAL_FLAGS}
     COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_compiler_default --parallel ${N}
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_compiler_default && ${CMAKE_CTEST_COMMAND} --parallel ${N} --exclude-regex "test-unicode" -LE git_required --output-on-failure
+    COMMAND cd ${PROJECT_BINARY_DIR}/build_compiler_default && ${CMAKE_CTEST_COMMAND} --parallel ${N} -LE git_required --output-on-failure
     COMMENT "Compile and test with default C++ compiler"
 )
 
@@ -825,7 +843,7 @@ add_custom_target(ci_icpc
         -DJSON_BuildTests=ON -DJSON_FastTests=ON
         -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_icpc
     COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_icpc
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_icpc && ${CMAKE_CTEST_COMMAND} --parallel ${N} --exclude-regex "test-unicode" --output-on-failure
+    COMMAND cd ${PROJECT_BINARY_DIR}/build_icpc && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
     COMMENT "Compile and test with ICPC"
 )
 
@@ -836,7 +854,7 @@ add_custom_target(ci_icpx
         -DJSON_BuildTests=ON -DJSON_FastTests=ON
         -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_icpx
     COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_icpx
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_icpx && ${CMAKE_CTEST_COMMAND} --parallel ${N} --exclude-regex "test-unicode" --output-on-failure
+    COMMAND cd ${PROJECT_BINARY_DIR}/build_icpx && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
     COMMENT "Compile and test with ICPX (Intel oneAPI DPC++/C++)"
 )
 
@@ -872,7 +890,7 @@ add_custom_target(ci_nvhpc
     COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_nvhpc
     # the pipes are escaped so the surrounding shell passes them to ctest verbatim
     # instead of treating them as shell pipe operators
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_nvhpc && ${CMAKE_CTEST_COMMAND} --parallel ${N} --exclude-regex "test-unicode\\|test-comparison_cpp20\\|test-comparison_legacy_cpp20\\|test-constructor1_cpp11\\|test-deserialization_cpp20" --output-on-failure
+    COMMAND cd ${PROJECT_BINARY_DIR}/build_nvhpc && ${CMAKE_CTEST_COMMAND} --parallel ${N} --exclude-regex "test-comparison_cpp20\\|test-comparison_legacy_cpp20\\|test-constructor1_cpp11\\|test-deserialization_cpp20" --output-on-failure
     COMMENT "Compile and test with NVIDIA HPC SDK (nvc++)"
 )
 

cmake/clang_sanitizer_ignorelist.txt

@@ -0,0 +1,8 @@
+# Sanitizer ignore list for ci_test_clang_sanitizer (-fsanitize-ignorelist).
+#
+# libstdc++ 14's <format> declares `_Scanner(basic_string_view<_CharT>, size_t __nargs = -1)`, so every std::format
+# call converts -1 to size_t, which -fsanitize=integer reports as implicit-integer-sign-change. This is
+# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=119429, not a bug in this library. Only that check and only <format> are
+# excluded, so implicit sign changes in the library and the tests are still reported.
+[implicit-integer-sign-change]
+src:*/include/c++/*/format

cmake/scripts/gen_bazel_build_file.cmake

@@ -48,6 +48,8 @@ cc_library(
     name = "singleheader-json",
     hdrs = [
         "single_include/nlohmann/json.hpp",
+        "single_include/nlohmann/json_fwd.hpp",
+        "single_include/nlohmann/json_view.hpp",
     ],
     includes = ["single_include"],
     visibility = ["//visibility:public"],

cmake/scripts/gen_hedley_undef_check.cmake

@@ -64,7 +64,7 @@ if(MODE STREQUAL "undef")
     # recipe is self-contained and its output is byte-stable across reruns.
     # The embedded SPDX tags below are part of the *generated* file's
     # content, not a REUSE header for this .cmake script itself (which is
-    # already covered by the blanket "Files: *" rule in .reuse/dep5) -- keep
+    # already covered by the blanket path = "**" rule in REUSE.toml) -- keep
     # them wrapped in REUSE-IgnoreStart/End so `reuse lint` does not try to
     # parse "MIT\n")" as this file's own SPDX-License-Identifier value.
     # REUSE-IgnoreStart

docs/docset/docSet.sql

@@ -131,8 +131,63 @@ INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::to_string', 'Meth
 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::with_t', 'Type', 'api/basic_json/with_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::at', 'Method', 'api/basic_json_view/at/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::back', 'Method', 'api/basic_json_view/back/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::begin', 'Method', 'api/basic_json_view/begin/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::cbegin', 'Method', 'api/basic_json_view/cbegin/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::cend', 'Method', 'api/basic_json_view/cend/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::contains', 'Method', 'api/basic_json_view/contains/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::count', 'Method', 'api/basic_json_view/count/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::empty', 'Method', 'api/basic_json_view/empty/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::end', 'Method', 'api/basic_json_view/end/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::find', 'Method', 'api/basic_json_view/find/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::front', 'Method', 'api/basic_json_view/front/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::get', 'Method', 'api/basic_json_view/get/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::get_string', 'Method', 'api/basic_json_view/get_string/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::get_to', 'Method', 'api/basic_json_view/get_to/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_array', 'Method', 'api/basic_json_view/is_array/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_binary', 'Method', 'api/basic_json_view/is_binary/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_boolean', 'Method', 'api/basic_json_view/is_boolean/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_discarded', 'Method', 'api/basic_json_view/is_discarded/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_null', 'Method', 'api/basic_json_view/is_null/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_number', 'Method', 'api/basic_json_view/is_number/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_number_float', 'Method', 'api/basic_json_view/is_number_float/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_number_integer', 'Method', 'api/basic_json_view/is_number_integer/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_number_unsigned', 'Method', 'api/basic_json_view/is_number_unsigned/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_object', 'Method', 'api/basic_json_view/is_object/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_primitive', 'Method', 'api/basic_json_view/is_primitive/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_string', 'Method', 'api/basic_json_view/is_string/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_structured', 'Method', 'api/basic_json_view/is_structured/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::items', 'Method', 'api/basic_json_view/items/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::materialize', 'Method', 'api/basic_json_view/materialize/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::number_token', 'Method', 'api/basic_json_view/number_token/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator bool', 'Method', 'api/basic_json_view/operator_bool/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator[]', 'Operator', 'api/basic_json_view/operator[]/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::size', 'Method', 'api/basic_json_view/size/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::source_offset', 'Method', 'api/basic_json_view/source_offset/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::type', 'Method', 'api/basic_json_view/type/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::type_name', 'Method', 'api/basic_json_view/type_name/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::value', 'Method', 'api/basic_json_view/value/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json', 'Class', 'api/json/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('json_document', 'Class', 'api/json_document/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('json_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');
@@ -170,6 +225,8 @@ 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::formatter<basic_json>', 'Class', 'api/basic_json/std_formatter/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('std::hash<basic_json>', 'Class', 'api/basic_json/std_hash/index.html');
@@ -200,6 +257,7 @@ 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');
@@ -219,6 +277,7 @@ INSERT INTO searchIndex(name, type, path) VALUES ('Supported Macros', 'Guide', '
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_ASSERT', 'Macro', 'api/macros/json_assert/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_BRACE_INIT_COPY_SEMANTICS', 'Macro', 'api/macros/json_brace_init_copy_semantics/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_CATCH_USER', 'Macro', 'api/macros/json_throw_user/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DELETE_DEPRECATED_FUNCTIONS', 'Macro', 'api/macros/json_delete_deprecated_functions/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DIAGNOSTICS', 'Macro', 'api/macros/json_diagnostics/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DIAGNOSTIC_POSITIONS', 'Macro', 'api/macros/json_diagnostic_positions/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DISABLE_ENUM_SERIALIZATION', 'Macro', 'api/macros/json_disable_enum_serialization/index.html');
@@ -249,6 +308,7 @@ INSERT INTO searchIndex(name, type, path) VALUES ('JSON_TRY_USER', 'Macro', 'api
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_GLOBAL_UDLS', 'Macro', 'api/macros/json_use_global_udls/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_IMPLICIT_CONVERSIONS', 'Macro', 'api/macros/json_use_implicit_conversions/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON', 'Macro', 'api/macros/json_use_legacy_discarded_value_comparison/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS', 'Macro', 'api/macros/json_use_objects_for_enum_keyed_maps/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_SIMDUTF', 'Macro', 'api/macros/json_use_simdutf/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Macros', 'Macro', 'api/macros/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE', 'Macro', 'api/macros/nlohmann_define_derived_type/index.html');

docs/mkdocs/docs/api/basic_json/at.md

@@ -233,6 +233,7 @@ Strong exception safety: if an exception occurs, the original value stays intact
 - documentation on [checked access](../../features/element_access/checked_access.md)
 - [`operator[]`](operator%5B%5D.md) for unchecked access by reference
 - [`value`](value.md) for access with default value
+- [basic_json_view::at](../basic_json_view/at.md) - the same access on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/back.md

@@ -58,6 +58,7 @@ Constant.
 ## See also
 
 - [front](front.md) to access the first element
+- [basic_json_view::back](../basic_json_view/back.md) - the same access on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/begin.md

@@ -44,6 +44,8 @@ Constant.
 - [rbegin](rbegin.md) returns a reverse iterator to the last element
 - [items](items.md) returns an iteration proxy to access keys and values during range-based for loops
 - [Iterators](../../features/iterators.md) - the article on iterators
+- [basic_json_view::begin](../basic_json_view/begin.md) - the same iteration on a zero-copy view (in document order,
+  not sorted by key)
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/cbegin.md

@@ -42,6 +42,7 @@ Constant.
 - [cend](cend.md) returns a const iterator to one past the last element
 - [crbegin](crbegin.md) returns a const reverse iterator to the last element
 - [Iterators](../../features/iterators.md) - the article on iterators
+- [basic_json_view::cbegin](../basic_json_view/cbegin.md) - the same iteration on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/cbor_tag_handler_t.md

@@ -9,10 +9,10 @@ enum class cbor_tag_handler_t
 };
 ```
 
-This enumeration is used in the [`from_cbor`](from_cbor.md) function to choose how to treat tags:
+This enumeration is used in [`from_cbor`](from_cbor.md) and [`sax_parse`](sax_parse.md) to choose how to treat tags:
 
 error
-:   throw a `parse_error` exception in case of a tag
+:   report a parse error in case of a tag (the `from_cbor` overloads throw a `parse_error` exception by default)
 
 ignore
 :   ignore tags

docs/mkdocs/docs/api/basic_json/cend.md

@@ -42,6 +42,7 @@ Constant.
 - [cbegin](cbegin.md) returns a const iterator to the first element
 - [crend](crend.md) returns a const reverse iterator to one before the first element
 - [Iterators](../../features/iterators.md) - the article on iterators
+- [basic_json_view::cend](../basic_json_view/cend.md) - the same iteration on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/contains.md

@@ -127,6 +127,7 @@ Logarithmic in the size of the JSON object.
 
 - [find](find.md) find a value in an object
 - [count](count.md) returns the number of occurrences of a key
+- [basic_json_view::contains](../basic_json_view/contains.md) - the same check on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/count.md

@@ -80,6 +80,7 @@ Logarithmic in the size of the JSON object.
 
 - [find](find.md) find a value in an object
 - [contains](contains.md) checks whether a key exists
+- [basic_json_view::count](../basic_json_view/count.md) - the same check on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/diff.md

@@ -8,7 +8,7 @@ static basic_json diff(const basic_json& source,
 Creates a [JSON Patch](http://jsonpatch.com) so that value `source` can be changed into the value `target` by calling
 [`patch`](patch.md) function.
 
-For two JSON values `source` and `target`, the following code yields always `#!cpp true`:
+For two JSON values `source` and `target`, the following code always yields `#!cpp true`:
 ```cpp
 source.patch(diff(source, target)) == target;
 ```
@@ -27,7 +27,7 @@ a JSON patch to convert the `source` to `target`
 
 ## Exception safety
 
-Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
+Strong guarantee: `source` and `target` are never modified.
 
 ## Complexity
 

docs/mkdocs/docs/api/basic_json/dump.md

@@ -62,6 +62,9 @@ Linear.
 
 ## Notes
 
+Floating-point numbers are written with the fewest digits that read back as the same value (for `#!cpp double`; see
+[number handling](../../features/types/number_handling.md#number-serialization)).
+
 Binary values are serialized as an object containing two keys:
 
 - "bytes": an array of bytes as integers
@@ -97,3 +100,5 @@ Binary values are serialized as an object containing two keys:
 - Error handlers added in version 3.4.0.
 - Serialization of binary values added in version 3.8.0.
 - Error handler `keep` added in version 3.13.0.
+- Doubles are written with the shortest digits (Żmij instead of Grisu2) since version 3.13.0; about 0.1% of doubles are
+  written differently, most of them with fewer digits.

docs/mkdocs/docs/api/basic_json/empty.md

@@ -64,6 +64,7 @@ itself is empty which is `#!cpp false` in the case of a string.
 
 - [size](size.md) returns the number of elements
 - [clear](clear.md) clears the content and resets the value to the default value
+- [basic_json_view::empty](../basic_json_view/empty.md) - the same check on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/end.md

@@ -43,6 +43,7 @@ Constant.
 - [cend](cend.md) returns a const iterator to one past the last element
 - [rend](rend.md) returns a reverse iterator to one before the first element
 - [Iterators](../../features/iterators.md) - the article on iterators
+- [basic_json_view::end](../basic_json_view/end.md) - the same iteration on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/find.md

@@ -84,6 +84,7 @@ Logarithmic in the size of the JSON object.
 
 - [count](count.md) returns the number of occurrences of a key
 - [contains](contains.md) checks whether a key exists
+- [basic_json_view::find](../basic_json_view/find.md) - the same lookup on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/from_bjdata.md

@@ -120,3 +120,12 @@ Linear in the size of the input.
 - Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.
 - Extended overload (2) to accept heterogeneous iterator+sentinel pairs (C++20 ranges support) in version 3.13.0.
 - Added `error_handler` parameter in version 3.13.0.
+
+!!! warning "Deprecation"
+
+    - Overload (2) replaces calls to `from_bjdata` with a pointer and a length as first two parameters, which has been
+      deprecated in version 3.13.0. This overload will be removed in version 4.0.0. Please replace all calls like
+      `#!cpp from_bjdata(ptr, len, ...);` with `#!cpp from_bjdata(ptr, ptr+len, ...);`.
+
+    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
+    function.

docs/mkdocs/docs/api/basic_json/from_bon8.md

@@ -106,3 +106,12 @@ Linear in the size of the input.
 ## Version history
 
 - Added in version 3.13.0.
+
+!!! warning "Deprecation"
+
+    - Overload (2) replaces calls to `from_bon8` with a pointer and a length as first two parameters, which has been
+      deprecated in version 3.13.0. This overload will be removed in version 4.0.0. Please replace all calls like
+      `#!cpp from_bon8(ptr, len, ...);` with `#!cpp from_bon8(ptr, ptr+len, ...);`.
+
+    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
+    function.

docs/mkdocs/docs/api/basic_json/front.md

@@ -51,6 +51,7 @@ Constant.
 ## See also
 
 - [back](back.md) to access the last element
+- [basic_json_view::front](../basic_json_view/front.md) - the same access on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/get.md

@@ -183,6 +183,8 @@ overload (3).
 - [get_ref](get_ref.md) get a reference to the stored value
 - [operator ValueType](operator_ValueType.md) get a value via implicit conversion
 - [Converting values](../../features/conversions.md) - the type conversions article
+- [basic_json_view::get](../basic_json_view/get.md) - the same conversion on a zero-copy view (many types are
+  converted without ever building a `basic_json` value)
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/get_ref.md

@@ -61,6 +61,8 @@ Constant.
 ## See also
 
 - [get_ptr()](get_ptr.md) get a pointer value
+- [basic_json_view::get_string](../basic_json_view/get_string.md) - the closest counterpart on a zero-copy view: a
+  string without a copy, but as a view rather than a reference to a value that must already exist
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/get_to.md

@@ -72,6 +72,7 @@ Depends on the `json_serializer<ValueType>::from_json()` implementation.
 - [get_ref](get_ref.md) get a reference to the stored value
 - [get_ptr](get_ptr.md) get a pointer to the stored value
 - [Converting values](../../features/conversions.md) - the type conversions article
+- [basic_json_view::get_to](../basic_json_view/get_to.md) - the same conversion on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/index.md

@@ -109,6 +109,9 @@ The class satisfies the following concept requirements:
 - **initializer_list_t** - type for initializer lists of `basic_json` values
 - [**input_format_t**](input_format_t.md) - type to choose the format to parse
 - [**json_sax_t**](../json_sax/index.md) - type for SAX events
+- [**with_object_t, with_array_t, with_string_t, with_boolean_t, with_integers_t, with_float_t, with_allocator_t,
+  with_json_serializer_t, with_binary_t, with_base_class_t**](with_t.md) - types to create a `basic_json` type with
+  one (or two) replaced template parameters
 
 ### Exceptions
 

docs/mkdocs/docs/api/basic_json/is_array.md

@@ -40,6 +40,7 @@ Constant.
 - [is_structured](is_structured.md) checks whether the JSON value is structured (array or object)
 - [type](type.md) returns the type of the JSON value
 - [array_t](array_t.md) the type used to store JSON arrays
+- [basic_json_view::is_array](../basic_json_view/is_array.md) - the same check on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/is_binary.md

@@ -39,6 +39,7 @@ Constant.
 - [is_primitive](is_primitive.md) checks whether the JSON value is primitive
 - [binary_t](binary_t.md) the type used to store binary values
 - [get_binary](get_binary.md) returns a reference to the stored binary value
+- [basic_json_view::is_binary](../basic_json_view/is_binary.md) - the same check on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/is_boolean.md

@@ -38,6 +38,7 @@ Constant.
 
 - [boolean_t](boolean_t.md) the type used to store JSON booleans
 - [is_primitive](is_primitive.md) checks whether the JSON value is primitive
+- [basic_json_view::is_boolean](../basic_json_view/is_boolean.md) - the same check on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/is_discarded.md

@@ -85,6 +85,11 @@ with `allow_exceptions` set to `#!cpp false`: a parse error then yields a discar
     --8<-- "examples/is_discarded__parse.output"
     ```
 
+## See also
+
+- [basic_json_view::is_discarded](../basic_json_view/is_discarded.md) - the corresponding check on a zero-copy view,
+  which is `#!cpp true` if the view refers to no value
+
 ## Version history
 
 - Added in version 1.0.0.

docs/mkdocs/docs/api/basic_json/is_null.md

@@ -40,6 +40,7 @@ Constant.
 - [is_object](is_object.md) checks whether the JSON value is an object
 - [type](type.md) returns the type of the JSON value
 - [value_t](value_t.md) the enumeration of JSON types
+- [basic_json_view::is_null](../basic_json_view/is_null.md) - the same check on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/is_number.md

@@ -49,6 +49,7 @@ 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
 

docs/mkdocs/docs/api/basic_json/is_number_float.md

@@ -40,6 +40,7 @@ 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
 

docs/mkdocs/docs/api/basic_json/is_number_integer.md

@@ -40,6 +40,7 @@ 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
 

docs/mkdocs/docs/api/basic_json/is_number_unsigned.md

@@ -40,6 +40,7 @@ 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
 

docs/mkdocs/docs/api/basic_json/is_object.md

@@ -40,6 +40,7 @@ Constant.
 - [is_structured](is_structured.md) checks whether the JSON value is structured (array or object)
 - [type](type.md) returns the type of the JSON value
 - [object_t](object_t.md) the type used to store JSON objects
+- [basic_json_view::is_object](../basic_json_view/is_object.md) - the same check on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/is_primitive.md

@@ -62,6 +62,7 @@ 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
 

docs/mkdocs/docs/api/basic_json/is_string.md

@@ -39,6 +39,7 @@ Constant.
 - [is_primitive](is_primitive.md) checks whether the JSON value is primitive
 - [type](type.md) returns the type of the JSON value
 - [string_t](string_t.md) the type used to store JSON strings
+- [basic_json_view::is_string](../basic_json_view/is_string.md) - the same check on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/is_structured.md

@@ -57,6 +57,7 @@ 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
 

docs/mkdocs/docs/api/basic_json/items.md

@@ -99,6 +99,8 @@ When iterating over an array, `key()` will return the index of the element as st
 
 - [begin](begin.md) returns an iterator to the first element
 - [end](end.md) returns an iterator to one past the last element
+- [basic_json_view::items](../basic_json_view/items.md) - the same range on a zero-copy view (`#!cpp const auto`,
+  not `#!cpp const auto&`: items are produced on the fly)
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/number_float_t.md

@@ -23,9 +23,10 @@ type to use.
 ## Template parameters
 
 `NumberFloatType`
-:   the type to store floating-point numbers. Parsing and serialization are implemented in terms of
+:   the type to store floating-point numbers. The parser converts `#!cpp float`, `#!cpp double`, and a
-    `#!cpp std::strtof`/`#!cpp std::strtod`/`#!cpp std::strtold` and `#!cpp std::snprintf`, so the type must be
+    `#!cpp long double` that is IEEE 754 binary64 itself and other `#!cpp long double` formats with
-    `#!cpp float`, `#!cpp double`, or `#!cpp long double`. The
+    `#!cpp std::from_chars` or `#!cpp std::strtold`, and serialization falls back to `#!cpp std::snprintf`, so the
+    type must be `#!cpp float`, `#!cpp double`, or `#!cpp long double`. The
     [binary formats](../../features/binary_formats/index.md) additionally require `#!cpp float` or `#!cpp double`,
     because they have no encoding for `#!cpp long double`. See
     [Template Parameter Requirements](../../features/types/template_parameters.md#numberfloattype).
@@ -55,6 +56,10 @@ This implementation does exactly follow this approach, as it uses double precisi
 smaller than `-1.79769313486232e+308` and values greater than `1.79769313486232e+308` will be stored as NaN internally
 and be serialized to `null`.
 
+During deserialization (from JSON text or any of the binary formats), a finite number that does not fit into
+`number_float_t` is rejected with [`out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406), for
+example a double-precision number in a binary format when `number_float_t` is `#!cpp float`.
+
 ### Storage
 
 Floating-point number values are stored directly inside a `basic_json` type.

docs/mkdocs/docs/api/basic_json/number_integer_t.md

@@ -47,8 +47,9 @@ With the default values for `NumberIntegerType` (`std::int64_t`), the default va
 
 When the default type is used, the maximal integer number that can be stored is `9223372036854775807` (INT64_MAX) and
 the minimal integer number that can be stored is `-9223372036854775808` (INT64_MIN). Integer numbers that are out of
-range will yield over/underflow when used in a constructor. During deserialization, too large or small integer numbers
+range will yield over/underflow when used in a constructor. During deserialization (from JSON text or any of the binary
-will automatically be stored as [`number_unsigned_t`](number_unsigned_t.md) or [`number_float_t`](number_float_t.md).
+formats), too large or small integer numbers will automatically be stored as [`number_unsigned_t`](number_unsigned_t.md)
+or [`number_float_t`](number_float_t.md).
 
 [RFC 8259](https://tools.ietf.org/html/rfc8259) further states:
 > Note that when such software is used, numbers that are integers and are in the range [-2<sup>53</sup>+1, 2<sup>53</sup>-1] are

docs/mkdocs/docs/api/basic_json/number_unsigned_t.md

@@ -48,8 +48,9 @@ With the default values for `NumberUnsignedType` (`std::uint64_t`), the default
 
 When the default type is used, the maximal integer number that can be stored is `18446744073709551615` (UINT64_MAX) and
 the minimal integer number that can be stored is `0`. Integer numbers that are out of range will yield over/underflow
-when used in a constructor. During deserialization, too large or small integer numbers will automatically be stored
+when used in a constructor. During deserialization (from JSON text or any of the binary formats), too large or small
-as [`number_integer_t`](number_integer_t.md) or [`number_float_t`](number_float_t.md).
+integer numbers will automatically be stored as [`number_integer_t`](number_integer_t.md) or
+[`number_float_t`](number_float_t.md).
 
 [RFC 8259](https://tools.ietf.org/html/rfc8259) further states:
 > Note that when such software is used, numbers that are integers and are in the range [-2<sup>53</sup>+1, 2<sup>53</sup>-1] are

docs/mkdocs/docs/api/basic_json/operator[].md

@@ -275,6 +275,8 @@ Strong exception safety: if an exception occurs, the original value stays intact
 - documentation on [runtime assertions](../../features/assertions.md)
 - see [`at`](at.md) for access by reference with range checking
 - see [`value`](value.md) for access with default value
+- [basic_json_view::operator[]](../basic_json_view/operator%5B%5D.md) - the same access on a zero-copy view (always
+  returns a discarded view instead of assuming undefined behavior)
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/sax_parse.md

@@ -8,7 +8,8 @@ static bool sax_parse(InputType&& i,
                       input_format_t format = input_format_t::json,
                       const bool strict = true,
                       const bool ignore_comments = false,
-                      const bool ignore_trailing_commas = false);
+                      const bool ignore_trailing_commas = false,
+                      const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error);
 
 // (2)
 template<class IteratorType, class SAX, class SentinelType = IteratorType>
@@ -17,13 +18,14 @@ static bool sax_parse(IteratorType first, SentinelType last,
                       input_format_t format = input_format_t::json,
                       const bool strict = true,
                       const bool ignore_comments = false,
-                      const bool ignore_trailing_commas = false);
+                      const bool ignore_trailing_commas = false,
+                      const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error);
 ```
 
 Read from input and generate SAX events
 
 1. Read from a compatible input.
-2. Read from a pair of character iterators, or an iterator and a sentinel of a different type (C++20 ranges support)
+2. Read from a pair of character iterators, or an iterator and a sentinel of a different type (C++20 ranges support).
     
     The value_type of the iterator must be an integral type with a size of 1, 2, or 4 bytes, which will be interpreted
     respectively as UTF-8, UTF-16, and UTF-32. If `SentinelType` differs from `IteratorType`, it must be comparable to
@@ -82,6 +84,10 @@ The SAX event lister must follow the interface of [`json_sax`](../json_sax/index
 :   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)
 
+`tag_handler` (in)
+:   how to handle CBOR tags; see [`cbor_tag_handler_t`](cbor_tag_handler_t.md). Ignored for formats other than CBOR
+    (optional, `cbor_tag_handler_t::error` by default).
+
 `first` (in)
 :   iterator to the start of a character range
 
@@ -137,6 +143,7 @@ A UTF-8 byte order mark is silently ignored.
 - Added in version 3.2.0.
 - Ignoring comments via `ignore_comments` added in version 3.9.0.
 - Added `ignore_trailing_commas` in version 3.13.0.
+- Added `tag_handler` 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

docs/mkdocs/docs/api/basic_json/size.md

@@ -55,6 +55,7 @@ JSON value which is `1` in the case of a string.
 
 - [empty](empty.md) checks whether the JSON value has no elements
 - [max_size](max_size.md) returns the maximum possible number of elements
+- [basic_json_view::size](../basic_json_view/size.md) - the same function on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/to_bjdata.md

@@ -68,6 +68,8 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
   not valid UTF-8 and `error_handler` is `strict` (the default only if
   [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
+- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if `j` or a value nested in it is
+  discarded; example: `"cannot serialize discarded value to BJData"`
 
 ## Complexity
 
@@ -120,3 +122,5 @@ Linear in the size of the JSON value `j`.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
   that is not valid UTF-8 unchanged, as before; `strict` (the default if
   [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
+- Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
+  array or object was silently skipped, producing invalid BJData.

docs/mkdocs/docs/api/basic_json/to_bson.md

@@ -58,6 +58,9 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key is
   not valid UTF-8 and `error_handler` is `strict` (the default only if
   [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
+- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if a value nested in `j` is discarded
+  (the top-level value itself is covered by `type_error.317` above, since it must be an object); example:
+  `"cannot serialize discarded value to BSON"`
 
 ## Complexity
 
@@ -110,6 +113,8 @@ pass before anything is written.
 - Throws `out_of_range.412` and `out_of_range.415` since version 3.13.0.
 - Linear in the size of `j`, and no longer limited by the call stack for deeply nested values, since version 3.13.0.
 - `out_of_range.415` is now detected before anything is written, like the other exceptions above, since version 3.13.0.
+- Throws `type_error.321` for a discarded value nested in `j` since version 3.13.0; previously, it was silently
+  skipped, producing a document whose declared size did not match what was actually written.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
   that is not valid UTF-8 unchanged, as before; `strict` (the default if
   [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316` before anything

docs/mkdocs/docs/api/basic_json/to_cbor.md

@@ -49,6 +49,8 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
   not valid UTF-8 and `error_handler` is `strict` (the default only if
   [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
+- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if `j` or a value nested in it is
+  discarded; example: `"cannot serialize discarded value to CBOR"`
 
 ## Complexity
 
@@ -86,3 +88,5 @@ Linear in the size of the JSON value `j`.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
   that is not valid UTF-8 unchanged, as before; `strict` (the default if
   [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
+- Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
+  array or object was silently skipped, producing invalid CBOR.

docs/mkdocs/docs/api/basic_json/to_msgpack.md

@@ -54,6 +54,8 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
   `"subtype 70000 is too large for the MessagePack ext type (max 255)"`
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
   not valid UTF-8 and `error_handler` is `strict`
+- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if `j` or a value nested in it is
+  discarded; example: `"cannot serialize discarded value to MessagePack"`
 
 ## Complexity
 
@@ -108,3 +110,5 @@ Linear in the size of the JSON value `j`.
 - 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`.
+- Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
+  array or object was silently skipped, producing invalid MessagePack.

docs/mkdocs/docs/api/basic_json/to_ubjson.md

@@ -61,6 +61,8 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
   not valid UTF-8 and `error_handler` is `strict` (the default only if
   [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
+- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if `j` or a value nested in it is
+  discarded; example: `"cannot serialize discarded value to UBJSON"`
 
 ## Complexity
 
@@ -112,3 +114,5 @@ Linear in the size of the JSON value `j`.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
   that is not valid UTF-8 unchanged, as before; `strict` (the default if
   [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
+- Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
+  array or object was silently skipped, producing invalid UBJSON.

docs/mkdocs/docs/api/basic_json/type.md

@@ -52,6 +52,7 @@ Constant.
 - [operator value_t](operator_value_t.md) implicit conversion operator equivalent to this named member function
 - [type_name](type_name.md) returns the type as a string, for use in error messages
 - [value_t](value_t.md) the enumeration of JSON types
+- [basic_json_view::type](../basic_json_view/type.md) - the same function on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/type_name.md

@@ -56,6 +56,7 @@ Constant.
 
 - [type](type.md) returns the type of the JSON value
 - [value_t](value_t.md) the enumeration of JSON types
+- [basic_json_view::type_name](../basic_json_view/type_name.md) - the same function on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/value.md

@@ -216,6 +216,7 @@ changes to any JSON value.
 
 - see [`at`](at.md) for access by reference with range checking
 - see [`operator[]`](operator%5B%5D.md) for unchecked access by reference
+- [basic_json_view::value](../basic_json_view/value.md) - the same access on a zero-copy view
 
 ## Version history
 

docs/mkdocs/docs/api/basic_json/with_t.md

@@ -0,0 +1,136 @@
+# <small>nlohmann::basic_json::</small>with_t
+
+Member alias templates `with_object_t`, `with_array_t`, `with_string_t`, `with_boolean_t`, `with_integers_t`,
+`with_float_t`, `with_allocator_t`, `with_json_serializer_t`, `with_binary_t`, and `with_base_class_t`.
+
+```cpp
+template<template<typename, typename, typename...> class ObjectType2>
+using with_object_t = basic_json<ObjectType2, ArrayType, StringType, BooleanType,
+      NumberIntegerType, NumberUnsignedType, NumberFloatType,
+      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
+
+template<template<typename, typename...> class ArrayType2>
+using with_array_t = basic_json<ObjectType, ArrayType2, StringType, BooleanType,
+      NumberIntegerType, NumberUnsignedType, NumberFloatType,
+      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
+
+template<class StringType2>
+using with_string_t = basic_json<ObjectType, ArrayType, StringType2, BooleanType,
+      NumberIntegerType, NumberUnsignedType, NumberFloatType,
+      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
+
+template<class BooleanType2>
+using with_boolean_t = basic_json<ObjectType, ArrayType, StringType, BooleanType2,
+      NumberIntegerType, NumberUnsignedType, NumberFloatType,
+      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
+
+template<class NumberIntegerType2, class NumberUnsignedType2>
+using with_integers_t = basic_json<ObjectType, ArrayType, StringType, BooleanType,
+      NumberIntegerType2, NumberUnsignedType2, NumberFloatType,
+      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
+
+template<class NumberFloatType2>
+using with_float_t = basic_json<ObjectType, ArrayType, StringType, BooleanType,
+      NumberIntegerType, NumberUnsignedType, NumberFloatType2,
+      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
+
+template<template<typename> class AllocatorType2>
+using with_allocator_t = basic_json<ObjectType, ArrayType, StringType, BooleanType,
+      NumberIntegerType, NumberUnsignedType, NumberFloatType,
+      AllocatorType2, JSONSerializer, BinaryType, CustomBaseClass>;
+
+template<template<typename, typename = void> class JSONSerializer2>
+using with_json_serializer_t = basic_json<ObjectType, ArrayType, StringType, BooleanType,
+      NumberIntegerType, NumberUnsignedType, NumberFloatType,
+      AllocatorType, JSONSerializer2, BinaryType, CustomBaseClass>;
+
+template<class BinaryType2>
+using with_binary_t = basic_json<ObjectType, ArrayType, StringType, BooleanType,
+      NumberIntegerType, NumberUnsignedType, NumberFloatType,
+      AllocatorType, JSONSerializer, BinaryType2, CustomBaseClass>;
+
+template<class CustomBaseClass2>
+using with_base_class_t = basic_json<ObjectType, ArrayType, StringType, BooleanType,
+      NumberIntegerType, NumberUnsignedType, NumberFloatType,
+      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass2>;
+```
+
+These member alias templates make it easier to create a `basic_json` type that is identical to the current type except
+for one (or, in the case of `with_integers_t`, two) of its [template parameters](index.md#template-parameters).
+Spelling out all 11 template parameters of `basic_json` just to change a single one is verbose and error-prone; these
+aliases only require the replacement type(s).
+
+with_object_t&lt;ObjectType2&gt;
+:   replaces `ObjectType`
+
+with_array_t&lt;ArrayType2&gt;
+:   replaces `ArrayType`
+
+with_string_t&lt;StringType2&gt;
+:   replaces `StringType`
+
+with_boolean_t&lt;BooleanType2&gt;
+:   replaces `BooleanType`
+
+with_integers_t&lt;NumberIntegerType2, NumberUnsignedType2&gt;
+:   replaces both `NumberIntegerType` and `NumberUnsignedType`; the two are combined into a single alias because they
+    are usually changed together (for instance, when switching to fixed-width integer types)
+
+with_float_t&lt;NumberFloatType2&gt;
+:   replaces `NumberFloatType`
+
+with_allocator_t&lt;AllocatorType2&gt;
+:   replaces `AllocatorType`
+
+with_json_serializer_t&lt;JSONSerializer2&gt;
+:   replaces `JSONSerializer`
+
+with_binary_t&lt;BinaryType2&gt;
+:   replaces `BinaryType`
+
+with_base_class_t&lt;CustomBaseClass2&gt;
+:   replaces `CustomBaseClass`; see also [`json_base_class_t`](json_base_class_t.md)
+
+## Notes
+
+All other template parameters are kept unchanged, so the resulting type still uses, for instance, the same
+`ObjectType` unless `with_object_t` itself is used.
+
+The aliases are members of every `basic_json` specialization, including [`ordered_json`](../ordered_json.md), and the
+type they produce is again a `basic_json` specialization. They can therefore be chained to replace several template
+parameters at once:
+
+```cpp
+using my_json = nlohmann::json::with_integers_t<int, unsigned int>::with_float_t<float>;
+using my_ordered_json = nlohmann::ordered_json::with_string_t<std::wstring>;
+```
+
+The result is the same type as spelling out all template parameters, so the order of the chained aliases does not
+matter. For instance, `nlohmann::json::with_object_t<nlohmann::ordered_map>` is `nlohmann::ordered_json`.
+
+## Examples
+
+??? example
+
+    The following code shows how `with_object_t` can be used to create a JSON type that stores object elements in a
+    `std::map` and therefore keeps them sorted by key, unlike the default type which preserves insertion order
+    only when `nlohmann::ordered_json` is used.
+
+    ```cpp
+    --8<-- "examples/with_t.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/with_t.output"
+    ```
+
+## See also
+
+- [basic_json](index.md#template-parameters) - the template parameters that can be replaced
+- [json_base_class_t](json_base_class_t.md) - the type used for `CustomBaseClass`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_document/accept.md

@@ -0,0 +1,67 @@
+# <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.

docs/mkdocs/docs/api/basic_json_document/basic_json_document.md

@@ -0,0 +1,58 @@
+# <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.

docs/mkdocs/docs/api/basic_json_document/index.md

@@ -0,0 +1,56 @@
+# <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.

docs/mkdocs/docs/api/basic_json_document/is_discarded.md

@@ -0,0 +1,49 @@
+# <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.

docs/mkdocs/docs/api/basic_json_document/memory_usage.md

@@ -0,0 +1,50 @@
+# <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.

docs/mkdocs/docs/api/basic_json_document/node_count.md

@@ -0,0 +1,49 @@
+# <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.

docs/mkdocs/docs/api/basic_json_document/owns_source.md

@@ -0,0 +1,49 @@
+# <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.

docs/mkdocs/docs/api/basic_json_document/parse.md

@@ -0,0 +1,139 @@
+# <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.

docs/mkdocs/docs/api/basic_json_document/parse_copy.md

@@ -0,0 +1,77 @@
+# <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.

docs/mkdocs/docs/api/basic_json_document/read.md

@@ -0,0 +1,76 @@
+# <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.

docs/mkdocs/docs/api/basic_json_document/root.md

@@ -0,0 +1,50 @@
+# <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.

docs/mkdocs/docs/api/basic_json_document/shrink_to_fit.md

@@ -0,0 +1,58 @@
+# <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.

docs/mkdocs/docs/api/basic_json_document/source.md

@@ -0,0 +1,48 @@
+# <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.

docs/mkdocs/docs/api/basic_json_view/at.md

@@ -0,0 +1,132 @@
+# <small>nlohmann::basic_json_view::</small>at
+
+```cpp
+// (1)
+basic_json_view at(string_view_t key) const;
+basic_json_view at(const char* key) const;
+basic_json_view at(const string_t& key) const;
+
+// (2)
+basic_json_view at(size_type idx) const;
+basic_json_view at(int idx) const;
+
+// (3)
+basic_json_view at(const json_pointer& ptr) const;
+```
+
+1. Returns the value of the object member with key `key` -- the first one, should the key occur more than once (see
+   [Notes on duplicate keys](operator[].md#notes)).
+2. Returns the array element at index `idx`.
+3. Returns the value a JSON pointer `ptr` refers to, starting at this value.
+
+## Parameters
+
+`key` (in)
+:   object key of the element to access
+
+`idx` (in)
+:   index of the element to access
+
+`ptr` (in)
+:   JSON pointer to the element to access
+
+## Return value
+
+1. the value of the first member with key `key`
+2. the element at index `idx`
+3. the value `ptr` resolves to, starting at this value
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+
+## Exceptions
+
+1. The function can throw the following exceptions, both with the same message as the corresponding call to
+   [`BasicJsonType::at`](../basic_json/at.md):
+    - Throws [`type_error.304`](../../home/exceptions.md#jsonexceptiontype_error304) if the value is not an object.
+    - Throws [`out_of_range.403`](../../home/exceptions.md#jsonexceptionout_of_range403) if no member has key `key`.
+2. The function can throw the following exceptions, both with the same message as the corresponding call to
+   [`BasicJsonType::at`](../basic_json/at.md):
+    - Throws [`type_error.304`](../../home/exceptions.md#jsonexceptiontype_error304) if the value is not an array.
+    - Throws [`out_of_range.401`](../../home/exceptions.md#jsonexceptionout_of_range401) if `#!cpp idx >= size()`.
+3. The function can throw the following exceptions, all with the same message as the corresponding call to
+   [`BasicJsonType::at`](../basic_json/at.md):
+    - Throws [`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106) if an array index in `ptr`
+      begins with `#!cpp '0'`.
+    - Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) if an array index in `ptr` is
+      not a number.
+    - Throws [`out_of_range.401`](../../home/exceptions.md#jsonexceptionout_of_range401) if an array index in `ptr`
+      is out of range.
+    - Throws [`out_of_range.402`](../../home/exceptions.md#jsonexceptionout_of_range402) if a reference token is
+      `#!cpp "-"` at an array -- `at` never inserts an element, so `#!cpp "-"` is always invalid.
+    - Throws [`out_of_range.403`](../../home/exceptions.md#jsonexceptionout_of_range403) if a reference token names
+      an object member that does not exist.
+    - Throws [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) if `ptr` cannot be resolved
+      because a reference token is used on a primitive value.
+
+None of these exceptions carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no
+`BasicJsonType` value to point at, so the exception is created without one, even if `BasicJsonType` was built with
+`JSON_DIAGNOSTICS` enabled.
+
+## Complexity
+
+1. Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
+   another, in document order, stopping at the first match. Each comparison first checks the key's length --
+   already known from the index, without reading the key bytes -- before comparing its content.
+2. Linear in `idx`: elements are skipped one at a time from the first one, since they are not a fixed size in the
+   index (unlike `BasicJsonType`'s array, which is random-access).
+3. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
+   that level (as 1.) or the index into the array (as 2.).
+
+## Notes
+
+Unlike [`operator[]`](operator[].md), which returns a [discarded](is_discarded.md) view for a missing key or an
+out-of-range index, `at` always throws -- exactly as `BasicJsonType::at` does, and with the same messages, so
+existing error handling written against `BasicJsonType::at` keeps working unchanged when switched to a view. This
+also holds for overload 3: unlike [`operator[]`](operator[].md) with a JSON pointer, which returns a discarded view
+for a missing key or an out-of-range index, `at` throws for those too (`out_of_range.403`/`out_of_range.401`).
+
+## Examples
+
+??? example "Example: (1)/(2) access specified element with bounds checking"
+
+    The example below reads required fields out of a service configuration with `at`, and shows that the exceptions
+    it throws -- for a wrong type and for a missing key -- carry the same messages
+    [`BasicJsonType::at`](../basic_json/at.md) would produce for the same JSON text.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__at.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__at.output"
+    ```
+
+??? example "Example: (3) access specified element via JSON pointer with bounds checking"
+
+    The example below shows that `at` with a JSON pointer throws exactly the exceptions, with exactly the messages,
+    that [`BasicJsonType::at`](../basic_json/at.md) throws for the same pointer and the same document.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__at_json_pointer.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__at_json_pointer.output"
+    ```
+
+## See also
+
+- [operator[]](operator[].md) - access specified element (returns a discarded view instead of throwing)
+- [front](front.md), [back](back.md) - access the first or last element
+- [`BasicJsonType::at`](../basic_json/at.md) - the corresponding function of `basic_json`
+- [`json_pointer`](../json_pointer/index.md) - JSON pointer type used by overload 3
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/back.md

@@ -0,0 +1,64 @@
+# <small>nlohmann::basic_json_view::</small>back
+
+```cpp
+basic_json_view back() const;
+```
+
+Returns the last element of an array, the last member value of an object, or the value itself if it is primitive
+(as for [`BasicJsonType::back()`](../basic_json/back.md), a primitive value is a range of one element).
+
+## Return value
+
+The last element or member value. For a primitive value (number, string, boolean), the value itself.
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+
+## Exceptions
+
+Throws [`invalid_iterator.214`](../../home/exceptions.md#jsonexceptioninvalid_iterator214) if the view is
+[null](is_null.md) or [discarded](is_discarded.md), or if it is an empty array or object.
+
+This exception does not carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no
+`BasicJsonType` value to point at, so the exception is created without one, even if `BasicJsonType` was built with
+`JSON_DIAGNOSTICS` enabled.
+
+## Complexity
+
+Linear in the size of the array or object: unlike [`front()`](front.md), which only ever looks at the first
+element, `back()` has to walk every element to find where they end, since elements are not a fixed size in the
+index.
+
+## Notes
+
+Unlike [`BasicJsonType::back()`](../basic_json/back.md), which has undefined behavior for an empty array or object,
+`back()` throws `invalid_iterator.214` in that case -- the same way it already does for `#!json null` and for a
+discarded view, where `BasicJsonType::back()` also throws.
+
+## Examples
+
+??? example
+
+    The example below reads only the final status of a build log with `back()`. Even though `back()` is linear in
+    the number of events (unlike [`front()`](front.md), which is constant), it still avoids building a
+    `BasicJsonType` value for the events that are not needed.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__back.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__back.output"
+    ```
+
+## See also
+
+- [front](front.md) - access the first element
+- [`BasicJsonType::back`](../basic_json/back.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/basic_json_view.md

@@ -0,0 +1,52 @@
+# <small>nlohmann::basic_json_view::</small>basic_json_view
+
+```cpp
+basic_json_view() noexcept = default;
+```
+
+Creates an invalid (discarded) view: [`type()`](type.md) is `#!cpp value_t::discarded`,
+[`is_discarded()`](is_discarded.md) is `#!cpp true`, and `#!cpp explicit operator bool()` is `#!cpp false`.
+
+This is the only constructor a caller can use directly. Every other view is obtained from a
+[`basic_json_document`](../basic_json_document/index.md), via [`root()`](../basic_json_document/root.md) or by
+navigating into a container with [`operator[]`](operator[].md), [`at`](at.md), [`front`](front.md), [`back`](back.md),
+[`find`](find.md), or iteration.
+
+## Exception safety
+
+No-throw guarantee: this constructor never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Notes
+
+`basic_json_view` is trivially copyable (it holds two pointers), so a default-constructed view can be used as a
+placeholder for "no value yet" and later be assigned a real view.
+
+## Examples
+
+??? example
+
+    The example below shows the default constructor and that a `basic_json_view` is a small, copyable handle.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__basic_json_view.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__basic_json_view.output"
+    ```
+
+## See also
+
+- [is_discarded](is_discarded.md) - return whether the view is invalid
+- [operator bool](operator_bool.md) - return whether the view refers to a value
+- [root](../basic_json_document/root.md) - the view of a document's root value
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/begin.md

@@ -0,0 +1,61 @@
+# <small>nlohmann::basic_json_view::</small>begin
+
+```cpp
+iterator begin() const noexcept;
+```
+
+Returns an iterator to the first element of an array, or the first member value of an object, in **document order**
+-- the order the values appear in the source text, not sorted by key. A primitive value iterates as a range of one
+element (itself); `#!json null` and a [discarded](is_discarded.md) view iterate as an empty range.
+
+## Return value
+
+Iterator to the first element.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Notes
+
+For an object, iteration visits **every** member, including all occurrences of a duplicate key -- unlike
+[`operator[]`](operator[].md), [`at`](at.md), [`find`](find.md), [`contains`](contains.md), and [`count`](count.md),
+which all resolve to the *first* member with a given key. See the
+[Notes on duplicate keys](operator[].md#notes) of `operator[]`.
+
+Because objects are iterated in document order rather than sorted by key, the order seen here can differ from what
+iterating the [`materialize()`](materialize.md)d `BasicJsonType` value would produce: a `#!cpp basic_json` object
+(`std::map`-backed by default) sorts its keys, while a view does not.
+
+## Examples
+
+??? example
+
+    The example below iterates a log record's members with `begin()`/[`end()`](end.md) and prints them in the order
+    they were written. Materializing the record into a `BasicJsonType` object and iterating that would instead print
+    the members sorted by key.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__begin.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__begin.output"
+    ```
+
+## See also
+
+- [end](end.md) - returns an iterator to one past the last element
+- [cbegin](cbegin.md) - returns a const iterator to the first element
+- [items](items.md) - access iterator member functions in range-based for
+- [`BasicJsonType::begin`](../basic_json/begin.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/cbegin.md

@@ -0,0 +1,49 @@
+# <small>nlohmann::basic_json_view::</small>cbegin
+
+```cpp
+iterator cbegin() const noexcept;
+```
+
+Returns an iterator to the first element, in [document order](begin.md). Equivalent to [`begin()`](begin.md): a view
+is always read-only, so `#!cpp const_iterator` and `#!cpp iterator` are the same type, and `cbegin()` exists only so
+that generic code that expects a `cbegin()`/`cend()` pair works with a view too.
+
+## Return value
+
+Iterator to the first element; identical to what [`begin()`](begin.md) returns.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Examples
+
+??? example
+
+    The example below sums many measurements with `std::accumulate`, using `cbegin()`/[`cend()`](cend.md) as the
+    range -- the same way it would for any standard container -- without ever materializing the whole array into a
+    `BasicJsonType` value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__cbegin.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__cbegin.output"
+    ```
+
+## See also
+
+- [begin](begin.md) - returns an iterator to the first element
+- [cend](cend.md) - returns a const iterator to one past the last element
+- [`BasicJsonType::cbegin`](../basic_json/cbegin.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/cend.md

@@ -0,0 +1,49 @@
+# <small>nlohmann::basic_json_view::</small>cend
+
+```cpp
+iterator cend() const noexcept;
+```
+
+Returns an iterator to one past the last element, in [document order](begin.md). Equivalent to [`end()`](end.md): a
+view is always read-only, so `#!cpp const_iterator` and `#!cpp iterator` are the same type, and `cend()` exists only
+so that generic code that expects a `cbegin()`/`cend()` pair works with a view too.
+
+## Return value
+
+Iterator one past the last element; identical to what [`end()`](end.md) returns.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Examples
+
+??? example
+
+    The example below checks that every record of a batch is an object with `std::all_of`, using
+    [`cbegin()`](cbegin.md)/`cend()` as the range -- the same way it would for any standard container -- before
+    materializing any record of the batch.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__cend.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__cend.output"
+    ```
+
+## See also
+
+- [end](end.md) - returns an iterator to one past the last element
+- [cbegin](cbegin.md) - returns a const iterator to the first element
+- [`BasicJsonType::cend`](../basic_json/cend.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/contains.md

@@ -0,0 +1,101 @@
+# <small>nlohmann::basic_json_view::</small>contains
+
+```cpp
+// (1)
+bool contains(string_view_t key) const;
+bool contains(const char* key) const;
+bool contains(const string_t& key) const;
+
+// (2)
+bool contains(const json_pointer& ptr) const;
+```
+
+1. Checks whether the value is an object with a member with key `key`.
+2. Checks whether a JSON pointer `ptr` can be resolved, starting at this value.
+
+## Parameters
+
+`key` (in)
+:   key value to check its existence
+
+`ptr` (in)
+:   JSON pointer to check its existence
+
+## Return value
+
+1. `#!cpp true` if the value is an object and has a member with key `key`, `#!cpp false` otherwise
+2. `#!cpp true` if `ptr` can be resolved to a value starting at this view, `#!cpp false` otherwise
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+1. Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
+   another, in document order, stopping at the first match. Each comparison first checks the key's length -- already
+   known from the index, without reading the key bytes -- before comparing its content.
+2. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
+   that level or the index into the array -- as for [`operator[]`](operator[].md#complexity) and
+   [`at`](at.md#complexity) with a JSON pointer.
+
+## Notes
+
+Overload 1 always returns `#!cpp false` when the value is not an object -- including a [discarded](is_discarded.md)
+view.
+
+!!! info "Postconditions"
+
+    If `#!cpp v.contains(key)` returns `#!cpp true`, then `#!cpp v[key]` is not [discarded](is_discarded.md). If
+    `#!cpp v.contains(ptr)` returns `#!cpp true`, then `#!cpp v[ptr]` is not discarded and `#!cpp v.at(ptr)` does not
+    throw.
+
+!!! info "Overload 2 never throws"
+
+    Unlike [`BasicJsonType::contains(const json_pointer&)`](../basic_json/contains.md), which can throw for certain
+    malformed pointers (for instance an empty array-index reference token), overload 2 never throws: a missing key,
+    an out-of-range or malformed array index, a `#!cpp "-"` index, or a reference token used on a primitive all
+    simply make it return `#!cpp false`.
+
+## Examples
+
+??? example "Example: (1) check with key"
+
+    The example below counts how many of a batch of records carry an optional `retry_of` field, using `contains()`
+    to check without ever materializing a single record of the batch.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__contains.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__contains.output"
+    ```
+
+??? example "Example: (2) check with JSON pointer"
+
+    The example below checks an optional, nested field with a JSON pointer, and shows two pointers that
+    `#!cpp contains()` resolves to `#!cpp false` without throwing.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__contains_json_pointer.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__contains_json_pointer.output"
+    ```
+
+## See also
+
+- [find](find.md) - find a value in an object
+- [count](count.md) - returns the number of occurrences of a key
+- [at](at.md), [operator[]](operator[].md) - resolve a JSON pointer and throw, or return a discarded view
+- [`BasicJsonType::contains`](../basic_json/contains.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/count.md

@@ -0,0 +1,66 @@
+# <small>nlohmann::basic_json_view::</small>count
+
+```cpp
+size_type count(string_view_t key) const;
+size_type count(const char* key) const;
+size_type count(const string_t& key) const;
+```
+
+Returns `#!cpp 1` if the value is an object with a member with key `key`, `#!cpp 0` otherwise.
+
+## Parameters
+
+`key` (in)
+:   key value of the element to count
+
+## Return value
+
+`#!cpp 1` if the value is an object and has a member with key `key`, `#!cpp 0` otherwise.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
+another, in document order, stopping at the first match. Each comparison first checks the key's length -- already
+known from the index, without reading the key bytes -- before comparing its content.
+
+## Notes
+
+This method always returns `#!cpp 0` when the value is not an object -- including a [discarded](is_discarded.md)
+view.
+
+Unlike [`BasicJsonType::count()`](../basic_json/count.md), whose return value can in principle exceed `#!cpp 1` for
+an `ObjectType` that allows multiple entries per key, `count()` here never does: it is exactly
+[`contains()`](contains.md) as `#!cpp 0`/`#!cpp 1`. This holds even if the source text has a duplicate key -- see the
+[Notes on duplicate keys](operator[].md#notes) of `operator[]` -- because a `#!cpp count() > 1` result would require
+counting every member with a matching key, not just finding the first one.
+
+## Examples
+
+??? example
+
+    The example below validates that every transaction of a batch carries a mandatory `amount` field, using
+    `count()` before deciding whether to materialize a transaction at all.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__count.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__count.output"
+    ```
+
+## See also
+
+- [find](find.md) - find a value in an object
+- [contains](contains.md) - checks whether a key exists
+- [`BasicJsonType::count`](../basic_json/count.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/empty.md

@@ -0,0 +1,61 @@
+# <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.

docs/mkdocs/docs/api/basic_json_view/end.md

@@ -0,0 +1,54 @@
+# <small>nlohmann::basic_json_view::</small>end
+
+```cpp
+iterator end() const noexcept;
+```
+
+Returns an iterator to one past the last element of an array, one past the last member value of an object, in
+**document order** -- see [`begin()`](begin.md). A primitive value iterates as a range of one element (itself);
+`#!json null` and a [discarded](is_discarded.md) view iterate as an empty range, so `#!cpp begin() == end()` for
+them.
+
+## Return value
+
+Iterator one past the last element.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Notes
+
+`#!cpp iterator` is a forward iterator: unlike `BasicJsonType::iterator`, it cannot be decremented, so there is no
+way to reach the last element by stepping back from `end()`. Use [`back()`](back.md) instead.
+
+## Examples
+
+??? example
+
+    The example below scans a (possibly large) array of readings for the first one over a threshold, stopping the
+    loop at `end()` as soon as one is found. Only the matching reading, if any, is ever materialized.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__end.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__end.output"
+    ```
+
+## See also
+
+- [begin](begin.md) - returns an iterator to the first element
+- [cend](cend.md) - returns a const iterator to one past the last element
+- [`BasicJsonType::end`](../basic_json/end.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/find.md

@@ -0,0 +1,63 @@
+# <small>nlohmann::basic_json_view::</small>find
+
+```cpp
+iterator find(string_view_t key) const;
+iterator find(const char* key) const;
+iterator find(const string_t& key) const;
+```
+
+Finds a member with key `key` -- the first one, should the key occur more than once (see
+[Notes on duplicate keys](operator[].md#notes)). If the value is not an object, or no member has this key,
+[`end()`](end.md) is returned.
+
+## Parameters
+
+`key` (in)
+:   key value of the element to search for
+
+## Return value
+
+An iterator to the member with key `key`, or [`end()`](end.md) if there is none or the value is not an object.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
+another, in document order, stopping at the first match. Each comparison first checks the key's length -- already
+known from the index, without reading the key bytes -- before comparing its content.
+
+## Notes
+
+Unlike [`BasicJsonType::find`](../basic_json/find.md), which always returns `#!cpp end()` for a non-object type, this
+also does so for a [discarded](is_discarded.md) view -- there is no separate "invalid" iterator to return.
+
+## Examples
+
+??? example
+
+    The example below scans a batch of events for those that carry an optional `user_id` field, using `find()`
+    instead of [`operator[]`](operator[].md) (which would throw for the events that are not objects at all) or
+    [`contains()`](contains.md) followed by a second lookup. Events without a match are never materialized.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__find.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__find.output"
+    ```
+
+## See also
+
+- [count](count.md) - returns the number of occurrences of a key
+- [contains](contains.md) - checks whether a key exists
+- [`BasicJsonType::find`](../basic_json/find.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/front.md

@@ -0,0 +1,61 @@
+# <small>nlohmann::basic_json_view::</small>front
+
+```cpp
+basic_json_view front() const;
+```
+
+Returns the first element of an array, the first member value of an object, or the value itself if it is primitive
+(as for [`BasicJsonType::front()`](../basic_json/front.md), a primitive value is a range of one element).
+
+## Return value
+
+The first element or member value. For a primitive value (number, string, boolean), the value itself.
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+
+## Exceptions
+
+Throws [`invalid_iterator.214`](../../home/exceptions.md#jsonexceptioninvalid_iterator214) if the view is
+[null](is_null.md) or [discarded](is_discarded.md), or if it is an empty array or object.
+
+This exception does not carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no
+`BasicJsonType` value to point at, so the exception is created without one, even if `BasicJsonType` was built with
+`JSON_DIAGNOSTICS` enabled.
+
+## Complexity
+
+Constant.
+
+## Notes
+
+Unlike [`BasicJsonType::front()`](../basic_json/front.md), which has undefined behavior for an empty array or
+object, `front()` throws `invalid_iterator.214` in that case -- the same way it already does for `#!json null` and
+for a discarded view, where `BasicJsonType::front()` also throws.
+
+## Examples
+
+??? example
+
+    The example below reads only the earliest entry of a build log with `front()`, without materializing the rest
+    of the (possibly long) log.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__front.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__front.output"
+    ```
+
+## See also
+
+- [back](back.md) - access the last element
+- [`BasicJsonType::front`](../basic_json/front.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/get.md

@@ -0,0 +1,130 @@
+# <small>nlohmann::basic_json_view::</small>get
+
+```cpp
+template<typename T>
+T get() const;
+```
+
+Converts the value to `T`.
+
+For the types below, the conversion works directly on the flat index -- no `BasicJsonType` value is built for it:
+
+- `#!cpp bool`
+- arithmetic types other than `#!cpp bool` (from a number; from a boolean, as `#!cpp 0`/`#!cpp 1`, exactly as
+  [`BasicJsonType::get<T>()`](../basic_json/get.md) converts a boolean)
+- `#!cpp std::nullptr_t`
+- `#!cpp std::basic_string<char, Traits, Alloc>` (including `string_t`) -- a copy of the string
+- [`string_view_t`](index.md#member-types) -- **no copy**: the returned view points into the document's
+  [`source()`](../basic_json_document/source.md) text, or, for a string that contains escape sequences, into the
+  document's own buffer of decoded strings (see [`get_string()`](get_string.md))
+- `BasicJsonType` -- equivalent to [`materialize()`](materialize.md)
+- `basic_json_view` -- returns `#!cpp *this`
+- `#!cpp std::vector<U, A>` -- element by element, each converted with `#!cpp get<U>()`; `#!cpp
+  std::vector<basic_json_view>` keeps a view of every element instead of a value
+- `#!cpp std::map<K, V, C, A>` and `#!cpp std::unordered_map<K, V, H, E, A>`, if `K` is constructible from a `#!cpp
+  (const char*, std::size_t)` pair -- member by member, each value converted with `#!cpp get<V>()`; with a repeated
+  key, the *last* value is kept, as [`BasicJsonType::parse()`](../basic_json/parse.md) (and
+  [`materialize()`](materialize.md)) does; `#!cpp std::map<std::string, basic_json_view>` keeps views of the members
+  instead of values
+
+Every other `T` -- `#!cpp std::list`, `#!cpp std::pair`, `#!cpp std::array`, enumerations, user types with a
+`from_json()`, ... -- is converted by `#!cpp materialize().get<T>()`: the subtree is built into a real `BasicJsonType`
+value first (as [`BasicJsonType::parse()`](../basic_json/parse.md) would), and converted from there exactly as
+[`BasicJsonType::get<T>()`](../basic_json/get.md) would convert it.
+
+## Template parameters
+
+`T`
+:   the type to convert the value to
+
+## Return value
+
+the value, converted to `T`
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+
+## Exceptions
+
+- For the directly-converted types listed above (other than `BasicJsonType` and `basic_json_view`, which never
+  throw): throws [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) if the value's type does not
+  match `T` -- the same exception, with the same message, that [`BasicJsonType::get<T>()`](../basic_json/get.md)
+  throws for the same JSON type and `T`.
+- For `#!cpp std::vector<U, A>`: throws `type_error.302` if the value is not an array; otherwise, whatever converting
+  an element to `U` throws.
+- For `#!cpp std::map`/`#!cpp std::unordered_map`: throws `type_error.302` if the value is not an object; otherwise,
+  whatever converting a member to the mapped type throws.
+- For every other `T`: whatever [`materialize().get<T>()`](../basic_json/get.md) throws -- typically `type_error.302`,
+  or whatever a user-provided `from_json()` throws.
+
+None of the exceptions thrown directly by this function (the first three bullets above) carry a
+[`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no `BasicJsonType` value to point at. An
+exception thrown while converting through `materialize()` (the last bullet) is different: it is thrown by a real
+`BasicJsonType` value, so it **does** carry a `JSON_DIAGNOSTICS` path if `BasicJsonType` was built with it enabled.
+
+## Complexity
+
+- `#!cpp bool`, arithmetic types, `#!cpp std::nullptr_t`, [`string_view_t`](index.md#member-types), `basic_json_view`:
+  constant.
+- `#!cpp std::basic_string<char, Traits, Alloc>`: constant, plus one allocation and a copy of the string's bytes.
+- `BasicJsonType`: linear in the size of the subtree, see [`materialize()`](materialize.md).
+- `#!cpp std::vector<U, A>`: linear in the number of elements, times the complexity of converting one element to `U`.
+- `#!cpp std::map`/`#!cpp std::unordered_map`: linear in the number of members for walking them, plus the container's
+  own insertion cost per member (logarithmic for `#!cpp std::map`, amortized constant for `#!cpp
+  std::unordered_map`), times the complexity of converting one member to the mapped type.
+- every other `T`: linear in the size of the subtree (building the `BasicJsonType` value), plus the complexity of
+  [`BasicJsonType::get<T>()`](../basic_json/get.md) on it.
+
+## Notes
+
+!!! info "Floating-point values"
+
+    A floating-point `T` is converted from the same digits the lexer would see during `#!cpp BasicJsonType::parse()`,
+    using the same conversion, so the result is bit-for-bit identical to `#!cpp BasicJsonType::parse(text).get<T>()`
+    for the same source text.
+
+!!! info "Duplicate keys"
+
+    `#!cpp std::map`/`#!cpp std::unordered_map` conversions keep the *last* value of a repeated key, like
+    [`materialize()`](materialize.md) and [`BasicJsonType::parse()`](../basic_json/parse.md) do. This is the opposite
+    of [`operator[]`](operator[].md)/[`at`](at.md)/[`find`](find.md)/[`contains`](contains.md), which resolve to the
+    *first* occurrence (see the [Notes on duplicate keys](operator[].md#notes)).
+
+!!! info "No pointers, references, or implicit conversion"
+
+    Unlike `BasicJsonType`, `basic_json_view` has no stored value anywhere to hand out a pointer or a reference to, so
+    it provides neither `#!cpp get_ptr()`, `#!cpp get_ref()`, nor `#!cpp operator ValueType()`.
+    [`get_string()`](get_string.md) (equivalently, `#!cpp get<string_view_t>()`) is the zero-copy alternative for
+    strings.
+
+## Examples
+
+??? example
+
+    The example below reads typed fields straight into C++ variables, collects a view of every array element with
+    `#!cpp get<std::vector<basic_json_view>>()` instead of a value, and converts a nested object into a user type
+    through its `from_json()` -- which runs on a `BasicJsonType` value `materialize()` builds for just that one
+    member.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__get.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__get.output"
+    ```
+
+## See also
+
+- [get_to](get_to.md) - convert and write into a passed value
+- [get_string](get_string.md) - the string, without a copy
+- [number_token](number_token.md) - a number's token text, without a copy
+- [materialize](materialize.md) - build the `BasicJsonType` value of this subtree
+- [`BasicJsonType::get`](../basic_json/get.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/get_string.md

@@ -0,0 +1,71 @@
+# <small>nlohmann::basic_json_view::</small>get_string
+
+```cpp
+string_view_t get_string() const;
+```
+
+Returns the string value as a [`string_view_t`](index.md#member-types), without copying it.
+
+## Return value
+
+The string, as a [`string_view_t`](index.md#member-types) that points either into the document's
+[`source()`](../basic_json_document/source.md) text (a string with no escape sequences), or into the document's own
+buffer of decoded strings (a string that contains escape sequences, such as `#!json "\n"` or `#!json "\u00e9"`, which
+had to be decoded once when the document was parsed).
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+
+## Exceptions
+
+Throws [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) if the value is not a string; example:
+`"type must be string, but is array"`.
+
+This exception does not carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no
+`BasicJsonType` value to point at, so the exception is created without one, even if `BasicJsonType` was built with
+`JSON_DIAGNOSTICS` enabled.
+
+## Complexity
+
+Constant.
+
+## Notes
+
+`basic_json_view` has no `BasicJsonType` value stored anywhere, so unlike `BasicJsonType`, it has no `get_ref()` to
+hand out a reference to a stored `string_t`. `get_string()` (equivalently, [`get<string_view_t>()`](get.md)) is the
+zero-copy alternative: [`BasicJsonType::get_ref<const string_t&>()`](../basic_json/get_ref.md) is its closest
+counterpart, except that it returns a view instead of a reference to a value that must already exist.
+
+The returned [`string_view_t`](index.md#member-types) is valid exactly as long as the view that produced it -- see the
+[validity rules](index.md) of `basic_json_view` -- and, for a string with no escapes, for as long as the document's
+source text.
+
+## Examples
+
+??? example
+
+    The example below pulls one field out of a JSON text that stands in for a large API response, and shows that no
+    `#!cpp std::string` was allocated for it: the returned view still points inside the original buffer. A field that
+    contains an escape sequence cannot point into the original text -- it was decoded once into the document's own
+    buffer instead -- but still avoids a per-field allocation.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__get_string.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__get_string.output"
+    ```
+
+## See also
+
+- [get](get.md) - convert the value to a given type (`#!cpp get<string_view_t>()` is equivalent to this function)
+- [number_token](number_token.md) - a number's token text, without a copy
+- [`BasicJsonType::get_ref`](../basic_json/get_ref.md) - the closest counterpart of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/get_to.md

@@ -0,0 +1,65 @@
+# <small>nlohmann::basic_json_view::</small>get_to
+
+```cpp
+template<typename T>
+T& get_to(T& v) const;
+```
+
+Converts the value to `T` and assigns it to `v`. Equivalent to
+
+```cpp
+v = get<T>();
+return v;
+```
+
+## Template parameters
+
+`T`
+:   the type to convert the value to
+
+## Parameters
+
+`v` (out)
+:   the variable to store the converted value in
+
+## Return value
+
+`v`, allowing calls to chain
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, `v` is not modified.
+
+## Exceptions
+
+Whatever [`get<T>()`](get.md) throws for the same value and `T`.
+
+## Complexity
+
+Whatever [`get<T>()`](get.md) has for the same `T`.
+
+## Examples
+
+??? example
+
+    The example below reads several fields of a service configuration directly into existing variables, then uses
+    the returned reference to fold the `#!cpp host`/`#!cpp port` pair into a single string in the same expression.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__get_to.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__get_to.output"
+    ```
+
+## See also
+
+- [get](get.md) - convert the value to a given type
+- [`BasicJsonType::get_to`](../basic_json/get_to.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.

docs/mkdocs/docs/api/basic_json_view/index.md

@@ -0,0 +1,115 @@
+# <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, element
+access, lookup, iteration, and conversion -- [`get<T>()`](get.md), [`get_string()`](get_string.md),
+[`number_token()`](number_token.md), and [`materialize()`](materialize.md) to build the `BasicJsonType` value of a
+subtree on demand. [`operator[]`](operator%5B%5D.md), [`at`](at.md), [`contains`](contains.md), and
+[`value`](value.md) also accept a [`json_pointer`](../json_pointer/index.md). It does not (yet) provide `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
+- **iterator**, **const_iterator** - a forward iterator over the elements of an array or the member values of an
+  object, in document order; both names refer to the same type, since a view is always read-only
+- **item** - a (key, value) pair produced by [`items()`](items.md)
+
+## Member functions
+
+- [(constructor)](basic_json_view.md)
+
+### Object inspection
+
+- [**type**](type.md) - return the type of the value
+- [**type_name**](type_name.md) - return the type as string
+- [**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
+
+### Element access
+
+- [**at**](at.md) - access specified element with bounds checking
+- [**operator[]**](operator[].md) - access specified element
+- [**value**](value.md) - access specified element with default value
+- [**front**](front.md) - access the first element
+- [**back**](back.md) - access the last element
+
+### Lookup
+
+- [**find**](find.md) - find an element in an object
+- [**count**](count.md) - returns the number of occurrences of a key in an object
+- [**contains**](contains.md) - check the existence of an element in an object
+
+### Iterators
+
+- [**begin**](begin.md) - returns an iterator to the first element
+- [**cbegin**](cbegin.md) - returns a const iterator to the first element
+- [**end**](end.md) - returns an iterator to one past the last element
+- [**cend**](cend.md) - returns a const iterator to one past the last element
+- [**items**](items.md) - wrapper to access iterator member functions in range-based for
+
+### Capacity
+
+- [**size**](size.md) - return the number of elements
+- [**empty**](empty.md) - return whether the value has no elements
+
+### Conversion
+
+- [**get**](get.md) - get a value
+- [**get_to**](get_to.md) - get a value and write it to a destination
+- [**get_string**](get_string.md) - get a string value without a copy
+- [**number_token**](number_token.md) - get a number's token text without a copy
+- [**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.