Write the floats of json_view from their digits

dump() writes a float token of at most 15 significant digits from its digits, without converting it to a double and back: two decimals of at most 15 digits are farther apart than the rounding interval of a normal double (the argument behind DBL_DIG), so the token's digits are the shortest ones of its double, which the library's conversion (Zmij) writes. The exponent must keep the value away from subnormals and overflow. Longer tokens are converted from the digits already read. Doubles are written into the output directly instead of through a local buffer. With NEON, the fixed layouts ("12.5", "0.001", "100.0") are put together in vector registers by a table lookup of the digit bytes: the portable layout copies the digits through a buffer at another offset, and a load that spans several recent stores waits until they reach the cache. dump() of float-heavy documents: numbers -69%, marine_ik -62%, mesh.pretty -34%, canada (mostly 16 or 17 digits) -14%. Tests: 20,000 float tokens of 1 to 17 significant digits in every spelling (point, exponent, leading and trailing zeros, sign), from about 1e-320 to 1e300, written as json::dump() writes them. On AArch64 they check the NEON layout; x86 and JSON_VIEW_NO_SIMD use the library's. Other float types, now the only ones on the general path, are tested with non-finite values set by edits (written as null). Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Write doubles with the shortest digits (Zmij)
2026-09-29 19:20:30 +00:00 · 2026-09-29 14:03:25 +02:00 · 2026-09-29 14:03:25 +02:00 · 2026-09-29 14:03:24 +02:00 · 2026-09-29 14:03:23 +02:00 · 2026-09-29 14:03:22 +02:00
191 changed files with 21562 additions and 363 deletions
@@ -51,12 +51,13 @@ labels:
    - "include/nlohmann/detail/view/.*"
    - "single_include/nlohmann/json_view\\.hpp"
    - "tests/src/unit-json_view.*"
-    - "tests/src/fuzzer-parse_json_view\\.cpp"
+    - "tests/src/fuzzer-(parse_json_view|json_view_image)\\.cpp"
+    - "tests/benchmarks/json_view/.*"
    - "tools/amalgamate/config_json_view\\.json"
    - "docs/mkdocs/docs/features/json_view\\.md"
    - "docs/mkdocs/docs/api/basic_json_(document|view)/.*"
-    - "docs/mkdocs/docs/api/(ordered_)?json_(document|view)\\.md"
-    - "docs/mkdocs/docs/examples/(basic_json_(document|view)__|(ordered_)?json_(document|view)).*"
+    - "docs/mkdocs/docs/api/(ordered_)?json_(editable_)?(document|view)\\.md"
+    - "docs/mkdocs/docs/examples/(basic_json_(document|view)__|(ordered_)?json_(editable_)?(document|view)).*"
    - "tests/benchmarks/src/benchmarks_view\\.cpp"

 - label: "aspect: json_view"
@@ -0,0 +1,78 @@
+name: "json_view benchmarks"
+
+# On demand only: runs the comparison of json_view with yyjson, simdjson, and
+# Boost.JSON (tests/benchmarks/json_view/compare.py) on GitHub-hosted runners,
+# for numbers from x86-64 and AArch64 Linux. It runs when started by hand, or
+# when a pull request gets the label "benchmark" (on both architectures, with
+# GCC and the default settings). Shared runners are noisy: the results show
+# where json_view stands, but published numbers need a quiet machine (see
+# tests/benchmarks/json_view/README.md).
+
+on:
+  pull_request:
+    types: [labeled]
+  workflow_dispatch:
+    inputs:
+      runner:
+        description: "Runner image"
+        type: choice
+        options:
+          - ubuntu-24.04
+          - ubuntu-24.04-arm
+        default: ubuntu-24.04
+      compiler:
+        description: "Compiler"
+        type: choice
+        options:
+          - g++
+          - clang++
+        default: g++
+      native:
+        description: "Compile for the runner's CPU (-march=native)"
+        type: boolean
+        default: false
+      rounds:
+        description: "Rounds of bench_view"
+        type: number
+        default: 30
+
+permissions:
+  contents: read
+
+jobs:
+  compare:
+    if: github.event_name == 'workflow_dispatch' || github.event.label.name == 'benchmark'
+    strategy:
+      matrix:
+        runner: ${{ fromJSON(github.event_name == 'workflow_dispatch' && format('["{0}"]', inputs.runner) || '["ubuntu-24.04", "ubuntu-24.04-arm"]') }}
+    runs-on: ${{ matrix.runner }}
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        with:
+          egress-policy: audit
+
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+
+      - name: Download test data
+        run: |
+          cmake -S . -B build -DJSON_BuildTests=On
+          cmake --build build --target download_test_data
+
+      - name: Run the comparison
+        env:
+          CXX: ${{ inputs.compiler || 'g++' }}
+          CC: ${{ inputs.compiler == 'clang++' && 'clang' || 'gcc' }}
+          ROUNDS: ${{ inputs.rounds || 30 }}
+          NATIVE: ${{ inputs.native && '--native' || '' }}
+        run: python3 tests/benchmarks/json_view/compare.py --data build/test_files --download --rounds "$ROUNDS" $NATIVE
+
+      - name: Summary
+        run: cat tests/benchmarks/json_view/results/*.md >> "$GITHUB_STEP_SUMMARY"
+
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: json_view-benchmarks-${{ matrix.runner }}-${{ inputs.compiler || 'g++' }}
+          path: tests/benchmarks/json_view/results/
@@ -26,6 +26,7 @@ cc_library(
        "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",
@@ -67,16 +68,27 @@ cc_library(
        "include/nlohmann/detail/string_utils.hpp",
        "include/nlohmann/detail/value_t.hpp",
        "include/nlohmann/detail/view/builder.hpp",
+        "include/nlohmann/detail/view/compare.hpp",
        "include/nlohmann/detail/view/document_data.hpp",
+        "include/nlohmann/detail/view/edit.hpp",
+        "include/nlohmann/detail/view/edit_storage.hpp",
        "include/nlohmann/detail/view/errors.hpp",
+        "include/nlohmann/detail/view/image.hpp",
        "include/nlohmann/detail/view/input.hpp",
+        "include/nlohmann/detail/view/iterator.hpp",
+        "include/nlohmann/detail/view/lookup.hpp",
        "include/nlohmann/detail/view/macro_scope.hpp",
        "include/nlohmann/detail/view/macro_unscope.hpp",
        "include/nlohmann/detail/view/materialize.hpp",
        "include/nlohmann/detail/view/node.hpp",
        "include/nlohmann/detail/view/number.hpp",
+        "include/nlohmann/detail/view/object_index.hpp",
+        "include/nlohmann/detail/view/pointer.hpp",
        "include/nlohmann/detail/view/scan.hpp",
+        "include/nlohmann/detail/view/serializer.hpp",
+        "include/nlohmann/detail/view/simd.hpp",
        "include/nlohmann/detail/view/string_ref.hpp",
+        "include/nlohmann/detail/view/value.hpp",
        "include/nlohmann/json.hpp",
        "include/nlohmann/json_fwd.hpp",
        "include/nlohmann/json_view.hpp",
@@ -1401,10 +1401,12 @@ 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 view's parser (`<nlohmann/json_view.hpp>`) contains techniques and code adapted from [yyjson](https://github.com/ibireme/yyjson) by YaoYuan, which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above): table-driven decoding of `\u` escapes and fixed-offset unrolled checks.
+- The view's parser (`<nlohmann/json_view.hpp>`) validates non-ASCII strings with the vector UTF-8 check of [simdjson](https://github.com/simdjson/simdjson) by Daniel Lemire, Geoff Langdale, John Keiser, and contributors (its "lookup4" algorithm and tables, after J. Keiser and D. Lemire, "Validating UTF-8 In Less Than One Instruction Per Byte", 2021), which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here) and the Apache 2.0 License. Copyright &copy; 2018-2025 The simdjson authors

 <img align="right" src="https://git.fsfe.org/reuse/reuse-ci/raw/branch/master/reuse-horizontal.png" alt="REUSE Software">

@@ -131,19 +131,39 @@ INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::~basic_json', 'Me
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document', 'Class', 'api/basic_json_document/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::basic_json_document', 'Constructor', 'api/basic_json_document/basic_json_document/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::accept', 'Function', 'api/basic_json_document/accept/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::erase', 'Method', 'api/basic_json_document/erase/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::insert', 'Method', 'api/basic_json_document/insert/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::is_discarded', 'Method', 'api/basic_json_document/is_discarded/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::load', 'Function', 'api/basic_json_document/load/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::memory_usage', 'Method', 'api/basic_json_document/memory_usage/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::node_count', 'Method', 'api/basic_json_document/node_count/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::owns_source', 'Method', 'api/basic_json_document/owns_source/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::parse', 'Function', 'api/basic_json_document/parse/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::parse_copy', 'Function', 'api/basic_json_document/parse_copy/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::push_back', 'Method', 'api/basic_json_document/push_back/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::read', 'Method', 'api/basic_json_document/read/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::root', 'Method', 'api/basic_json_document/root/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::save', 'Method', 'api/basic_json_document/save/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::set', 'Method', 'api/basic_json_document/set/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::shrink_to_fit', 'Method', 'api/basic_json_document/shrink_to_fit/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::source', 'Method', 'api/basic_json_document/source/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view', 'Class', 'api/basic_json_view/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::basic_json_view', 'Constructor', 'api/basic_json_view/basic_json_view/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::at', 'Method', 'api/basic_json_view/at/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::back', 'Method', 'api/basic_json_view/back/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::begin', 'Method', 'api/basic_json_view/begin/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::cbegin', 'Method', 'api/basic_json_view/cbegin/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::cend', 'Method', 'api/basic_json_view/cend/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::contains', 'Method', 'api/basic_json_view/contains/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::count', 'Method', 'api/basic_json_view/count/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::dump', 'Method', 'api/basic_json_view/dump/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::empty', 'Method', 'api/basic_json_view/empty/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::end', 'Method', 'api/basic_json_view/end/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::find', 'Method', 'api/basic_json_view/find/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::front', 'Method', 'api/basic_json_view/front/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::get', 'Method', 'api/basic_json_view/get/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::get_string', 'Method', 'api/basic_json_view/get_string/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::get_to', 'Method', 'api/basic_json_view/get_to/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_array', 'Method', 'api/basic_json_view/is_array/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_binary', 'Method', 'api/basic_json_view/is_binary/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_boolean', 'Method', 'api/basic_json_view/is_boolean/index.html');
@@ -157,13 +177,24 @@ INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_object',
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_primitive', 'Method', 'api/basic_json_view/is_primitive/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_string', 'Method', 'api/basic_json_view/is_string/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_structured', 'Method', 'api/basic_json_view/is_structured/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::items', 'Method', 'api/basic_json_view/items/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::materialize', 'Method', 'api/basic_json_view/materialize/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::number_format', 'Enum', 'api/basic_json_view/number_format/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::number_token', 'Method', 'api/basic_json_view/number_token/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator bool', 'Method', 'api/basic_json_view/operator_bool/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator<<', 'Operator', 'api/basic_json_view/operator_ltlt/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator[]', 'Operator', 'api/basic_json_view/operator[]/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator==', 'Operator', 'api/basic_json_view/operator_eq/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator!=', 'Operator', 'api/basic_json_view/operator_ne/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::size', 'Method', 'api/basic_json_view/size/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::source_offset', 'Method', 'api/basic_json_view/source_offset/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::type', 'Method', 'api/basic_json_view/type/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::type_name', 'Method', 'api/basic_json_view/type_name/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::value', 'Method', 'api/basic_json_view/value/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json', 'Class', 'api/json/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_document', 'Class', 'api/json_document/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('json_editable_document', 'Class', 'api/json_editable_document/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('json_editable_view', 'Class', 'api/json_editable_view/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_view', 'Class', 'api/json_view/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer', 'Class', 'api/json_pointer/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_pointer::back', 'Method', 'api/json_pointer/back/index.html');
@@ -199,6 +230,8 @@ INSERT INTO searchIndex(name, type, path) VALUES ('operator<<', 'Operator', 'api
 INSERT INTO searchIndex(name, type, path) VALUES ('operator>>', 'Operator', 'api/operator_gtgt/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('ordered_json', 'Class', 'api/ordered_json/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('ordered_json_document', 'Class', 'api/ordered_json_document/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('ordered_json_editable_document', 'Class', 'api/ordered_json_editable_document/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('ordered_json_editable_view', 'Class', 'api/ordered_json_editable_view/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('ordered_json_view', 'Class', 'api/ordered_json_view/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('ordered_map', 'Class', 'api/ordered_map/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('std::hash<basic_json>', 'Class', 'api/basic_json/std_hash/index.html');
@@ -284,3 +317,5 @@ INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_JSON_SERIALIZE_ENUM'
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_JSON_VERSION_MAJOR', 'Macro', 'api/macros/nlohmann_json_version_major/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_JSON_VERSION_MINOR', 'Macro', 'api/macros/nlohmann_json_version_major/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_JSON_VERSION_PATCH', 'Macro', 'api/macros/nlohmann_json_version_major/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('JSON_VIEW_NO_SIMD', 'Macro', 'api/macros/json_view_no_simd/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('JSON_VIEW_USE_SSSE3', 'Macro', 'api/macros/json_view_use_ssse3/index.html');
@@ -219,6 +219,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

@@ -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

@@ -37,6 +37,12 @@ Constant.
    --8<-- "examples/begin.output"
    ```

+## See also
+
+- [end](end.md) - returns an iterator to one past the last element
+- [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

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

+## See also
+
+- [cend](cend.md) - returns a const iterator to one past the last element
+- [basic_json_view::cbegin](../basic_json_view/cbegin.md) - the same iteration on a zero-copy view
+
 ## Version history

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

+## See also
+
+- [cbegin](cbegin.md) - returns a const iterator to the first element
+- [basic_json_view::cend](../basic_json_view/cend.md) - the same iteration on a zero-copy view
+
 ## Version history

 - Added in version 1.0.0.
@@ -111,6 +111,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

@@ -76,6 +76,7 @@ This method always returns `0` when executed on a JSON type that is not an objec

 - [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

@@ -60,6 +60,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
@@ -86,6 +89,8 @@ Binary values are serialized as an object containing two keys:

 - [to_string](to_string.md) returns a string representation of a JSON value
 - [operator<<](../operator_ltlt.md) serialize to stream
+- [`basic_json_view::dump`](../basic_json_view/dump.md) the corresponding function of `basic_json_view`, serializing
+  directly from a flat index without building a `basic_json` value
 - [Serialization](../../features/serialization.md) - the serialization article

 ## Version history
@@ -94,3 +99,5 @@ Binary values are serialized as an object containing two keys:
 - Indentation character `indent_char`, option `ensure_ascii` and exceptions added in version 3.0.0.
 - Error handlers added in version 3.4.0.
 - Serialization of binary values added in version 3.8.0.
+- 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.
@@ -37,6 +37,11 @@ Constant.
    --8<-- "examples/end.output"
    ```

+## See also
+
+- [begin](begin.md) - returns an iterator to the first element
+- [basic_json_view::end](../basic_json_view/end.md) - the same iteration on a zero-copy view
+
 ## Version history

 - Added in version 1.0.0.
@@ -80,6 +80,7 @@ This method always returns `end()` when executed on a JSON type that is not an o

 - [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

@@ -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

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

@@ -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

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

@@ -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

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

@@ -166,6 +166,8 @@ Linear.

 - [operator!=](operator_ne.md) compare for inequality
 - [operator<=>](operator_spaceship.md) comparison: 3-way (C++20)
+- [basic_json_view::operator==](../basic_json_view/operator_eq.md) - the same comparison on a zero-copy view, without
+  building a `basic_json` value for it

 ## Version history

@@ -89,6 +89,12 @@ Linear.
    --8<-- "examples/operator__notequal__nullptr_t.output"
    ```

+## See also
+
+- [operator==](operator_eq.md) compare for equality
+- [basic_json_view::operator!=](../basic_json_view/operator_ne.md) - the same comparison on a zero-copy view, without
+  building a `basic_json` value for it
+
 ## Version history

 1. Added in version 1.0.0. Added C++20 member functions in version 3.11.0. Changed in version 3.13.0 to remove 
@@ -52,6 +52,11 @@ Constant.
    --8<-- "examples/type_name.output"
    ```

+## See also
+
+- [type](type.md) - return the type of the JSON value
+- [basic_json_view::type_name](../basic_json_view/type_name.md) - the same function on a zero-copy view
+
 ## Version history

 - Added in version 1.0.0.
@@ -181,6 +181,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

@@ -0,0 +1,128 @@
+# <small>nlohmann::basic_json_document::</small>erase
+
+```cpp
+// (1)
+std::size_t erase(view_type object, string_view_t key);
+
+// (2)
+template<typename I>
+void erase(view_type array, I idx);
+
+// (3)
+std::size_t erase(const json_pointer& ptr);
+```
+
+Only an **editable** document (`#!cpp Editable == true`, e.g. [`json_editable_document`](../json_editable_document.md))
+has `erase`; calling it on a read-only `basic_json_document` fails to compile (`#!cpp static_assert`).
+
+1. Removes every member of `object` whose key is `key` (see [Notes](#notes) on duplicate keys) and returns how many
+   were removed; `#!cpp 0` if `object` has no member with this key.
+2. Removes the element at index `idx` of `array`, which must already exist (`#!cpp idx < array.size()`).
+3. Removes the value the JSON pointer `ptr` refers to, relative to [`root()`](root.md), and returns how many values
+   were removed: the *parent* of the target must already exist, and the target itself is removed as in 1. (an object
+   member; `#!cpp 0` or more) or 2. (an array element; always `#!cpp 1`). `ptr` must not be empty -- [`root()`](root.md)
+   itself cannot be erased.
+
+## Template parameters
+
+`I`
+:   an integral type other than `#!cpp bool`, deduced (overloads taking a `#!cpp bool` or a non-integral type for
+    `idx` do not participate in overload resolution).
+
+## Parameters
+
+`object` (in)
+:   the object to remove a member of
+
+`array` (in)
+:   the array to remove an element of
+
+`key` (in)
+:   the key of the member(s) to remove
+
+`idx` (in)
+:   the index of the element to remove; a negative value throws (see [Exceptions](#exceptions))
+
+`ptr` (in)
+:   a JSON pointer to the value to remove, relative to `root()`
+
+## Return value
+
+1. the number of removed members (`#!cpp 0` if `object` had none with this `key`)
+2. (nothing)
+3. the number of removed values (`#!cpp 0` or more for an object member, always `#!cpp 1` for an array element)
+
+## Exceptions
+
+1. Throws [`type_error.307`](../../home/exceptions.md#jsonexceptiontype_error307) if `object` is not an object -- the
+   same message [`BasicJsonType::erase`](../basic_json/erase.md) throws for the same type.
+2. Throws `type_error.307` if `array` is not an array. Throws
+   [`out_of_range.401`](../../home/exceptions.md#jsonexceptionout_of_range401) if `idx` is negative, or if
+   `#!cpp idx >= array.size()`.
+3. Throws [`out_of_range.405`](../../home/exceptions.md#jsonexceptionout_of_range405) ("JSON pointer has no parent")
+   if `ptr` is empty. Throws what [`at`](../basic_json_view/at.md) throws (overload 3) for resolving `ptr`'s parent.
+   For the last reference token itself: if the parent is an array, throws what 2. throws for an index that is out of
+   range, or, for a token that is not a valid array index,
+   [`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106) (a leading `#!cpp '0'`),
+   [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) (not a number),
+   [`out_of_range.410`](../../home/exceptions.md#jsonexceptionout_of_range410) (too large for `size_type`), or
+   [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) (an empty token); otherwise (an
+   object, or a primitive value the pointer's parent resolves to) throws what 1. throws.
+
+Every overload also throws [`invalid_iterator.202`](../../home/exceptions.md#jsonexceptioninvalid_iterator202) ("view
+does not belong to this document") if `object`/`array` is a [discarded](../basic_json_view/is_discarded.md) view or a
+view of a *different* document (overloads 1-2 only; overload 3 always starts from this document's own
+[`root()`](root.md)).
+
+## Complexity
+
+1. Linear in the number of members of `object`.
+2. Linear in the number of elements of `array` at or after `idx` (they move one slot over).
+3. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
+   that level or the index into the array (as [`at`](../basic_json_view/at.md)), plus the complexity of 1. or 2. for
+   the last token.
+
+## Notes
+
+!!! info "Duplicate keys"
+
+    Overload 1. removes *every* member with `key`, not just the first -- unlike [`set`](set.md), which assigns the
+    first occurrence and drops the rest. This is why it returns a count rather than a single view: there may be
+    more than one member removed, or none.
+
+Like [`set`](set.md) and [`push_back`](push_back.md), `erase` never moves an element's *value*: a view still
+referring to a removed member or element keeps showing what it last held (see [Edits](index.md#edits)) -- it just no
+longer appears when `array`/`object` is read, dumped, or iterated. Removing an element of `array` (2.) does shift the
+*links* to the elements after it, the same way `insert`, `set`, or `push_back` on the same array would; any iterator
+already taken over `array`/`object` is invalidated by an erase, since it was walking the old layout.
+
+## Examples
+
+??? example
+
+    The example below drops a deprecated field and a decommissioned entry from a configuration document -- using all
+    three overloads -- and shows what stays intact that would not with a plain `json`/`ordered_json` value: the order
+    of the fields around the ones removed, and the exact spelling of a number that was never touched.
+
+    ```cpp
+    --8<-- "examples/basic_json_document__erase.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_document__erase.output"
+    ```
+
+## See also
+
+- [insert](insert.md) - insert an element into an array
+- [set](set.md) - replace a value, or set an object member, an array element, or the value a JSON pointer refers to
+- [push_back](push_back.md) - append to an array
+- [root](root.md) - the view of the root value, the starting point of overload 3
+- [`BasicJsonType::erase`](../basic_json/erase.md) - the corresponding function of `basic_json`
+- [Edits](index.md#edits) - what an edit guarantees, for every overload
+
+## Version history
+
+- Added in version 3.13.0.
@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>

 ```cpp
-template<typename BasicJsonType>
+template<typename BasicJsonType, bool Editable = false>
 class basic_json_document;
 ```

@@ -19,6 +19,11 @@ it (a copy, or an rvalue `#!cpp std::string` that was moved in); see [`owns_sour
 is move-only: copying a document would either duplicate a potentially large index and text, or leave two documents
 claiming to borrow the same buffer, so it is disabled.

+With `#!cpp Editable == true`, the document also offers [`set`](set.md), [`push_back`](push_back.md),
+[`insert`](insert.md), and [`erase`](erase.md) to change values in place, see [Edits](#edits) below. The source text
+itself is never written; a read-only document (`#!cpp Editable == false`, the default) does not carry any of the
+bookkeeping edits need, and calling any of them on one fails to compile (`#!cpp static_assert`).
+
 ## Template parameters

 `BasicJsonType`
@@ -26,23 +31,37 @@ claiming to borrow the same buffer, so it is disabled.
    [`ordered_json`](../ordered_json.md). Only 64-bit `number_integer_t`/`number_unsigned_t` types are supported; this
    is checked with a `static_assert`.

+`Editable`
+:   whether the document supports [`set`](set.md), [`push_back`](push_back.md), [`insert`](insert.md), and
+    [`erase`](erase.md) (optional, `#!cpp false` by default). See [Edits](#edits) below.
+
 ## Specializations

- [**json_document**](../json_document.md) - documents of the default specialization [`json`](../json.md)
- [**ordered_json_document**](../ordered_json_document.md) - documents of [`ordered_json`](../ordered_json.md)
+- [**json_document**](../json_document.md) - read-only documents of the default specialization [`json`](../json.md)
+- [**ordered_json_document**](../ordered_json_document.md) - read-only documents of
+  [`ordered_json`](../ordered_json.md)
+- [**json_editable_document**](../json_editable_document.md) - editable documents of [`json`](../json.md)
+- [**ordered_json_editable_document**](../ordered_json_editable_document.md) - editable documents of
+  [`ordered_json`](../ordered_json.md)

 ## Member types

- **view_type** - the type of view returned by [`root()`](root.md) (`#!cpp basic_json_view<BasicJsonType>`)
+- **view_type** - the type of view returned by [`root()`](root.md) (`#!cpp basic_json_view<BasicJsonType, Editable>`)
 - **value_t** - the JSON type enumeration, see [`basic_json::value_t`](../basic_json/value_t.md)

 ## Member functions

 - [(constructor)](basic_json_document.md)
+
+### Parsing
+
 - [**parse**](parse.md) (_static_) - deserialize from a compatible input, borrowing or owning it as appropriate
 - [**parse_copy**](parse_copy.md) (_static_) - deserialize a copy of a compatible input
 - [**accept**](accept.md) (_static_) - check whether the input is valid JSON
 - [**read**](read.md) - (re-)parse into this document, reusing its memory
+
+### Access
+
 - [**root**](root.md) - the view of the root value
 - [**is_discarded**](is_discarded.md) - return whether the last parse failed
 - [**source**](source.md) - the parsed text
@@ -51,6 +70,49 @@ claiming to borrow the same buffer, so it is disabled.
 - [**memory_usage**](memory_usage.md) - the number of bytes held by the document
 - [**shrink_to_fit**](shrink_to_fit.md) - release unused index capacity

+### Images
+
+- [**save**](save.md) - the document as an image that `load()` reads without parsing
+- [**load**](load.md) (_static_) - read an image written by `save()`
+
+### Edits
+
+- [**set**](set.md) - replace a value, or set an object member, an array element, or the value a JSON pointer refers
+  to (`#!cpp Editable` documents only)
+- [**push_back**](push_back.md) - append to an array (`#!cpp Editable` documents only)
+- [**insert**](insert.md) - insert an element into an array before a given position (`#!cpp Editable` documents only)
+- [**erase**](erase.md) - remove an object member, an array element, or the value a JSON pointer refers to
+  (`#!cpp Editable` documents only)
+
+## Edits
+
+An editable document (`#!cpp Editable == true`) can be changed after parsing, with [`set`](set.md),
+[`push_back`](push_back.md), [`insert`](insert.md), and [`erase`](erase.md);
+[`json_editable_document`](../json_editable_document.md) and
+[`ordered_json_editable_document`](../ordered_json_editable_document.md) are the corresponding specializations. A few
+points apply to every edit:
+
+- **The source text is never written**, and the parsed index never moves: every value keeps the node it was parsed
+  into, so [views](../basic_json_view/index.md) taken before an edit stay valid, including
+  [`root()`](root.md). New values (and the element sequences of an edited array/object) go to storage owned by the
+  document, allocated on demand.
+- **A view keeps referring to the same value.** After [`set`](set.md) replaces the value a view refers to, that view
+  sees the new value; a view of a value that a later edit replaces or drops keeps showing what it last held. An edit
+  of an array or object, however, **invalidates the iterators taken over it** (its members may now live in a
+  different sequence), and a string obtained with [`get_string()`](../basic_json_view/get_string.md) stays valid even
+  as further edits happen (earlier buffers of edited text are kept alive, not overwritten).
+- **Values are accepted three ways:** a [`basic_json_view`](../basic_json_view/index.md) of *any* document
+  (read-only or editable; it is copied, nothing is shared with the source document), a `BasicJsonType` value, or
+  anything `BasicJsonType` can be constructed from (numbers, strings, `#!cpp bool`, `#!cpp nullptr`, containers, ...).
+- [`dump()`](../basic_json_view/dump.md) writes an edited document with members in document order, new members at
+  the end, and, with [`number_format::source`](../basic_json_view/number_format.md), keeps the spelling of every
+  number that was not itself edited -- see [Editing a document](../../features/json_view.md#editing-a-document) for
+  why this matters.
+- [`read()`](read.md) discards all edits, [`shrink_to_fit()`](shrink_to_fit.md) does not move the node index once
+  there are edits, and [`memory_usage()`](memory_usage.md) includes the memory edits use.
+  [`source_offset()`](../basic_json_view/source_offset.md) of a value introduced by an edit is
+  `#!cpp static_cast<std::size_t>(-1)`, the same value it reports for a decoded string.
+
 ## Version history

 - Added in version 3.13.0.
@@ -0,0 +1,114 @@
+# <small>nlohmann::basic_json_document::</small>insert
+
+```cpp
+template<typename I, typename V>
+view_type insert(view_type array, I idx, V&& value);
+```
+
+Only an **editable** document (`#!cpp Editable == true`, e.g. [`json_editable_document`](../json_editable_document.md))
+has `insert`; calling it on a read-only `basic_json_document` fails to compile (`#!cpp static_assert`).
+
+Inserts `value` into `array` as a new element before position `idx`, which must not be past the end
+(`#!cpp idx <= array.size()`; `#!cpp idx == array.size()` appends, like [`push_back`](push_back.md)). Unlike
+[`push_back`](push_back.md), a [null](../basic_json_view/is_null.md) `array` does *not* first become an empty array:
+`array` must already be an array.
+
+`value` is accepted three ways: a [`basic_json_view`](../basic_json_view/index.md) of *any* document -- read-only or
+editable, and it does not have to be `array`'s own document -- which is copied so that nothing is shared with the
+source document afterward; a `BasicJsonType` value; or anything `BasicJsonType` can be constructed from (numbers,
+strings, `#!cpp bool`, `#!cpp nullptr`, containers, ...).
+
+## Template parameters
+
+`I`
+:   an integral type other than `#!cpp bool`, deduced (overloads taking a `#!cpp bool` or a non-integral type for
+    `idx` do not participate in overload resolution).
+
+`V`
+:   the type of `value`, deduced; see above for what is accepted.
+
+## Parameters
+
+`array` (in)
+:   the array to insert into
+
+`idx` (in)
+:   the position to insert `value` before; a negative value throws (see [Exceptions](#exceptions))
+
+`value` (in)
+:   the value to insert
+
+## Return value
+
+a view of the new element, now holding `value`
+
+## Exception safety
+
+Basic exception safety: `value` is fully encoded -- including the checks below -- into storage owned by the document
+before anything already reachable from [`root()`](root.md) is touched, so a failure while encoding `value` (an
+invalid argument, or `#!cpp std::bad_alloc`) leaves the document completely unchanged, other than memory allocated
+for the encoding that is not reclaimed. A failure of a later allocation -- while `array` switches from its parsed
+layout to a growable block, or while that block grows, see [Notes](#notes) -- can still leave `array` already
+switched to that layout even though `value` itself was not inserted.
+
+## Exceptions
+
+Throws [`type_error.309`](../../home/exceptions.md#jsonexceptiontype_error309) if `array` is not an array -- the same
+message [`BasicJsonType::insert`](../basic_json/insert.md) throws for the same type; a null `array` throws this too
+(see above). Throws [`out_of_range.401`](../../home/exceptions.md#jsonexceptionout_of_range401) if `idx` is negative,
+or if `#!cpp idx > array.size()`. Throws
+[`invalid_iterator.202`](../../home/exceptions.md#jsonexceptioninvalid_iterator202) ("view does not belong to this
+document") if `array` is a [discarded](../basic_json_view/is_discarded.md) view or a view of a *different* document.
+Throws [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) if `value` is a
+[discarded](../basic_json_view/is_discarded.md) view or a [discarded](../basic_json/is_discarded.md) `BasicJsonType`
+value, and [`type_error.319`](../../home/exceptions.md#jsonexceptiontype_error319) if `value` is (or contains) a
+binary value -- `BasicJsonType` can hold one, but a `json_document` cannot. Throws
+[`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316) if `value` is (or contains) a string that is
+not valid UTF-8, with the same message [`BasicJsonType::dump()`](../basic_json/dump.md) gives for that string.
+
+## Complexity
+
+Linear in the number of elements of `array` at or after `idx` (they move one slot over), plus time linear in the
+size of `value` to encode it into the document's storage (constant for a scalar, linear in the number of nested
+values for an array or object): like [`push_back`](push_back.md), the elements of `array` move to a growable block
+of links the first time it is inserted into (or [`set`](set.md)/[`push_back`](push_back.md) on), and that block
+grows in amortized constant time; inserting before the end within that block still shifts every later element.
+
+## Notes
+
+Like [`set`](set.md) on a member or an element, `insert` never moves an existing *element's value* -- only where
+`array`'s *links* to its elements live -- so a view of an existing element of `array` stays valid across an
+`insert`, and keeps referring to the same element even though its index shifts. Any iterator already taken over
+`array` is invalidated, since it was walking the old layout. See [Edits](index.md#edits) for what stays valid across
+an edit in general.
+
+## Examples
+
+??? example
+
+    The example below inserts a step into the middle of a deployment plan, without touching the steps that come
+    after it, and shows that a view taken before the insert keeps referring to the same element even though its
+    index shifts -- something a plain `json`/`ordered_json` array, or its `std::vector`-based storage, has no
+    equivalent for.
+
+    ```cpp
+    --8<-- "examples/basic_json_document__insert.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_document__insert.output"
+    ```
+
+## See also
+
+- [push_back](push_back.md) - append to an array
+- [erase](erase.md) - remove an object member, an array element, or the value a JSON pointer refers to
+- [set](set.md) - replace a value, or set an object member, an array element, or the value a JSON pointer refers to
+- [`BasicJsonType::insert`](../basic_json/insert.md) - the corresponding function of `basic_json`
+- [Edits](index.md#edits) - what an edit guarantees, for every overload
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,169 @@
+# <small>nlohmann::basic_json_document::</small>load
+
+```cpp
+// (1)
+static basic_json_document load(const std::uint8_t* image, std::size_t size,
+                                 const image_check check = image_check::full);
+
+// (2)
+static basic_json_document load(const std::vector<std::uint8_t>& image,
+                                 const image_check check = image_check::full);
+
+// (3)
+static basic_json_document load(std::vector<std::uint8_t>&& image,
+                                 const image_check check = image_check::full);
+```
+
+1. Reads an image [`save()`](save.md) wrote, from a pointer and a byte count. The image is **borrowed**: `image`
+   must stay alive and unchanged for as long as the returned document, and any view taken from it, is used.
+2. Reads an image from a `#!cpp std::vector`. Also **borrowed** -- equivalent to overload 1 called with
+   `#!cpp image.data()` and `#!cpp image.size()`.
+3. Reads an image, keeping the vector instead of copying it: `image` is moved into the document (no copy), which
+   then owns it for as long as it needs the text and the decoded strings. [`owns_source()`](owns_source.md) is
+   `#!cpp true` afterward.
+
+In every overload, the node index is copied into storage the document itself owns -- so that it is properly aligned,
+and, for an [editable](index.md#edits) document, can be edited -- while the text and the decoded strings stay in
+`image`. The hash indexes [large objects](../../features/json_view.md) use for lookup are rebuilt, exactly as after
+parsing.
+
+## Parameters
+
+`image` (in)
+:   the image [`save()`](save.md) wrote (overloads 1 and 2), or one to take ownership of (overload 3)
+
+`size` (in)
+:   the number of bytes at `image` (overload 1)
+
+`check` (in)
+:   how thoroughly to validate `image` before trusting it; see [`image_check`](#image_check) below (optional,
+    `#!cpp image_check::full` by default)
+
+## Return value
+
+The document read from the image.
+
+## Exception safety
+
+Overloads 1 and 2 give the strong guarantee: `image` is only read, never written, so a thrown exception leaves the
+caller's buffer untouched.
+
+Overload 3 moves `image` into the document *before* validating it, so that a good image is kept without a copy. If
+loading then fails, the partially built document -- and the vector now inside it -- is discarded along with the
+exception, and `image` itself is left **empty**, not restored to what was passed in. Move a copy in instead, or
+validate with overload 2 first, if the original vector must survive a failed load.
+
+## Exceptions
+
+On a big-endian target, throws [`type_error.320`](../../home/exceptions.md#jsonexceptiontype_error320) -- the same
+exception [`save()`](save.md#exceptions) throws there, since the image format is little-endian only.
+
+Otherwise throws [`parse_error.116`](../../home/exceptions.md#jsonexceptionparse_error116) if `image` is not one
+`save()` could have written, or fails the requested `check`:
+
+| message               | when                                                                                                |
+|------------------------|------------------------------------------------------------------------------------------------------|
+| `too short`            | `image` is `#!cpp nullptr`, or `size` is smaller than the 64-byte header                             |
+| `unknown format`       | the header's magic bytes or version do not match, or a reserved header field is not zero             |
+| `sizes out of range`   | the node count, text size, or decoded-string size the header describes does not fit `size`, or the `#!cpp '\0'` after the text or after the decoded strings is missing |
+| `the check failed`     | `check` is not `#!cpp image_check::none`, and the image fails it -- see [`image_check`](#image_check) |
+
+!!! failure "Example messages"
+
+    ```
+    [json.exception.parse_error.116] parse error: invalid json_document image: too short
+    ```
+    ```
+    [json.exception.parse_error.116] parse error: invalid json_document image: unknown format
+    ```
+    ```
+    [json.exception.parse_error.116] parse error: invalid json_document image: sizes out of range
+    ```
+    ```
+    [json.exception.parse_error.116] parse error: invalid json_document image: the check failed
+    ```
+
+## Complexity
+
+Linear in the number of nodes, which are always copied into the document. With `#!cpp check == image_check::full`,
+additionally linear in the combined length of the text and the decoded strings; `#!cpp image_check::bounds` and
+`#!cpp image_check::none` do not read them.
+
+## `image_check`
+
+```cpp
+using image_check = detail::view::image_check;
+
+enum class image_check
+{
+    full,
+    bounds,
+    none
+};
+```
+
+How thoroughly `load()` validates `image` before trusting it.
+
+| value    | checks                                                                                                    | guarantees |
+|----------|--------------------------------------------------------------------------------------------------------------|------------|
+| `full`   | everything the parser itself guarantees: structure and bounds; that every string is valid UTF-8 (and, for a string still in the source text, that it contains no quote, backslash, or control character); and that every number token is well-formed and matches the value stored for it | reading and serializing a checked image is safe and always produces valid JSON, exactly as for a parsed document |
+| `bounds` | structure and bounds only -- that every offset and count in the node index stays inside the image            | reading and serializing stay memory-safe, but a crafted image can hold strings that are not valid UTF-8 or that serialize to invalid JSON ([`dump()`](../basic_json_view/dump.md) writes them unchanged or throws [`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316)), and numbers whose values differ from their text |
+| `none`   | nothing                                                                                                       | images from a trusted source only -- reading a damaged image is undefined behavior |
+
+`full` is the default and the right choice for an image from anything you do not fully control -- a file, a cache
+shared with other processes, a peer on the network. `bounds` skips scanning the text and the decoded strings, so it
+fits a cache your own process just wrote and reads straight back, where damage would mean a bug or a hardware fault
+rather than adversarial input; it still cannot crash or read out of bounds. `none` skips validation entirely and
+should only be used for an image you trust as much as your own memory.
+
+## Notes
+
+**Lifetime.** Overloads 1 and 2 borrow `image`: it must stay alive and byte-for-byte unchanged for as long as the
+returned document, and any [view](../basic_json_view/index.md) taken from it, is used -- exactly like a document
+[`parse()`](parse.md) borrowed its input for. Overload 3 avoids this by keeping the vector itself; see
+[`owns_source`](owns_source.md).
+
+!!! warning "Experimental"
+
+    The image format is versioned but not yet stable, and may change in an incompatible way before it is declared
+    stable; `load()` already rejects an image written by a different format version with `parse_error.116`
+    ("unknown format"). Use images to cache a document within one build of the library, or to hand one to another
+    process running the *same* build on the *same* (little-endian) machine -- not as a long-term storage format.
+
+**What `image_check::bounds` does not guarantee.** A bounds-checked image can never make `load()`,
+[`root()`](root.md), element access, or [`materialize()`](../basic_json_view/materialize.md) read outside the image,
+so those stay safe on a damaged one. It does *not* guarantee that the image describes valid JSON: a string
+that a `full` check would have rejected can make [`dump()`](../basic_json_view/dump.md) write invalid UTF-8 or invalid
+JSON, or throw `type_error.316`, and a number can read back with a value that does not match how it is spelled. Reserve `bounds` for images you already trust to be well-formed, and use it
+only to skip the extra scan.
+
+## Examples
+
+??? example "Caching a document, ownership, and a rejected image"
+
+    The example below saves a parsed document as an image, checks that `load()` reproduces the original
+    [`dump()`](../basic_json_view/dump.md) without parsing, and shows the difference between
+    `load(std::move(image))` (owned) and `load(image)` (borrowed). It then damages one byte of the image and shows
+    `image_check::full` rejecting it with `parse_error.116`, while `image_check::bounds` -- meant for a cache the
+    process already trusts -- still reads it without going out of bounds.
+
+    ```cpp
+    --8<-- "examples/basic_json_document__load.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_document__load.output"
+    ```
+
+## See also
+
+- [save](save.md) - write the document as an image
+- [owns_source](owns_source.md) - return whether the document holds its own copy of the text
+- [parse](parse.md) - deserialize from JSON text instead of an image
+- [Images](../../features/json_view.md#images) - why and when to use images
+
+## Version history
+
+- Added in version 3.13.0.
@@ -132,6 +132,7 @@ integer type becomes a floating-point value.
 - [accept](accept.md) - check whether the input is valid JSON
 - [read](read.md) - (re-)parse into this document, reusing its memory
 - [owns_source](owns_source.md) - return whether the document holds its own copy of the text
+- [load](load.md) - read a document from an image instead of parsing JSON text
 - [`BasicJsonType::parse`](../basic_json/parse.md) - the corresponding function of `basic_json`

 ## Version history
@@ -0,0 +1,102 @@
+# <small>nlohmann::basic_json_document::</small>push_back
+
+```cpp
+template<typename V>
+view_type push_back(view_type array, V&& value);
+```
+
+Appends `value` as a new last element of `array`. A [null](../basic_json_view/is_null.md) `array` first becomes an
+empty array, the same way [`set`](set.md) turns a null `object` into an empty object.
+
+`value` is accepted three ways: a [`basic_json_view`](../basic_json_view/index.md) of *any* document -- read-only or
+editable, and it does not have to be `array`'s own document -- which is copied so that nothing is shared with the
+source document afterward; a `BasicJsonType` value; or anything `BasicJsonType` can be constructed from (numbers,
+strings, `#!cpp bool`, `#!cpp nullptr`, containers, ...).
+
+Only an **editable** document (`#!cpp Editable == true`, e.g. [`json_editable_document`](../json_editable_document.md))
+has `push_back`; calling it on a read-only `basic_json_document` fails to compile (`#!cpp static_assert`).
+
+## Template parameters
+
+`V`
+:   the type of `value`, deduced; see above for what is accepted.
+
+## Parameters
+
+`array` (in)
+:   the array (or null value) to append to
+
+`value` (in)
+:   the value to append
+
+## Return value
+
+a view of the new last element of `array`, now holding `value`
+
+## Exception safety
+
+Basic exception safety: `value` is fully encoded -- including the checks below -- into storage owned by the document
+before anything already reachable from [`root()`](root.md) is touched, so a failure while encoding `value` (an
+invalid argument, or `#!cpp std::bad_alloc`) leaves the document completely unchanged, other than memory allocated
+for the encoding that is not reclaimed. A failure of a later allocation -- while `array` switches from its parsed
+layout to a growable block, or while that block grows, see [Notes](#notes) -- can still leave a partial effect, such
+as a null `array` argument already turned into an empty array even though `value` itself was not appended.
+
+## Exceptions
+
+Throws [`type_error.308`](../../home/exceptions.md#jsonexceptiontype_error308) if `array` is neither an array nor
+null -- the same message [`BasicJsonType::push_back`](../basic_json/push_back.md) throws for the same type. Throws
+[`invalid_iterator.202`](../../home/exceptions.md#jsonexceptioninvalid_iterator202) ("view does not belong to this
+document") if `array` is a [discarded](../basic_json_view/is_discarded.md) view or a view of a *different* document.
+Throws [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) if `value` is a
+[discarded](../basic_json_view/is_discarded.md) view or a [discarded](../basic_json/is_discarded.md) `BasicJsonType`
+value, and [`type_error.319`](../../home/exceptions.md#jsonexceptiontype_error319) if `value` is (or contains) a
+binary value -- `BasicJsonType` can hold one, but a `json_document` cannot. Throws
+[`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316) if `value` is (or contains) a string that is
+not valid UTF-8, with the same message [`BasicJsonType::dump()`](../basic_json/dump.md) gives for that string.
+
+## Complexity
+
+Amortized constant, plus time linear in the size of `value` to encode it into the document's storage (constant for
+a scalar, linear in the number of nested values for an array or object): the elements of `array` move to a growable
+block of links the first time it is appended to (or [`set`](set.md) on), and that block itself grows -- doubling its
+capacity, so the cost of growing it amortizes to constant per element -- only once it runs out of room. See
+[Notes](#notes).
+
+## Notes
+
+Like [`set`](set.md) on a member or an element, `push_back` never moves an existing element itself -- only where
+`array`'s *links* to its elements live -- so a view of an existing element of `array` stays valid across a
+`push_back`, but any iterator already taken over `array` is invalidated, since it was walking the old layout. See
+[Edits](index.md#edits) for what stays valid across an edit in general.
+
+## Examples
+
+??? example
+
+    The example below appends records to an array one at a time, as they might arrive from a stream of events,
+    without ever building a `BasicJsonType` value for the array or for the records already in it, and shows that a
+    view taken from an earlier `push_back` still refers to the same element once later ones have run.
+
+    ```cpp
+    --8<-- "examples/basic_json_document__push_back.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_document__push_back.output"
+    ```
+
+## See also
+
+- [set](set.md) - replace a value, or set an object member, an array element, or the value a JSON pointer refers to
+- [insert](insert.md) - insert an element into an array before a given position
+- [erase](erase.md) - remove an object member, an array element, or the value a JSON pointer refers to
+- [root](root.md) - the view of the root value
+- [`BasicJsonType::push_back`](../basic_json/push_back.md) - the corresponding function of `basic_json`
+- [Edits](index.md#edits) - what an edit guarantees, for every overload
+
+## Version history
+
+- Added in version 3.13.0.
@@ -70,6 +70,7 @@ own on the next, since ownership is decided freshly each time.

 - [parse](parse.md) - deserialize from a compatible input
 - [root](root.md) - the view of the root value
+- [load](load.md) - read a document from an image instead of parsing JSON text

 ## Version history

@@ -0,0 +1,104 @@
+# <small>nlohmann::basic_json_document::</small>save
+
+```cpp
+std::vector<std::uint8_t> save() const;
+```
+
+Writes the document as an *image*: a byte buffer that [`load`](load.md) reads back without parsing. The image holds
+the node index, the source text (plus, for an edited document, the number tokens edits wrote), and the decoded
+strings (plus the strings edits wrote) -- everything [`root()`](root.md) needs, with nothing left to parse.
+
+An edited document is written in its *current* state, with its values in document order, the way the library's own
+parser would have produced them for that JSON text: a member [`set`](set.md) added goes at the end, an
+[`erase`](erase.md)d member leaves no trace, and a float that is not finite (NaN or positive/negative infinity)
+becomes null, the same substitution [`dump()`](../basic_json_view/dump.md) makes. The same document always saves to
+the same bytes -- also across `BasicJsonType` and `#!cpp Editable`, since the image reflects document order and
+values only, not which specialization produced them.
+
+## Return value
+
+The image, as a `#!cpp std::vector<std::uint8_t>`. Pass it, or a pointer to its data together with its size, to
+[`load`](load.md) to read the document back.
+
+## Exception safety
+
+Strong guarantee: `save()` does not modify `#!cpp *this` (it is `#!cpp const`), so if it throws, the document is left
+exactly as it was, and the partially built image is discarded with the exception.
+
+## Exceptions
+
+Throws [`type_error.320`](../../home/exceptions.md#jsonexceptiontype_error320) if the document is
+[discarded](is_discarded.md) -- a default-constructed document, or one a failed [`parse()`](parse.md)/
+[`read()`](read.md) with `allow_exceptions == false` left discarded.
+
+On a big-endian target, throws `type_error.320` with a different message instead: the image format is little-endian
+only (see [Notes](#notes)).
+
+Throws [`out_of_range.416`](../../home/exceptions.md#jsonexceptionout_of_range416) if the node count, the text, or
+the decoded strings of the image would individually reach 4 GiB -- the same 32-bit offsets
+[`parse()`](parse.md#exceptions) and, for edits, [`set`](set.md)/[`push_back`](push_back.md) are already limited to.
+
+!!! failure "Example messages"
+
+    ```
+    [json.exception.type_error.320] cannot save a discarded json_document
+    ```
+    ```
+    [json.exception.type_error.320] json_document images need a little-endian target
+    ```
+    ```
+    [json.exception.out_of_range.416] images of 4 GiB or more are not supported by json_document
+    ```
+
+## Complexity
+
+Linear in the size of the document: the number of nodes, plus the length of the text and the decoded strings that end
+up in the image.
+
+## Notes
+
+**Format.** The image begins with a 64-byte header (the magic bytes `#!cpp "NJVI"`, a version number, the node count,
+and the sizes of the text and the decoded strings, all little-endian), followed by the nodes
+([16 bytes each](../../home/architecture.md#node-index-of-json-views)), the text and a `#!cpp '\0'`, and the decoded
+strings and a `#!cpp '\0'`. [`load`](load.md) checks the header, and the sizes it describes, before reading anything
+else -- see [`load`'s Exceptions](load.md#exceptions).
+
+!!! warning "Experimental"
+
+    The image format is versioned but not yet stable: it may change in an incompatible way before it is declared
+    stable. Use images to cache a document within one build of the library, or to hand one to another process running
+    the *same* build on the *same* (little-endian) machine -- not as a long-term storage format. Keep the original
+    JSON text if you need to read a saved document back with a future library version.
+
+**Little-endian only.** The image is written as raw little-endian bytes, with no byte-swapping. `save()` (and
+[`load`](load.md)) throw `type_error.320` on a big-endian target rather than silently produce bytes a big-endian
+reader could not interpret correctly.
+
+## Examples
+
+??? example "Caching a parsed document as an image"
+
+    The example below saves a parsed configuration as an image -- the way a service might cache one to answer later
+    requests without parsing the text again -- and confirms that loading it back gives exactly the same result as
+    parsing did, and that saving is deterministic.
+
+    ```cpp
+    --8<-- "examples/basic_json_document__save.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_document__save.output"
+    ```
+
+## See also
+
+- [load](load.md) - read an image written by `save()`
+- [owns_source](owns_source.md) - return whether the document holds its own copy of the text
+- [`basic_json_view::dump`](../basic_json_view/dump.md) - serialize the document to JSON text instead of an image
+- [Images](../../features/json_view.md#images) - why and when to use images
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,194 @@
+# <small>nlohmann::basic_json_document::</small>set
+
+```cpp
+// (1)
+template<typename V>
+view_type set(view_type target, V&& value);
+
+// (2)
+template<typename V>
+view_type set(view_type object, string_view_t key, V&& value);
+
+// (3)
+template<typename I, typename V>
+view_type set(view_type array, I idx, V&& value);
+
+// (4)
+template<typename V>
+view_type set(const json_pointer& ptr, V&& value);
+```
+
+Only an **editable** document (`#!cpp Editable == true`, e.g. [`json_editable_document`](../json_editable_document.md))
+has `set`; calling it on a read-only `basic_json_document` fails to compile (`#!cpp static_assert`).
+
+1. Replaces the value `target` refers to with `value`.
+2. Sets the member `key` of the object `object` to `value`: assigns it if `object` already has a member with this
+   key -- the first one, should the key occur more than once, and the later duplicates are then dropped (see the
+   [Notes](#notes) below) -- or appends a new member at the end otherwise. A [null](../basic_json_view/is_null.md)
+   `object` first becomes an empty object.
+3. Assigns `value` to the element at index `idx` of the array `array`, which must already exist (`#!cpp idx <
+   array.size()`).
+4. Sets the value the JSON pointer `ptr` refers to, relative to [`root()`](root.md), to `value`. The *parent* of the
+   target must already exist: an object member is set as in 2. (added if it does not exist yet), an array element is
+   assigned as in 3., and a last reference token of `#!cpp "-"`, or equal to the size of the array, appends `value`
+   instead, exactly as [`push_back`](push_back.md) would. An empty `ptr` sets [`root()`](root.md) itself, as in 1.
+
+In every overload, `value` is accepted three ways: a [`basic_json_view`](../basic_json_view/index.md) of *any*
+document -- read-only or editable, and it does not have to be `target`'s/`object`'s/`array`'s own document -- which
+is copied so that nothing is shared with the source document afterward; a `BasicJsonType` value; or anything
+`BasicJsonType` can be constructed from (numbers, strings, `#!cpp bool`, `#!cpp nullptr`, containers, ...).
+
+## Template parameters
+
+`V`
+:   the type of `value`, deduced; see above for what is accepted.
+
+`I`
+:   an integral type other than `#!cpp bool`, deduced (overloads taking a `#!cpp bool` or a non-integral type for
+    `idx` do not participate in overload resolution).
+
+## Parameters
+
+`target` (in)
+:   the value to replace
+
+`object` (in)
+:   the object (or null value) whose member to set
+
+`array` (in)
+:   the array whose element to assign
+
+`key` (in)
+:   the key of the member to set
+
+`idx` (in)
+:   the index of the element to assign; a negative value throws (see [Exceptions](#exceptions))
+
+`ptr` (in)
+:   a JSON pointer to the value to set, relative to `root()`
+
+`value` (in)
+:   the new value
+
+## Return value
+
+1. a view of `target`, now holding `value`
+2. a view of the member `key` of `object`, now holding `value`
+3. a view of the element `idx` of `array`, now holding `value`
+4. a view of the value `ptr` refers to, now holding `value`
+
+## Exception safety
+
+Basic exception safety: `value` is fully encoded -- including the checks below -- into storage owned by the document
+before anything already reachable from [`root()`](root.md) is touched, so a failure while encoding `value` (an
+invalid argument, or `#!cpp std::bad_alloc`) leaves the document completely unchanged, other than memory allocated
+for the encoding that is not reclaimed. A failure of a later allocation -- while an edited array or object switches
+from its parsed layout to a growable block, see [Notes](#notes) -- can still leave a partial effect, such as a
+[null](../basic_json_view/is_null.md) `object`/`array` argument already turned into an empty object/array even
+though `value` itself was not linked in.
+
+## Exceptions
+
+1. Throws [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) if `value` is a
+   [discarded](../basic_json_view/is_discarded.md) view, or a [discarded](../basic_json/is_discarded.md)
+   `BasicJsonType` value (e.g. `#!cpp BasicJsonType(value_t::discarded)`) -- an object or array `value`, of either
+   kind, is fine and is encoded as a whole subtree.
+2. Throws [`type_error.305`](../../home/exceptions.md#jsonexceptiontype_error305) if `object` is neither an object
+   nor null -- the same message [`operator[]`](../basic_json_view/operator%5B%5D.md) throws for a string argument on
+   such a value. Throws [`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316) if `key` is not
+   valid UTF-8, with the same message [`BasicJsonType::dump()`](../basic_json/dump.md) gives for that string.
+   Also throws what 1. throws for `value`.
+3. Throws `type_error.305` if `array` is not an array -- the same message `operator[]` throws for a numeric argument
+   on such a value. Throws [`out_of_range.401`](../../home/exceptions.md#jsonexceptionout_of_range401) if `idx` is
+   negative, or if `#!cpp idx >= array.size()`. Also throws what 1. throws for `value`.
+4. Throws what [`at`](../basic_json_view/at.md) throws (overload 3) for resolving `ptr`'s parent, except that a
+   missing object member or an array index equal to the array's size at the very last reference token is not an
+   error there (it becomes a new member or an appended element) instead of
+   [`out_of_range.403`](../../home/exceptions.md#jsonexceptionout_of_range403)/[`out_of_range.402`](../../home/exceptions.md#jsonexceptionout_of_range402).
+   For the last reference token itself: if the parent is an object (or a primitive value, where it throws
+   `type_error.305`), throws what 2. throws; if the parent is an array, throws what 3. throws for an index that is
+   out of range, or, for a token that is not a valid array index,
+   [`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106) (a leading `#!cpp '0'`),
+   [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) (not a number),
+   [`out_of_range.410`](../../home/exceptions.md#jsonexceptionout_of_range410) (too large for `size_type`), or
+   [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) (an empty token). Also throws what 1.
+   throws for `value`.
+
+Every overload also throws [`type_error.319`](../../home/exceptions.md#jsonexceptiontype_error319) if `value` is (or
+contains) a binary value -- `BasicJsonType` can hold one, but a `json_document` cannot -- and
+[`invalid_iterator.202`](../../home/exceptions.md#jsonexceptioninvalid_iterator202) ("view does not belong to this
+document") if `target`/`object`/`array` is a [discarded](../basic_json_view/is_discarded.md) view or a view of a
+*different* document (overloads 1-3 only; overload 4 always starts from this document's own [`root()`](root.md)).
+
+## Complexity
+
+1. Linear in the size of `value` (encoding it into the document's storage): constant for a scalar, linear in the
+   number of nested values for an array or object. If `target` is itself an array or object that spans more than one
+   node in its parent's original, unedited layout, and `value` is a scalar, replacing it additionally costs time
+   linear in the number of elements of that parent, the *first* time -- see [Notes](#notes).
+2. Linear in the number of members of `object`, to find an existing member with `key`, plus the complexity of 1. for
+   `value`.
+3. Constant, plus the complexity of 1. for `value`.
+4. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
+   that level or the index into the array (as [`at`](../basic_json_view/at.md)), plus the complexity of 2. or 3. for
+   the last token.
+
+## Notes
+
+!!! info "Duplicate keys"
+
+    If `object` already has more than one member with `key` (2.), the *first* one is assigned `value` and every
+    later member with the same key is removed -- so that a lookup, an iteration, and
+    [`materialize()`](../basic_json_view/materialize.md) of `object` afterward all agree on a single value for
+    `key`, the same way [`operator[]`](../basic_json_view/operator%5B%5D.md) already picks the first occurrence of a
+    duplicate key for reading. See the [Notes on duplicate keys](../basic_json_view/operator%5B%5D.md#notes) of
+    `operator[]`.
+
+Setting a member (2.) or an element (3., through 4.) of an array or object whose elements have not been edited
+before switches it from its parsed layout to a growable block holding links to its elements; a later
+[`push_back`](push_back.md) or `set` on the same container reuses that block, growing it (amortized constant time)
+only once it runs out of room. This never moves an element itself -- only where the container's *links* to its
+elements live -- so a view of an element stays valid, but any iterator already taken over the container is
+invalidated, since it was walking the old layout. See [Edits](index.md#edits) for what stays valid across an edit in
+general.
+
+The same switch happens, for the same reason, when overload 1. replaces a multi-node array/object value with a
+scalar: the *parent's* element sequence is what has to switch to links, not `target` itself, because the parent
+originally stepped over `target`'s whole subtree by its node count, which no longer applies once `target` is a
+one-node scalar.
+
+## Examples
+
+??? example "Example: (1)/(2)/(3)/(4) replace a value, set a member, assign an element, set via a JSON pointer"
+
+    The example below edits a small configuration document -- replacing a value, adding an object member, assigning
+    an array element, and reaching a field through a JSON pointer -- and shows what
+    [`dump()`](../basic_json_view/dump.md) preserves that is lost once the same edits are made on a `BasicJsonType`
+    value instead: the order object members were written in, and the exact spelling of a number that was never
+    touched.
+
+    ```cpp
+    --8<-- "examples/basic_json_document__set.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_document__set.output"
+    ```
+
+## See also
+
+- [push_back](push_back.md) - append to an array
+- [insert](insert.md) - insert an element into an array
+- [erase](erase.md) - remove an object member, an array element, or the value a JSON pointer refers to
+- [root](root.md) - the view of the root value, the starting point of overload 4
+- [`basic_json_view::dump`](../basic_json_view/dump.md) - serialize the document, keeping an untouched number's
+  spelling with `#!cpp number_format::source`
+- [Edits](index.md#edits) - what an edit guarantees, for every overload
+- [Editing a document](../../features/json_view.md#editing-a-document) - why editable documents keep the source
+  text's order and number spelling
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,134 @@
+# <small>nlohmann::basic_json_view::</small>at
+
+```cpp
+// (1)
+basic_json_view at(string_view_t key) const;
+basic_json_view at(const char* key) const;
+basic_json_view at(const string_t& key) const;
+
+// (2)
+basic_json_view at(size_type idx) const;
+basic_json_view at(int idx) const;
+
+// (3)
+basic_json_view at(const json_pointer& ptr) const;
+```
+
+1. Returns the value of the object member with key `key` -- the first one, should the key occur more than once (see
+   [Notes on duplicate keys](operator[].md#notes)).
+2. Returns the array element at index `idx`.
+3. Returns the value a JSON pointer `ptr` refers to, starting at this value.
+
+## Parameters
+
+`key` (in)
+:   object key of the element to access
+
+`idx` (in)
+:   index of the element to access
+
+`ptr` (in)
+:   JSON pointer to the element to access
+
+## Return value
+
+1. the value of the first member with key `key`
+2. the element at index `idx`
+3. the value `ptr` resolves to, starting at this value
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+
+## Exceptions
+
+1. The function can throw the following exceptions, both with the same message as the corresponding call to
+   [`BasicJsonType::at`](../basic_json/at.md):
+    - Throws [`type_error.304`](../../home/exceptions.md#jsonexceptiontype_error304) if the value is not an object.
+    - Throws [`out_of_range.403`](../../home/exceptions.md#jsonexceptionout_of_range403) if no member has key `key`.
+2. The function can throw the following exceptions, both with the same message as the corresponding call to
+   [`BasicJsonType::at`](../basic_json/at.md):
+    - Throws [`type_error.304`](../../home/exceptions.md#jsonexceptiontype_error304) if the value is not an array.
+    - Throws [`out_of_range.401`](../../home/exceptions.md#jsonexceptionout_of_range401) if `#!cpp idx >= size()`.
+3. The function can throw the following exceptions, all with the same message as the corresponding call to
+   [`BasicJsonType::at`](../basic_json/at.md):
+    - Throws [`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106) if an array index in `ptr`
+      begins with `#!cpp '0'`.
+    - Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) if an array index in `ptr` is
+      not a number.
+    - Throws [`out_of_range.401`](../../home/exceptions.md#jsonexceptionout_of_range401) if an array index in `ptr`
+      is out of range.
+    - Throws [`out_of_range.402`](../../home/exceptions.md#jsonexceptionout_of_range402) if a reference token is
+      `#!cpp "-"` at an array -- `at` never inserts an element, so `#!cpp "-"` is always invalid.
+    - Throws [`out_of_range.403`](../../home/exceptions.md#jsonexceptionout_of_range403) if a reference token names
+      an object member that does not exist.
+    - Throws [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) if `ptr` cannot be resolved
+      because a reference token is used on a primitive value.
+
+None of these exceptions carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no
+`BasicJsonType` value to point at, so the exception is created without one, even if `BasicJsonType` was built with
+`JSON_DIAGNOSTICS` enabled.
+
+## Complexity
+
+1. Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
+   another, in document order, stopping at the first match. Each comparison first checks the key's length --
+   already known from the index, without reading the key bytes -- before comparing its content.
+   Objects with 128 or more members get a hash index while parsing, so that a lookup in them takes constant time
+   on average.
+2. Linear in `idx`: elements are skipped one at a time from the first one, since they are not a fixed size in the
+   index (unlike `BasicJsonType`'s array, which is random-access).
+3. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
+   that level (as 1.) or the index into the array (as 2.).
+
+## Notes
+
+Unlike [`operator[]`](operator[].md), which returns a [discarded](is_discarded.md) view for a missing key or an
+out-of-range index, `at` always throws -- exactly as `BasicJsonType::at` does, and with the same messages, so
+existing error handling written against `BasicJsonType::at` keeps working unchanged when switched to a view. This
+also holds for overload 3: unlike [`operator[]`](operator[].md) with a JSON pointer, which returns a discarded view
+for a missing key or an out-of-range index, `at` throws for those too (`out_of_range.403`/`out_of_range.401`).
+
+## Examples
+
+??? example "Example: (1)/(2) access specified element with bounds checking"
+
+    The example below reads required fields out of a service configuration with `at`, and shows that the exceptions
+    it throws -- for a wrong type and for a missing key -- carry the same messages
+    [`BasicJsonType::at`](../basic_json/at.md) would produce for the same JSON text.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__at.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__at.output"
+    ```
+
+??? example "Example: (3) access specified element via JSON pointer with bounds checking"
+
+    The example below shows that `at` with a JSON pointer throws exactly the exceptions, with exactly the messages,
+    that [`BasicJsonType::at`](../basic_json/at.md) throws for the same pointer and the same document.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__at_json_pointer.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__at_json_pointer.output"
+    ```
+
+## See also
+
+- [operator[]](operator[].md) - access specified element (returns a discarded view instead of throwing)
+- [front](front.md), [back](back.md) - access the first or last element
+- [`BasicJsonType::at`](../basic_json/at.md) - the corresponding function of `basic_json`
+- [`json_pointer`](../json_pointer/index.md) - JSON pointer type used by overload 3
+
+## Version history
+
+- Added in version 3.13.0.
@@ -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.
@@ -8,8 +8,9 @@ Creates an invalid (discarded) view: [`type()`](type.md) is `#!cpp value_t::disc
 [`is_discarded()`](is_discarded.md) is `#!cpp true`, and `#!cpp explicit operator bool()` is `#!cpp false`.

 This is the only constructor a caller can use directly. Every other view is obtained from a
-[`basic_json_document`](../basic_json_document/index.md), via [`root()`](../basic_json_document/root.md) or (once
-element access is added) from navigating into a container.
+[`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

@@ -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.
@@ -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.
@@ -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.
@@ -0,0 +1,103 @@
+# <small>nlohmann::basic_json_view::</small>contains
+
+```cpp
+// (1)
+bool contains(string_view_t key) const;
+bool contains(const char* key) const;
+bool contains(const string_t& key) const;
+
+// (2)
+bool contains(const json_pointer& ptr) const;
+```
+
+1. Checks whether the value is an object with a member with key `key`.
+2. Checks whether a JSON pointer `ptr` can be resolved, starting at this value.
+
+## Parameters
+
+`key` (in)
+:   key value to check its existence
+
+`ptr` (in)
+:   JSON pointer to check its existence
+
+## Return value
+
+1. `#!cpp true` if the value is an object and has a member with key `key`, `#!cpp false` otherwise
+2. `#!cpp true` if `ptr` can be resolved to a value starting at this view, `#!cpp false` otherwise
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+1. Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
+   another, in document order, stopping at the first match. Each comparison first checks the key's length -- already
+   known from the index, without reading the key bytes -- before comparing its content.
+   Objects with 128 or more members get a hash index while parsing, so that a lookup in them takes constant time
+   on average.
+2. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
+   that level or the index into the array -- as for [`operator[]`](operator[].md#complexity) and
+   [`at`](at.md#complexity) with a JSON pointer.
+
+## Notes
+
+Overload 1 always returns `#!cpp false` when the value is not an object -- including a [discarded](is_discarded.md)
+view.
+
+!!! info "Postconditions"
+
+    If `#!cpp v.contains(key)` returns `#!cpp true`, then `#!cpp v[key]` is not [discarded](is_discarded.md). If
+    `#!cpp v.contains(ptr)` returns `#!cpp true`, then `#!cpp v[ptr]` is not discarded and `#!cpp v.at(ptr)` does not
+    throw.
+
+!!! info "Overload 2 never throws"
+
+    Unlike [`BasicJsonType::contains(const json_pointer&)`](../basic_json/contains.md), which can throw for certain
+    malformed pointers (for instance an empty array-index reference token), overload 2 never throws: a missing key,
+    an out-of-range or malformed array index, a `#!cpp "-"` index, or a reference token used on a primitive all
+    simply make it return `#!cpp false`.
+
+## Examples
+
+??? example "Example: (1) check with key"
+
+    The example below counts how many of a batch of records carry an optional `retry_of` field, using `contains()`
+    to check without ever materializing a single record of the batch.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__contains.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__contains.output"
+    ```
+
+??? example "Example: (2) check with JSON pointer"
+
+    The example below checks an optional, nested field with a JSON pointer, and shows two pointers that
+    `#!cpp contains()` resolves to `#!cpp false` without throwing.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__contains_json_pointer.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__contains_json_pointer.output"
+    ```
+
+## See also
+
+- [find](find.md) - find a value in an object
+- [count](count.md) - returns the number of occurrences of a key
+- [at](at.md), [operator[]](operator[].md) - resolve a JSON pointer and throw, or return a discarded view
+- [`BasicJsonType::contains`](../basic_json/contains.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,68 @@
+# <small>nlohmann::basic_json_view::</small>count
+
+```cpp
+size_type count(string_view_t key) const;
+size_type count(const char* key) const;
+size_type count(const string_t& key) const;
+```
+
+Returns `#!cpp 1` if the value is an object with a member with key `key`, `#!cpp 0` otherwise.
+
+## Parameters
+
+`key` (in)
+:   key value of the element to count
+
+## Return value
+
+`#!cpp 1` if the value is an object and has a member with key `key`, `#!cpp 0` otherwise.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
+another, in document order, stopping at the first match. Each comparison first checks the key's length -- already
+known from the index, without reading the key bytes -- before comparing its content.
+Objects with 128 or more members get a hash index while parsing, so that a lookup in them takes constant time on
+average.
+
+## Notes
+
+This method always returns `#!cpp 0` when the value is not an object -- including a [discarded](is_discarded.md)
+view.
+
+Unlike [`BasicJsonType::count()`](../basic_json/count.md), whose return value can in principle exceed `#!cpp 1` for
+an `ObjectType` that allows multiple entries per key, `count()` here never does: it is exactly
+[`contains()`](contains.md) as `#!cpp 0`/`#!cpp 1`. This holds even if the source text has a duplicate key -- see the
+[Notes on duplicate keys](operator[].md#notes) of `operator[]` -- because a `#!cpp count() > 1` result would require
+counting every member with a matching key, not just finding the first one.
+
+## Examples
+
+??? example
+
+    The example below validates that every transaction of a batch carries a mandatory `amount` field, using
+    `count()` before deciding whether to materialize a transaction at all.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__count.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__count.output"
+    ```
+
+## See also
+
+- [find](find.md) - find a value in an object
+- [contains](contains.md) - checks whether a key exists
+- [`BasicJsonType::count`](../basic_json/count.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,102 @@
+# <small>nlohmann::basic_json_view::</small>dump
+
+```cpp
+string_t dump(const int indent = -1,
+              const char indent_char = ' ',
+              const bool ensure_ascii = false,
+              const number_format numbers = number_format::shortest) const;
+```
+
+Serializes this value (and its subtree) directly from the flat index, without ever building a `BasicJsonType` value
+first. With the default `#!cpp numbers == number_format::shortest`, the result is the same string
+[`BasicJsonType::dump`](../basic_json/dump.md) would produce for the value
+[`BasicJsonType::parse()`](../basic_json/parse.md) builds from the same source text, called with the same `indent`,
+`indent_char`, and `ensure_ascii` -- except that members of an object appear in document order rather than sorted by
+key, and *every* occurrence of a repeated key is written rather than only the last one (see
+[Notes on duplicate keys](operator[].md#notes)). For a `json_view` (whose `BasicJsonType` is not ordered), this means
+`dump()` can print an object's members in a different order than [`materialize()`](materialize.md)`.dump()` of the
+same subtree.
+
+## Parameters
+
+`indent` (in)
+:   If `indent` is nonnegative, array elements and object members are pretty-printed with that indent level. An
+    indent level of `0` only inserts newlines. `-1` (the default) selects the most compact representation.
+
+`indent_char` (in)
+:   The character used for indentation if `indent` is greater than `0`. The default is ` ` (space).
+
+`ensure_ascii` (in)
+:   If `ensure_ascii` is `#!cpp true`, all non-ASCII characters in the output are escaped with `\uXXXX` sequences, and
+    the result consists of ASCII characters only.
+
+`numbers` (in)
+:   how to write numbers, see [`number_format`](number_format.md): `shortest` (the default) writes them the way
+    [`BasicJsonType::dump`](../basic_json/dump.md) would; `source` copies every number exactly as it appears in the
+    source text.
+
+## Return value
+
+string containing the serialization of this value, or `#!cpp "<discarded>"` if the view is
+[discarded](is_discarded.md).
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+
+## Exceptions
+
+May throw `#!cpp std::bad_alloc` if allocating the output string fails. Unlike
+[`BasicJsonType::dump`](../basic_json/dump.md), there is no `error_handler` parameter and no
+[`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316): the view only ever holds text the parser
+already validated as UTF-8, so there is nothing to replace or ignore.
+
+## Complexity
+
+Linear in the size of the output text.
+
+## Notes
+
+The walk over the subtree is iterative, so the nesting depth it can write is limited by available memory only, not by
+the call stack -- as for [`materialize()`](materialize.md).
+
+Strings are escaped by the same rules as [`BasicJsonType::dump`](../basic_json/dump.md). With
+`#!cpp numbers == number_format::shortest`, floats are written with the library's shortest round-trip conversion,
+exactly as [`BasicJsonType::dump`](../basic_json/dump.md) would (e.g. `#!cpp 1.5`, `#!cpp 100.0`, `#!cpp 1e+100`), and
+integers are copied from the source text -- already canonical in JSON, so this matches their shortest form too --
+except that `#!cpp -0` is written as `#!cpp 0`, the way [`BasicJsonType::parse()`](../basic_json/parse.md) reads it.
+`#!cpp number_format::source` copies every number exactly as written in the source text instead, with no exception
+for `#!cpp -0` -- `#!cpp 1.50`, `#!cpp 1E2`, `#!cpp -0.0`, `#!cpp -0`, or all digits of an integer literal with more
+digits than any number type holds (such a literal is itself classified as a float, see
+[What is different](../../features/json_view.md#what-is-different)) -- something `BasicJsonType` cannot do, since
+parsing already reduces every number to its parsed value.
+
+## Examples
+
+??? example
+
+    The example below forwards a single record out of a larger batch, and re-serializes a configuration file, both
+    without ever building a `BasicJsonType` value for the surrounding array or for the parts of it that were not
+    needed. It also shows that [`materialize()`](materialize.md)`.dump()` of the configuration sorts its keys, where
+    `dump()` on the view keeps the order they appear in the source text.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__dump.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__dump.output"
+    ```
+
+## See also
+
+- [`number_format`](number_format.md) - how `dump()` writes numbers
+- [operator<<](operator_ltlt.md) - serialize this value to a stream
+- [materialize](materialize.md) - build a `BasicJsonType` value, e.g. to use `BasicJsonType::dump`'s `error_handler`
+- [`BasicJsonType::dump`](../basic_json/dump.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -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.
@@ -0,0 +1,65 @@
+# <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.
+Objects with 128 or more members get a hash index while parsing, so that a lookup in them takes constant time on
+average.
+
+## 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.
@@ -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.
@@ -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.
@@ -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.
@@ -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.
@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>

 ```cpp
-template<typename BasicJsonType>
+template<typename BasicJsonType, bool Editable = false>
 class basic_json_view;
 ```

@@ -19,9 +19,20 @@ to the document and a pointer into its index), trivially copyable. A view is val
 Moving the document itself does not invalidate its views: the index is heap-allocated independently of the
 `basic_json_document` object.

-`basic_json_view` provides the read-only part of the `BasicJsonType` interface: the type-inspection functions, and
-[`materialize()`](materialize.md) to build the `BasicJsonType` value of a subtree on demand. It does not (yet) provide
-element access, iteration, `get<T>()`, JSON Pointer support, `dump()`, or comparison.
+`basic_json_view` provides the read-only part of the `BasicJsonType` interface: the type-inspection functions, element
+access, lookup, iteration, conversion, and comparison -- [`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). [`operator==`](operator_eq.md) and
+[`operator!=`](operator_ne.md) compare two views, or a view and a `BasicJsonType` value, without ever building a
+`BasicJsonType` value for a view; no ordering comparison (`#!cpp operator<`) is provided.
+
+`basic_json_view` itself is always read-only -- it never has a `set` or `push_back` of its own. A view of an
+**editable** document (`#!cpp Editable == true`) sees every edit made through
+[`basic_json_document::set`](../basic_json_document/set.md) and
+[`basic_json_document::push_back`](../basic_json_document/push_back.md): once a value is changed, every view that
+still refers to it -- including ones taken before the change -- reads the new value. See
+[Edits](../basic_json_document/index.md#edits).

 ## Template parameters

@@ -29,10 +40,17 @@ element access, iteration, `get<T>()`, JSON Pointer support, `dump()`, or compar
 :   a specialization of [`basic_json`](../basic_json/index.md), matching the
    [`basic_json_document`](../basic_json_document/index.md) the view was taken from.

+`Editable`
+:   whether the view is of an editable document, matching the [`basic_json_document`](../basic_json_document/index.md)
+    it was taken from (optional, `#!cpp false` by default). See [Edits](../basic_json_document/index.md#edits).
+
 ## 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)
+- [**json_editable_view**](../json_editable_view.md) - views of a [`json_editable_document`](../json_editable_document.md)
+- [**ordered_json_editable_view**](../ordered_json_editable_view.md) - views of an
+  [`ordered_json_editable_document`](../ordered_json_editable_document.md)

 ## Member types

@@ -41,6 +59,10 @@ element access, iteration, `get<T>()`, JSON Pointer support, `dump()`, or compar
  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)
+- [**number_format**](number_format.md) - how [`dump()`](dump.md) writes numbers

 ## Member functions

@@ -49,6 +71,7 @@ element access, iteration, `get<T>()`, JSON Pointer support, `dump()`, or compar
 ### 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
@@ -64,6 +87,28 @@ element access, iteration, `get<T>()`, JSON Pointer support, `dump()`, or compar
 - [**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
@@ -71,8 +116,22 @@ element access, iteration, `get<T>()`, JSON Pointer support, `dump()`, or compar

 ### 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

+### Comparison
+
+- [**operator==**](operator_eq.md) - comparison: equal
+- [**operator!=**](operator_ne.md) - comparison: not equal
+
+### Serialization
+
+- [**dump**](dump.md) - serialize to a JSON-formatted string
+- [**operator<<**](operator_ltlt.md) - serialize to stream
+
 ### Source access

 - [**source_offset**](source_offset.md) - byte offset of this value in the document's source text
@@ -0,0 +1,86 @@
+# <small>nlohmann::basic_json_view::</small>items
+
+```cpp
+/* unspecified */ items() const noexcept;
+```
+
+Returns a range of [`item`](index.md#member-types) values -- (key, value) pairs -- for use in range-based for loops.
+The key of an array element is its index, converted to a string, as for
+[`BasicJsonType::items()`](../basic_json/items.md).
+
+The returned type is not part of the public API and may change between versions; use a range-based for loop (see the
+example), or `#!cpp decltype(v.items())` if you need to name it.
+
+```cpp
+for (const auto& item : v.items())
+{
+    std::cout << "key: " << item.key() << ", value: " << item.value() << '\n';
+}
+```
+
+On C++17, `item` also supports [structured bindings](https://en.cppreference.com/w/cpp/language/structured_binding):
+
+```cpp
+for (const auto [key, value] : v.items())
+{
+    std::cout << "key: " << key << ", value: " << value << '\n';
+}
+```
+
+Note the `#!cpp const auto` (by value), not `#!cpp const auto&`: unlike `BasicJsonType::items()`, whose elements are
+references into an existing object, a view's `item` is produced on the fly for each step of the iteration, so there
+is nothing for a reference to bind to.
+
+## Return value
+
+A range whose iterators dereference to [`item`](index.md#member-types) and whose `#!cpp begin()`/`#!cpp end()` are
+equivalent to [`basic_json_view::begin()`](begin.md)/[`end()`](end.md), in document order.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Notes
+
+As for [`begin()`](begin.md)/[`end()`](end.md), `items()` visits **every** member of an object, 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 resolve to the *first* member with a given key. See the
+[Notes on duplicate keys](operator[].md#notes) of `operator[]`.
+
+!!! danger "Lifetime issues"
+
+    As for `BasicJsonType::items()`, calling `items()` on a temporary view (or a temporary document) is dangerous:
+    the range refers back to the document, so the document must outlive the loop. See
+    [#2040](https://github.com/nlohmann/json/issues/2040) for the `BasicJsonType` background.
+
+## Examples
+
+??? example
+
+    The example below shows a settings object whose source text records every update to a key as a duplicate
+    member, in the order they happened. `items()` walks all of them, so the update history is visible, while
+    [`operator[]`](operator[].md) only ever sees the *first* one and [`materialize()`](materialize.md) -- like
+    [`BasicJsonType::parse()`](../basic_json/parse.md) -- keeps only the *last*.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__items.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__items.output"
+    ```
+
+## See also
+
+- [begin](begin.md), [end](end.md) - the iterators `items()` is built on
+- [`BasicJsonType::items`](../basic_json/items.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,51 @@
+# <small>nlohmann::basic_json_view::</small>number_format
+
+```cpp
+enum class number_format {
+    shortest,
+    source
+};
+```
+
+This enumeration is used in [`dump`](dump.md) to choose how numbers are written. Two values are differentiated:
+
+shortest
+:   integers are copied from the source text -- already canonical in JSON -- except that `#!cpp -0` becomes
+    `#!cpp 0`, the way [`BasicJsonType::parse()`](../basic_json/parse.md) reads it; floats are written with the
+    library's shortest round-trip conversion, exactly as [`BasicJsonType::dump()`](../basic_json/dump.md) would (e.g.
+    `#!cpp 1.5`, `#!cpp 100.0`, `#!cpp 1e+100`)
+
+source
+:   every number is copied exactly as it appears in the source text -- `#!cpp 1.50`, `#!cpp 1E2`, `#!cpp -0`, all
+    digits of an integer literal with more digits than any number type holds -- something `BasicJsonType` cannot do,
+    since parsing already reduces every number to its parsed value
+
+## Examples
+
+??? example
+
+    The example below writes back a price list received from a supplier: with `number_format::shortest` (the
+    default), a trailing zero and scientific notation are normalized away and a long account number that overflows
+    every number type is rounded, the same way `#!cpp materialize().dump()` (or `basic_json::dump()`) would;
+    `number_format::source` keeps every number exactly as it was written in the source text instead.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__number_format.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__number_format.output"
+    ```
+
+## See also
+
+- [dump](dump.md) - serialize to a JSON-formatted string
+- [number_token](number_token.md) - get a single number's token text without dumping the whole value
+- [`BasicJsonType::error_handler_t`](../basic_json/error_handler_t.md) - the analogous enumeration for
+  `BasicJsonType::dump`'s decoding-error behavior
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,74 @@
+# <small>nlohmann::basic_json_view::</small>number_token
+
+```cpp
+string_view_t number_token() const;
+```
+
+Returns the number exactly as it appears in the source text, without parsing or rounding it.
+
+## Return value
+
+The number's token text, as a [`string_view_t`](index.md#member-types) into the document's
+[`source()`](../basic_json_document/source.md) text -- for example `#!cpp "1.50"`, `#!cpp "1E2"`, `#!cpp "-0"`, or an
+integer literal with more digits than any number type holds (such as a 30-digit integer, which [`get<T>()`](get.md)
+and [`materialize()`](materialize.md) can only represent approximately, as a `number_float_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
+
+Throws [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) if the value is not a number; example:
+`"type must be number, but is string"`.
+
+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
+
+`BasicJsonType` has no counterpart to this function: once a number is parsed into `number_integer_t`,
+`number_unsigned_t`, or `number_float_t`, its original textual form (leading zeros aside, which are already rejected
+by the grammar; trailing zeros in the fraction; the case and sign of the exponent; ...) is gone. `number_token()` is
+useful precisely where that form must survive -- a price or an identifier that must be reproduced exactly, or a
+number too large for any of `BasicJsonType`'s number types to hold without loss.
+
+The returned [`string_view_t`](index.md#member-types) always points into the document's
+[`source()`](../basic_json_document/source.md) text -- numbers are never decoded into the document's separate string
+buffer -- and is valid exactly as long as that text is, see the [validity rules](index.md) of `basic_json_view`.
+
+## Examples
+
+??? example
+
+    The example below keeps a price and an order ID exactly as they were written in an incoming order, where
+    converting them with [`get<T>()`](get.md) would lose information: the price picks up floating-point rounding, and
+    the order ID -- more digits than a 64-bit integer holds -- can only be approximated as a `#!cpp double` once
+    `#!cpp materialize()`d.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__number_token.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__number_token.output"
+    ```
+
+## See also
+
+- [get](get.md) - convert the value to a given type
+- [get_string](get_string.md) - the string, without a copy
+- [`BasicJsonType::number_integer_t`](../basic_json/number_integer_t.md),
+  [`number_unsigned_t`](../basic_json/number_unsigned_t.md), [`number_float_t`](../basic_json/number_float_t.md) - the
+  number types `#!cpp get<T>()` and `materialize()` convert into
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,158 @@
+# <small>nlohmann::basic_json_view::</small>operator[]
+
+```cpp
+// (1)
+basic_json_view operator[](string_view_t key) const;
+basic_json_view operator[](const char* key) const;
+basic_json_view operator[](const string_t& key) const;
+
+// (2)
+basic_json_view operator[](size_type idx) const;
+basic_json_view operator[](int idx) const;
+
+// (3)
+basic_json_view operator[](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
+   the [Notes](#notes) below) -- or a [discarded](is_discarded.md) view if there is no such member.
+2. Returns the array element at index `idx`, or a [discarded](is_discarded.md) view if `idx` is out of range. (The
+   `#!cpp int` overload only exists so that an integer literal is not ambiguous between this overload and 1.)
+3. Returns the value a JSON pointer `ptr` refers to, starting at this value, or a [discarded](is_discarded.md) view
+   wherever resolving it further is not possible without inserting into or extending the document (see
+   [Return value](#return-value) and [Exceptions](#exceptions) below).
+
+## 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`, or a discarded view if `#!cpp is_object()` is `#!cpp false` or no
+   member has this key
+2. the element at index `idx`, or a discarded view if `#!cpp is_array()` is `#!cpp false` or `#!cpp idx >= size()`
+3. the value `ptr` resolves to, starting at this value, or a discarded view for exactly the reference tokens where the
+   **const** overload of [`BasicJsonType::operator[]`](../basic_json/operator%5B%5D.md) invokes undefined behavior for
+   the same pointer and the same document: an object member that does not exist, or an array index that is out of
+   range
+
+## 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. Throws [`type_error.305`](../../home/exceptions.md#jsonexceptiontype_error305) if the value is not an object --
+   the same exception, with the same message, that the **const** overload of
+   [`BasicJsonType::operator[]`](../basic_json/operator%5B%5D.md) throws for a string argument on a non-object value.
+2. Throws [`type_error.305`](../../home/exceptions.md#jsonexceptiontype_error305) if the value is not an array --
+   the same exception, with the same message, that the **const** overload of
+   [`BasicJsonType::operator[]`](../basic_json/operator%5B%5D.md) throws for a numeric argument on a non-array value.
+3. Throws the same exceptions, with the same messages, that the **const** overload of
+   [`BasicJsonType::operator[]`](../basic_json/operator%5B%5D.md) throws for the same pointer and the same document:
+    - [`out_of_range.402`](../../home/exceptions.md#jsonexceptionout_of_range402) if a reference token is `#!cpp "-"`
+      at an array.
+    - [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) if a reference token cannot be
+      resolved because it is used on a primitive value.
+    - [`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106) if an array index in `ptr` begins
+      with `#!cpp '0'`.
+    - [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) if an array index in `ptr` is not a
+      number.
+
+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, so a key of a
+   different length than `key` is rejected without touching the source text.
+   Objects with 128 or more members get a hash index while parsing, so that a lookup in them takes constant time
+   on average.
+2. Linear in `idx`: elements are skipped one at a time from the first one, since they are not a fixed size in the
+   index (unlike `BasicJsonType`'s array, which is random-access).
+3. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
+   that level (as 1.) or the index into the array (as 2.).
+
+## Notes
+
+Unlike `BasicJsonType::operator[]`, which is undefined behavior (guarded by a
+[runtime assertion](../../features/assertions.md)) for a missing key on a **const** value, this operator always
+returns a safe, testable result: a [discarded](is_discarded.md) view, which is `#!cpp false` in a boolean context.
+There is also no non-const overload that inserts a missing key or extends an array -- a view never modifies the
+document.
+
+!!! info "Duplicate keys"
+
+    If the source text has an object with a duplicate key, `#!cpp operator[]` (and [`at`](at.md), [`find`](find.md),
+    [`contains`](contains.md), [`count`](count.md)) all resolve to the *first* member with that key, because a
+    lookup can stop as soon as it finds a match. This is different from
+    [`materialize()`](materialize.md) (and [`BasicJsonType::parse()`](../basic_json/parse.md)), which replay every
+    member in order and so end up keeping the *last* value for a repeated key -- there is no reason for them to stop
+    early. [`begin()`](begin.md)/[`end()`](end.md) and [`items()`](items.md) iterate over *all* members, including
+    duplicates, in document order. See the example below and [`size()`](size.md#notes).
+
+!!! info "JSON pointer resolution"
+
+    Overload 3 walks `ptr` one reference token at a time, starting at this value, the same way [`at`](at.md) and
+    [`contains`](contains.md) do. It only ever returns a discarded view where the **const** overload of
+    `BasicJsonType::operator[]` would be undefined behavior for the same pointer -- a missing object member or an
+    out-of-range array index -- and still throws for every other way `ptr` can fail to resolve. See
+    [`at`](at.md#exceptions) for the checked version, which throws in every case instead, and
+    [`contains`](contains.md) for a version that never throws.
+
+## Examples
+
+??? example "Example: (1)/(2) access specified element"
+
+    The example below reads a couple of fields out of a batch of user records without ever materializing a full
+    `BasicJsonType` value for the batch. `operator[]` is used both to look up an optional object member and to index
+    into an array -- in both cases, a missing value comes back as a discarded view that can be tested with a plain
+    `#!cpp if`, instead of relying on undefined behavior.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__operator[].cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__operator[].output"
+    ```
+
+??? example "Example: (3) access specified element via JSON pointer"
+
+    The example below reaches straight into one deeply nested field of a large document with a single JSON pointer,
+    without ever building a tree for the rest of it, and shows the discarded-view and throwing outcomes of a pointer
+    that cannot be fully resolved.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__operator[]_json_pointer.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__operator[]_json_pointer.output"
+    ```
+
+## See also
+
+- [at](at.md) - access specified element with bounds checking (throws instead of returning a discarded view)
+- [front](front.md), [back](back.md) - access the first or last element
+- [find](find.md), [contains](contains.md) - look up a member without throwing
+- [`BasicJsonType::operator[]`](../basic_json/operator%5B%5D.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.
@@ -0,0 +1,107 @@
+# <small>nlohmann::basic_json_view::</small>operator==
+
+```cpp
+// (1)
+bool operator==(const basic_json_view& lhs, const basic_json_view& rhs);
+
+// (2)
+bool operator==(const basic_json_view& lhs, const BasicJsonType& rhs);
+bool operator==(const BasicJsonType& lhs, const basic_json_view& rhs);
+```
+
+1. Compares two views for equality: whether the values [`BasicJsonType::parse()`](../basic_json/parse.md) would
+   produce for `lhs` and `rhs` are equal, according to `BasicJsonType`'s [`operator==`](../basic_json/operator_eq.md).
+2. Compares a view and a `BasicJsonType` value for equality, in either order: whether the value `parse()` would
+   produce for the view and the other operand are equal, according to `BasicJsonType`'s
+   [`operator==`](../basic_json/operator_eq.md).
+
+Neither overload builds a `BasicJsonType` value for a view to do the comparison (see [Notes](#notes) below). Numbers
+compare by value across their types (`#!cpp 1 == 1.0`), and an object compares by its members, with duplicate keys
+resolved exactly as `parse()` resolves them -- the last value, at the position of the first occurrence of the key.
+
+## Parameters
+
+`lhs` (in)
+:   first value to consider
+
+`rhs` (in)
+:   second value to consider
+
+## Return value
+
+whether the values `lhs` and `rhs` are equal
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to either operand, or to the document(s) a
+view refers to.
+
+## Exceptions
+
+May throw `#!cpp std::bad_alloc`. Unlike the other comparison and most other `basic_json_view` functions,
+`operator==` is not `#!cpp noexcept`: resolving an object's members needs a temporary array to sort them by key (see
+[Complexity](#complexity) below), and that allocation can fail.
+
+## Complexity
+
+Linear in the size of the compared values: every number, string, array element, and object member is visited at most
+once, and the walk is iterative, so the nesting depth it can compare is limited by available memory only, not by the
+call stack (as for [`materialize()`](materialize.md)). Resolving an object's members takes an additional O(n log n)
+in the number of members at that level, since they are sorted by key to detect and resolve duplicates before being
+compared. Two arrays of different [`size()`](size.md) are rejected without visiting either one's elements.
+
+## Notes
+
+Only a single number, boolean, or `#!cpp null` value is ever materialized into a `BasicJsonType`, to reuse its
+`operator==` -- for numbers, so that values written differently in the source text but equal in value (e.g. an
+integer and a floating-point literal) still compare equal, following the same rules `BasicJsonType` does for special
+values such as `#!cpp NaN`. Constructing one of these scalars never allocates. Strings are compared directly, without
+allocating, either from the source text on both sides or, for overload 2, against `BasicJsonType`'s own string.
+Arrays and objects are never materialized at all; only their elements or members are visited, one pair at a time.
+
+!!! info "How objects are compared"
+
+    For a [`json_view`](../json_view.md) (`BasicJsonType::object_t` is `#!cpp std::map`), members are compared by
+    key, regardless of the order they appear in the source text. For an
+    [`ordered_json_view`](../ordered_json_view.md) (`object_t` is `ordered_map`), they are compared in the order
+    they occur, so the very same two objects with their members reordered can compare equal as `json_view`s but not
+    as `ordered_json_view`s. This is exactly how [`json`](../json.md) and [`ordered_json`](../ordered_json.md)
+    compare, see ["Comparing different `basic_json` specializations"](../basic_json/operator_eq.md#notes).
+
+!!! info "Discarded views"
+
+    A [discarded](is_discarded.md) view compares the same way a discarded `BasicJsonType` value does, which is
+    governed by
+    [`JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](../macros/json_use_legacy_discarded_value_comparison.md): by
+    default, a discarded view is never equal to anything, not even another discarded view.
+
+No ordering comparison (`#!cpp operator<`) is provided for `basic_json_view`; [`materialize()`](materialize.md) is
+the way to get a `BasicJsonType` value that supports it.
+
+## Examples
+
+??? example
+
+    The example below checks whether a newly received configuration differs from the previous one, and whether a
+    received document matches what a test expects -- directly on views, without ever materializing a `BasicJsonType`
+    value for either side.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__operator_eq.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__operator_eq.output"
+    ```
+
+## See also
+
+- [operator!=](operator_ne.md) - compare for inequality
+- [materialize](materialize.md) - build a `BasicJsonType` value, e.g. to keep comparing after the document is gone
+- [`BasicJsonType::operator==`](../basic_json/operator_eq.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,74 @@
+# <small>nlohmann::basic_json_view::</small>operator<<
+
+```cpp
+std::ostream& operator<<(std::ostream& o, const basic_json_view& v);
+```
+
+Not available when [`JSON_NO_IO`](../macros/json_no_io.md) is defined.
+
+Serializes the given view `v` to the output stream `o`, using [`dump`](dump.md) -- exactly as
+`#!cpp operator<<(std::ostream&, const basic_json&)` does for a `basic_json` value.
+
+- The indentation of the output can be controlled with the member variable `width` of the output stream `o`. For
+  instance, using the manipulator `std::setw(4)` on `o` sets the indentation level to `4`, and the serialization
+  result is the same as calling `#!cpp v.dump(4)`. A `width` of `0` or less (the default) selects the most compact
+  representation, as `#!cpp v.dump(-1)` does.
+- The indentation character can be controlled with the member variable `fill` of the output stream `o`. For instance,
+  the manipulator `std::setfill('\t')` sets indentation to use a tab character rather than the default space
+  character.
+- As for `basic_json`, `o`'s `width` is reset to `0` after this call, whether or not it was greater than `0` before.
+
+Numbers are always written as `#!cpp v.dump()` writes them by default, i.e. as with
+[`number_format::shortest`](number_format.md); there is no way to select `#!cpp number_format::source` through the
+stream.
+
+## Parameters
+
+`o` (in, out)
+:   stream to write to
+
+`v` (in)
+:   view to serialize
+
+## Return value
+
+the stream `o`
+
+## Exceptions
+
+May throw `#!cpp std::bad_alloc`, propagated from [`dump`](dump.md#exceptions). Unlike
+`#!cpp operator<<(std::ostream&, const basic_json&)`, there is no UTF-8 decoding step that could throw
+[`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316), and no `error_handler` to choose between --
+see the [Exceptions](dump.md#exceptions) of `dump`.
+
+## Complexity
+
+Linear, as [`dump`](dump.md#complexity).
+
+## Examples
+
+??? example
+
+    The example below writes one record out of a larger batch straight to a log stream -- compact for a one-line
+    entry, and pretty-printed with `std::setw`/`std::setfill` for a readable dump -- without ever building a
+    `BasicJsonType` value for the record, or for the rest of the batch.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__operator_ltlt.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__operator_ltlt.output"
+    ```
+
+## See also
+
+- [dump](dump.md) - serialize to a JSON-formatted string
+- [`operator<<(std::ostream&)`](../operator_ltlt.md) - the corresponding operator for `basic_json`
+- [`JSON_NO_IO`](../macros/json_no_io.md) - switch off functions relying on certain C++ I/O headers
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,82 @@
+# <small>nlohmann::basic_json_view::</small>operator!=
+
+```cpp
+// (1)
+bool operator!=(const basic_json_view& lhs, const basic_json_view& rhs);
+
+// (2)
+bool operator!=(const basic_json_view& lhs, const BasicJsonType& rhs);
+bool operator!=(const BasicJsonType& lhs, const basic_json_view& rhs);
+```
+
+1. Compares two views for inequality. Returns `#!cpp !(lhs == rhs)`, see [operator==](operator_eq.md).
+2. Compares a view and a `BasicJsonType` value for inequality, in either order. Returns `#!cpp !(lhs == rhs)` (or,
+   for the reversed order, `#!cpp !(rhs == lhs)`), see [operator==](operator_eq.md).
+
+Since `operator!=` is defined as the negation of [`operator==`](operator_eq.md), it follows the same rules for
+special cases: for instance, since a [discarded](is_discarded.md) view is never equal to anything by default (see
+[operator=='s Notes](operator_eq.md#notes)), it is never *unequal* to anything either -- `#!cpp discarded != discarded`
+is also `#!cpp false`, exactly as for a discarded `BasicJsonType` value.
+
+## Parameters
+
+`lhs` (in)
+:   first value to consider
+
+`rhs` (in)
+:   second value to consider
+
+## Return value
+
+whether the values `lhs` and `rhs` are not equal
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to either operand, or to the document(s) a
+view refers to.
+
+## Exceptions
+
+May throw `#!cpp std::bad_alloc`, propagated from [`operator==`](operator_eq.md#exceptions). Unlike most other
+`basic_json_view` functions, `operator!=` is not `#!cpp noexcept`.
+
+## Complexity
+
+Linear, as [`operator==`](operator_eq.md#complexity).
+
+## Notes
+
+See the [Notes](operator_eq.md#notes) of `operator==` -- in particular for how an object's members are compared
+(order matters for [`ordered_json_view`](../ordered_json_view.md) but not for [`json_view`](../json_view.md)) and
+for how discarded views compare.
+
+No ordering comparison (`#!cpp operator<`) is provided for `basic_json_view`; [`materialize()`](materialize.md) is
+the way to get a `BasicJsonType` value that supports it.
+
+## Examples
+
+??? example
+
+    The example below asserts, as a test would, that a received document differs from an unwanted value, and shows
+    that -- as for [`json`](../json.md)/[`ordered_json`](../ordered_json.md) -- reordering an object's members is
+    detected as a difference for an `ordered_json_view` but not for a `json_view`.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__operator_ne.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__operator_ne.output"
+    ```
+
+## See also
+
+- [operator==](operator_eq.md) - compare for equality
+- [materialize](materialize.md) - build a `BasicJsonType` value, e.g. to keep comparing after the document is gone
+- [`BasicJsonType::operator!=`](../basic_json/operator_ne.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -33,6 +33,12 @@ Constant: for an object or array, the element count is stored in the index, not
 As for [`BasicJsonType::size()`](../basic_json/size.md), this does not return the length of a string value -- it is
 `1` for a string, regardless of its length.

+If the source text has an object with a duplicate key, every occurrence counts towards its `size()` -- unlike
+[`materialize()`](materialize.md) (and [`BasicJsonType::parse()`](../basic_json/parse.md)), which keeps only the last
+value for a repeated key. This means `#!cpp v.size()` can be larger than `#!cpp v.materialize().size()`. See the
+[Notes on duplicate keys](operator[].md#notes) of `operator[]` for why lookups and iteration disagree on how many
+members there are.
+
 ## Examples

 ??? example
@@ -0,0 +1,63 @@
+# <small>nlohmann::basic_json_view::</small>type_name
+
+```cpp
+const char* type_name() const noexcept;
+```
+
+Returns the type name as string to be used in error messages -- usually to indicate that a function was called on a
+wrong JSON type. Identical to [`BasicJsonType::type_name()`](../basic_json/type_name.md), including the extra
+`#!cpp "discarded"` return value for a [discarded](is_discarded.md) view (`BasicJsonType::type_name()` produces the
+same string for a discarded `BasicJsonType` value).
+
+## Return value
+
+a string representation of the type ([`value_t`](../basic_json/value_t.md)):
+
+| Value type                                         | return value  |
+|-----------------------------------------------------|---------------|
+| `#!json null`                                        | `"null"`      |
+| boolean                                              | `"boolean"`   |
+| string                                               | `"string"`    |
+| number (integer, unsigned integer, floating-point)   | `"number"`    |
+| object                                               | `"object"`    |
+| array                                                | `"array"`     |
+| discarded                                            | `"discarded"` |
+
+`type_name()` never returns `#!cpp "binary"`, since a JSON text has no binary values (see
+[`is_binary()`](is_binary.md)); it also never returns `#!cpp "invalid"`, since a view's `#!cpp kind` always comes
+from a value the parser actually produced.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Examples
+
+??? example
+
+    The example below reports why some parsed messages were rejected, using only `type_name()` -- no
+    `BasicJsonType` value is ever built for the ones that are wrong, and the message text matches what
+    [`BasicJsonType::type_name()`](../basic_json/type_name.md) would produce for the same value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__type_name.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__type_name.output"
+    ```
+
+## See also
+
+- [type](type.md) - return the type of the value
+- [`BasicJsonType::type_name`](../basic_json/type_name.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,133 @@
+# <small>nlohmann::basic_json_view::</small>value
+
+```cpp
+// (1)
+template<typename T>
+T value(string_view_t key, const T& default_value) const;
+string_t value(string_view_t key, const char* default_value) const;
+
+// (2)
+template<typename T>
+T value(const json_pointer& ptr, const T& default_value) const;
+string_t value(const json_pointer& ptr, const char* default_value) 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)) -- converted to `T`, or `default_value` if there is no such member.
+2. Returns the value a JSON pointer `ptr` refers to, starting at this value, converted to `T`, or `default_value` if
+   `ptr` cannot be resolved.
+
+Both overloads have a dedicated `#!cpp const char*` overload, so `#!cpp v.value(key, "default")` (and the JSON pointer
+equivalent) deduce `string_t`, not `const char*`, for their return type and for the comparison used to pick between
+`key` and `default_value`.
+
+## Template parameters
+
+`T`
+:   the type to convert the found value to; also the type of `default_value`
+
+## Parameters
+
+`key` (in)
+:   object key of the element to access
+
+`ptr` (in)
+:   JSON pointer to the element to access
+
+`default_value` (in)
+:   the value to return if `key`/`ptr` resolves to no value
+
+## Return value
+
+1. the first member with key `key`, converted to `T`, or `default_value`
+2. the value `ptr` resolves to, converted to `T`, or `default_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. Throws [`type_error.306`](../../home/exceptions.md#jsonexceptiontype_error306) if the value is not an object --
+   the same exception, with the same message, that [`BasicJsonType::value`](../basic_json/value.md) throws for the
+   same call. If a member with key `key` is found, throws whatever converting it to `T` throws (typically
+   [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302), with the same message
+   [`BasicJsonType::value`](../basic_json/value.md) throws for the same mismatch); a missing member never throws.
+2. Throws [`type_error.306`](../../home/exceptions.md#jsonexceptiontype_error306) if this value -- not the value `ptr`
+   resolves to -- is neither an object nor an array. Throws [`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106)
+   or [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) if `ptr` contains a malformed array
+   index. If `ptr` resolves to a value, throws whatever converting it to `T` throws. Every other way `ptr` can fail to
+   resolve -- a missing key, an out-of-range or "`-`" array index, an unresolvable token on a primitive -- yields
+   `default_value` instead of throwing, exactly as [`BasicJsonType::value`](../basic_json/value.md) catches
+   `out_of_range` and returns `default_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 [`operator[]`](operator[].md#complexity), members are compared one after
+   another, in document order, stopping at the first match. Plus the complexity of converting the found member to
+   `T` (see [`get`](get.md)).
+   Objects with 128 or more members get a hash index while parsing, so that a lookup in them takes constant time
+   on average.
+2. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
+   that level or the index into the array -- as for the [`operator[]`](operator[].md#complexity) and
+   [`at`](at.md#complexity) overloads that take a JSON pointer. Plus the complexity of converting the resolved value
+   to `T`.
+
+## Notes
+
+!!! info "Differences to `at` and `operator[]`"
+
+    Unlike [`at`](at.md), this function does not throw if `key`/`ptr` resolves to no value. Unlike
+    [`operator[]`](operator[].md), it never returns a [discarded](is_discarded.md) view -- it always returns a `T` --
+    and it is available on any view, since it never needs to insert a missing element the way the non-const
+    `BasicJsonType::operator[]` would.
+
+!!! info "Which values can be asked"
+
+    As for [`BasicJsonType::value`](../basic_json/value.md), the key overload (1) requires an object, and the JSON
+    pointer overload (2) an object or an array.
+
+## Examples
+
+??? example "Example: (1) access specified object element with default value"
+
+    The example below reads a couple of optional configuration fields with a default, so that a missing key never
+    needs a `#!cpp try`/`#!cpp catch` of its own.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__value.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__value.output"
+    ```
+
+??? example "Example: (2) access specified element via JSON pointer with default value"
+
+    The example below reads an optional, nested configuration value with a default, given as a JSON pointer.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__value_json_pointer.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__value_json_pointer.output"
+    ```
+
+## See also
+
+- [at](at.md) - access specified element with bounds checking (throws instead of returning a default value)
+- [operator[]](operator[].md) - access specified element (returns a discarded view instead of a default value)
+- [`BasicJsonType::value`](../basic_json/value.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,43 @@
+# <small>nlohmann::</small>json_editable_document
+
+<small>Defined in header `<nlohmann/json_view.hpp>`</small>
+
+```cpp
+using json_editable_document = basic_json_document<json, true>;
+```
+
+This type is an **editable** [`basic_json_document`](basic_json_document/index.md) of the default
+[`json`](json.md) specialization: in addition to everything [`json_document`](json_document.md) offers,
+[`set`](basic_json_document/set.md) and [`push_back`](basic_json_document/push_back.md) change values after
+parsing, without ever rewriting the source text -- see [Edits](basic_json_document/index.md#edits) and
+[Editing a document](../features/json_view.md#editing-a-document).
+
+## Examples
+
+??? example
+
+    The example below patches two fields of a small configuration document -- changing one and adding another --
+    and dumps it back out with the member order and the spelling of the untouched number preserved, something a
+    plain [`json`](json.md) value cannot do.
+
+    ```cpp
+    --8<-- "examples/json_editable_document.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/json_editable_document.output"
+    ```
+
+## See also
+
+- [json_editable_view](json_editable_view.md) - a view of a value of a `json_editable_document`
+- [json_document](json_document.md) - the read-only document this type adds edits to
+- [ordered_json_editable_document](ordered_json_editable_document.md) - the corresponding editable document for
+  `ordered_json`
+- [Edits](basic_json_document/index.md#edits) - what an edit guarantees
+
+## Version history
+
+Since version 3.13.0.
@@ -0,0 +1,41 @@
+# <small>nlohmann::</small>json_editable_view
+
+<small>Defined in header `<nlohmann/json_view.hpp>`</small>
+
+```cpp
+using json_editable_view = basic_json_view<json, true>;
+```
+
+This type is a [`basic_json_view`](basic_json_view/index.md) of a value of a
+[`json_editable_document`](json_editable_document.md). It offers the same read-only interface as
+[`json_view`](json_view.md); what is different is what it can be a view *of* -- a value that
+[`set`](basic_json_document/set.md) and [`push_back`](basic_json_document/push_back.md) can change, with every view
+still referring to it seeing the change, see [Edits](basic_json_document/index.md#edits).
+
+## Examples
+
+??? example
+
+    The example below is the same as [`json_editable_document`'s](json_editable_document.md): every view read back
+    out of the document -- `#!cpp doc.root()` and the views nested under it -- sees the edits made through `set`.
+
+    ```cpp
+    --8<-- "examples/json_editable_document.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/json_editable_document.output"
+    ```
+
+## See also
+
+- [json_editable_document](json_editable_document.md) - the document type this view refers into
+- [json_view](json_view.md) - the corresponding read-only view
+- [ordered_json_editable_view](ordered_json_editable_view.md) - the corresponding view for
+  `ordered_json_editable_document`
+
+## Version history
+
+Since version 3.13.0.
@@ -33,6 +33,8 @@ header. See also the [macro overview page](../../features/macros.md).
 - [**JSON_SKIP_UNSUPPORTED_COMPILER_CHECK**](json_skip_unsupported_compiler_check.md) - do not warn about unsupported compilers
 - [**JSON_USE_GLOBAL_UDLS**](json_use_global_udls.md) - place user-defined string literals (UDLs) into the global namespace
 - [**JSON_USE_SIMDUTF**](json_use_simdutf.md) - use the simdutf library to accelerate UTF-8 validation
+- [**JSON_VIEW_NO_SIMD**](json_view_no_simd.md) - use only portable code in the parser of `json_view.hpp`
+- [**JSON_VIEW_USE_SSSE3**](json_view_use_ssse3.md) - validate non-ASCII strings with SSSE3 in the parser of `json_view.hpp`

 ## Library version

@@ -0,0 +1,50 @@
+# JSON_VIEW_NO_SIMD
+
+```cpp
+#define JSON_VIEW_NO_SIMD
+```
+
+When defined, the parser of [`basic_json_document`](../basic_json_document/index.md) (`<nlohmann/json_view.hpp>`)
+uses only portable C++ to scan strings. By default, it scans long runs of string bytes 16 at a time with NEON on
+AArch64 (with GCC and Clang) and SSE2 on x86-64, which are part of the baseline instruction sets of these
+architectures, and validates non-ASCII text with NEON (or SSSE3, see
+[`JSON_VIEW_USE_SSSE3`](json_view_use_ssse3.md)).
+
+The same input is accepted or rejected either way, with the same values, and errors are reported the same way; only
+the speed differs. The macro exists for platforms whose compilers lack the intrinsics headers, and to test the portable
+code.
+
+!!! warning "Define consistently"
+
+    The macro selects between two definitions of the same inline functions. It must therefore be defined identically for
+    **every** translation unit that includes `<nlohmann/json_view.hpp>`; prefer a compile definition on the target.
+
+## Default definition
+
+By default, `#!cpp JSON_VIEW_NO_SIMD` is not defined, and the vector code is used where available.
+
+```cpp
+#undef JSON_VIEW_NO_SIMD
+```
+
+## Examples
+
+??? example
+
+    The code below uses the portable string scanning of the view.
+
+    ```cpp
+    #define JSON_VIEW_NO_SIMD
+    #include <nlohmann/json_view.hpp>
+
+    ...
+    ```
+
+## See also
+
+- [JSON_VIEW_USE_SSSE3](json_view_use_ssse3.md) - validate non-ASCII strings with SSSE3 on x86-64
+- [json_view](../../features/json_view.md) - the zero-copy view
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,49 @@
+# JSON_VIEW_USE_SSSE3
+
+```cpp
+#define JSON_VIEW_USE_SSSE3
+```
+
+When defined on x86-64, the parser of [`basic_json_document`](../basic_json_document/index.md)
+(`<nlohmann/json_view.hpp>`) validates non-ASCII text in strings with SSSE3, 16 bytes at a time, using the "lookup4"
+algorithm of [simdjson](https://github.com/simdjson/simdjson). Without it, non-ASCII text is validated one UTF-8
+sequence at a time on x86-64; on AArch64, the vector check uses NEON and is always on.
+
+SSSE3 is not part of the x86-64 baseline, so the code must be compiled for it: define the macro only together with a
+compiler option that enables SSSE3 (e.g. `-mssse3`, or `-march=` with a CPU that has it), and only for programs that
+run on such CPUs. The same input is accepted or rejected either way; only the speed of non-ASCII text differs.
+
+!!! warning "Define consistently"
+
+    The macro selects between two definitions of the same inline functions. It must therefore be defined identically,
+    with the same compiler options, for **every** translation unit that includes `<nlohmann/json_view.hpp>`; mixing
+    translation units that define it with ones that do not is an ODR violation. Prefer a compile definition on the
+    target.
+
+## Default definition
+
+By default, `#!cpp JSON_VIEW_USE_SSSE3` is not defined.
+
+```cpp
+#undef JSON_VIEW_USE_SSSE3
+```
+
+## Examples
+
+??? example
+
+    With CMake, for a program that only runs on CPUs with SSSE3:
+
+    ```cmake
+    target_compile_definitions(your_target PRIVATE JSON_VIEW_USE_SSSE3)
+    target_compile_options(your_target PRIVATE -mssse3)
+    ```
+
+## See also
+
+- [JSON_VIEW_NO_SIMD](json_view_no_simd.md) - use only portable code in the view's parser
+- [JSON_USE_SIMDUTF](json_use_simdutf.md) - validate UTF-8 with simdutf in `basic_json`'s parser
+
+## Version history
+
+- Added in version 3.13.0.
@@ -84,6 +84,8 @@ Linear.
 ## See also

 - [dump](basic_json/dump.md) - serialize to a JSON-formatted string
+- [`basic_json_view::operator<<`](basic_json_view/operator_ltlt.md) - the corresponding operator for
+  `basic_json_view`
 - [Serialization](../features/serialization.md) - the serialization article

 ## Version history
@@ -0,0 +1,47 @@
+# <small>nlohmann::</small>ordered_json_editable_document
+
+<small>Defined in header `<nlohmann/json_view.hpp>`</small>
+
+```cpp
+using ordered_json_editable_document = basic_json_document<ordered_json, true>;
+```
+
+This type is an **editable** [`basic_json_document`](basic_json_document/index.md) of the
+[`ordered_json`](ordered_json.md) specialization: [`set`](basic_json_document/set.md) and
+[`push_back`](basic_json_document/push_back.md) change values after parsing, as for
+[`json_editable_document`](json_editable_document.md), and
+[`materialize()`](basic_json_view/materialize.md) preserves the document order of object members -- including
+members [`set`](basic_json_document/set.md) added -- instead of sorting them like
+[`json_editable_document`](json_editable_document.md) does.
+
+## Examples
+
+??? example
+
+    The example below edits a document with `set`, then shows that `materialize()` keeps the member order of the
+    source text (with the new member at the end) for `ordered_json_editable_document`, where it would sort the
+    members alphabetically for [`json_editable_document`](json_editable_document.md).
+
+    ```cpp
+    --8<-- "examples/ordered_json_editable_document.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/ordered_json_editable_document.output"
+    ```
+
+## See also
+
+- [ordered_json_editable_view](ordered_json_editable_view.md) - a view of a value of an
+  `ordered_json_editable_document`
+- [ordered_json_document](ordered_json_document.md) - the read-only document this type adds edits to
+- [json_editable_document](json_editable_document.md) - the corresponding editable document for the default `json`
+  specialization
+- [Object Order](../features/object_order.md)
+- [Edits](basic_json_document/index.md#edits) - what an edit guarantees
+
+## Version history
+
+Since version 3.13.0.
@@ -0,0 +1,40 @@
+# <small>nlohmann::</small>ordered_json_editable_view
+
+<small>Defined in header `<nlohmann/json_view.hpp>`</small>
+
+```cpp
+using ordered_json_editable_view = basic_json_view<ordered_json, true>;
+```
+
+This type is a [`basic_json_view`](basic_json_view/index.md) of a value of an
+[`ordered_json_editable_document`](ordered_json_editable_document.md), the corresponding view for
+[`ordered_json_view`](ordered_json_view.md) the way [`json_editable_view`](json_editable_view.md) is for
+[`json_view`](json_view.md).
+
+## Examples
+
+??? example
+
+    The example below is the same as [`ordered_json_editable_document`'s](ordered_json_editable_document.md): the
+    views `set` returns see the document's member order preserved on `materialize()`, unlike for a
+    [`json_editable_document`](json_editable_document.md).
+
+    ```cpp
+    --8<-- "examples/ordered_json_editable_document.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/ordered_json_editable_document.output"
+    ```
+
+## See also
+
+- [ordered_json_editable_document](ordered_json_editable_document.md) - the document type this view refers into
+- [ordered_json_view](ordered_json_view.md) - the corresponding read-only view
+- [json_editable_view](json_editable_view.md) - the corresponding view for `json_editable_document`
+
+## Version history
+
+Since version 3.13.0.
@@ -0,0 +1,38 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json = nlohmann::json;
+using json_editable_document = nlohmann::json_editable_document;
+using json_editable_view = nlohmann::json_editable_view;
+
+int main()
+{
+    // a deprecated field is dropped from a configuration file, and a
+    // decommissioned replica is removed from the list -- "price" keeps its
+    // trailing zero, and the fields around the removed ones keep their order
+    const std::string text = R"({
+  "name": "cache",
+  "legacy_host": "db0",
+  "host": "db1",
+  "price": 19.90,
+  "replicas": ["db2", "db3", "db4"]
+})";
+
+    json_editable_document doc = json_editable_document::parse(text);
+
+    doc.erase(doc.root(), "legacy_host");                                      // (1) an object member
+    doc.erase(doc.root()["replicas"], 1);                                      // (2) an array element ("db3")
+    const std::size_t removed = doc.erase(json::json_pointer("/replicas/0"));  // (3) via a JSON pointer
+
+    std::cout << removed << '\n';
+    std::cout << doc.root().dump(2, ' ', false, json_editable_view::number_format::source) << "\n\n";
+
+    // the same edits on a plain json value: object_t is a std::map, so
+    // parsing already sorted the keys, and dump() rewrites every number to
+    // its shortest form, even "price", which was never touched
+    json plain = json::parse(text);
+    plain.erase("legacy_host");
+    plain["replicas"].erase(1);
+    plain["replicas"].erase(0);
+    std::cout << plain.dump(2) << '\n';
+}
@@ -0,0 +1,18 @@
+1
+{
+  "name": "cache",
+  "host": "db1",
+  "price": 19.90,
+  "replicas": [
+    "db4"
+  ]
+}
+
+{
+  "host": "db1",
+  "name": "cache",
+  "price": 19.9,
+  "replicas": [
+    "db4"
+  ]
+}
@@ -0,0 +1,38 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json = nlohmann::json;
+using json_editable_document = nlohmann::json_editable_document;
+using json_editable_view = nlohmann::json_editable_view;
+
+int main()
+{
+    // a deployment plan -- "budget" is written with a trailing zero that has
+    // no effect on its value
+    const std::string text = R"({
+  "release": "2026.09",
+  "steps": ["build", "test", "deploy"],
+  "budget": 19.90
+})";
+
+    json_editable_document doc = json_editable_document::parse(text);
+
+    const std::size_t deploy_index = 2;
+    const auto deploy = doc.root()["steps"][deploy_index];  // held across the insert
+
+    doc.insert(doc.root()["steps"], deploy_index, "smoke-test"); // insert before "deploy"
+
+    // the held view still refers to "deploy", even though its index moved
+    // from 2 to 3, and nothing else in the document was touched
+    std::cout << deploy.dump() << '\n';
+    std::cout << doc.root().dump(2, ' ', false, json_editable_view::number_format::source) << "\n\n";
+
+    // the same edit on a plain json value: an index held from before the
+    // insert now refers to whatever moved into that slot, and dump()
+    // rewrites "budget" to its shortest form even though it was never
+    // touched
+    json plain = json::parse(text);
+    plain["steps"].insert(plain["steps"].begin() + static_cast<std::ptrdiff_t>(deploy_index), "smoke-test");
+    std::cout << plain["steps"][deploy_index].dump() << '\n';
+    std::cout << plain.dump(2) << '\n';
+}
@@ -0,0 +1,23 @@
+"deploy"
+{
+  "release": "2026.09",
+  "steps": [
+    "build",
+    "test",
+    "smoke-test",
+    "deploy"
+  ],
+  "budget": 19.90
+}
+
+"smoke-test"
+{
+  "budget": 19.9,
+  "release": "2026.09",
+  "steps": [
+    "build",
+    "test",
+    "smoke-test",
+    "deploy"
+  ]
+}
@@ -0,0 +1,52 @@
+#include <cstdint>
+#include <iostream>
+#include <string>
+#include <vector>
+#include <nlohmann/json_view.hpp>
+
+using json = nlohmann::json;
+using json_document = nlohmann::json_document;
+using image_check = json_document::image_check;
+
+int main()
+{
+    std::cout << std::boolalpha;
+
+    // the image of a parsed document -- as if read back from a cache file or
+    // received from another process running the same build of the library
+    const std::string text = R"({"name": "cache", "note": "caf\u00e9", "replicas": ["db2", "db3"]})";
+    const json_document parsed = json_document::parse(text);
+    const std::vector<std::uint8_t> image = parsed.save();
+
+    // (1)/(2) load() needs no parsing, yet dumps exactly what parsing did
+    const json_document borrowed = json_document::load(image);
+    std::cout << (borrowed.root().dump() == parsed.root().dump()) << '\n';
+    std::cout << borrowed.owns_source() << '\n'; // borrowed: still points into `image`
+
+    // (3) load(std::move(image)) keeps the vector instead of copying it
+    std::vector<std::uint8_t> to_move = image;
+    const json_document owned = json_document::load(std::move(to_move));
+    std::cout << owned.owns_source() << '\n';
+
+    // a damaged image -- the last byte of the decoded string "note" holds
+    // (an escape sequence, so it was unescaped into the document's own
+    // buffer), flipped, as storage or transport corruption might do
+    std::vector<std::uint8_t> damaged = image;
+    damaged[damaged.size() - 2] = 0xFF;
+
+    // image_check::full inspects strings and numbers, so it catches the damage
+    try
+    {
+        static_cast<void>(json_document::load(damaged, image_check::full));
+    }
+    catch (const json::parse_error& e)
+    {
+        std::cout << e.id << '\n';
+    }
+
+    // image_check::bounds only checks structure and bounds, so a cache the
+    // process already trusts loads without the extra scan -- reading a value
+    // the damage did not touch is still safe
+    const json_document trusted = json_document::load(damaged, image_check::bounds);
+    std::cout << trusted.root()["name"].get<std::string>() << '\n';
+}
@@ -0,0 +1,5 @@
+true
+false
+true
+116
+cache
@@ -0,0 +1,24 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json = nlohmann::json;
+using json_editable_document = nlohmann::json_editable_document;
+
+int main()
+{
+    // "events" starts out null -- the first push_back() turns it into an
+    // array, exactly like set() turns a null object member into an object
+    json_editable_document doc = json_editable_document::parse(R"({"source": "sensor-1", "events": null})");
+
+    const auto first = doc.push_back(doc.root()["events"], json{{"type", "start"}, {"t", 0}});
+    for (int t = 1; t <= 3; ++t)
+    {
+        doc.push_back(doc.root()["events"], json{{"type", "tick"}, {"t", t}});
+    }
+
+    // push_back() never moves an existing element: a view taken from an
+    // earlier call still refers to the same element after later ones
+    std::cout << first.dump() << '\n';
+    std::cout << doc.root()["events"].size() << '\n';
+    std::cout << doc.root().dump(2) << '\n';
+}
@@ -0,0 +1,23 @@
+{"t":0,"type":"start"}
+4
+{
+  "source": "sensor-1",
+  "events": [
+    {
+      "t": 0,
+      "type": "start"
+    },
+    {
+      "t": 1,
+      "type": "tick"
+    },
+    {
+      "t": 2,
+      "type": "tick"
+    },
+    {
+      "t": 3,
+      "type": "tick"
+    }
+  ]
+}
@@ -0,0 +1,30 @@
+#include <cstdint>
+#include <iostream>
+#include <string>
+#include <vector>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    std::cout << std::boolalpha;
+
+    // a configuration a service parses once and then caches as an image, so
+    // that later requests can load() it instead of parsing the text again
+    const std::string text = R"({"name": "cache", "host": "db1", "port": 6379, "replicas": ["db2", "db3"]})";
+    const json_document config = json_document::parse(text);
+
+    // save() turns the parsed document into a byte buffer: a 64-byte header,
+    // the node index, the source text, and the decoded strings
+    const std::vector<std::uint8_t> image = config.save();
+    std::cout << image.size() << '\n';
+
+    // the same document always saves to the same bytes
+    std::cout << (image == json_document::parse(text).save()) << '\n';
+
+    // loading the image back needs no parsing, yet dumps exactly what
+    // parsing the text produced
+    const json_document reloaded = json_document::load(image);
+    std::cout << (reloaded.root().dump() == config.root().dump()) << '\n';
+}
@@ -0,0 +1,3 @@
+316
+true
+true
@@ -0,0 +1,41 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json = nlohmann::json;
+using json_editable_document = nlohmann::json_editable_document;
+using json_editable_view = nlohmann::json_editable_view;
+
+int main()
+{
+    // a configuration file, as it might be read from disk -- "price" is
+    // written with a trailing zero that has no effect on its value
+    const std::string text = R"({
+  "name": "cache",
+  "host": "db1",
+  "port": 6379,
+  "price": 19.90,
+  "replicas": ["db2", "db3"],
+  "timeout": 30
+})";
+
+    json_editable_document doc = json_editable_document::parse(text);
+
+    doc.set(doc.root()["port"], 6380);                    // (1) replace a value
+    doc.set(doc.root(), "region", "us-east");              // (2) add a member
+    doc.set(doc.root()["replicas"], 0, "db4");             // (3) assign an element
+    doc.set(json::json_pointer("/timeout"), 45);           // (4) via a JSON pointer
+
+    // members stay in document order (the new one at the end), and a number
+    // that was not itself edited keeps its exact spelling
+    std::cout << doc.root().dump(2, ' ', false, json_editable_view::number_format::source) << "\n\n";
+
+    // the same edits on a plain json value: object_t is a std::map, so
+    // parsing already sorted the keys, and dump() rewrites every number to
+    // its shortest form, even "price", which was never touched
+    json plain = json::parse(text);
+    plain["port"] = 6380;
+    plain["region"] = "us-east";
+    plain["replicas"][0] = "db4";
+    plain[json::json_pointer("/timeout")] = 45;
+    std::cout << plain.dump(2) << '\n';
+}
@@ -0,0 +1,25 @@
+{
+  "name": "cache",
+  "host": "db1",
+  "port": 6380,
+  "price": 19.90,
+  "replicas": [
+    "db4",
+    "db3"
+  ],
+  "timeout": 45,
+  "region": "us-east"
+}
+
+{
+  "host": "db1",
+  "name": "cache",
+  "port": 6380,
+  "price": 19.9,
+  "region": "us-east",
+  "replicas": [
+    "db4",
+    "db3"
+  ],
+  "timeout": 45
+}
@@ -0,0 +1,36 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // required fields of a service configuration -- at() reports a missing
+    // or wrong-typed field with the very same exception basic_json::at()
+    // would throw for the equivalent nlohmann::json value, so error
+    // handling written against basic_json::at() keeps working unchanged
+    json_document config = json_document::parse(R"({"name": "cache", "port": "6379"})");
+    const json_view service = config.root();
+
+    std::cout << service.at("port").materialize().dump() << '\n';
+
+    try
+    {
+        // "port" is a string, not an array
+        static_cast<void>(service.at("port").at(0));
+    }
+    catch (const nlohmann::json::type_error& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+
+    try
+    {
+        static_cast<void>(service.at("timeout"));
+    }
+    catch (const nlohmann::json::out_of_range& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+}
@@ -0,0 +1,3 @@
+"6379"
+[json.exception.type_error.304] cannot use at() with string
+[json.exception.out_of_range.403] key 'timeout' not found
@@ -0,0 +1,34 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_pointer = nlohmann::json::json_pointer;
+
+int main()
+{
+    json_document doc = json_document::parse(R"({"region": "eu", "servers": ["eu-1", "eu-2"]})");
+    const auto root = doc.root();
+
+    std::cout << root.at(json_pointer("/servers/1")).materialize().dump() << '\n';
+
+    // at() throws for every resolution failure -- with the very same
+    // message json::at(ptr) would throw for the same pointer and the same
+    // document
+    try
+    {
+        static_cast<void>(root.at(json_pointer("/servers/5")));
+    }
+    catch (const nlohmann::json::out_of_range& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+
+    try
+    {
+        static_cast<void>(root.at(json_pointer("/missing")));
+    }
+    catch (const nlohmann::json::out_of_range& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+}
@@ -0,0 +1,3 @@
+"eu-2"
+[json.exception.out_of_range.401] array index 5 is out of range
+[json.exception.out_of_range.403] key 'missing' not found
@@ -0,0 +1,25 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // the same build log; back() reads only the final status. It is linear
+    // in the number of events (unlike front(), which is constant), but
+    // still far less work than materializing the whole array
+    json_document log = json_document::parse(R"(["queued", "started", "compiling", "linking", "done"])");
+    std::cout << log.root().back().materialize().dump() << '\n';
+
+    // an empty log -- back() throws instead of the undefined behavior
+    // basic_json::back() has for an empty array
+    json_document empty_log = json_document::parse("[]");
+    try
+    {
+        static_cast<void>(empty_log.root().back());
+    }
+    catch (const nlohmann::json::invalid_iterator& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+}
@@ -0,0 +1,2 @@
+"done"
+[json.exception.invalid_iterator.214] cannot get value
@@ -0,0 +1,18 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // a log record: the fields matter in the order they were written, e.g.
+    // to reproduce the record as it was logged. A nlohmann::json object
+    // sorts its keys, so materializing and iterating it would instead print
+    // them alphabetically ("level", "message", "time")
+    json_document record = json_document::parse(R"({"time": "10:00:01", "level": "info", "message": "started"})");
+
+    for (auto it = record.root().begin(); it != record.root().end(); ++it)
+    {
+        std::cout << it.key() << '=' << it->materialize().dump() << '\n';
+    }
+}
@@ -0,0 +1,3 @@
+time="10:00:01"
+level="info"
+message="started"
@@ -0,0 +1,24 @@
+#include <iostream>
+#include <numeric>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // sum many measurements with std::accumulate; cbegin()/cend() (identical
+    // to begin()/end() here -- the view is always read-only) let the view be
+    // used with standard algorithms without ever materializing the whole
+    // array into a nlohmann::json value
+    json_document measurements = json_document::parse("[3, 1, 4, 1, 5, 9, 2, 6]");
+    const auto values = measurements.root();
+
+    const int sum = std::accumulate(values.cbegin(), values.cend(), 0,
+                                     [](int total, const json_view & v)
+    {
+        return total + v.materialize().get<int>();
+    });
+
+    std::cout << sum << '\n';
+}
@@ -0,0 +1 @@
+31
@@ -0,0 +1,24 @@
+#include <algorithm>
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // check that every element of a (possibly large) batch is an object,
+    // before materializing any of them -- cbegin()/cend() (identical to
+    // begin()/end() here) work as the range for std::all_of like they would
+    // for any standard container
+    json_document batch = json_document::parse(R"([{"id": 1}, {"id": 2}, {"id": 3}])");
+    const auto records = batch.root();
+
+    const bool all_objects = std::all_of(records.cbegin(), records.cend(),
+                                          [](const json_view & v)
+    {
+        return v.is_object();
+    });
+
+    std::cout << std::boolalpha << all_objects << '\n';
+}
@@ -0,0 +1 @@
+true
@@ -0,0 +1,30 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // count how many of many incoming records carry an optional "retry_of"
+    // field -- contains() only walks the flat index, so scanning a large
+    // batch like this never builds a single nlohmann::json value
+    json_document batch = json_document::parse(R"(
+      [
+        {"id": 1},
+        {"id": 2, "retry_of": 1},
+        {"id": 3},
+        {"id": 4, "retry_of": 3}
+      ]
+    )");
+
+    const auto records = batch.root();
+    std::size_t retries = 0;
+    for (std::size_t i = 0; i < records.size(); ++i)
+    {
+        if (records[i].contains("retry_of"))
+        {
+            ++retries;
+        }
+    }
+    std::cout << retries << " of " << records.size() << " records are retries\n";
+}
@@ -0,0 +1 @@
+2 of 4 records are retries
@@ -0,0 +1,39 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_pointer = nlohmann::json::json_pointer;
+
+int main()
+{
+    // "retry_of" is only present on some records, nested a level down
+    // inside "meta"
+    json_document batch = json_document::parse(R"(
+      [
+        {"id": 1, "meta": {}},
+        {"id": 2, "meta": {"retry_of": 1}}
+      ]
+    )");
+
+    const auto records = batch.root();
+    const json_pointer retry_of("/meta/retry_of");
+    for (std::size_t i = 0; i < records.size(); ++i)
+    {
+        const auto record = records[i];
+        if (record.contains(retry_of))
+        {
+            std::cout << "record " << i << " is a retry of " << record[retry_of].get<int>() << '\n';
+        }
+        else
+        {
+            std::cout << "record " << i << " is original\n";
+        }
+    }
+
+    // contains() with a JSON pointer never throws -- not even for a
+    // pointer that indexes into a primitive ("/0/id/x") or uses a
+    // malformed array index ("/01"), either of which would need a
+    // try/catch with json::contains(ptr)
+    std::cout << std::boolalpha << records.contains(json_pointer("/0/id/x")) << '\n';
+    std::cout << std::boolalpha << records.contains(json_pointer("/01")) << '\n';
+}
@@ -0,0 +1,4 @@
+record 0 is original
+record 1 is a retry of 1
+false
+false
@@ -0,0 +1,29 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // validate that every transaction of a batch carries a mandatory
+    // "amount" field before materializing any of them into a nlohmann::json
+    // value -- count() returns 0 or 1 for an object
+    json_document batch = json_document::parse(R"(
+      [
+        {"id": 1, "amount": 9.99},
+        {"id": 2}
+      ]
+    )");
+
+    const auto transactions = batch.root();
+    for (std::size_t i = 0; i < transactions.size(); ++i)
+    {
+        const auto transaction = transactions[i];
+        if (transaction.count("amount") == 0)
+        {
+            std::cout << "transaction " << i << " is missing \"amount\"\n";
+            continue;
+        }
+        std::cout << "transaction " << i << ": " << transaction["amount"].materialize().dump() << '\n';
+    }
+}
@@ -0,0 +1,2 @@
+transaction 0: 9.99
+transaction 1 is missing "amount"
@@ -0,0 +1,25 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // a large batch of sensor readings -- forward just the one that changed,
+    // without ever building a basic_json value for the batch or for the
+    // readings that are not needed
+    const json_document batch = json_document::parse(R"(
+      [{"id": 1, "temp": 21.5}, {"id": 2, "temp": 87.3}, {"id": 3, "temp": 21.7}]
+    )");
+    const json_view readings = batch.root();
+    std::cout << readings[1].dump() << '\n';
+
+    // a configuration file -- dump() on the view keeps the member order of
+    // the source text; a json value's object_t is std::map, so
+    // materialize().dump() of the very same view sorts the keys instead
+    const json_document config = json_document::parse(
+        R"({"name": "cache", "host": "db1", "port": 6379, "timeout": 30})");
+    std::cout << config.root().dump(2) << "\n\n";
+    std::cout << config.root().materialize().dump(2) << '\n';
+}
@@ -0,0 +1,14 @@
+{"id":2,"temp":87.3}
+{
+  "name": "cache",
+  "host": "db1",
+  "port": 6379,
+  "timeout": 30
+}
+
+{
+  "host": "db1",
+  "name": "cache",
+  "port": 6379,
+  "timeout": 30
+}
--- a/Show More
+++ b/Show More