json_view: the library's std conversions read views directly

The library's from_json() overloads (containers, maps, std::array, C arrays, pairs, tuples, optional, valarray, forward_list, enums, binary, paths, and scalars) accept views: their traits use the view's basic_json type, and the few accesses that differ (get_ptr) go through small helpers. from_json() of a view now finds them; only the probe still looks up by ADL only. get<T>() of a view thus converts these types without materialize(), with the same values and exceptions; from an object, a repeated key keeps the last value, as parse() does. The view keeps its direct paths for vectors of the types it converts directly (faster than from_json()) and for containers of views; its other vector and map paths are replaced by from_json(). For basic_json, std::valarray and std::forward_list are read in one pass (40 % and 3.5 % fewer instructions); all other conversions are unchanged. Signed-off-by: Niels Lohmann <mail@nlohmann.me>
json_view: from_json() of the macros reads views directly
2026-10-25 15:28:54 +00:00 · 2026-10-25 13:33:40 +01:00 · 2026-10-25 13:33:39 +01:00 · 2026-10-25 12:17:42 +01:00 · 2026-10-25 12:12:21 +01:00 · 2026-10-25 12:07:13 +01:00
218 changed files with 7565 additions and 8836 deletions
@@ -163,9 +163,9 @@ jobs:
          python3 $GENERATOR --list-tags
          TAG_COUNT=$(python3 $GENERATOR --list-tags | wc -l)
-          python3 $GENERATOR --abi-tags diag,_dp,_vns --abi-tags _diag --output $RUNNER_TEMP/abi_tags.natvis
+          python3 $GENERATOR --abi-tags diag,_dp,_ns --abi-tags _diag --output $RUNNER_TEMP/abi_tags.natvis
-          grep -q '<!-- Namespace nlohmann::json_abi_diag_dp_vns -->' $RUNNER_TEMP/abi_tags.natvis
+          grep -q '<!-- Namespace nlohmann::json_abi_diag_dp_ns -->' $RUNNER_TEMP/abi_tags.natvis
-          grep -q '<!-- Namespace nlohmann::json_abi_diag_dp_vns_v[0-9_]* -->' $RUNNER_TEMP/abi_tags.natvis
+          grep -q '<!-- Namespace nlohmann::json_abi_diag_dp_ns_v[0-9_]* -->' $RUNNER_TEMP/abi_tags.natvis
          test $(grep -c '<!-- Namespace ' $RUNNER_TEMP/abi_tags.natvis) -eq $(( $(grep -c '<!-- Namespace ' nlohmann_json.natvis) + 2 ))
          python3 $GENERATOR --all --output $RUNNER_TEMP/all.natvis
@@ -90,6 +90,7 @@ cc_library(
        "include/nlohmann/detail/view/simd.hpp",
        "include/nlohmann/detail/view/string_ref.hpp",
        "include/nlohmann/detail/view/value.hpp",
        "include/nlohmann/detail/view/view_mode.hpp",
        "include/nlohmann/json.hpp",
        "include/nlohmann/json_fwd.hpp",
        "include/nlohmann/json_literals.hpp",
@@ -309,7 +309,7 @@ The "Check amalgamation" workflow fails if the file is out of date.
 The file covers the namespace variants with up to two ABI tags. A Natvis file for other configurations can be
 generated with the `--abi-tags` or `--all` options, for example
-`make natvis NATVIS_ARGS="--abi-tags _diag,_dp,_vns --output my_nlohmann_json.natvis"`; see
+`make natvis NATVIS_ARGS="--abi-tags _diag,_dp,_ns --output my_nlohmann_json.natvis"`; see
 [`tools/generate_natvis`](tools/generate_natvis/README.md). With MSVC, CMake adds the file to the `nlohmann_json`
 target and installs it.
@@ -120,7 +120,7 @@ $(AMALGAMATED_VIEW_FILE): $(SRCS)
 	tools/amalgamate/amalgamate.py -c tools/amalgamate/config_json_view.json -s . --verbose=yes
 NATVIS_VENV=tools/generate_natvis/venv
-# extra options for generate_natvis.py, e.g. NATVIS_ARGS="--abi-tags _diag,_dp,_vns --output my.natvis"
+# extra options for generate_natvis.py, e.g. NATVIS_ARGS="--abi-tags _diag,_dp,_ns --output my.natvis"
 NATVIS_ARGS=
 # regenerate nlohmann_json.natvis from the ABI tags and version in include/nlohmann/detail/abi_macros.hpp
@@ -30,6 +30,14 @@ struct adl_serializer {
 - [**from_json**](from_json.md) - convert a JSON value to any value type
 - [**to_json**](to_json.md) - convert any value type to a JSON value
 ## See also
 - [Arbitrary type conversions](../../features/arbitrary_types.md) - how to make your types convertible
 - [**get**](../basic_json/get.md) / [**get_to**](../basic_json/get_to.md) - convert a JSON value to a C++ type
 - [**basic_json**](../basic_json/basic_json.md) - construct a JSON value from a C++ value
 - [**NLOHMANN_DEFINE_TYPE_INTRUSIVE**](../macros/nlohmann_define_type_intrusive.md) - generate the conversion functions for a type
 - [Specializing enum conversion](../../features/enum_conversion.md)
 ## Version history
 - Added in version 2.1.0.
@@ -23,6 +23,9 @@ Checks whether the input is valid JSON.
    respectively as UTF-8, UTF-16, and UTF-32. If `SentinelType` differs from `IteratorType`, it must be comparable to
    the iterator type with `operator!=`.
    Ill-formed UTF-16 and UTF-32 sequences are rejected: a lone surrogate, a high surrogate that is not followed by its
    low surrogate, and a code point above `U+10FFFF` all make this function return `false`.
 Unlike the [`parse()`](parse.md) function, this function neither throws an exception in case of invalid JSON input
 (i.e., a parse error) nor creates diagnostic information.
@@ -35,9 +38,12 @@ Unlike the [`parse()`](parse.md) function, this function neither throws an excep
    - a `#!c FILE` pointer (throws if null)
    - a C-style array of characters
    - a pointer to a null-terminated string of single byte characters (throws if null)
-    - a `std::string`
+    - a `std::string` or a `std::string_view` (C++17)
    - a container `obj` for which `begin(obj)` and `end(obj)` produce a valid pair of iterators
      (as found via ADL or member functions, with semantics compatible to `std::begin` and `std::end`)
    - wide characters (`wchar_t`, `char16_t`, `char32_t`), which are converted to UTF-8: a wide string object
      (`std::wstring`, `std::u16string`, `std::u32string`) or an array (e.g. a wide string literal); a pointer to a
      null-terminated wide string (e.g. `std::u16string::c_str()`) is not supported
 `IteratorType`
 :   a compatible iterator type, for instance.
@@ -125,6 +131,21 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
    --8<-- "examples/accept__iterator_pair.output"
    ```
 ??? example "Example: (3) reading from UTF-16 strings"
    The encoding is deduced from the character type of the input. String literals like `u"..."`, `U"..."`, and
    `L"..."` work as well.
    ```cpp
    --8<-- "examples/accept__wide_string.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/accept__wide_string.output"
    ```
 ## See also
 - [parse](parse.md) - deserialize from a compatible input
@@ -151,6 +172,9 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
  ([`JSON_DISABLE_STREAM_BULK_SCAN`](../macros/json_disable_stream_bulk_scan.md)).
 - Parsing from a `FILE*` locks the file once instead of once per character in version 3.13.0
  ([`JSON_DISABLE_UNLOCKED_FILE_IO`](../macros/json_disable_unlocked_file_io.md)).
 - Ill-formed UTF-16 and UTF-32 input (a lone surrogate, a high surrogate that is not followed by its low surrogate, or
  a code point above `U+10FFFF`) is rejected in version 3.13.0; before that, some such sequences were accepted or
  ended the input silently.
 !!! warning "Deprecation"
@@ -239,9 +239,8 @@ Strong exception safety: if an exception occurs, the original value stays intact
 1. Added in version 1.0.0.
 2. Added in version 1.0.0.
-3. Added in version 3.11.0. Fixed in version 3.13.0 to consistently accept `std::string_view`-convertible keys, as
+3. Added in version 3.11.0. Support for keys convertible to `std::string_view` added in version 3.13.0, consistently
-   already supported by [`operator[]`](operator[].md), [`value`](value.md), [`find`](find.md), and other lookup
+   across the lookup functions.
   functions.
 4. Added in version 2.0.0. Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) instead of
 [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) for a one-character array index that is not
 a digit (e.g., `/x`) in version 3.13.0, as it already did for longer ones.
@@ -63,4 +63,4 @@ Constant.
 ## Version history
 - Added in version 1.0.0.
- Adjusted code to return reference to binary values in version 3.8.0.
+- Binary values are supported since version 3.8.0.
@@ -482,15 +482,15 @@ basic_json(basic_json&& other) noexcept;
 ## Version history
-1. Since version 1.0.0.
+1. Added in version 1.0.0.
-2. Since version 1.0.0.
+2. Added in version 1.0.0.
-3. Since version 2.1.0.
+3. Added in version 2.1.0.
-4. Since version 3.2.0. Explicit for different string types if `JSON_USE_IMPLICIT_CONVERSIONS` is `0` since
+4. Added in version 3.1.2. Explicit for different string types if `JSON_USE_IMPLICIT_CONVERSIONS` is `0` since
   version 3.13.0.
-5. Since version 1.0.0.
+5. Added in version 1.0.0.
-6. Since version 1.0.0.
+6. Added in version 1.0.0.
-7. Since version 1.0.0. Fixed in version 3.13.0 to also check the iterator range for binary values; before, a range
+7. Added in version 1.0.0. Fixed in version 3.13.0 to also check the iterator range for binary values; before, a range
   that did not cover the whole value (such as `(end(), end())`) was accepted and the whole binary value was copied,
   unlike the other primitive types.
-8. Since version 1.0.0.
+8. Added in version 1.0.0.
-9. Since version 1.0.0.
+9. Added in version 1.0.0.
@@ -141,9 +141,8 @@ Logarithmic in the size of the JSON object.
 ## Version history
 1. Added in version 3.11.0.
-2. Added in version 3.6.0. Extended template `KeyType` to support comparable types in version 3.11.0. Fixed in
+2. Added in version 3.6.0. Extended template `KeyType` to support comparable types in version 3.11.0. Support for keys
-   version 3.13.0 to consistently accept `std::string_view`-convertible keys, as already supported by
+   convertible to `std::string_view` added in version 3.13.0, consistently across the lookup functions.
   [`operator[]`](operator[].md), [`at`](at.md), [`value`](value.md), and other lookup functions.
 3. Added in version 3.7.0.
 4. Deleted overloads for integral key types added in version 3.13.0 to reject such calls at compile time instead of
   causing undefined behavior at runtime.
@@ -92,8 +92,7 @@ Logarithmic in the size of the JSON object.
 ## Version history
 1. Added in version 3.11.0.
-2. Added in version 1.0.0. Changed parameter `key` type to `KeyType&&` in version 3.11.0. Fixed in version 3.13.0 to
+2. Added in version 1.0.0. Changed to support comparable key types in version 3.11.0. Support for keys convertible to
-   consistently accept `std::string_view`-convertible keys, as already supported by [`operator[]`](operator[].md),
+   `std::string_view` added in version 3.13.0, consistently across the lookup functions.
   [`at`](at.md), [`value`](value.md), and other lookup functions.
 3. Deleted overload for integral key types added in version 3.13.0 to reject such calls at compile time instead of
   causing undefined behavior at runtime.
@@ -69,6 +69,6 @@ Logarithmic in the size of the container, O(log(`size()`)).
 ## Version history
- Since version 2.0.8.
+- Added in version 2.0.8.
 - Fixed in version 3.13.0: for [`ordered_json`](../ordered_json.md), the value could previously only be passed as an
  rvalue; it can now also be passed as an lvalue or a `#!cpp const` lvalue, matching the behavior of `json`.
@@ -67,5 +67,5 @@ Amortized constant.
 ## Version history
- Since version 2.0.8.
+- Added in version 2.0.8.
 - Returns reference since 3.7.0.
@@ -213,7 +213,6 @@ Strong exception safety: if an exception occurs, the original value stays intact
 1. Added in version 1.0.0. Added support for binary types in version 3.8.0.
 2. Added in version 1.0.0. Added support for binary types in version 3.8.0.
 3. Added in version 1.0.0.
-4. Added in version 3.11.0. Fixed in version 3.13.0 to consistently accept `std::string_view`-convertible keys, as
+4. Added in version 3.11.0. Support for keys convertible to `std::string_view` added in version 3.13.0, consistently
-   already supported by [`operator[]`](operator[].md), [`at`](at.md), [`value`](value.md), and other lookup
+   across the lookup functions.
   functions.
 5. Added in version 1.0.0.
@@ -84,4 +84,4 @@ constructor.
 ## Version history
- Since version 3.0.0.
+- Added in version 3.0.0.
@@ -99,8 +99,7 @@ Logarithmic in the size of the JSON object.
 ## Version history
 1. Added in version 3.11.0.
-2. Added in version 1.0.0. Changed to support comparable types in version 3.11.0. Fixed in version 3.13.0 to
+2. Added in version 1.0.0. Changed to support comparable types in version 3.11.0. Support for keys convertible to
-   consistently accept `std::string_view`-convertible keys, as already supported by [`operator[]`](operator[].md),
+   `std::string_view` added in version 3.13.0, consistently across the lookup functions.
   [`at`](at.md), [`value`](value.md), and other lookup functions.
 3. Deleted overloads for integral key types added in version 3.13.0 to reject such calls at compile time instead of
   causing undefined behavior at runtime.
@@ -57,4 +57,4 @@ Constant.
 ## Version history
 - Added in version 1.0.0.
- Adjusted code to return reference to binary values in version 3.8.0.
+- Binary values are supported since version 3.8.0.
@@ -188,6 +188,6 @@ overload (3).
 ## Version history
-1. Since version 2.1.0.
+1. Added in version 2.1.0.
-2. Since version 2.1.0. Extended to work with other specializations of `basic_json` in version 3.2.0.
+2. Added in version 2.1.0. Extended to work with other specializations of `basic_json` in version 3.1.2.
-3. Since version 1.0.0.
+3. Added in version 1.0.0.
@@ -76,5 +76,5 @@ Depends on the `json_serializer<ValueType>::from_json()` implementation.
 ## Version history
- Since version 3.3.0.
+- Added in version 3.3.0.
 - Added a `static_assert` with a clear message for `const` arguments in version 3.13.0.
@@ -44,6 +44,22 @@ are collected in [Template Parameter Requirements](../../features/types/template
 - [**json**](../json.md) - default specialization
 - [**ordered_json**](../ordered_json.md) - a specialization that maintains the insertion order of object keys
 ## Documents and views
 Besides `basic_json`, the library offers a second way to hold a parsed JSON text: a
 [`basic_json_document`](../basic_json_document/index.md), which owns or borrows the text and holds a flat index of the
 values in it, and a [`basic_json_view`](../basic_json_view/index.md), a read-only handle to one value of such a document.
 Both are defined in the header `<nlohmann/json_view.hpp>`; see
 [Zero-copy JSON views](../../features/json_view.md) for the concept and the trade-offs.
 - [**json_document**](../json_document.md) / [**ordered_json_document**](../ordered_json_document.md) - read-only
  documents of the `basic_json` specialization they belong to
 - [**json_editable_document**](../json_editable_document.md) /
  [**ordered_json_editable_document**](../ordered_json_editable_document.md) - documents that can be modified in place
 - [**json_view**](../json_view.md) / [**ordered_json_view**](../ordered_json_view.md) - views of a document
 - [**json_editable_view**](../json_editable_view.md) /
  [**ordered_json_editable_view**](../ordered_json_editable_view.md) - views of an editable document
 ## Iterator invalidation
 All operations that add values to an **array** ([`push_back`](push_back.md) , [`operator+=`](operator+=.md),
@@ -343,6 +359,9 @@ Access to the JSON value
 ## See also
 - [RFC 8259: The JavaScript Object Notation (JSON) Data Interchange Format](https://tools.ietf.org/html/rfc8259)
 - [basic_json_document](../basic_json_document/index.md) / [basic_json_view](../basic_json_view/index.md) - parse a JSON
  text into a flat index and read it through a view
 - [Zero-copy JSON views](../../features/json_view.md) - when to use a document and a view instead of a `basic_json`
 ## Version history
@@ -75,4 +75,4 @@ classDiagram
 ## Version history
- Since version 3.0.0.
+- Added in version 3.0.0.
@@ -104,8 +104,8 @@ When iterating over an array, `key()` will return the index of the element as st
 ## Version history
- Added `iterator_wrapper` in version 3.0.0.
+- Added in version 3.1.0 as the replacement of the static function `iterator_wrapper`, which was available since
- Added `items` and deprecated `iterator_wrapper` in version 3.1.0.
+  version 1.0.0 and is deprecated since version 3.1.0.
 - Added structured binding support in version 3.5.0.
 !!! warning "Deprecation"
@@ -51,4 +51,4 @@ deserializes. See [Template Parameter Requirements](../../features/types/templat
 ## Version history
- Since version 2.0.0.
+- Added in version 2.1.0.
@@ -71,6 +71,6 @@ returned by `#!cpp (*this)[key]`); it is read as it was when `merge_patch()` was
 ## Version history
- Added in version 3.0.0.
+- Added in version 3.1.0.
 - Fixed use of freed or relocated memory when `apply_patch` is `#!cpp *this` or refers to a value contained in
  `#!cpp *this`, in version 3.13.0.
@@ -128,6 +128,6 @@ interpreted as `object_t::value_type` or `std::initializer_list<basic_json>`, se
 ## Version history
-1. Since version 1.0.0.
+1. Added in version 1.0.0.
-2. Since version 1.0.0.
+2. Added in version 1.0.0.
-3. Since version 2.0.0.
+3. Added in version 2.0.0.
@@ -284,10 +284,10 @@ Strong exception safety: if an exception occurs, the original value stays intact
 1. Added in version 1.0.0. Fixed in version 3.13.0 to throw `#!cpp std::length_error` instead of emptying the array and
   accessing it out of bounds when `idx` equals the maximum value of `size_type`. A missing index in the const version
   is guarded by a runtime assertion since version 3.13.0.
-2. Added in version 1.0.0. Added overloads for `T* key` in version 1.1.0. Removed overloads for `T* key` (replaced by 3)
+2. Added in version 1.0.0. Added overloads for `T* key` in version 1.1.0. The `T* key` overloads forward to
-   in version 3.11.0.
+   overload 3 since version 3.11.0.
-3. Added in version 3.11.0. Fixed in version 3.13.0 to consistently accept `std::string_view`-convertible keys, as
+3. Added in version 3.11.0. Support for keys convertible to `std::string_view` added in version 3.13.0, consistently
-   already supported by [`at`](at.md), [`value`](value.md), [`find`](find.md), and other lookup functions.
+   across the lookup functions.
 4. Added in version 2.0.0. A missing array index in the const version is guarded by a runtime assertion since
   version 3.13.0. Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) instead of
 [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) for a one-character array index that is not
@@ -89,6 +89,6 @@ Linear in the size of the JSON value.
 ## Version history
- Since version 1.0.0.
+- Added in version 1.0.0.
 - Macros `JSON_EXPLICIT`/[`JSON_USE_IMPLICIT_CONVERSIONS`](../macros/json_use_implicit_conversions.md) added
  in version 3.9.0.
@@ -75,4 +75,4 @@ classDiagram
 ## Version history
- Since version 3.0.0.
+- Added in version 3.0.0.
@@ -76,4 +76,4 @@ classDiagram
 ## Version history
- Since version 3.0.0.
+- Added in version 3.0.0.
@@ -25,6 +25,10 @@ static basic_json parse(IteratorType first, SentinelType last,
    respectively as UTF-8, UTF-16, and UTF-32. If `SentinelType` differs from `IteratorType`, it must be comparable to
    the iterator type with `operator!=`.
    Ill-formed UTF-16 and UTF-32 sequences are rejected: a lone surrogate, a high surrogate that is not followed by its
    low surrogate, and a code point above `U+10FFFF` all yield a
    [`parse_error.101`](../../home/exceptions.md#jsonexceptionparse_error101).
 ## Template parameters
 `InputType`
@@ -34,9 +38,12 @@ static basic_json parse(IteratorType first, SentinelType last,
    - a `FILE` pointer (throws if null)
    - a C-style array of characters
    - a pointer to a null-terminated string of single byte characters (throws if null)
-    - a `std::string`
+    - a `std::string` or a `std::string_view` (C++17)
    - a container `obj` for which `begin(obj)` and `end(obj)` produce a valid pair of iterators
      (as found via ADL or member functions, with semantics compatible to `std::begin` and `std::end`)
    - wide characters (`wchar_t`, `char16_t`, `char32_t`), which are converted to UTF-8: a wide string object
      (`std::wstring`, `std::u16string`, `std::u32string`) or an array (e.g. a wide string literal); a pointer to a
      null-terminated wide string (e.g. `std::u16string::c_str()`) is not supported
 `IteratorType`
 :   a compatible iterator type, for instance.
@@ -112,6 +119,13 @@ By default, a `'\0'` (NUL) byte anywhere in the input is treated as end of input
 outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-bytes-in-the-input) for details and the
 [`JSON_STRICT_NUL_HANDLING`](../macros/json_strict_nul_handling.md) macro to opt into rejecting it instead.
 !!! tip "Parsing into a document instead of a value"
    [`basic_json_document::parse`](../basic_json_document/parse.md) accepts the same inputs and the same options, but
    keeps the result as a flat index of the parsed values instead of a tree of `basic_json` values. It is faster and uses
    less memory when only parts of the document are read, and it also accepts a pointer to a null-terminated wide string,
    which `parse()` does not. See [Zero-copy JSON views](../../features/json_view.md).
 !!! tip "Performance"
    Contiguous inputs (strings, string views, vectors, arrays, pointer ranges) are the fastest to parse. A
@@ -250,6 +264,22 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
    --8<-- "examples/trailing_commas.output"
    ```
 ??? example "Example: parse from UTF-16, UTF-32, and wide strings"
    The encoding is deduced from the character type of the input; `std::u16string` and `std::u32string` are interpreted
    as UTF-16 and UTF-32, and `std::wstring` uses the platform's `wchar_t` width. String literals like `u"..."`,
    `U"..."`, and `L"..."` work as well, as do iterators over wide characters.
    ```cpp
    --8<-- "examples/parse__wide_string.cpp"
    ```
    Output:
    ```json
    --8<-- "examples/parse__wide_string.output"
    ```
 ## See also
 - [accept](accept.md) - check if the input is valid JSON
@@ -280,6 +310,9 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
  time).
 - Parsing from a `FILE*` locks the file once instead of once per character in version 3.13.0
  ([`JSON_DISABLE_UNLOCKED_FILE_IO`](../macros/json_disable_unlocked_file_io.md) restores `std::fgetc`).
 - Ill-formed UTF-16 and UTF-32 input (a lone surrogate, a high surrogate that is not followed by its low surrogate, or
  a code point above `U+10FFFF`) is rejected with `parse_error.101` in version 3.13.0; before that, some such
  sequences were accepted or ended the input silently.
 !!! warning "Deprecation"
@@ -84,4 +84,4 @@ or the end of file. This also holds true when reading a byte vector for binary f
 ## Version history
- Since version 3.0.0.
+- Added in version 3.0.0.
@@ -125,6 +125,6 @@ throws.
 ## Version history
-1. Since version 1.0.0.
+1. Added in version 1.0.0.
-2. Since version 1.0.0.
+2. Added in version 1.0.0.
-3. Since version 2.0.0.
+3. Added in version 2.0.0.
@@ -31,6 +31,10 @@ Read from input and generate SAX events
    respectively as UTF-8, UTF-16, and UTF-32. If `SentinelType` differs from `IteratorType`, it must be comparable to
    the iterator type with `operator!=`.
    Ill-formed UTF-16 and UTF-32 sequences are rejected: a lone surrogate, a high surrogate that is not followed by its
    low surrogate, and a code point above `U+10FFFF` all yield a
    [`parse_error.101`](../../home/exceptions.md#jsonexceptionparse_error101).
 The SAX event lister must follow the interface of [`json_sax`](../json_sax/index.md).
 ## Template parameters
@@ -42,8 +46,12 @@ The SAX event lister must follow the interface of [`json_sax`](../json_sax/index
    - a `FILE` pointer
    - a C-style array of characters
    - a pointer to a null-terminated string of single byte characters
    - a `std::string` or a `std::string_view` (C++17)
    - a container `obj` for which `begin(obj)` and `end(obj)` produce a valid pair of iterators
      (as found via ADL or member functions, with semantics compatible to `std::begin` and `std::end`)
    - wide characters (`wchar_t`, `char16_t`, `char32_t`), which are converted to UTF-8: a wide string object
      (`std::wstring`, `std::u16string`, `std::u32string`) or an array (e.g. a wide string literal); a pointer to a
      null-terminated wide string (e.g. `std::u16string::c_str()`) is not supported
 `IteratorType`
 :   a compatible iterator type for overload (2); a pair of character iterators whose `value_type` is an integral type
@@ -160,6 +168,9 @@ use the same file with stdio functions, but it must not wait for another thread
  ([`JSON_DISABLE_STREAM_BULK_SCAN`](../macros/json_disable_stream_bulk_scan.md)).
 - Parsing from a `FILE*` locks the file once instead of once per character in version 3.13.0
  ([`JSON_DISABLE_UNLOCKED_FILE_IO`](../macros/json_disable_unlocked_file_io.md)).
 - Ill-formed UTF-16 and UTF-32 input (a lone surrogate, a high surrogate that is not followed by its low surrogate, or
  a code point above `U+10FFFF`) is rejected with `parse_error.101` in version 3.13.0; before that, some such
  sequences were accepted or ended the input silently.
 !!! warning "Deprecation"
@@ -182,10 +182,10 @@ Constant.
 ## Version history
-1. Since version 1.0.0. Exchanges the `json_base_class_t` subobject along with the value since version 3.13.0.
+1. Added in version 1.0.0. Exchanges the `json_base_class_t` subobject along with the value since version 3.13.0.
-2. Since version 1.0.0. Exchanges the `json_base_class_t` subobject along with the value since version 3.13.0.
+2. Added in version 1.0.0. Exchanges the `json_base_class_t` subobject along with the value since version 3.13.0.
-3. Since version 1.0.0.
+3. Added in version 1.0.0.
-4. Since version 1.0.0.
+4. Added in version 1.0.0.
-5. Since version 1.0.0.
+5. Added in version 1.0.0.
-6. Since version 3.8.0.
+6. Added in version 3.8.0.
-7. Since version 3.8.0.
+7. Added in version 3.8.0.
@@ -124,5 +124,3 @@ Linear in the size of the JSON value `j`.
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
 - Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
  array or object was silently skipped, producing invalid BJData.
 - Writes unsigned integers wider than 64 bits as high-precision numbers since version 3.13.0; previously, they were
  silently truncated to 64 bits.
@@ -76,4 +76,4 @@ classDiagram
 ## Version history
- Since version 3.0.0.
+- Added in version 3.0.0.
@@ -231,11 +231,8 @@ changes to any JSON value.
 1. Added in version 1.0.0. Changed parameter `default_value` type from `const ValueType&` to `ValueType&&` in version
   3.11.0. Deleted overload for integral key types added in version 3.13.0 to reject such calls at compile time
   instead of causing undefined behavior at runtime.
-2. Added in version 3.11.0. Made `ValueType` the first template parameter in version 3.11.2. Fixed in version 3.13.0
+2. Added in version 3.11.0. Made `ValueType` the first template parameter in version 3.11.2. Support for keys
-   to consistently accept `std::string_view`-convertible keys, as already supported by
+   convertible to `std::string_view` added in version 3.13.0, consistently across the lookup functions.
-   [`operator[]`](operator[].md), [`at`](at.md), [`find`](find.md), and other lookup functions.
+3. Added in version 2.0.2. Extended to work with arrays in version 3.13.0. Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109)
 3. Added in version 2.0.2. Extended to work with arrays in version 3.13.0, including fixing an issue where resolving
   `ptr` through an array unexpectedly threw `out_of_range` instead of returning the resolved element (or
   `default_value`, as documented). Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109)
   instead of returning `default_value` for a one-character array index that is not a digit (e.g., `/x`) in version
   3.13.0, as it already did for longer ones.
@@ -12,7 +12,7 @@ void erase(view_type array, I idx);
 std::size_t erase(const json_pointer& ptr);
 ```
-Only an **editable** document (`#!cpp Editable == true`, e.g. [`json_editable_document`](../json_editable_document.md))
+Only an **editable** document (`#!cpp view_mode::editable`, 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
@@ -3,14 +3,14 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
-template<typename BasicJsonType, bool Editable = false>
+template<typename BasicJsonType, view_mode Mode = view_mode::read_only>
 class basic_json_document;
 ```
 A parsed JSON text, held as a flat index of its values
 ([16 bytes per value](../../home/architecture.md#node-index-of-json-views)) instead of a tree of `BasicJsonType` values.
-Strings and numbers stay in the source text; only strings that contain escapes are decoded, into one buffer owned by
+Strings and floating-point numbers stay in the source text; integers are converted while parsing, and strings that
-the document. [`basic_json_view`](../basic_json_view/index.md) is a read-only handle to one value of a
+contain escapes are decoded into one buffer owned by the document. [`basic_json_view`](../basic_json_view/index.md) is a read-only handle to one value of a
 `basic_json_document`; [`materialize()`](../basic_json_view/materialize.md) turns a subtree into the
 `BasicJsonType` value that [`BasicJsonType::parse()`](../basic_json/parse.md) would have produced for it.
@@ -20,9 +20,9 @@ is move-only: a copy would duplicate the whole index, the decoded-string buffer,
 enough in every use we know of. The index, the decoded strings, and the owned text live in one heap block that the
 document holds through a `#!cpp std::unique_ptr`; this is also why views survive a move of the document.
-With `#!cpp Editable == true`, the document also offers [`set`](set.md), [`push_back`](push_back.md),
+With `#!cpp Mode == view_mode::editable`, 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
+itself is never written; a read-only document (`#!cpp view_mode::read_only`, 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
@@ -32,9 +32,10 @@ bookkeeping edits need, and calling any of them on one fails to compile (`#!cpp
    [`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`
+`Mode`
-:   whether the document supports [`set`](set.md), [`push_back`](push_back.md), [`insert`](insert.md), and
+:   a [`view_mode`](../view_mode.md): `#!cpp view_mode::editable` if the document supports [`set`](set.md),
-    [`erase`](erase.md) (optional, `#!cpp false` by default). See [Edits](#edits) below.
+    [`push_back`](push_back.md), [`insert`](insert.md), and [`erase`](erase.md) (optional, `#!cpp view_mode::read_only`
    by default). See [Edits](#edits) below.
 ## Specializations
@@ -47,7 +48,7 @@ bookkeeping edits need, and calling any of them on one fails to compile (`#!cpp
 ## Member types
- **view_type** - the type of view returned by [`root()`](root.md) (`#!cpp basic_json_view<BasicJsonType, Editable>`)
+- **view_type** - the type of view returned by [`root()`](root.md) (`#!cpp basic_json_view<BasicJsonType, Mode>`)
 - **value_t** - the JSON type enumeration, see [`basic_json::value_t`](../basic_json/value_t.md)
 - **image_check** - how [`load()`](load.md) validates an image (`full`, `bounds`, `none`), see [`image_check`](load.md#image_check)
@@ -80,15 +81,15 @@ bookkeeping edits need, and calling any of them on one fails to compile (`#!cpp
 ### 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)
+  to (editable documents only)
- [**push_back**](push_back.md) - append to an array (`#!cpp Editable` documents only)
+- [**push_back**](push_back.md) - append to an array (editable documents only)
- [**insert**](insert.md) - insert an element into an array before a given position (`#!cpp Editable` documents only)
+- [**insert**](insert.md) - insert an element into an array before a given position (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)
+  (editable documents only)
 ## Edits
-An editable document (`#!cpp Editable == true`) can be changed after parsing, with [`set`](set.md),
+An editable document (`#!cpp view_mode::editable`) 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
@@ -115,6 +116,13 @@ points apply to every edit:
  [`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.
 ## See also
 - [Zero-copy JSON views](../../features/json_view.md) - guide to documents and views
 - [**basic_json_view**](../basic_json_view/index.md) - the non-owning handle to a value in a document
 - [**json_document**](../json_document.md) and [**json_editable_document**](../json_editable_document.md) - the default specializations
 - [**materialize**](../basic_json_view/materialize.md) - build a `basic_json` value from a view
 ## Version history
 - Added in version 3.13.0.
@@ -5,7 +5,7 @@ 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))
+Only an **editable** document (`#!cpp view_mode::editable`, 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
@@ -55,10 +55,7 @@ validate with overload 2 first, if the original vector must survive a failed loa
 ## Exceptions
-On a big-endian target, throws [`type_error.320`](../../home/exceptions.md#jsonexceptiontype_error320) -- the same
+Throws [`parse_error.116`](../../home/exceptions.md#jsonexceptionparse_error116) if `image` is not one
 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                                                                                                |
@@ -95,6 +92,9 @@ are checked once, however many nodes refer to it.
 ## Notes
 **Little-endian targets only.** On a big-endian target, `load()` does not exist, just like
 [`save()`](save.md#notes): the image format is little-endian, so a call fails to compile.
 ### `image_check` { #image_check }
 ```cpp
@@ -21,17 +21,19 @@ static basic_json_document parse(IteratorType first, IteratorType last,
 Both overloads accept the same JSON text as [`BasicJsonType::parse()`](../basic_json/parse.md), with the same
 `ignore_comments`/`ignore_trailing_commas` options, but build a [`basic_json_document`](index.md) (a flat index into
-the input) instead of a tree of `BasicJsonType` values. They take the same inputs as `BasicJsonType::parse()`. Byte
+the input) instead of a tree of `BasicJsonType` values. They accept every input `BasicJsonType::parse()` takes, and in
-inputs that stay alive can be borrowed; all others (streams, `#!cpp FILE*`, wide characters, non-contiguous
+addition a pointer to a null-terminated wide string (which `BasicJsonType::parse()` rejects). Contiguous inputs of
-iterators) are read into a copy that the document owns -- see the Notes. Use [`parse_copy()`](parse_copy.md) to get an
+single-byte characters that stay alive can be borrowed; all others (streams, `#!cpp FILE*`, wide characters, which
-owned copy of a borrowable input as well.
+must be converted to UTF-8, and non-contiguous iterators) are read into a copy that the document owns -- see the
 Notes. Use [`parse_copy()`](parse_copy.md) to get an owned copy of a borrowable input
 as well.
 ## Template parameters
 `InputType`
 :   A compatible input, for instance:
-    - a `#!cpp std::string`, `#!cpp std::string_view`, or a C-style array of single-byte characters
+    - a `#!cpp std::string`, a `#!cpp std::string_view` (C++17), or a C-style array of single-byte characters
    - a pointer to a null-terminated string of single-byte characters (`#!cpp char`, `#!cpp signed char`,
      `#!cpp unsigned char`, `#!cpp std::uint8_t`)
    - a container for which `#!cpp obj.data()` and `#!cpp obj.size()` give contiguous single-byte access, e.g.
@@ -47,6 +49,10 @@ owned copy of a borrowable input as well.
    `#!cpp std::string::iterator`; the iterators of single-byte characters are borrowed or read like the byte inputs
    above, those of wide characters are converted to UTF-8
 Ill-formed UTF-16 and UTF-32 sequences are rejected: a lone surrogate, a high surrogate that is not followed by its low
 surrogate, and a code point above `U+10FFFF` all yield a
 [`parse_error.101`](../../home/exceptions.md#jsonexceptionparse_error101).
 ## Parameters
 `input` (in)
@@ -155,3 +161,5 @@ buffer of a given length, pass a pair of pointers: `#!cpp parse(ptr, ptr + len)`
 ## Version history
 - Added in version 3.13.0.
 - Ill-formed UTF-16 and UTF-32 input (a lone surrogate, a high surrogate that is not followed by its low surrogate, or
  a code point above `U+10FFFF`) is rejected with `parse_error.101`.
@@ -13,7 +13,7 @@ editable, and it does not have to be `array`'s own document -- which is copied s
 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))
+Only an **editable** document (`#!cpp view_mode::editable`, 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
@@ -12,7 +12,7 @@ An edited document is written in its *current* state, with its values in documen
 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
+the same bytes -- also across `BasicJsonType` and the [`view_mode`](../view_mode.md), since the image reflects document order and
 values only, not which specialization produced them.
 ## Return value
@@ -31,9 +31,6 @@ Throws [`type_error.320`](../../home/exceptions.md#jsonexceptiontype_error320) i
 [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.
@@ -44,9 +41,6 @@ the decoded strings of the image would individually reach 4 GiB -- the same 32-b
    [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
    ```
@@ -70,9 +64,9 @@ else -- see [`load`'s Exceptions](load.md#exceptions).
    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
+**Little-endian targets only.** The image is written as raw little-endian bytes, with no byte-swapping. On a
-[`load`](load.md)) throw `type_error.320` on a big-endian target rather than silently produce bytes a big-endian
+big-endian target, `save()` and [`load`](load.md) do not exist: a call fails to compile rather than produce bytes a
-reader could not interpret correctly.
+big-endian reader could not interpret correctly.
 ## Examples
@@ -18,7 +18,7 @@ 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))
+Only an **editable** document (`#!cpp view_mode::editable`, 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`.
@@ -19,16 +19,36 @@ For the types below, the conversion works directly on the flat index -- no `Basi
  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>` -- from an array, element by element, each converted with `#!cpp get<U>()`; `#!cpp
+- `#!cpp std::vector<U, A>` of the types above -- from an array, element by element, each converted with
-  std::vector<basic_json_view>` keeps a view of every element instead of a value
+  `#!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
+- `#!cpp std::map<K, basic_json_view, C, A>` and `#!cpp std::unordered_map<K, basic_json_view, H, E, A>`, if `K` is
-  (const char*, std::size_t)` pair -- from an object, member by member, each value converted with `#!cpp get<V>()`; with a repeated
+  constructible from a `#!cpp (const char*, std::size_t)` pair -- views of the members of an object; with a repeated
-  key, the *last* value is kept, as [`BasicJsonType::parse()`](../basic_json/parse.md) (and
+  key, the view of the *last* member is kept, as [`BasicJsonType::parse()`](../basic_json/parse.md) keeps its value
  [`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
+A default-constructible `T` whose `from_json()` accepts views reads the view directly as well, without building a
-`from_json()`, ... -- is converted by `#!cpp materialize().get<T>()`: the subtree is built into a real `BasicJsonType`
+`BasicJsonType` value. This covers the library's own conversions of the standard library types -- all other
 `#!cpp std::vector`s, `#!cpp std::map`/`#!cpp std::unordered_map` (also with other key types), `#!cpp std::list`,
 `#!cpp std::deque`, `#!cpp std::set`, `#!cpp std::forward_list`, `#!cpp std::valarray`, `#!cpp std::array`, C arrays,
 `#!cpp std::pair`, `#!cpp std::tuple`, `#!cpp std::optional`, enumerations, `#!cpp std::filesystem::path`, ... --
 which give the same values as `#!cpp materialize().get<T>()` (from an object, a repeated key keeps the *last* value,
 as [`BasicJsonType::parse()`](../basic_json/parse.md) does), as well as the types of the
 [`NLOHMANN_DEFINE_TYPE_*`](../macros/nlohmann_define_type_intrusive.md) and
 [`NLOHMANN_DEFINE_DERIVED_TYPE_*`](../macros/nlohmann_define_derived_type.md) macros and the enumerations of
 [`NLOHMANN_JSON_SERIALIZE_ENUM`](../macros/nlohmann_json_serialize_enum.md), and any `from_json()` constrained to
 accept views, e.g. with [`is_json_view`](../is_json_view.md). A `from_json()` that also accepts types that are no JSON
 values at all, such as the unconstrained `#!cpp template<typename BasicJsonType> void from_json(const BasicJsonType&,
 T&)` of [arbitrary type conversions](../../features/arbitrary_types.md), is not called with a view: it may use
 `BasicJsonType` functions a view does not have. See [json_view](../../features/json_view.md).
 !!! warning "Duplicate keys"
    Such a `from_json()` looks members up in the view, where a repeated key finds the **first** member, while
    `#!cpp materialize().get<T>()` sees the **last** one, as [`BasicJsonType::parse()`](../basic_json/parse.md)
    keeps it: for `#!cpp {"x":1,"x":2}`, `#!cpp get<point>()` reads `#!cpp x == 1`. See
    [Duplicate keys](../../features/json_view.md#duplicate-keys).
 Every other `T` -- user types whose `from_json()` is written for `BasicJsonType` only, types without a default
 constructor, `#!cpp std::tuple`s holding references, ... -- 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.
@@ -53,12 +73,15 @@ Strong guarantee: there are no changes to the view or the document it refers to.
  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,
+- For `#!cpp std::map`/`#!cpp std::unordered_map` of views: throws `type_error.302` if the value is not an object.
-  whatever converting a member to the mapped type throws.
+- For a `T` whose `from_json()` reads the view: whatever that `from_json()` throws; for the library's conversions and
  the macros, the same exceptions with the same messages as [`BasicJsonType::get<T>()`](../basic_json/get.md) of the
  same value.
 - 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
+None of the exceptions thrown directly by this function or by a `from_json()` that reads the view (the first four
 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.
@@ -76,6 +99,8 @@ document.
 - `#!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.
 - a `T` whose `from_json()` reads the view: the cost of that `from_json()`; for the macros, linear in the number of
  members times the cost of a lookup, plus the cost of converting the members.
 - every other `T`: the cost of [`materialize()`](materialize.md) and of destroying the `BasicJsonType` value
  afterwards, plus that of [`BasicJsonType::get<T>()`](../basic_json/get.md).
@@ -5,12 +5,13 @@ template<typename T>
 T& get_to(T& v) const;
 ```
-Converts the value to `T` and stores it in `v`, in one of two ways:
+Converts the value to `T` and stores it in `v`, in one of three ways:
 - For the types that [`get<T>()`](get.md) converts directly -- arithmetic types, `#!cpp bool`,
  `#!cpp std::nullptr_t`, [`string_view_t`](index.md#member-types), `#!cpp std::basic_string`, `BasicJsonType`,
-  `basic_json_view`, `#!cpp std::vector`, and `#!cpp std::map`/`#!cpp std::unordered_map` with string keys -- `v` is
+  `basic_json_view`, vectors of these, and maps of views -- `v` is assigned: `#!cpp v = get<T>()`.
-  assigned: `#!cpp v = get<T>()`.
+- For a type whose `from_json()` accepts views (see [`get<T>()`](get.md)), that `from_json()` is called with the
  view and the existing `v`, without building a `BasicJsonType` value.
 - For every other type, the subtree is built into a `BasicJsonType` value and `#!cpp materialize().get_to(v)` is
  called, i.e. `from_json()` is invoked with the existing `v`, exactly as
  [`BasicJsonType::get_to()`](../basic_json/get_to.md) does.
@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
-template<typename BasicJsonType, bool Editable = false>
+template<typename BasicJsonType, view_mode Mode = view_mode::read_only>
 class basic_json_view;
 ```
@@ -37,7 +37,7 @@ Moving the document itself does not invalidate its views: the index is heap-allo
 `#!cpp operator ValueType()`), and no `#!cpp get_ptr()` or `#!cpp get_ref()`; see [`get`](get.md).
 `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
+**editable** document (`#!cpp view_mode::editable`) 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
@@ -49,9 +49,10 @@ still refers to it -- including ones taken before the change -- reads the new va
 :   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`
+`Mode`
-:   whether the view is of an editable document, matching the [`basic_json_document`](../basic_json_document/index.md)
+:   a [`view_mode`](../view_mode.md): whether the view is of an editable document, matching the
-    it was taken from (optional, `#!cpp false` by default). See [Edits](../basic_json_document/index.md#edits).
+    [`basic_json_document`](../basic_json_document/index.md) it was taken from (optional, `#!cpp view_mode::read_only` by
    default). See [Edits](../basic_json_document/index.md#edits).
 ## Specializations
@@ -63,6 +64,7 @@ still refers to it -- including ones taken before the change -- reads the new va
 ## Member types
 - **basic_json_type** - `BasicJsonType` (it also marks the class for [`is_json_view`](../is_json_view.md))
 - **value_t** - the JSON type enumeration, see [`basic_json::value_t`](../basic_json/value_t.md)
 - **string_t**, **number_integer_t**, **number_unsigned_t**, **number_float_t**, **json_pointer** - the corresponding
  member types of `BasicJsonType`
@@ -143,6 +145,13 @@ still refers to it -- including ones taken before the change -- reads the new va
 - [**source_offset**](source_offset.md) - byte offset of this value in the document's source text
 ## See also
 - [Zero-copy JSON views](../../features/json_view.md) - guide to documents and views
 - [**basic_json_document**](../basic_json_document/index.md) - the document that owns the parsed data
 - [**json_view**](../json_view.md) and [**json_editable_view**](../json_editable_view.md) - the default specializations
 - [**materialize**](materialize.md) - build a `basic_json` value from a view
 ## Version history
 - Added in version 3.13.0.
@@ -51,4 +51,4 @@ byte_container_with_subtype(container_type&& container, subtype_type subtype);
 ## Version history
-Since version 3.8.0.
+Added in version 3.8.0.
@@ -39,4 +39,4 @@ Constant.
 ## Version history
-Since version 3.8.0.
+Added in version 3.8.0.
@@ -42,4 +42,4 @@ Constant.
 ## Version history
-Since version 3.8.0.
+Added in version 3.8.0.
@@ -29,6 +29,14 @@ specific naming scheme in order to override the binary type.
 - [**has_subtype**](has_subtype.md) - return whether the value has a subtype
 - [**clear_subtype**](clear_subtype.md) - clears the binary subtype
 ## See also
 - [Binary values](../../features/binary_values.md) - how binary values and subtypes are handled
 - [**binary**](../basic_json/binary.md) - create a binary array value
 - [**get_binary**](../basic_json/get_binary.md) - get a reference to the stored binary value
 - [**binary_t**](../basic_json/binary_t.md) - type for binary arrays
 - [Binary formats](../../features/binary_formats/index.md) - formats that can store binary values
 ## Version history
 - Added in version 3.8.0.
@@ -44,4 +44,4 @@ Constant.
 ## Version history
-Since version 3.8.0.
+Added in version 3.8.0.
@@ -0,0 +1,55 @@
 # <small>nlohmann::</small>is_json_view
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
 template<typename T>
 struct is_json_view;
 ```
 A type trait: `#!cpp is_json_view<T>::value` is `#!cpp true` if `T` is a [`basic_json_view`](basic_json_view/index.md)
 of any `BasicJsonType` and any [`view_mode`](view_mode.md) -- [`json_view`](json_view.md),
 [`json_editable_view`](json_editable_view.md), [`ordered_json_view`](ordered_json_view.md), ... -- and
 `#!cpp false` otherwise, for [`basic_json`](basic_json/index.md) as well.
 It is meant for constraining templates that accept views, in particular a `from_json()` that should read views
 directly: [`get<T>()`](basic_json_view/get.md) on a view calls a `from_json()` with the view only if that `from_json()`
 accepts views but not arbitrary types.
 ## Template parameters
 `T`
 :   the type to check (without cv-qualifiers or references)
 ## Notes
 A view is recognized by its member type `basic_json_type` (a [`basic_json`](basic_json/index.md) specialization) and
 its [`materialize()`](basic_json_view/materialize.md) returning that type, so the trait needs no declaration of the
 view class.
 ## Examples
 ??? example
    The example below shows the trait, and a `from_json()` constrained to `json` values and views: `get<T>()` on a view
    reads the view directly.
    ```cpp
    --8<-- "examples/is_json_view.cpp"
    ```
    Output:
    ```
    --8<-- "examples/is_json_view.output"
    ```
 ## See also
 - [basic_json_view](basic_json_view/index.md) - a handle to one value of a document
 - [get](basic_json_view/get.md) - which conversions read the view directly
 - [view_mode](view_mode.md) - read-only or editable
 ## Version history
 Added in version 3.13.0.
@@ -30,4 +30,4 @@ types.
 ## Version history
-Since version 1.0.0.
+Added in version 1.0.0.
@@ -32,4 +32,4 @@ specialization.
 ## Version history
-Since version 3.13.0.
+Added in version 3.13.0.
@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
-using json_editable_document = basic_json_document<json, true>;
+using json_editable_document = basic_json_document<json, view_mode::editable>;
 ```
 This type is an **editable** [`basic_json_document`](basic_json_document/index.md) of the default
@@ -40,4 +40,4 @@ parsing, without ever rewriting the source text -- see [Edits](basic_json_docume
 ## Version history
-Since version 3.13.0.
+Added in version 3.13.0.
@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
-using json_editable_view = basic_json_view<json, true>;
+using json_editable_view = basic_json_view<json, view_mode::editable>;
 ```
 This type is a [`basic_json_view`](basic_json_view/index.md) of a value of a
@@ -38,4 +38,4 @@ still referring to it seeing the change, see [Edits](basic_json_document/index.m
 ## Version history
-Since version 3.13.0.
+Added in version 3.13.0.
@@ -51,5 +51,5 @@ operator string_t() const
 ## Version history
- Since version 2.0.0.
+- Added in version 2.0.0.
 - Changed type to `string_t` and deprecated in version 3.11.0.
@@ -49,5 +49,5 @@ ptr == json_pointer(ptr.to_string());
 ## Version history
- Since version 2.0.0.
+- Added in version 2.0.0.
 - Changed return type to `string_t` in version 3.11.0.
@@ -59,6 +59,13 @@ leading `-` sign.
 - [**start_object**](start_object.md) (_virtual_) - the beginning of an object was read
 - [**string**](string.md) (_virtual_) - a string value was read
 ## See also
 - [SAX interface](../../features/parsing/sax_interface.md) - guide to event-based parsing
 - [**sax_parse**](../basic_json/sax_parse.md) - generate SAX events from an input
 - [**parse**](../basic_json/parse.md) - DOM parsing, with optional [parser callbacks](../../features/parsing/parser_callbacks.md)
 - [Parse exceptions](../../features/parsing/parse_exceptions.md)
 ## Version history
 - Added in version 3.2.0.
@@ -31,4 +31,4 @@ This type is a [`basic_json_view`](basic_json_view/index.md) of a value of a [`j
 ## Version history
-Since version 3.13.0.
+Added in version 3.13.0.
@@ -43,8 +43,6 @@ 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
@@ -137,4 +135,13 @@ header. See also the [macro overview page](../../features/macros.md).
 - [**NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT_WITH_NAMES**](nlohmann_define_type_with_names.md) - serialize/deserialize
  a derived class; uses default values; uses custom names
 - [**NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE_WITH_NAMES**](nlohmann_define_type_with_names.md) - serialize a derived
-  class; uses custom names
+  class; uses custom names
 ## See also
 - [Macros](../../features/macros.md) - guide to the supported macros
 - [Runtime assertions](../../features/assertions.md)
 - [Arbitrary type conversions](../../features/arbitrary_types.md) - using the `NLOHMANN_DEFINE_TYPE_*` macros
 - [Enum conversion](../../features/enum_conversion.md) - using `NLOHMANN_JSON_SERIALIZE_ENUM`
 - [The `nlohmann` namespace](../../features/namespace.md)
 - [CMake integration](../../integration/cmake.md) - setting macros from the build system
@@ -5,7 +5,8 @@
 ```
 When defined, the library uses only portable C++ code where it would otherwise use vector instructions: when scanning
-strings during parsing, and when writing floating-point numbers during serialization.
+strings during parsing, and when writing floating-point numbers during serialization. This includes the parser of
 [`basic_json_document`](../basic_json_document/index.md) (`<nlohmann/json_view.hpp>`).
 The macro is an escape hatch, for example for toolchains that cannot compile the vector code, for sanitizers or
 analyzers that do not understand it, or to compare the speed of both variants. It does not change any result: values,
@@ -77,6 +78,7 @@ By default, `#!cpp JSON_NO_SIMD` is not defined, and vector instructions are use
 - [**JSON_USE_SIMDUTF**](json_use_simdutf.md) - use the simdutf library to accelerate UTF-8 validation
 - [**JSON_DISABLE_STREAM_BULK_SCAN**](json_disable_stream_bulk_scan.md) - read a `std::istream` one character at a time
 - [Parsing: input sources and performance](../../features/parsing/index.md#input-sources-and-performance)
 - [json_view](../../features/json_view.md) - the zero-copy view, whose parser the macro also affects
 ## Version history
@@ -1,52 +0,0 @@
 # 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.
 !!! note "ABI compatibility"
    The macro selects between two definitions of the same inline functions. Whether it is defined is encoded in the
    [namespace](../../features/namespace.md) (tag `_vns`), resulting in distinct symbol names. Translation units
    compiled with and without it can therefore be linked into the same program without One Definition Rule (ODR)
    violations, but they cannot exchange instances of library types.
 ## 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.
@@ -1,53 +0,0 @@
 # 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 without asking the CPU first.
 By default, the parser checks once at run time whether the CPU has SSSE3 (all x86-64 CPUs since about 2011 have it)
 and then validates non-ASCII text 16 bytes at a time, using the "lookup4" algorithm of
 [simdjson](https://github.com/simdjson/simdjson); on CPUs without SSSE3, it validates one UTF-8 sequence at a time.
 The vector check is compiled for SSSE3 with a function attribute (GCC 4.9 and later, Clang), so this needs no compiler
 option. With MSVC, the check uses `__cpuid`. On AArch64, the vector check uses NEON and is always on.
 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. It saves the check of the CPU, which costs little. The same
 input is accepted or rejected either way; only the speed of non-ASCII text differs.
 !!! note "ABI compatibility"
    The macro selects between two definitions of the same inline functions. Whether it is defined is encoded in the
    [namespace](../../features/namespace.md) (tag `_vssse3`, on every architecture), resulting in distinct symbol
    names. Translation units compiled with and without it can therefore be linked into the same program without One
    Definition Rule (ODR) violations, but they cannot exchange instances of library types.
 ## 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.
@@ -147,6 +147,13 @@ void to_json(BasicJsonType& j, const B& b) {
    See Implementation limits for [NLOHMANN_DEFINE_TYPE_INTRUSIVE](nlohmann_define_type_intrusive.md) and
    [NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE](nlohmann_define_type_non_intrusive.md), respectively.
 !!! info "Views"
    The generated `from_json()` also reads the views of [`json_document`](../json_document.md)s
    (`<nlohmann/json_view.hpp>`): [`get<T>()`](../basic_json_view/get.md) on a view looks the members up in the
    view, without building a `json` value first. The base part is read from the view as well if the base's
    `from_json()` accepts views, and from [`materialize()`](../basic_json_view/materialize.md) otherwise.
 ## Examples
 ??? example "Example: (1) NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE"
@@ -192,3 +199,5 @@ void to_json(BasicJsonType& j, const B& b) {
 6. Added in version 3.12.0.
 All six macros were changed to allow an empty member list in version 3.13.0.
 The generated `from_json()` reads the views of `json_document`s since version 3.13.0.
@@ -81,6 +81,12 @@ See the examples below for the concrete generated code.
      that serializes a struct's members positionally into a JSON array; for that, write `to_json`/`from_json` by
      hand, building/reading a `json::array()` of the members in order.
 !!! info "Views"
    The generated `from_json()` also reads the views of [`json_document`](../json_document.md)s
    (`<nlohmann/json_view.hpp>`): [`get<T>()`](../basic_json_view/get.md) on a view looks the members up in the
    view, without building a `json` value first.
 ## Examples
 ??? example "Example: (1) NLOHMANN_DEFINE_TYPE_INTRUSIVE"
@@ -189,3 +195,5 @@ See the examples below for the concrete generated code.
 All three macros were changed to work with any `basic_json` specialization (not only `nlohmann::json`) in version 3.12.0,
 and to allow an empty member list in version 3.13.0.
 The generated `from_json()` reads the views of `json_document`s since version 3.13.0.
@@ -80,6 +80,12 @@ See the examples below for the concrete generated code.
      that serializes a struct's members positionally into a JSON array; for that, write `to_json`/`from_json` by
      hand, building/reading a `json::array()` of the members in order.
 !!! info "Views"
    The generated `from_json()` also reads the views of [`json_document`](../json_document.md)s
    (`<nlohmann/json_view.hpp>`): [`get<T>()`](../basic_json_view/get.md) on a view looks the members up in the
    view, without building a `json` value first.
 ## Examples
 ??? example "Example: (1) NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE"
@@ -188,3 +194,5 @@ See the examples below for the concrete generated code.
 All three macros were changed to work with any `basic_json` specialization (not only `nlohmann::json`) in version 3.12.0,
 and to allow an empty member list in version 3.13.0.
 The generated `from_json()` reads the views of `json_document`s since version 3.13.0.
@@ -39,6 +39,6 @@ the library.
 ## Version history
 - Added in version 3.11.0. Changed inline namespace name in version 3.11.2. Added the ABI tag `_dp` in
-  version 3.12.0, and the ABI tags `_bics`, `_psp`, `_snul`, `_sbu8`, `_ekmo`, `_dsbs`, `_dufio`, `_ns`, `_vns`,
+  version 3.12.0, and the ABI tags `_bics`, `_psp`, `_snul`, `_sbu8`, `_ekmo`, `_dsbs`, `_dufio`, and `_ns` in
-  and `_vssse3` in version 3.13.0; see
+  version 3.13.0; see
  [`nlohmann` Namespace](../../features/namespace.md#structure).
@@ -45,6 +45,12 @@ inline void from_json(const BasicJsonType& j, type& e);
      Define [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](json_use_objects_for_enum_keyed_maps.md) to store them as objects
      with the converted keys. Such maps can be read from both forms.
 !!! info "Views"
    The generated `from_json()` also reads the views of [`json_document`](../json_document.md)s
    (`<nlohmann/json_view.hpp>`), comparing the view with the entries of the mapping, without building a `json` value
    first.
 ## Examples
 ??? example "Example: Basic usage"
@@ -88,3 +94,5 @@ inline void from_json(const BasicJsonType& j, type& e);
 ## Version history
 Added in version 3.4.0.
 The generated `from_json()` reads the views of `json_document`s since version 3.13.0.
@@ -48,6 +48,12 @@ inline void from_json(const BasicJsonType& j, type& e);
      Define [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](json_use_objects_for_enum_keyed_maps.md) to store them as objects
      with the converted keys. Such maps can be read from both forms.
 !!! info "Views"
    The generated `from_json()` also reads the views of [`json_document`](../json_document.md)s
    (`<nlohmann/json_view.hpp>`), comparing the view with the entries of the mapping, without building a `json` value
    first.
 ## Examples
 ??? example "Example: Basic usage"
@@ -42,4 +42,4 @@ parsing an object of `n` keys costs O(n²) rather than O(n log n). See
 ## Version history
-Since version 3.9.0.
+Added in version 3.9.0.
@@ -35,4 +35,4 @@ of object keys, instead of sorting them like [`json_document`](json_document.md)
 ## Version history
-Since version 3.13.0.
+Added in version 3.13.0.
@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
-using ordered_json_editable_document = basic_json_document<ordered_json, true>;
+using ordered_json_editable_document = basic_json_document<ordered_json, view_mode::editable>;
 ```
 This type is an **editable** [`basic_json_document`](basic_json_document/index.md) of the
@@ -44,4 +44,4 @@ members [`set`](basic_json_document/set.md) added -- instead of sorting them lik
 ## Version history
-Since version 3.13.0.
+Added in version 3.13.0.
@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
-using ordered_json_editable_view = basic_json_view<ordered_json, true>;
+using ordered_json_editable_view = basic_json_view<ordered_json, view_mode::editable>;
 ```
 This type is a [`basic_json_view`](basic_json_view/index.md) of a value of an
@@ -37,4 +37,4 @@ This type is a [`basic_json_view`](basic_json_view/index.md) of a value of an
 ## Version history
-Since version 3.13.0.
+Added in version 3.13.0.
@@ -32,4 +32,4 @@ This type is a [`basic_json_view`](basic_json_view/index.md) of a value of an
 ## Version history
-Since version 3.13.0.
+Added in version 3.13.0.
@@ -0,0 +1,80 @@
 # <small>nlohmann::</small>view_mode
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 ```cpp
 enum class view_mode : std::uint8_t
 {
    read_only,
    editable
 };
 ```
 The second template parameter of [`basic_json_document`](basic_json_document/index.md) and
 [`basic_json_view`](basic_json_view/index.md): whether a document can be changed after parsing, and whether a view is
 of such a document.
 `read_only`
 :   the default: the document is parsed once and then only read. It carries none of the bookkeeping edits need, and
    calling [`set`](basic_json_document/set.md), [`push_back`](basic_json_document/push_back.md),
    [`insert`](basic_json_document/insert.md), or [`erase`](basic_json_document/erase.md) on it fails to compile.
 `editable`
 :   the document also offers [`set`](basic_json_document/set.md), [`push_back`](basic_json_document/push_back.md),
    [`insert`](basic_json_document/insert.md), and [`erase`](basic_json_document/erase.md); its views see every edit,
    see [Edits](basic_json_document/index.md#edits).
 The shortcuts name both modes: [`json_document`](json_document.md) and [`json_view`](json_view.md) are read-only,
 [`json_editable_document`](json_editable_document.md) and [`json_editable_view`](json_editable_view.md) are editable
 (and likewise for `ordered_json`).
 ## Notes
 The mode is part of the view's type, and there is no conversion between the two modes: a read-only view reads a
 container in place, while a view of an editable document follows the links that edits leave behind. A function that
 accepts views therefore names the modes it accepts in its signature:
 ```cpp
 // views of editable documents only
 template<typename BasicJsonType>
 void f(basic_json_view<BasicJsonType, view_mode::editable> v);
 // views of read-only documents only
 template<typename BasicJsonType>
 void f(basic_json_view<BasicJsonType, view_mode::read_only> v);
 // either
 template<typename BasicJsonType, view_mode Mode>
 void f(basic_json_view<BasicJsonType, Mode> v);
 ```
 A function that takes a [`json_view`](json_view.md) accepts neither an [`ordered_json_view`](ordered_json_view.md)
 nor a [`json_editable_view`](json_editable_view.md). Views of the two modes still compare with
 [`operator==`](basic_json_view/operator_eq.md).
 ## Examples
 ??? example
    The example below shows a function template that accepts the views of both modes, and one that accepts only
    views of editable documents.
    ```cpp
    --8<-- "examples/view_mode.cpp"
    ```
    Output:
    ```
    --8<-- "examples/view_mode.output"
    ```
 ## See also
 - [basic_json_document](basic_json_document/index.md) - a parsed JSON text
 - [basic_json_view](basic_json_view/index.md) - a handle to one value of a document
 - [json_editable_document](json_editable_document.md) - an editable document of `json`
 ## Version history
 Added in version 3.13.0.
@@ -58,7 +58,7 @@ particular, a 3.x release does not:
 - remove or rename a documented macro, CMake option, CMake target, or header, or change what a documented macro does.
 Exceptions to these rules, for instance when fixing a bug requires changing the exception a function throws, are
-documented in the [release notes](../home/releases.md).
+documented in the [release notes](../home/releases/index.md).
 The following are **not** part of the public API and may change in any release, including patch releases:
@@ -18,3 +18,32 @@
    white-space: nowrap;
    cursor: help;
 }
 /* byte layout tables of the binary formats */
 .md-typeset .byte-layout td code {
    white-space: pre-wrap;
 }
 .md-typeset .bl {
    display: inline-block;
    padding: 0 .25em;
    border-radius: .2em;
    font-family: var(--md-code-font-family);
    font-size: .85em;
    white-space: nowrap;
 }
 .md-typeset .bl-t {
    background-color: rgba(66, 133, 244, .25);
    box-shadow: inset 0 -.12em 0 rgba(66, 133, 244, .8);
 }
 .md-typeset .bl-l {
    background-color: rgba(251, 140, 0, .25);
    box-shadow: inset 0 -.12em 0 rgba(251, 140, 0, .8);
 }
 .md-typeset .bl-d {
    background-color: rgba(67, 160, 71, .25);
    box-shadow: inset 0 -.12em 0 rgba(67, 160, 71, .8);
 }
@@ -0,0 +1,18 @@
 #include <iostream>
 #include <string>
 #include <nlohmann/json.hpp>
 using json = nlohmann::json;
 int main()
 {
    // a valid JSON text, given as UTF-16
    const std::u16string valid_text = u"{\"name\":\"\u00e9\"}";
    // an invalid JSON text, given as UTF-16
    const std::u16string invalid_text = u"{\"name\":\"\u00e9\",}";
    std::cout << std::boolalpha
              << json::accept(valid_text) << ' '
              << json::accept(invalid_text) << '\n';
 }
@@ -0,0 +1 @@
 true false
@@ -0,0 +1,34 @@
 #include <iostream>
 #include <type_traits>
 #include <nlohmann/json_view.hpp>
 using nlohmann::json;
 namespace ns
 {
 struct person
 {
    std::string name;
    int age = 0;
 };
 // reads json values and views (of any document type), but nothing else
 template < typename J, typename std::enable_if < nlohmann::is_json_view<J>::value || std::is_same<J, json>::value, int >::type = 0 >
 void from_json(const J& j, person& p)
 {
    p.name = j.at("name").template get<std::string>();
    p.age = j.at("age").template get<int>();
 }
 } // namespace ns
 int main()
 {
    std::cout << std::boolalpha
              << nlohmann::is_json_view<nlohmann::json_view>::value << ' '
              << nlohmann::is_json_view<nlohmann::ordered_json_editable_view>::value << ' '
              << nlohmann::is_json_view<json>::value << '\n';
    const nlohmann::json_document doc = nlohmann::json_document::parse(R"({"name": "Ada", "age": 36})");
    const auto p = doc.root().get<ns::person>(); // reads the view, no json value is built
    std::cout << p.name << ' ' << p.age << '\n';
 }
@@ -0,0 +1,2 @@
 true true false
 Ada 36
@@ -5,7 +5,7 @@ using ordered_json_editable_document = nlohmann::ordered_json_editable_document;
 int main()
 {
-    // ordered_json_editable_document is basic_json_document<nlohmann::ordered_json, true>
+    // ordered_json_editable_document is basic_json_document<nlohmann::ordered_json, nlohmann::view_mode::editable>
    ordered_json_editable_document doc = ordered_json_editable_document::parse(R"({"z": 1, "a": 2, "m": 3})");
    doc.set(doc.root(), "b", 4); // set() always appends a new member at the end
@@ -0,0 +1,27 @@
 #include <iostream>
 #include <string>
 #include <nlohmann/json.hpp>
 using json = nlohmann::json;
 int main()
 {
    // the same JSON text, given in different encodings
    const std::string utf8 = "{\"name\":\"\u00e9\"}";
    const std::u16string utf16 = u"{\"name\":\"\u00e9\"}";
    const std::u32string utf32 = U"{\"name\":\"\u00e9\"}";
    const std::wstring wide = L"{\"name\":\"\u00e9\"}";
    // the encoding is deduced from the character type of the input, and all
    // of them yield the same value
    std::cout << json::parse(utf8) << '\n'
              << json::parse(utf16) << '\n'
              << json::parse(utf32) << '\n'
              << json::parse(wide) << '\n';
    // a wide string literal works as well: u"..." is UTF-16, U"..." is UTF-32
    std::cout << json::parse(u"[1, 2, 3]") << '\n';
    // iterators over wide characters work as well
    std::cout << json::parse(utf16.begin(), utf16.end()) << '\n';
 }
@@ -0,0 +1,6 @@
 {"name":"é"}
 {"name":"é"}
 {"name":"é"}
 {"name":"é"}
 [1,2,3]
 {"name":"é"}
@@ -0,0 +1,29 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 using nlohmann::basic_json_view;
 using nlohmann::view_mode;
 // accepts the views of read-only and of editable documents, of json and of ordered_json
 template<typename BasicJsonType, view_mode Mode>
 std::size_t count_members(basic_json_view<BasicJsonType, Mode> v)
 {
    return v.is_object() ? v.size() : 0;
 }
 // accepts only the views of editable documents
 template<typename BasicJsonType>
 bool is_edited(basic_json_view<BasicJsonType, view_mode::editable> v)
 {
    return v.is_string() && v.get_string() == "edited";
 }
 int main()
 {
    const nlohmann::json_document doc = nlohmann::json_document::parse(R"({"a": 1, "b": 2})");
    nlohmann::json_editable_document edoc = nlohmann::json_editable_document::parse(R"({"a": 1})");
    edoc.set(edoc.root()["a"], "edited");
    std::cout << count_members(doc.root()) << ' ' << count_members(edoc.root()) << '\n';
    std::cout << std::boolalpha << is_edited(edoc.root()["a"]) << '\n';
 }
@@ -0,0 +1,2 @@
 2 1
 true
@@ -190,6 +190,41 @@ The library uses the following mapping from JSON values types to BJData types ac
    --8<-- "examples/to_bjdata.output"
    ```
 ### Byte layout
 Consider the following JSON value (shown formatted for readability):
 ```json
 {
  "id": 300,
  "name": "json",
  "pi": 3.14,
  "tags": [
    "a",
    "b"
  ]
 }
 ```
 `to_bjdata` encodes it to 51 bytes (shown in hexadecimal; the encoding contains no whitespace). The colors mark the role of each byte: <span class="bl bl-t">type/marker</span> <span class="bl bl-l">length/count/size</span> <span class="bl bl-d">data</span>.
 <div class="byte-layout" markdown="0"><table>
 <thead><tr><th>JSON</th><th>Bytes</th><th>Meaning</th></tr></thead><tbody>
 <tr><td><code>{</code></td><td><span class="bl bl-t">7B</span></td><td>object start (<code>{</code>)</td></tr>
 <tr><td><code>&quot;id&quot;: 300,</code></td><td><span class="bl bl-l">69 02</span> <span class="bl bl-d">69 64</span> <span class="bl bl-t">49</span> <span class="bl bl-d">2C 01</span></td><td>key: length 2 as int8 (<code>i</code>), then UTF-8 bytes; value: int16 (<code>I</code>), little-endian</td></tr>
 <tr><td><code>&quot;name&quot;: &quot;json&quot;,</code></td><td><span class="bl bl-l">69 04</span> <span class="bl bl-d">6E 61 6D 65</span> <span class="bl bl-t">53</span> <span class="bl bl-l">69 04</span> <span class="bl bl-d">6A 73 6F 6E</span></td><td>key: length 4; value: string (<code>S</code>), length 4 as int8, UTF-8 bytes</td></tr>
 <tr><td><code>&quot;pi&quot;: 3.14,</code></td><td><span class="bl bl-l">69 02</span> <span class="bl bl-d">70 69</span> <span class="bl bl-t">44</span> <span class="bl bl-d">1F 85 EB 51 B8 1E 09 40</span></td><td>key: length 2; value: float64 (<code>D</code>), little-endian</td></tr>
 <tr><td><code>&quot;tags&quot;: [</code></td><td><span class="bl bl-l">69 04</span> <span class="bl bl-d">74 61 67 73</span> <span class="bl bl-t">5B</span></td><td>key: length 4; value: array start (<code>[</code>)</td></tr>
 <tr><td><code>&quot;a&quot;,</code></td><td><span class="bl bl-t">53</span> <span class="bl bl-l">69 01</span> <span class="bl bl-d">61</span></td><td>string, length 1</td></tr>
 <tr><td><code>&quot;b&quot;</code></td><td><span class="bl bl-t">53</span> <span class="bl bl-l">69 01</span> <span class="bl bl-d">62</span></td><td>string, length 1</td></tr>
 <tr><td><code>]</code></td><td><span class="bl bl-t">5D</span></td><td>array end (<code>]</code>)</td></tr>
 <tr><td><code>}</code></td><td><span class="bl bl-t">7D</span></td><td>object end (<code>}</code>)</td></tr>
 </tbody></table></div>
 ## Deserialization
 The library maps BJData types to JSON value types as follows:
@@ -105,6 +105,41 @@ serialized as 0x81 0x65 0xFF, but `[1,2,3,4,"e"]` as 0x85 0x91 0x92 0x93 0x94 0x
    --8<-- "examples/to_bon8.output"
    ```
 ### Byte layout
 Consider the following JSON value (shown formatted for readability):
 ```json
 {
  "id": 300,
  "name": "json",
  "pi": 3.14,
  "tags": [
    "a",
    "b"
  ]
 }
 ```
 `to_bon8` encodes it to 35 bytes (shown in hexadecimal; the encoding contains no whitespace). The colors mark the role of each byte: <span class="bl bl-t">type/marker</span> <span class="bl bl-l">length/count/size</span> <span class="bl bl-d">data</span>.
 <div class="byte-layout" markdown="0"><table>
 <thead><tr><th>JSON</th><th>Bytes</th><th>Meaning</th></tr></thead><tbody>
 <tr><td><code>{</code></td><td><span class="bl bl-t">8A</span></td><td>object with 4 members</td></tr>
 <tr><td><code>&quot;id&quot;: 300,</code></td><td><span class="bl bl-d">69 64</span> <span class="bl bl-t">C4</span> <span class="bl bl-d">04</span></td><td>key: UTF-8 bytes; the string ends at the next byte, which cannot continue a UTF-8 character; value: 2-byte positive integer (lead byte, then a byte below 0x80)</td></tr>
 <tr><td><code>&quot;name&quot;: &quot;json&quot;,</code></td><td><span class="bl bl-d">6E 61 6D 65</span> <span class="bl bl-l">FF</span> <span class="bl bl-d">6A 73 6F 6E</span> <span class="bl bl-l">FF</span></td><td>key: UTF-8 bytes; 0xFF terminates the string as another string follows; value: UTF-8 bytes; terminated as a string key follows</td></tr>
 <tr><td><code>&quot;pi&quot;: 3.14,</code></td><td><span class="bl bl-d">70 69</span> <span class="bl bl-t">8F</span> <span class="bl bl-d">40 09 1E B8 51 EB 85 1F</span></td><td>key: UTF-8 bytes; value: binary64 (IEEE 754, big-endian); its marker also ends <code>&quot;pi&quot;</code></td></tr>
 <tr><td><code>&quot;tags&quot;: [</code></td><td><span class="bl bl-d">74 61 67 73</span> <span class="bl bl-t">82</span></td><td>key: UTF-8 bytes; value: array with 2 elements; its marker also ends <code>&quot;tags&quot;</code></td></tr>
 <tr><td><code>&quot;a&quot;,</code></td><td><span class="bl bl-d">61</span> <span class="bl bl-l">FF</span></td><td>UTF-8 bytes; terminated as a string follows</td></tr>
 <tr><td><code>&quot;b&quot;</code></td><td><span class="bl bl-d">62</span> <span class="bl bl-l">FF</span></td><td>UTF-8 bytes; terminated as nothing follows</td></tr>
 <tr><td><code>]</code></td><td></td><td>no end marker: the element count was given up front</td></tr>
 <tr><td><code>}</code></td><td></td><td>no end marker: the member count was given up front</td></tr>
 </tbody></table></div>
 ## Deserialization
 The library maps BON8 types to JSON value types as follows:
@@ -61,6 +61,41 @@ The library uses the following mapping from JSON values types to BSON types:
    ```
 ### Byte layout
 Consider the following JSON value (shown formatted for readability):
 ```json
 {
  "id": 300,
  "name": "json",
  "pi": 3.14,
  "tags": [
    "a",
    "b"
  ]
 }
 ```
 `to_bson` encodes it to 69 bytes (shown in hexadecimal; the encoding contains no whitespace). The colors mark the role of each byte: <span class="bl bl-t">type/marker</span> <span class="bl bl-l">length/count/size</span> <span class="bl bl-d">data</span>.
 <div class="byte-layout" markdown="0"><table>
 <thead><tr><th>JSON</th><th>Bytes</th><th>Meaning</th></tr></thead><tbody>
 <tr><td><code>{</code></td><td><span class="bl bl-l">45 00 00 00</span></td><td>document size: 69 bytes (int32, little-endian)</td></tr>
 <tr><td><code>&quot;id&quot;: 300,</code></td><td><span class="bl bl-t">10</span> <span class="bl bl-d">69 64 00</span> <span class="bl bl-d">2C 01 00 00</span></td><td>int32 element; key as NUL-terminated string; value (little-endian)</td></tr>
 <tr><td><code>&quot;name&quot;: &quot;json&quot;,</code></td><td><span class="bl bl-t">02</span> <span class="bl bl-d">6E 61 6D 65 00</span> <span class="bl bl-l">05 00 00 00</span> <span class="bl bl-d">6A 73 6F 6E 00</span></td><td>string element; key; length incl. NUL (int32); NUL-terminated UTF-8 bytes</td></tr>
 <tr><td><code>&quot;pi&quot;: 3.14,</code></td><td><span class="bl bl-t">01</span> <span class="bl bl-d">70 69 00</span> <span class="bl bl-d">1F 85 EB 51 B8 1E 09 40</span></td><td>double element; key; value (little-endian)</td></tr>
 <tr><td><code>&quot;tags&quot;: [</code></td><td><span class="bl bl-t">04</span> <span class="bl bl-d">74 61 67 73 00</span> <span class="bl bl-l">17 00 00 00</span></td><td>array element; key; embedded document of 23 bytes (keys are the indices)</td></tr>
 <tr><td><code>&quot;a&quot;,</code></td><td><span class="bl bl-t">02</span> <span class="bl bl-d">30 00</span> <span class="bl bl-l">02 00 00 00</span> <span class="bl bl-d">61 00</span></td><td>string element; key <code>&quot;0&quot;</code>; length 2; <code>a</code> + NUL</td></tr>
 <tr><td><code>&quot;b&quot;</code></td><td><span class="bl bl-t">02</span> <span class="bl bl-d">31 00</span> <span class="bl bl-l">02 00 00 00</span> <span class="bl bl-d">62 00</span></td><td>string element; key <code>&quot;1&quot;</code>; length 2; <code>b</code> + NUL</td></tr>
 <tr><td><code>]</code></td><td><span class="bl bl-t">00</span></td><td>end of the array document</td></tr>
 <tr><td><code>}</code></td><td><span class="bl bl-t">00</span></td><td>end of the document</td></tr>
 </tbody></table></div>
 ## Deserialization
 The library maps BSON record types to JSON value types as follows:
@@ -110,6 +110,41 @@ see "binary" cells in the table above.
    --8<-- "examples/to_cbor.output"
    ```
 ### Byte layout
 Consider the following JSON value (shown formatted for readability):
 ```json
 {
  "id": 300,
  "name": "json",
  "pi": 3.14,
  "tags": [
    "a",
    "b"
  ]
 }
 ```
 `to_cbor` encodes it to 39 bytes (shown in hexadecimal; the encoding contains no whitespace). The colors mark the role of each byte: <span class="bl bl-t">type/marker</span> <span class="bl bl-l">length/count/size</span> <span class="bl bl-d">data</span>.
 <div class="byte-layout" markdown="0"><table>
 <thead><tr><th>JSON</th><th>Bytes</th><th>Meaning</th></tr></thead><tbody>
 <tr><td><code>{</code></td><td><span class="bl bl-t">A4</span></td><td>map with 4 key/value pairs</td></tr>
 <tr><td><code>&quot;id&quot;: 300,</code></td><td><span class="bl bl-t">62</span> <span class="bl bl-d">69 64</span> <span class="bl bl-t">19</span> <span class="bl bl-d">01 2C</span></td><td>key: text string of length 2, then its UTF-8 bytes; value: unsigned integer, 2 bytes follow (big-endian)</td></tr>
 <tr><td><code>&quot;name&quot;: &quot;json&quot;,</code></td><td><span class="bl bl-t">64</span> <span class="bl bl-d">6E 61 6D 65</span> <span class="bl bl-t">64</span> <span class="bl bl-d">6A 73 6F 6E</span></td><td>key: text string of length 4; value: text string of length 4</td></tr>
 <tr><td><code>&quot;pi&quot;: 3.14,</code></td><td><span class="bl bl-t">62</span> <span class="bl bl-d">70 69</span> <span class="bl bl-t">FB</span> <span class="bl bl-d">40 09 1E B8 51 EB 85 1F</span></td><td>key: text string of length 2; value: double-precision float (IEEE 754, big-endian)</td></tr>
 <tr><td><code>&quot;tags&quot;: [</code></td><td><span class="bl bl-t">64</span> <span class="bl bl-d">74 61 67 73</span> <span class="bl bl-t">82</span></td><td>key: text string of length 4; value: array with 2 elements</td></tr>
 <tr><td><code>&quot;a&quot;,</code></td><td><span class="bl bl-t">61</span> <span class="bl bl-d">61</span></td><td>text string of length 1</td></tr>
 <tr><td><code>&quot;b&quot;</code></td><td><span class="bl bl-t">61</span> <span class="bl bl-d">62</span></td><td>text string of length 1</td></tr>
 <tr><td><code>]</code></td><td></td><td>no end marker: the element count was given up front</td></tr>
 <tr><td><code>}</code></td><td></td><td>no end marker: the member count was given up front</td></tr>
 </tbody></table></div>
 ## Deserialization
 The library maps CBOR types to JSON value types as follows:
@@ -45,12 +45,19 @@ See [binary values](../binary_values.md) for more information.
 | BJData             | 53.2 %      | 91.1 %       | 78.1 %            | 96.6 %        |
 | BJData (size)      | 58.6 %      | 92.1 %       | 86.7 %            | 97.4 %        |
 | BJData (size+type) | 58.6 %      | 92.1 %       | 86.5 %            | 97.4 %        |
-| BON8               | 50.5 %      | 83.8 %       | 63.5 %            | 87.5 %        |
+| BON8               | **50.5 %**  | **83.8 %**   | **63.5 %**        | **87.5 %**    |
 | BSON               | 85.8 %      | 95.2 %       | 95.8 %            | 106.7 %       |
-| CBOR               | 50.5 %      | 86.3 %       | 68.4 %            | 88.0 %        |
+| CBOR               | **50.5 %**  | 86.3 %       | 68.4 %            | 88.0 %        |
-| MessagePack        | 50.5 %      | 86.0 %       | 68.5 %            | 87.9 %        |
+| MessagePack        | **50.5 %**  | 86.0 %       | 68.5 %            | 87.9 %        |
 | UBJSON             | 53.2 %      | 91.3 %       | 78.2 %            | 96.6 %        |
 | UBJSON (size)      | 58.6 %      | 92.3 %       | 86.8 %            | 97.4 %        |
 | UBJSON (size+type) | 55.9 %      | 92.3 %       | 85.0 %            | 95.0 %        |
-Sizes compared to minified JSON value.
+Sizes compared to minified JSON value; the smallest size per file is printed in bold.
 ## See also
 - [Binary values](../binary_values.md) - binary values and subtypes
 - [**to_cbor**](../../api/basic_json/to_cbor.md) / [**from_cbor**](../../api/basic_json/from_cbor.md), [**to_msgpack**](../../api/basic_json/to_msgpack.md) / [**from_msgpack**](../../api/basic_json/from_msgpack.md), [**to_bson**](../../api/basic_json/to_bson.md) / [**from_bson**](../../api/basic_json/from_bson.md), [**to_ubjson**](../../api/basic_json/to_ubjson.md) / [**from_ubjson**](../../api/basic_json/from_ubjson.md), [**to_bjdata**](../../api/basic_json/to_bjdata.md) / [**from_bjdata**](../../api/basic_json/from_bjdata.md), [**to_bon8**](../../api/basic_json/to_bon8.md) / [**from_bon8**](../../api/basic_json/from_bon8.md) - the conversion functions
 - [Parsing untrusted input](../parsing/untrusted_input.md)
 - [SAX interface](../parsing/sax_interface.md) - decode binary formats without building a value
@@ -91,6 +91,41 @@ specification:
    --8<-- "examples/to_msgpack.output"
    ```
 ### Byte layout
 Consider the following JSON value (shown formatted for readability):
 ```json
 {
  "id": 300,
  "name": "json",
  "pi": 3.14,
  "tags": [
    "a",
    "b"
  ]
 }
 ```
 `to_msgpack` encodes it to 39 bytes (shown in hexadecimal; the encoding contains no whitespace). The colors mark the role of each byte: <span class="bl bl-t">type/marker</span> <span class="bl bl-l">length/count/size</span> <span class="bl bl-d">data</span>.
 <div class="byte-layout" markdown="0"><table>
 <thead><tr><th>JSON</th><th>Bytes</th><th>Meaning</th></tr></thead><tbody>
 <tr><td><code>{</code></td><td><span class="bl bl-t">84</span></td><td>map with 4 key/value pairs</td></tr>
 <tr><td><code>&quot;id&quot;: 300,</code></td><td><span class="bl bl-t">A2</span> <span class="bl bl-d">69 64</span> <span class="bl bl-t">CD</span> <span class="bl bl-d">01 2C</span></td><td>key: fixstr of length 2, then its UTF-8 bytes; value: uint 16 (big-endian)</td></tr>
 <tr><td><code>&quot;name&quot;: &quot;json&quot;,</code></td><td><span class="bl bl-t">A4</span> <span class="bl bl-d">6E 61 6D 65</span> <span class="bl bl-t">A4</span> <span class="bl bl-d">6A 73 6F 6E</span></td><td>key: fixstr of length 4; value: fixstr of length 4</td></tr>
 <tr><td><code>&quot;pi&quot;: 3.14,</code></td><td><span class="bl bl-t">A2</span> <span class="bl bl-d">70 69</span> <span class="bl bl-t">CB</span> <span class="bl bl-d">40 09 1E B8 51 EB 85 1F</span></td><td>key: fixstr of length 2; value: float 64 (IEEE 754, big-endian)</td></tr>
 <tr><td><code>&quot;tags&quot;: [</code></td><td><span class="bl bl-t">A4</span> <span class="bl bl-d">74 61 67 73</span> <span class="bl bl-t">92</span></td><td>key: fixstr of length 4; value: fixarray with 2 elements</td></tr>
 <tr><td><code>&quot;a&quot;,</code></td><td><span class="bl bl-t">A1</span> <span class="bl bl-d">61</span></td><td>fixstr of length 1</td></tr>
 <tr><td><code>&quot;b&quot;</code></td><td><span class="bl bl-t">A1</span> <span class="bl bl-d">62</span></td><td>fixstr of length 1</td></tr>
 <tr><td><code>]</code></td><td></td><td>no end marker: the element count was given up front</td></tr>
 <tr><td><code>}</code></td><td></td><td>no end marker: the member count was given up front</td></tr>
 </tbody></table></div>
 ## Deserialization
 The library maps MessagePack types to JSON value types as follows:
@@ -103,6 +103,41 @@ The library uses the following mapping from JSON values types to UBJSON types ac
    --8<-- "examples/to_ubjson.output"
    ```
 ### Byte layout
 Consider the following JSON value (shown formatted for readability):
 ```json
 {
  "id": 300,
  "name": "json",
  "pi": 3.14,
  "tags": [
    "a",
    "b"
  ]
 }
 ```
 `to_ubjson` encodes it to 51 bytes (shown in hexadecimal; the encoding contains no whitespace). The colors mark the role of each byte: <span class="bl bl-t">type/marker</span> <span class="bl bl-l">length/count/size</span> <span class="bl bl-d">data</span>.
 <div class="byte-layout" markdown="0"><table>
 <thead><tr><th>JSON</th><th>Bytes</th><th>Meaning</th></tr></thead><tbody>
 <tr><td><code>{</code></td><td><span class="bl bl-t">7B</span></td><td>object start (<code>{</code>)</td></tr>
 <tr><td><code>&quot;id&quot;: 300,</code></td><td><span class="bl bl-l">69 02</span> <span class="bl bl-d">69 64</span> <span class="bl bl-t">49</span> <span class="bl bl-d">01 2C</span></td><td>key: length 2 as int8 (<code>i</code>), then UTF-8 bytes; value: int16 (<code>I</code>), big-endian</td></tr>
 <tr><td><code>&quot;name&quot;: &quot;json&quot;,</code></td><td><span class="bl bl-l">69 04</span> <span class="bl bl-d">6E 61 6D 65</span> <span class="bl bl-t">53</span> <span class="bl bl-l">69 04</span> <span class="bl bl-d">6A 73 6F 6E</span></td><td>key: length 4; value: string (<code>S</code>), length 4 as int8, UTF-8 bytes</td></tr>
 <tr><td><code>&quot;pi&quot;: 3.14,</code></td><td><span class="bl bl-l">69 02</span> <span class="bl bl-d">70 69</span> <span class="bl bl-t">44</span> <span class="bl bl-d">40 09 1E B8 51 EB 85 1F</span></td><td>key: length 2; value: float64 (<code>D</code>), big-endian</td></tr>
 <tr><td><code>&quot;tags&quot;: [</code></td><td><span class="bl bl-l">69 04</span> <span class="bl bl-d">74 61 67 73</span> <span class="bl bl-t">5B</span></td><td>key: length 4; value: array start (<code>[</code>)</td></tr>
 <tr><td><code>&quot;a&quot;,</code></td><td><span class="bl bl-t">53</span> <span class="bl bl-l">69 01</span> <span class="bl bl-d">61</span></td><td>string, length 1</td></tr>
 <tr><td><code>&quot;b&quot;</code></td><td><span class="bl bl-t">53</span> <span class="bl bl-l">69 01</span> <span class="bl bl-d">62</span></td><td>string, length 1</td></tr>
 <tr><td><code>]</code></td><td><span class="bl bl-t">5D</span></td><td>array end (<code>]</code>)</td></tr>
 <tr><td><code>}</code></td><td><span class="bl bl-t">7D</span></td><td>object end (<code>}</code>)</td></tr>
 </tbody></table></div>
 ## Deserialization
 The library maps UBJSON types to JSON value types as follows:
@@ -38,6 +38,18 @@ which avoids repeating it:
    --8<-- "examples/get_to.output"
    ```
 !!! info "Getting values out of a document or a view"
    A [view](../api/basic_json_view/index.md) offers the same `get<T>()` conversion. For the built-in types (booleans,
    numbers, strings, `#!cpp std::vector`, `#!cpp std::map`, ...) it reads the value straight from the document's
    index, without building a `basic_json` value first; user-defined types with a `from_json()` are converted from a
    `basic_json` value, see the [list](../api/basic_json_view/get.md). Two conversions never copy at all:
    [`get_string()`](../api/basic_json_view/get_string.md) returns a string as a view into the source text, and
    [`number_token()`](../api/basic_json_view/number_token.md) returns a number exactly as it was written. Every other
    type is obtained from a subtree that is built on demand with
    [`materialize()`](../api/basic_json_view/materialize.md). See
    [Zero-copy JSON views](json_view.md#getting-values-out-without-copying).
 The library already knows how to convert to and from the scalar types and the STL containers (such as
 `#!cpp std::vector`, `#!cpp std::map`, `#!cpp std::array`, `#!cpp std::optional`, and many more). Converting a JSON
 object back to a `#!cpp std::map` or a JSON array back to a `#!cpp std::vector` therefore works without any extra code:
@@ -234,3 +246,4 @@ The conversions above are built in for standard types. To make the same syntax w
 - [`get_ref`](../api/basic_json/get_ref.md) / [`get_ptr`](../api/basic_json/get_ptr.md) - access the stored value without copying
 - [Arbitrary types conversions](arbitrary_types.md) - support your own types
 - [`JSON_USE_IMPLICIT_CONVERSIONS`](../api/macros/json_use_implicit_conversions.md) - toggle implicit conversions
 - [Zero-copy JSON views](json_view.md) - get values out of a document or a view
@@ -1,7 +1,9 @@
 # Creating JSON values
 There are several ways to create a JSON value in memory. This page gives an overview; to read a value from JSON text
-instead, see [parsing](parsing/index.md).
+instead, see [parsing](parsing/index.md). A JSON text can also be parsed into a
 [document](../api/basic_json_document/index.md) and read through a [view](../api/basic_json_view/index.md) instead of
 into a value; see [Zero-copy JSON views](json_view.md).
 ## From C++ values
@@ -101,3 +103,4 @@ string `#!json "42"`.
 - [`operator""_json`](../api/operator_literal_json.md) - the `_json` literal
 - [Converting values](conversions.md) - which C++ types can be used
 - [Parsing](parsing/index.md) - create a value from JSON text
 - [Zero-copy JSON views](json_view.md) - create a document and a view from JSON text instead of a value
@@ -21,3 +21,12 @@ flowchart TD
    A --> F{"just testing first?"}
    F -->|"yes"| G["contains() / find()"]
 ```
 ## See also
 - [**operator[]**](../../api/basic_json/operator%5B%5D.md) - unchecked access
 - [**at**](../../api/basic_json/at.md) - checked access
 - [**value**](../../api/basic_json/value.md) - access with default value
 - [**contains**](../../api/basic_json/contains.md) and [**find**](../../api/basic_json/find.md) - test for existence
 - [**front**](../../api/basic_json/front.md) and [**back**](../../api/basic_json/back.md) - first and last element
 - [**items**](../../api/basic_json/items.md) - iterate over keys and values
@@ -59,3 +59,11 @@ C++ types, and finally serialize it again.
    This section gives conceptual overviews. For the precise signature, parameters, and return value of a function, see
    the [API Documentation](../api/basic_json/index.md).
 ## See also
 - [API documentation](../api/basic_json/index.md) - reference of all classes and functions
 - [FAQ](../home/faq.md) - answers to common questions
 - [Exceptions](../home/exceptions.md) - all exceptions and their error codes
 - [Design goals](../home/design_goals.md)
 - [Integration](../integration/index.md) - how to add the library to a project
Author	SHA1	Message	Date
Niels Lohmann	b3f7f80fb7	json_view: the library's std conversions read views directly The library's from_json() overloads (containers, maps, std::array, C arrays, pairs, tuples, optional, valarray, forward_list, enums, binary, paths, and scalars) accept views: their traits use the view's basic_json type, and the few accesses that differ (get_ptr) go through small helpers. from_json() of a view now finds them; only the probe still looks up by ADL only. get<T>() of a view thus converts these types without materialize(), with the same values and exceptions; from an object, a repeated key keeps the last value, as parse() does. The view keeps its direct paths for vectors of the types it converts directly (faster than from_json()) and for containers of views; its other vector and map paths are replaced by from_json(). For basic_json, std::valarray and std::forward_list are read in one pass (40 % and 3.5 % fewer instructions); all other conversions are unchanged. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-25 13:33:40 +01:00
Niels Lohmann	64a5d233d0	json_view: from_json() of the macros reads views directly get<T>() and get_to() of a view call T's from_json() with the view itself when that from_json() accepts views but not an unrelated probe type, and fall back to materialize() otherwise. The from_json() functions of the NLOHMANN_DEFINE_TYPE_, NLOHMANN_DEFINE_DERIVED_TYPE_ and NLOHMANN_JSON_SERIALIZE_ENUM(_STRICT) macros accept basic_json values and views; a derived type whose base reads only json reads the base part through materialize(). The library's own from_json() overloads are not called with views: from_json() of a view (and of the probe) only looks up functions by ADL. New public trait nlohmann::is_json_view<T>, and the member type basic_json_type of basic_json_view. With duplicate keys, the members of such a T are those the view's lookups find (the first ones). bench_decode.cpp measures decoding into structs (4-6x faster than materialize().get<T>() on twitter, citm_catalog, and synthetic records). Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-25 13:33:39 +01:00
Niels Lohmann	315bd04c55	json_view: one SIMD macro set with the library The view's vector code follows JSON_NO_SIMD, like the lexer and the float writer, and skips the CPU check of SSSE3 when the code is compiled for SSSE3 anyway (__SSSE3__), like the lexer. JSON_VIEW_NO_SIMD and JSON_VIEW_USE_SSSE3 and their ABI tags _vns and _vssse3 are removed; they were never released. JSON_NO_SIMD keeps its tag _ns. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-25 12:17:42 +01:00
Niels Lohmann	ea3dca202b	json_view: no save() and load() on big-endian targets The image format is little-endian only. Instead of throwing type_error.320 at runtime, save_image(), load_image() and the members save() and load() do not exist on a big-endian target, so a call fails to compile, like set() on a read-only document. type_error.320 remains for saving a discarded document. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-25 12:12:21 +01:00
Niels Lohmann	bcc19dca3f	json_view: view_mode enum instead of bool Editable, node_kind for node::kind basic_json_document and basic_json_view take a view_mode (read_only, the default, or editable) instead of a bool: basic_json_document<json, true> did not say what true means. The shortcut aliases are unchanged. The kind of a node is a node_kind (the value_t values plus link, 10 as before), which removes the static_cast<std::uint8_t>(value_t::...) of every comparison. The node and image layouts are unchanged. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-25 12:07:13 +01:00
Niels Lohmann	cc917d7123	docs: cross-reference json_view and json_document for 3.13.0 (#5892 ) * docs: cross-reference json_view and json_document for 3.13.0 Document the new zero-copy document/view API across the docs: add a "Documents and views" section to the basic_json API hub linking to all specializations, point parsing/conversion/modifying pages to the view-based alternatives, add document/view sections to feature pages, update the landing page to mention json_view.hpp/json_literals.hpp, and cross-link debugging/exceptions. Also document wide-string inputs (and ill-formed UTF-16/32 rejection), add parse/accept examples for wide strings, fix related doc gaps, and align features/parsing and FAQ with the added support. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * docs: fix article before std::istream in FAQ Signed-off-by: Niels Lohmann <mail@nlohmann.me> * docs: clarify document inputs, decoding, get<T>() and editing Address review comments: say which inputs are borrowed and that a wide string pointer is an extra input, which values are decoded during parsing, that get<T>() reads only built-in types directly, all forms of set() and that the document's insert() is array-only, and how to store wide strings. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * docs: integers are converted while parsing a document Also say "They accept every input" in basic_json_document::parse. Signed-off-by: Niels Lohmann <mail@nlohmann.me> --------- Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-25 06:18:07 +01:00
Niels Lohmann	3eae5680d6	from_json: number-first dispatch for arithmetic types, loop for std::array (#5902 ) * from_json: number-first dispatch for arithmetic types, loop for std::array (#5891) from_json(ArithmeticType&) now reads numbers through get_number_value() and handles a boolean on a cold path, which puts the three number types first in the per-element type dispatch. get<std::array<T, N>>() always took the identity_tag overload, a pack expansion of N calls j.at(i).get<T>() that clang unrolls into straight-line code (about 28,000 instructions for N = 1000), so its speed depended on inlining decisions in that body. For trivial element types, which cannot tell default construction plus assignment from construction in place, it now fills a std::array in a loop. That loop, shared with get_to(), checks the size once and reads the inner array directly; a short array still converts the elements it has and then throws the out_of_range error at() would throw. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * Skip the get_to result check without exceptions Without exceptions, the get_to calls in CHECK_THROWS_WITH_AS do not run, so the array keeps its initial values (ci_test_noexceptions). Signed-off-by: Niels Lohmann <mail@nlohmann.me> * Make is_trivial_element a struct so astyle does not indent it Signed-off-by: Niels Lohmann <mail@nlohmann.me> * Expect the element path in the std::array type-error tests with JSON_DIAGNOSTICS Signed-off-by: Niels Lohmann <mail@nlohmann.me> * Shorten from_json_inplace_array so astyle aligns its parameters The opening parenthesis of the previous name sat in column 41, beyond astyle's default --max-continuation-indent of 40, so the continuation lines fell back to a plain double indent. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * Use the compact template<...> style for the new from_json overloads Signed-off-by: Niels Lohmann <mail@nlohmann.me> --------- Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-25 06:17:51 +01:00
Niels Lohmann	fe5e401870	Consolidate duplicated detail helpers and bodies (#5891 ) (#5901 ) * Add shared detail helpers for the #5891 cleanup Add detail::is_primitive(value_t), detail::hex4_lower(), detail::utf8_shape(), detail::input_format_name(), detail::empty_input_message(), the exception ids 116, 319, 320 and 416 to detail::exception_id, and make detail::is_ascii_copyable() constexpr. Later commits switch the duplicated code over to them. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 1.4: BSON writers share one write-pass UTF-8 sanitizer (#5891) write_bson_entry_header and write_bson_string re-derived the error-handler policy differently. Both now use sanitize_utf8_for_bson_write, which treats strict like keep (the size pass already validated) and sanitizes replace/ignore into the bytes the size pass measured. No context plumbing is needed. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.1.1: one MessagePack container prefix helper (#5891) Array and object prefixes differed only in the fix marker and the 16/32-bit markers; both now delegate to write_msgpack_container_prefix. Output is byte-identical. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.1.2: one iterative walker for CBOR and MessagePack (#5891) write_cbor_iterative and write_msgpack_iterative (and their _value_or_push helpers) were identical but for the head, scalar, and key writers. They are now one template over a small policy struct, so everything inlines. BON8 keeps its own walker (open string run, closing marker), noted in a comment. Signed-off-by: Niels Lohmann <mail@nlohmann.me> 2.1.3, 2.1.8: one UBJSON container start helper, shared frame base (#5891) write_ubjson_start_array/_object are now write_ubjson_start_container<IsArray>, keeping the array-only begin()+1 scan and excessive_valueless rule. ubjson_frame derives from binary_container_frame instead of duplicating it. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.1.4: write_bytes helper for the byte-string write sites (#5891) The 13 oa.write_characters(reinterpret_cast<const CharType>(x.data()), n) sites now call write_bytes(const void, size_t); copy_characters sites and the buffer-based writes are untouched. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.1.5: shared object-key writer for CBOR and MessagePack (#5891) write_cbor_key and write_msgpack_key were the same SFINAE pair apart from the string/scalar writers; both now delegate to write_object_key<Walk>. UBJSON key and to_format_length stay as they are. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.3.10: writer-side format names from input_format_name (#5891) The CBOR/MessagePack/UBJSON/BSON/BJData/BON8 literals in throw_on_discarded and throw_integer_out_of_range calls now come from detail::input_format_name; the texts are identical, and UBJSON vs BJData still follows use_bjdata. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * serializer: constexpr ascii table, hex4_lower, dedupe helpers (#5891) 1.1: build ascii_copyable() at compile time from is_ascii_copyable and test find_ascii_copyable_run against it for every byte. 1.2/2.5.4: use detail::hex4_lower in both \uXXXX writers. 2.1.6: factor the repeated flush/emit blocks in dump_escaped_impl into always-inline helpers. 2.1.7: comment why the escape copy does not use put_buffer. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 1.6: use string_t-aware to_string/concat in meta() (#5891) Replaces the four std::to_string sites; rendered text unchanged. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 1.7: use detail::is_primitive in json.hpp switches (#5891) has_no_children, set_parents, max_size and the two diff walkers. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.2.1: factor insert()/iterator throw helpers (#5891) Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.2.2: share swap() overloads via swap_impl (#5891) Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.2.4: factor primitive reset and range check in erase()/range ctor (#5891) Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.2.6: share push_back array bodies via push_back_array_impl (#5891) Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.2.7: route parse/accept/sax_parse through _impl helpers (#5891) Signed-off-by: Niels Lohmann <mail@nlohmann.me> 2.2.8: share the vector-returning to_* bodies via to_binary_vector (#5891) Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.2.10: merge destroy_string/destroy_binary into destroy_pointer (#5891) Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.4.1/1.7: exceptions: share what_impl, flatten diagnostics switch (#5891) The four create() bodies build their message through one protected static helper; the diagnostics parent walk handles array/object and ignores all other types. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.4.2/2.4.3/1.7: json_pointer: share slash and escape checks, drop primitive case lists (#5891) The leading-slash and invalid '~' escape checks are shared helpers; the reference-token walks test object and array first and treat everything else as primitive. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 1.7/2.4.9: iter_impl, iteration_proxy: drop primitive case lists, share compare preamble (#5891) Object and array stay the first branches; everything else is the primitive case. operator== and operator< share the different-container check. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.4.5/2.4.6: from_json: share get_number_value and reserve_if_possible (#5891) The three number cases of get_arithmetic_value and the arithmetic from_json share one helper (boolean stays accepted only by the latter); the array and object reserve overload pairs become one. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.4.8: ordered_map: share erase_impl between the key erase overloads (#5891) Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 1.7: json_pointer: flatten walk drops the primitive case list (#5891) Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 1.2/1.3/1.5/2.5.1/2.5.2/2.5.5: share helpers in the view code (#5891) - detail::exception_id at every numeric id; throw_* helpers take it - hex_byte, hex4_lower, utf8_shape replace local hex/table code - throw_array_index_out_of_range/_past_end, throw_key_not_found - has_native_float_format replaces the hand-written IEEE check No change of messages, ids or output. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 1.5: use utf8_shape in get_bon8_string, add exhaustive UTF-8 validator test (#5891) get_bon8_string takes the valid range of the second byte from utf8_shape() (0xF5..0xF7 stay errors, unget behavior unchanged). validate_one_utf8 keeps its if-chain (hot bulk path); the new test checks decode, validate_one_utf8, utf8_shape, json::accept and the BON8 reader against each other for every lead and second byte. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.3.1: get_cbor_sized_bytes for the CBOR chunk getters (#5891) Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.3.2: get_string_with_length for the plain-order string sites (#5891) Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.3.3, 2.3.4, 2.3.10: unsupported_key_type, empty_input_message, input_format_name in the readers (#5891) Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.3.7, 2.3.9: read_object_key and leave_container_and_check for CBOR/MessagePack/BON8 (#5891) UBJSON keys (different getter signature) and its container tail stay as is. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.3.5: json_sax_dom_error_state base for the DOM SAX parsers (#5891) Holds errored, allow_exceptions, parse_error() and is_errored(). The scalar handlers stay in each class (parse hot path). Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.3.6: table of control-character messages in the lexer (#5891) Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.3.8: finish_input helper for the strict-EOF block in the parser (#5891) sax_parse keeps its if (result) guard and return value. Also adds the clang-tidy NOLINT for the 2.3.6 message table. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.5.7: share parse_array_index between json_pointer and json_view (#5891) Move json_pointer::parse_array_index() and its status enum to namespace detail (json_pointer keeps a forwarding member), and let the json_view pointer resolution use it instead of its own copy of the RFC 6901 index grammar. Both accepted the same tokens with the same outcome. Also update the comment on detail::decode(), which listed four of the five UTF-8 validators and now points to the test that keeps them in sync. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * Amalgamate (#5891) Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.4.5: keep the inlined number cases in from_json(ArithmeticType&) (#5891) Calling get_number_value() from from_json(ArithmeticType&) made GetArray<std::array<int, 1000>> 2.4x slower (it changes the inlining of the std::array conversion), so that overload keeps its own switch, with a comment. get_arithmetic_value() still uses the shared helper. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 2.5.7: force-inline detail::parse_array_index (#5891) Moving parse_array_index out of json_pointer stopped clang from inlining it into the pointer resolution (JsonPointerAt/citm_catalog +17%, JsonPointerAt/twitter +8%); JSON_HEDLEY_ALWAYS_INLINE restores the baseline. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * 1.5: keep get_bon8_string's own UTF-8 ranges (#5891) Taking the second-byte range from utf8_shape() made BON8 decoding 2-3% slower (FromBinaryShape/scalars, FromBinaryBuffer, alignment-pinned builds), so the byte path keeps its hand-written ranges. The exhaustive validator test still checks that it accepts the same sequences as the other validators. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * Amalgamate (#5891) Signed-off-by: Niels Lohmann <mail@nlohmann.me> * Fix CI failures: constexpr, NRVO, cppcheck, IWYU (#5891) - json_sax_dom_error_state::is_errored() cannot be constexpr: the class is not a literal type (GCC 4.8, GCC -Wpedantic, Clang 3.5). - to_binary_vector: destroy the vector writer before returning, as the output_vector_sink sets the size of the vector in its destructor. Without NRVO (MSVC Debug in C++14 mode), the vector was moved out before it was resized. - parser::sax_parse: return false instead of result after the early exit (cppcheck identicalConditionAfterEarlyExit). - json.hpp: export detail/exceptions.hpp for IWYU, so json_view.hpp can name exception_id without including a detail header. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * Address review: throw helpers take input_format_t, simpler type checks - throw_on_discarded() and throw_integer_out_of_range() take an input_format_t and call input_format_name() themselves - has_no_children(), set_parents() and max_size() check array, then object, instead of calling is_primitive() first - parse_impl() chains like accept_impl(); sax_parse_impl() uses if/else - std::array for the control character messages; negation<> in write_object_key(); clarify the is_primitive() comment Signed-off-by: Niels Lohmann <mail@nlohmann.me> * json_view: use exception_id in the value() overloads Signed-off-by: Niels Lohmann <mail@nlohmann.me> * json_sax: assert the invariant of place_container for the static analyzer Signed-off-by: Niels Lohmann <mail@nlohmann.me> --------- Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-25 06:17:50 +01:00
Niels Lohmann	52b72b5684	Improve documentation: byte layouts, release pages, See also, dark-mode images (#5906 ) - Make the iterator range illustrations legible in dark mode (prefers-color-scheme rules inside the SVGs). - Add a "Byte layout" section with a color-coded byte table to each binary format page (BJData, BON8, BSON, CBOR, MessagePack, UBJSON), and highlight the smallest size per file in the comparison table. - Add "See also" sections to the overview pages that lacked one. - Split the release notes into one page per release, grouped by minor version on the overview page, with an "API changes" section per release generated from the API pages' version histories (hooks/api_changes.py). - Fact-check the release notes and version histories against the release tags and correct wrong or misleading entries (e.g., json_serializer 2.1.0, merge_patch 3.1.0, items, count, operator[], to_bjdata, std::string_view key support). Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-24 17:57:44 +02:00
Niels Lohmann	01139dc192	Silence an Infer false positive in json_view materialize (#5905 ) Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-24 17:10:31 +02:00
`@@ -84,4 +84,4 @@ constructor.`

	`## Version history`	`## Version history`

	`- Since version 3.0.0.`	`- Added in version 3.0.0.`
`@@ -75,4 +75,4 @@ classDiagram`

	`## Version history`	`## Version history`

	`- Since version 3.0.0.`	`- Added in version 3.0.0.`
`@@ -51,4 +51,4 @@ deserializes. See [Template Parameter Requirements](../../features/types/templat`

	`## Version history`	`## Version history`

	`- Since version 2.0.0.`	`- Added in version 2.1.0.`
`@@ -76,4 +76,4 @@ classDiagram`

	`## Version history`	`## Version history`

	`- Since version 3.0.0.`	`- Added in version 3.0.0.`
`@@ -84,4 +84,4 @@ or the end of file. This also holds true when reading a byte vector for binary f`

	`## Version history`	`## Version history`

	`- Since version 3.0.0.`	`- Added in version 3.0.0.`
`@@ -51,4 +51,4 @@ byte_container_with_subtype(container_type&& container, subtype_type subtype);`

	`## Version history`	`## Version history`

	`Since version 3.8.0.`	`Added in version 3.8.0.`
`@@ -39,4 +39,4 @@ Constant.`

	`## Version history`	`## Version history`

	`Since version 3.8.0.`	`Added in version 3.8.0.`
`@@ -42,4 +42,4 @@ Constant.`

	`## Version history`	`## Version history`

	`Since version 3.8.0.`	`Added in version 3.8.0.`
`@@ -44,4 +44,4 @@ Constant.`

	`## Version history`	`## Version history`

	`Since version 3.8.0.`	`Added in version 3.8.0.`