json_view: fix GCC useless-cast, MSVC C4127, and MinGW object size

- drop the redundant int cast of the promoted uint16_t shift (-Wuseless-cast) - route the constant part of the float-pair condition through enabled() (C4127) - split unit-json_view_dump.cpp in three files for the MinGW assembler Signed-off-by: Niels Lohmann <mail@nlohmann.me>
json_view: dump canada.json faster than yyjson (batched float decisions)
2026-10-25 15:28:54 +00:00 · 2026-10-25 10:45:57 +01:00 · 2026-10-25 07:23:43 +01:00 · 2026-10-25 07:23:42 +01:00
80 changed files with 6435 additions and 3210 deletions
@@ -163,9 +163,9 @@ jobs:
          python3 $GENERATOR --list-tags
          TAG_COUNT=$(python3 $GENERATOR --list-tags | wc -l)

-          python3 $GENERATOR --abi-tags diag,_dp,_ns --abi-tags _diag --output $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_ns_v[0-9_]* -->' $RUNNER_TEMP/abi_tags.natvis
+          python3 $GENERATOR --abi-tags diag,_dp,_vns --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_vns_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,7 +90,6 @@ 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,_ns --output my_nlohmann_json.natvis"`; see
+`make natvis NATVIS_ARGS="--abi-tags _diag,_dp,_vns --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,_ns --output my.natvis"
+# extra options for generate_natvis.py, e.g. NATVIS_ARGS="--abi-tags _diag,_dp,_vns --output my.natvis"
 NATVIS_ARGS=

 # regenerate nlohmann_json.natvis from the ABI tags and version in include/nlohmann/detail/abi_macros.hpp
@@ -12,7 +12,7 @@ void erase(view_type array, I idx);
 std::size_t erase(const json_pointer& ptr);
 ```

-Only an **editable** document (`#!cpp view_mode::editable`, e.g. [`json_editable_document`](../json_editable_document.md))
+Only an **editable** document (`#!cpp Editable == true`, e.g. [`json_editable_document`](../json_editable_document.md))
 has `erase`; calling it on a read-only `basic_json_document` fails to compile (`#!cpp static_assert`).

 1. Removes every member of `object` whose key is `key` (see [Notes](#notes) on duplicate keys) and returns how many
@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>

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

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

 ## Template parameters
@@ -32,10 +32,9 @@ 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`.

-`Mode`
-:   a [`view_mode`](../view_mode.md): `#!cpp view_mode::editable` if the document supports [`set`](set.md),
-    [`push_back`](push_back.md), [`insert`](insert.md), and [`erase`](erase.md) (optional, `#!cpp view_mode::read_only`
-    by default). See [Edits](#edits) below.
+`Editable`
+:   whether the document supports [`set`](set.md), [`push_back`](push_back.md), [`insert`](insert.md), and
+    [`erase`](erase.md) (optional, `#!cpp false` by default). See [Edits](#edits) below.

 ## Specializations

@@ -48,7 +47,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, Mode>`)
+- **view_type** - the type of view returned by [`root()`](root.md) (`#!cpp basic_json_view<BasicJsonType, Editable>`)
 - **value_t** - the JSON type enumeration, see [`basic_json::value_t`](../basic_json/value_t.md)
 - **image_check** - how [`load()`](load.md) validates an image (`full`, `bounds`, `none`), see [`image_check`](load.md#image_check)

@@ -81,15 +80,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 (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 (editable documents only)
+  to (`#!cpp Editable` documents only)
+- [**push_back**](push_back.md) - append to an array (`#!cpp Editable` documents only)
+- [**insert**](insert.md) - insert an element into an array before a given position (`#!cpp Editable` documents only)
 - [**erase**](erase.md) - remove an object member, an array element, or the value a JSON pointer refers to
-  (editable documents only)
+  (`#!cpp Editable` documents only)

 ## Edits

-An editable document (`#!cpp view_mode::editable`) can be changed after parsing, with [`set`](set.md),
+An editable document (`#!cpp Editable == true`) can be changed after parsing, with [`set`](set.md),
 [`push_back`](push_back.md), [`insert`](insert.md), and [`erase`](erase.md);
 [`json_editable_document`](../json_editable_document.md) and
 [`ordered_json_editable_document`](../ordered_json_editable_document.md) are the corresponding specializations. A few
@@ -5,7 +5,7 @@ template<typename I, typename V>
 view_type insert(view_type array, I idx, V&& value);
 ```

-Only an **editable** document (`#!cpp view_mode::editable`, e.g. [`json_editable_document`](../json_editable_document.md))
+Only an **editable** document (`#!cpp Editable == true`, e.g. [`json_editable_document`](../json_editable_document.md))
 has `insert`; calling it on a read-only `basic_json_document` fails to compile (`#!cpp static_assert`).

 Inserts `value` into `array` as a new element before position `idx`, which must not be past the end
@@ -55,7 +55,10 @@ validate with overload 2 first, if the original vector must survive a failed loa

 ## Exceptions

-Throws [`parse_error.116`](../../home/exceptions.md#jsonexceptionparse_error116) if `image` is not one
+On a big-endian target, throws [`type_error.320`](../../home/exceptions.md#jsonexceptiontype_error320) -- the same
+exception [`save()`](save.md#exceptions) throws there, since the image format is little-endian only.
+
+Otherwise throws [`parse_error.116`](../../home/exceptions.md#jsonexceptionparse_error116) if `image` is not one
 `save()` could have written, or fails the requested `check`:

 | message               | when                                                                                                |
@@ -92,9 +95,6 @@ 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
@@ -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 view_mode::editable`, e.g. [`json_editable_document`](../json_editable_document.md))
+Only an **editable** document (`#!cpp Editable == true`, e.g. [`json_editable_document`](../json_editable_document.md))
 has `push_back`; calling it on a read-only `basic_json_document` fails to compile (`#!cpp static_assert`).

 ## Template parameters
@@ -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 the [`view_mode`](../view_mode.md), since the image reflects document order and
+the same bytes -- also across `BasicJsonType` and `#!cpp Editable`, since the image reflects document order and
 values only, not which specialization produced them.

 ## Return value
@@ -31,6 +31,9 @@ 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.
@@ -41,6 +44,9 @@ 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
    ```

@@ -64,9 +70,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 targets only.** The image is written as raw little-endian bytes, with no byte-swapping. On a
-big-endian target, `save()` and [`load`](load.md) do not exist: a call fails to compile rather than produce bytes a
-big-endian reader could not interpret correctly.
+**Little-endian only.** The image is written as raw little-endian bytes, with no byte-swapping. `save()` (and
+[`load`](load.md)) throw `type_error.320` on a big-endian target rather than silently produce bytes a big-endian
+reader could not interpret correctly.

 ## Examples

@@ -18,7 +18,7 @@ template<typename V>
 view_type set(const json_pointer& ptr, V&& value);
 ```

-Only an **editable** document (`#!cpp view_mode::editable`, e.g. [`json_editable_document`](../json_editable_document.md))
+Only an **editable** document (`#!cpp Editable == true`, e.g. [`json_editable_document`](../json_editable_document.md))
 has `set`; calling it on a read-only `basic_json_document` fails to compile (`#!cpp static_assert`).

 1. Replaces the value `target` refers to with `value`.
@@ -19,36 +19,16 @@ 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>` of the types above -- from an array, element by element, each converted with
-  `#!cpp get<U>()`; `#!cpp std::vector<basic_json_view>` keeps a view of every element instead of a value
- `#!cpp std::map<K, basic_json_view, C, A>` and `#!cpp std::unordered_map<K, basic_json_view, H, E, A>`, if `K` is
-  constructible from a `#!cpp (const char*, std::size_t)` pair -- views of the members of an object; with a repeated
-  key, the view of the *last* member is kept, as [`BasicJsonType::parse()`](../basic_json/parse.md) keeps its value
+- `#!cpp std::vector<U, A>` -- from an array, element by element, each converted with `#!cpp get<U>()`; `#!cpp
+  std::vector<basic_json_view>` keeps a view of every element instead of a value
+- `#!cpp std::map<K, V, C, A>` and `#!cpp std::unordered_map<K, V, H, E, A>`, if `K` is constructible from a `#!cpp
+  (const char*, std::size_t)` pair -- from an object, member by member, each value converted with `#!cpp get<V>()`; with a repeated
+  key, the *last* value is kept, as [`BasicJsonType::parse()`](../basic_json/parse.md) (and
+  [`materialize()`](materialize.md)) does; `#!cpp std::map<std::string, basic_json_view>` keeps views of the members
+  instead of values

-A default-constructible `T` whose `from_json()` accepts views reads the view directly as well, without building a
-`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`
+Every other `T` -- `#!cpp std::list`, `#!cpp std::pair`, `#!cpp std::array`, enumerations, user types with a
+`from_json()`, ... -- is converted by `#!cpp materialize().get<T>()`: the subtree is built into a real `BasicJsonType`
 value first (as [`BasicJsonType::parse()`](../basic_json/parse.md) would), and converted from there exactly as
 [`BasicJsonType::get<T>()`](../basic_json/get.md) would convert it.

@@ -73,15 +53,12 @@ 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` of views: throws `type_error.302` if the value is not an object.
- 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 `#!cpp std::map`/`#!cpp std::unordered_map`: throws `type_error.302` if the value is not an object; otherwise,
+  whatever converting a member to the mapped type throws.
 - For every other `T`: whatever [`materialize().get<T>()`](../basic_json/get.md) throws -- typically `type_error.302`,
  or whatever a user-provided `from_json()` throws.

-None of the exceptions thrown directly by this function or by a `from_json()` that reads the view (the first four
-bullets above) carry a
+None of the exceptions thrown directly by this function (the first three bullets above) carry a
 [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no `BasicJsonType` value to point at. An
 exception thrown while converting through `materialize()` (the last bullet) is different: it is thrown by a real
 `BasicJsonType` value, so it **does** carry a `JSON_DIAGNOSTICS` path if `BasicJsonType` was built with it enabled.
@@ -99,8 +76,6 @@ 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,13 +5,12 @@ template<typename T>
 T& get_to(T& v) const;
 ```

-Converts the value to `T` and stores it in `v`, in one of three ways:
+Converts the value to `T` and stores it in `v`, in one of two 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`, vectors of these, and maps of views -- `v` is 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.
+  `basic_json_view`, `#!cpp std::vector`, and `#!cpp std::map`/`#!cpp std::unordered_map` with string keys -- `v` is
+  assigned: `#!cpp v = get<T>()`.
 - 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, view_mode Mode = view_mode::read_only>
+template<typename BasicJsonType, bool Editable = false>
 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 view_mode::editable`) sees every edit made through
+**editable** document (`#!cpp Editable == true`) sees every edit made through
 [`basic_json_document::set`](../basic_json_document/set.md) and
 [`basic_json_document::push_back`](../basic_json_document/push_back.md): once a value is changed, every view that
 still refers to it -- including ones taken before the change -- reads the new value. See
@@ -49,10 +49,9 @@ 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.

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

 ## Specializations

@@ -64,7 +63,6 @@ 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`
@@ -1,55 +0,0 @@
-# <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.
@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>

 ```cpp
-using json_editable_document = basic_json_document<json, view_mode::editable>;
+using json_editable_document = basic_json_document<json, true>;
 ```

 This type is an **editable** [`basic_json_document`](basic_json_document/index.md) of the default
@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>

 ```cpp
-using json_editable_view = basic_json_view<json, view_mode::editable>;
+using json_editable_view = basic_json_view<json, true>;
 ```

 This type is a [`basic_json_view`](basic_json_view/index.md) of a value of a
@@ -43,6 +43,8 @@ header. See also the [macro overview page](../../features/macros.md).
 - [**JSON_SKIP_UNSUPPORTED_COMPILER_CHECK**](json_skip_unsupported_compiler_check.md) - do not warn about unsupported compilers
 - [**JSON_USE_GLOBAL_UDLS**](json_use_global_udls.md) - place user-defined string literals (UDLs) into the global namespace
 - [**JSON_USE_SIMDUTF**](json_use_simdutf.md) - use the simdutf library to accelerate UTF-8 validation
+- [**JSON_VIEW_NO_SIMD**](json_view_no_simd.md) - use only portable code in the parser of `json_view.hpp`
+- [**JSON_VIEW_USE_SSSE3**](json_view_use_ssse3.md) - validate non-ASCII strings with SSSE3 in the parser of `json_view.hpp`

 ## Library version

@@ -5,8 +5,7 @@
 ```

 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. This includes the parser of
-[`basic_json_document`](../basic_json_document/index.md) (`<nlohmann/json_view.hpp>`).
+strings during parsing, and when writing floating-point numbers during serialization.

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

@@ -0,0 +1,52 @@
+# 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.
@@ -0,0 +1,53 @@
+# 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,13 +147,6 @@ 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"
@@ -199,5 +192,3 @@ 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,12 +81,6 @@ 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"
@@ -195,5 +189,3 @@ 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,12 +80,6 @@ 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"
@@ -194,5 +188,3 @@ 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`, and `_ns` in
-  version 3.13.0; see
+  version 3.12.0, and the ABI tags `_bics`, `_psp`, `_snul`, `_sbu8`, `_ekmo`, `_dsbs`, `_dufio`, `_ns`, `_vns`,
+  and `_vssse3` in version 3.13.0; see
  [`nlohmann` Namespace](../../features/namespace.md#structure).
@@ -45,12 +45,6 @@ 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"
@@ -94,5 +88,3 @@ 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,12 +48,6 @@ 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"
@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>

 ```cpp
-using ordered_json_editable_document = basic_json_document<ordered_json, view_mode::editable>;
+using ordered_json_editable_document = basic_json_document<ordered_json, true>;
 ```

 This type is an **editable** [`basic_json_document`](basic_json_document/index.md) of the
@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>

 ```cpp
-using ordered_json_editable_view = basic_json_view<ordered_json, view_mode::editable>;
+using ordered_json_editable_view = basic_json_view<ordered_json, true>;
 ```

 This type is a [`basic_json_view`](basic_json_view/index.md) of a value of an
@@ -1,80 +0,0 @@
-# <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.
@@ -1,34 +0,0 @@
-#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';
-}
@@ -1,2 +0,0 @@
-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, nlohmann::view_mode::editable>
+    // ordered_json_editable_document is basic_json_document<nlohmann::ordered_json, true>
    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

@@ -1,29 +0,0 @@
-#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';
-}
@@ -1,2 +0,0 @@
-2 1
-true
@@ -185,10 +185,6 @@ key as well. Other zero-copy parsers that index the source text, such as yyjson
 member. RFC 8259 only says that names within an object SHOULD be unique and that the behavior of a receiver that sees
 duplicates is unpredictable, so neither choice is wrong.

-The same holds for [`get<T>()`](../api/basic_json_view/get.md) of a type whose `from_json()` reads the view, such as
-the types of the `NLOHMANN_DEFINE_TYPE_*` macros: their members are looked up, so `#!cpp get<point>()` of
-`#!cpp {"x":1,"x":2}` reads `#!cpp x == 1`, while `#!cpp materialize().get<point>()` reads `#!cpp 2`.
-
 **What stays the same as `parse()`?** [`materialize()`](../api/basic_json_view/materialize.md) and
 [`get<std::map<...>>()`](../api/basic_json_view/get.md) replay every member in order, so they keep the *last* value
 exactly like `#!cpp basic_json::parse()` (at the position of the first occurrence of the key, for an
@@ -256,14 +252,14 @@ the stream's `width`/`fill` for indentation.
 ## Editing a document

 Everything above is read-only: a `json_document`/`json_view` lets you look at a parsed text without copying it, but
-not change it. [`basic_json_document<BasicJsonType, view_mode::editable>`](../api/basic_json_document/index.md) -- more conveniently
+not change it. [`basic_json_document<BasicJsonType, true>`](../api/basic_json_document/index.md) -- more conveniently
 spelled [`json_editable_document`](../api/json_editable_document.md) or
 [`ordered_json_editable_document`](../api/ordered_json_editable_document.md) -- also lets you
 [`set`](../api/basic_json_document/set.md) a value, [`push_back`](../api/basic_json_document/push_back.md) onto or
 [`insert`](../api/basic_json_document/insert.md) into an array, and [`erase`](../api/basic_json_document/erase.md)
 an object member or an array element, still without ever building a `basic_json` tree for parts you do not touch.

-The [mode](../api/view_mode.md) defaults to `#!cpp view_mode::read_only`, so `json_document`/`ordered_json_document` are unaffected -- they carry
+`#!cpp Editable` defaults to `#!cpp false`, so `json_document`/`ordered_json_document` are unaffected -- they carry
 none of the bookkeeping edits need, and calling `set`/`push_back`/`insert`/`erase` on one is a compile error, not a
 runtime one.

@@ -358,10 +354,9 @@ validation entirely, for an image trusted as much as the process's own memory. S
 !!! warning "Experimental"

    The image format is versioned but not yet stable, and may change in an incompatible way before it is declared
-    stable. It is little-endian only (on big-endian targets, `save()` and `load()` do not exist), and tied to the
-    library build that wrote it -- use it to cache a document or to hand one to another process running the *same*
-    build, not as a long-term storage format; keep the original JSON text if a saved document needs to be readable by
-    a future library version.
+    stable. It is little-endian only, and tied to the library build that wrote it -- use it to cache a document or to
+    hand one to another process running the *same* build, not as a long-term storage format; keep the original JSON
+    text if a saved document needs to be readable by a future library version.

 The idea of a document you can read without parsing comes from zero-copy formats such as
 [FlatBuffers](https://github.com/google/flatbuffers) and [YaFF](https://github.com/yandex/yaff); the check
@@ -287,6 +287,23 @@ external dependency and is not defined by default.

 See [full documentation of `JSON_USE_SIMDUTF`](../api/macros/json_use_simdutf.md).

+## `JSON_VIEW_NO_SIMD`
+
+When defined, the parser of [`basic_json_document`](../api/basic_json_document/index.md)
+(`<nlohmann/json_view.hpp>`) uses only portable C++ to scan strings, instead of vector instructions (SSE2 on x86-64,
+NEON on AArch64). The same input is accepted or rejected either way; only the speed differs. It is not defined by
+default.
+
+See [full documentation of `JSON_VIEW_NO_SIMD`](../api/macros/json_view_no_simd.md).
+
+## `JSON_VIEW_USE_SSSE3`
+
+When defined on x86-64, the parser of [`basic_json_document`](../api/basic_json_document/index.md)
+(`<nlohmann/json_view.hpp>`) validates non-ASCII text in strings with SSSE3 without asking the CPU first. It is not
+defined by default.
+
+See [full documentation of `JSON_VIEW_USE_SSSE3`](../api/macros/json_view_use_ssse3.md).
+
 ## `NLOHMANN_DEFINE_TYPE_*(...)`, `NLOHMANN_DEFINE_DERIVED_TYPE_*(...)`

 The library defines 12 macros to simplify the serialization/deserialization of types. See the page on
@@ -28,6 +28,8 @@ The complete default namespace name is derived as follows:
    - [`JSON_DISABLE_UNLOCKED_FILE_IO`](../api/macros/json_disable_unlocked_file_io.md) defined non-zero appends
      `_dufio`.
    - [`JSON_NO_SIMD`](../api/macros/json_no_simd.md) defined appends `_ns`.
+    - [`JSON_VIEW_NO_SIMD`](../api/macros/json_view_no_simd.md) defined appends `_vns`.
+    - [`JSON_VIEW_USE_SSSE3`](../api/macros/json_view_use_ssse3.md) defined appends `_vssse3`.
 - The inline namespace ends with the suffix `_v` followed by the 3 components of the version number separated by
  underscores. To omit the version component, see [Disabling the version component](#disabling-the-version-component)
  below.
@@ -113,5 +115,7 @@ follows:
  ([`JSON_STRICT_BINARY_UTF8`](../api/macros/json_strict_binary_utf8.md)), `_ekmo`
  ([`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md)), `_dsbs`
  ([`JSON_DISABLE_STREAM_BULK_SCAN`](../api/macros/json_disable_stream_bulk_scan.md)), `_dufio`
-  ([`JSON_DISABLE_UNLOCKED_FILE_IO`](../api/macros/json_disable_unlocked_file_io.md)), and `_ns`
-  ([`JSON_NO_SIMD`](../api/macros/json_no_simd.md)) in version 3.13.0.
+  ([`JSON_DISABLE_UNLOCKED_FILE_IO`](../api/macros/json_disable_unlocked_file_io.md)), `_ns`
+  ([`JSON_NO_SIMD`](../api/macros/json_no_simd.md)), `_vns`
+  ([`JSON_VIEW_NO_SIMD`](../api/macros/json_view_no_simd.md)), and `_vssse3`
+  ([`JSON_VIEW_USE_SSSE3`](../api/macros/json_view_use_ssse3.md)) in version 3.13.0.
@@ -21,10 +21,10 @@ ABI tags are not covered and may show raw internal fields instead. To generate a
    ```

 3. Generate a Natvis file with the tags of your configuration, for example for `JSON_DIAGNOSTICS`,
-    `JSON_DIAGNOSTIC_POSITIONS`, and `JSON_NO_SIMD`:
+    `JSON_DIAGNOSTIC_POSITIONS`, and `JSON_VIEW_NO_SIMD`:

    ```shell
-    make natvis NATVIS_ARGS="--abi-tags _diag,_dp,_ns --output my_nlohmann_json.natvis"
+    make natvis NATVIS_ARGS="--abi-tags _diag,_dp,_vns --output my_nlohmann_json.natvis"
    ```

 4. Use the generated file instead of `nlohmann_json.natvis`.
@@ -853,12 +853,17 @@ from JSON text.

 [`basic_json_document::save()`](../api/basic_json_document/save.md) cannot write an
 [image](../features/json_view.md#images) of a [discarded](../api/basic_json_document/is_discarded.md) document.
+[`save()`](../api/basic_json_document/save.md) and [`load()`](../api/basic_json_document/load.md) also throw this
+exception on a big-endian target, since the image format is little-endian only.

 !!! failure "Example messages"

    ```
    [json.exception.type_error.320] cannot save a discarded json_document
    ```
+    ```
+    [json.exception.type_error.320] json_document images need a little-endian target
+    ```

 !!! note

@@ -358,7 +358,6 @@ nav:
          - 'Overview': api/adl_serializer/index.md
          - 'from_json': api/adl_serializer/from_json.md
          - 'to_json': api/adl_serializer/to_json.md
-      - 'is_json_view': api/is_json_view.md
      - 'json': api/json.md
      - 'json_document': api/json_document.md
      - 'json_editable_document': api/json_editable_document.md
@@ -408,7 +407,6 @@ nav:
      - 'ordered_json_editable_view': api/ordered_json_editable_view.md
      - 'ordered_json_view': api/ordered_json_view.md
      - 'ordered_map': api/ordered_map.md
-      - 'view_mode': api/view_mode.md
      - macros:
          - 'Overview': api/macros/index.md
          - 'JSON_ASSERT': api/macros/json_assert.md
@@ -443,6 +441,8 @@ nav:
          - 'JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON': api/macros/json_use_legacy_discarded_value_comparison.md
          - 'JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS': api/macros/json_use_objects_for_enum_keyed_maps.md
          - 'JSON_USE_SIMDUTF': api/macros/json_use_simdutf.md
+          - 'JSON_VIEW_NO_SIMD': api/macros/json_view_no_simd.md
+          - 'JSON_VIEW_USE_SSSE3': api/macros/json_view_use_ssse3.md
          - 'NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE, NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE': api/macros/nlohmann_define_derived_type.md
          - 'NLOHMANN_DEFINE_TYPE_INTRUSIVE, NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE': api/macros/nlohmann_define_type_intrusive.md
          - 'NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE, NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE': api/macros/nlohmann_define_type_non_intrusive.md
@@ -128,14 +128,26 @@
    #define NLOHMANN_JSON_ABI_TAG_NO_SIMD
 #endif

+#ifdef JSON_VIEW_NO_SIMD
+    #define NLOHMANN_JSON_ABI_TAG_VIEW_NO_SIMD _vns
+#else
+    #define NLOHMANN_JSON_ABI_TAG_VIEW_NO_SIMD
+#endif
+
+#ifdef JSON_VIEW_USE_SSSE3
+    #define NLOHMANN_JSON_ABI_TAG_VIEW_USE_SSSE3 _vssse3
+#else
+    #define NLOHMANN_JSON_ABI_TAG_VIEW_USE_SSSE3
+#endif
+
 #ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
    #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
 #endif

 // Construct the namespace ABI tags component
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h, i, j, k) json_abi ## a ## b ## c ## d ## e ## f ## g ## h ## i ## j ## k
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g, h, i, j, k) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h, i, j, k)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h, i, j, k, l, m) json_abi ## a ## b ## c ## d ## e ## f ## g ## h ## i ## j ## k ## l ## m
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g, h, i, j, k, l, m) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h, i, j, k, l, m)

 #define NLOHMANN_JSON_ABI_TAGS                                       \
    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
@@ -149,7 +161,9 @@
            NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS,       \
            NLOHMANN_JSON_ABI_TAG_DISABLE_STREAM_BULK_SCAN,          \
            NLOHMANN_JSON_ABI_TAG_DISABLE_UNLOCKED_FILE_IO,          \
-            NLOHMANN_JSON_ABI_TAG_NO_SIMD)
+            NLOHMANN_JSON_ABI_TAG_NO_SIMD,                           \
+            NLOHMANN_JSON_ABI_TAG_VIEW_NO_SIMD,                      \
+            NLOHMANN_JSON_ABI_TAG_VIEW_USE_SSSE3)

 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
@@ -10,7 +10,6 @@

 #include <algorithm> // min, transform
 #include <array> // array
-#include <cstddef> // nullptr_t
 #include <forward_list> // forward_list
 #include <iterator> // inserter, front_inserter, end
 #include <map> // map
@@ -28,7 +27,6 @@
 #include <nlohmann/detail/meta/identity_tag.hpp>
 #include <nlohmann/detail/meta/std_fs.hpp>
 #include <nlohmann/detail/meta/type_traits.hpp>
-#include <nlohmann/detail/output/error_handler.hpp>
 #include <nlohmann/detail/string_concat.hpp>
 #include <nlohmann/detail/value_t.hpp>

@@ -45,65 +43,6 @@ NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
 {

-// The from_json() overloads below read basic_json values and the views of
-// <nlohmann/json_view.hpp> (BasicJsonType is then a view, and
-// json_type_of_t<BasicJsonType> its basic_json type). The helpers below are
-// the accesses that differ between the two.
-
-// the boolean of j, a boolean
-template < typename BasicJsonType, enable_if_t < !is_json_view<BasicJsonType>::value, int > = 0 >
-typename BasicJsonType::boolean_t boolean_value(const BasicJsonType& j)
-{
-    return *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
-}
-
-template<typename View, enable_if_t<is_json_view<View>::value, int> = 0>
-bool boolean_value(const View& v)
-{
-    return v.template get<bool>();
-}
-
-// the string of j, a string
-template < typename BasicJsonType, enable_if_t < !is_json_view<BasicJsonType>::value, int > = 0 >
-const typename BasicJsonType::string_t& string_value(const BasicJsonType& j)
-{
-    return *j.template get_ptr<const typename BasicJsonType::string_t*>();
-}
-
-template<typename View, enable_if_t<is_json_view<View>::value, int> = 0>
-typename View::string_t string_value(const View& v)
-{
-    const auto s = v.get_string();
-    return typename View::string_t(s.data(), s.size());
-}
-
-// the binary value of j, a binary value (never a view: a view of a JSON text
-// holds no binary values)
-template < typename BasicJsonType, enable_if_t < !is_json_view<BasicJsonType>::value, int > = 0 >
-const typename BasicJsonType::binary_t& binary_value(const BasicJsonType& j)
-{
-    return *j.template get_ptr<const typename BasicJsonType::binary_t*>();
-}
-
-template<typename View, enable_if_t<is_json_view<View>::value, int> = 0>
-typename View::basic_json_type::binary_t binary_value(const View& /*unused*/)
-{
-    return {}; // LCOV_EXCL_LINE
-}
-
-// the elements of j, an array, for a range-based for loop
-template < typename BasicJsonType, enable_if_t < !is_json_view<BasicJsonType>::value, int > = 0 >
-const typename BasicJsonType::array_t& array_elements(const BasicJsonType& j)
-{
-    return *j.template get_ptr<const typename BasicJsonType::array_t*>();
-}
-
-template<typename View, enable_if_t<is_json_view<View>::value, int> = 0>
-View array_elements(const View& v) noexcept
-{
-    return v; // (a view is two pointers)
-}
-
 template<typename BasicJsonType>
 inline void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
 {
@@ -132,7 +71,7 @@ void from_json(const BasicJsonType& j, std::optional<T>& opt)

 // read a number value of any of the three number types into val;
 // returns false (leaving val untouched) if j is not a number
-template < typename BasicJsonType, typename ArithmeticType, enable_if_t < !is_json_view<BasicJsonType>::value, int > = 0 >
+template<typename BasicJsonType, typename ArithmeticType>
 bool get_number_value(const BasicJsonType& j, ArithmeticType& val)
 {
    switch (static_cast<value_t>(j))
@@ -169,22 +108,10 @@ bool get_number_value(const BasicJsonType& j, ArithmeticType& val)
    }
 }

-// a view converts numbers itself (as basic_json does)
-template<typename View, typename ArithmeticType, enable_if_t<is_json_view<View>::value, int> = 0>
-bool get_number_value(const View& v, ArithmeticType& val)
-{
-    if (!v.is_number())
-    {
-        return false;
-    }
-    val = v.template get<ArithmeticType>();
-    return true;
-}
-
 // overloads for basic_json template parameters
 template < typename BasicJsonType, typename ArithmeticType,
           enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
-                         !std::is_same<ArithmeticType, typename json_type_of_t<BasicJsonType>::boolean_t>::value,
+                         !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
                         int > = 0 >
 void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
 {
@@ -195,31 +122,31 @@ void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
 }

 template<typename BasicJsonType>
-inline void from_json(const BasicJsonType& j, typename json_type_of_t<BasicJsonType>::boolean_t& b)
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
    {
        throw_type_must_be("boolean", j);
    }
-    b = boolean_value(j);
+    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
 }

 template<typename BasicJsonType>
-inline void from_json(const BasicJsonType& j, typename json_type_of_t<BasicJsonType>::string_t& s)
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
    {
        throw_type_must_be("string", j);
    }
-    s = string_value(j);
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
 }

 template <
    typename BasicJsonType, typename StringType,
    enable_if_t <
-        std::is_assignable<StringType&, const typename json_type_of_t<BasicJsonType>::string_t>::value
-        && is_detected_exact<typename json_type_of_t<BasicJsonType>::string_t::value_type, value_type_t, StringType>::value
-        && !std::is_same<typename json_type_of_t<BasicJsonType>::string_t, StringType>::value
+        std::is_assignable<StringType&, const typename BasicJsonType::string_t>::value
+        && is_detected_exact<typename BasicJsonType::string_t::value_type, value_type_t, StringType>::value
+        && !std::is_same<typename BasicJsonType::string_t, StringType>::value
        && !is_json_ref<StringType>::value, int > = 0 >
 inline void from_json(const BasicJsonType& j, StringType& s)
 {
@@ -228,23 +155,23 @@ inline void from_json(const BasicJsonType& j, StringType& s)
        throw_type_must_be("string", j);
    }

-    s = string_value(j);
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
 }

 template<typename BasicJsonType>
-inline void from_json(const BasicJsonType& j, typename json_type_of_t<BasicJsonType>::number_float_t& val)
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
 {
    get_arithmetic_value(j, val);
 }

 template<typename BasicJsonType>
-inline void from_json(const BasicJsonType& j, number_unsigned_overload_t<json_type_of_t<BasicJsonType>>& val)
+inline void from_json(const BasicJsonType& j, number_unsigned_overload_t<BasicJsonType>& val)
 {
    get_arithmetic_value(j, val);
 }

 template<typename BasicJsonType>
-inline void from_json(const BasicJsonType& j, typename json_type_of_t<BasicJsonType>::number_integer_t& val)
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
 {
    get_arithmetic_value(j, val);
 }
@@ -256,8 +183,8 @@ inline void from_json(const BasicJsonType& j, EnumType& e)
 {
    using underlying_type = typename std::underlying_type<EnumType>::type;
    // get_arithmetic_value() does not accept boolean_t; read the number that to_json() wrote instead
-    using value_type = typename std::conditional<std::is_same<underlying_type, typename json_type_of_t<BasicJsonType>::boolean_t>::value,
-          typename json_type_of_t<BasicJsonType>::number_unsigned_t, underlying_type>::type;
+    using value_type = typename std::conditional<std::is_same<underlying_type, typename BasicJsonType::boolean_t>::value,
+          typename BasicJsonType::number_unsigned_t, underlying_type>::type;
    value_type val;
    get_arithmetic_value(j, val);
    e = static_cast<EnumType>(bool_aware_static_cast<underlying_type>(val));
@@ -266,7 +193,7 @@ inline void from_json(const BasicJsonType& j, EnumType& e)

 // forward_list doesn't have an insert method
 template<typename BasicJsonType, typename T, typename Allocator,
-         enable_if_t<is_getable<json_type_of_t<BasicJsonType>, T>::value, int> = 0>
+         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
 inline void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
@@ -274,16 +201,16 @@ inline void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l
        throw_type_must_be("array", j);
    }
    l.clear();
-    auto pos = l.before_begin();
-    for (const auto& elem : array_elements(j))
+    std::transform(j.rbegin(), j.rend(),
+                   std::front_inserter(l), [](const BasicJsonType & i)
    {
-        pos = l.insert_after(pos, elem.template get<T>());
-    }
+        return i.template get<T>();
+    });
 }

 // valarray doesn't have an insert method
 template<typename BasicJsonType, typename T,
-         enable_if_t<is_getable<json_type_of_t<BasicJsonType>, T>::value, int> = 0>
+         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
 inline void from_json(const BasicJsonType& j, std::valarray<T>& l)
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
@@ -291,11 +218,11 @@ inline void from_json(const BasicJsonType& j, std::valarray<T>& l)
        throw_type_must_be("array", j);
    }
    l.resize(j.size());
-    std::size_t i = 0;
-    for (const auto& elem : array_elements(j))
+    std::transform(j.begin(), j.end(), std::begin(l),
+                   [](const BasicJsonType & elem)
    {
-        l[i++] = elem.template get<T>();
-    }
+        return elem.template get<T>();
+    });
 }

 // element is not itself a C array: read it directly
@@ -323,8 +250,7 @@ auto from_json(const BasicJsonType& j, T (&arr)[N])  // NOLINT(cppcoreguidelines
    from_json_c_array_element(j, arr);
 }

-// (for a view, array_t is read element by element below)
-template < typename BasicJsonType, enable_if_t < !is_json_view<BasicJsonType>::value, int > = 0 >
+template<typename BasicJsonType>
 inline void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
 {
    arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
@@ -333,7 +259,7 @@ inline void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType:
 // fill a std::array from the JSON array j: the size is checked once and the
 // elements are read in order, so a short array converts the elements it has and
 // then throws the out_of_range error at() would throw for the first missing one
-template < typename BasicJsonType, typename T, std::size_t N, enable_if_t < !is_json_view<BasicJsonType>::value, int > = 0 >
+template<typename BasicJsonType, typename T, std::size_t N>
 void from_json_std_array(const BasicJsonType& j, std::array<T, N>& arr)
 {
    const auto& inner_array = *j.template get_ptr<const typename BasicJsonType::array_t*>();
@@ -348,21 +274,6 @@ void from_json_std_array(const BasicJsonType& j, std::array<T, N>& arr)
    }
 }

-// (a view has no random access to the elements: they are read in order)
-template<typename View, typename T, std::size_t N, enable_if_t<is_json_view<View>::value, int> = 0>
-void from_json_std_array(const View& v, std::array<T, N>& arr)
-{
-    std::size_t size = 0;
-    for (auto it = v.begin(); size < N && it != v.end(); ++it)
-    {
-        arr[size++] = (*it).template get<T>();
-    }
-    if (JSON_HEDLEY_UNLIKELY(size < N))
-    {
-        static_cast<void>(v.at(size));
-    }
-}
-
 template<typename BasicJsonType, typename T, std::size_t N>
 auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
                          priority_tag<2> /*unused*/)
@@ -411,8 +322,9 @@ auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, p
    void())
 {
    ConstructibleArrayType ret;
-    reserve_if_possible(ret, j.size(), priority_tag<1> {});
-    for (const auto& elem : array_elements(j))
+    const auto* inner_array = j.template get_ptr<const typename BasicJsonType::array_t*>();
+    reserve_if_possible(ret, inner_array->size(), priority_tag<1> {});
+    for (const auto& elem : *inner_array)
    {
        // get<BasicJsonType>() returns *this, this won't call a from_json
        // method when value_type is BasicJsonType
@@ -423,11 +335,11 @@ auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, p

 template < typename BasicJsonType, typename ConstructibleArrayType,
           enable_if_t <
-               is_constructible_array_type<json_type_of_t<BasicJsonType>, ConstructibleArrayType>::value&&
-               !is_constructible_object_type<json_type_of_t<BasicJsonType>, ConstructibleArrayType>::value&&
-               !is_constructible_string_type<json_type_of_t<BasicJsonType>, ConstructibleArrayType>::value&&
-               !std::is_same<ConstructibleArrayType, typename json_type_of_t<BasicJsonType>::binary_t>::value&&
-               !is_compatible_binary_type<json_type_of_t<BasicJsonType>, ConstructibleArrayType>::value&&
+               is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
+               !is_compatible_binary_type<BasicJsonType, ConstructibleArrayType>::value&&
               !is_basic_json<ConstructibleArrayType>::value,
               int > = 0 >
 auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
@@ -494,24 +406,24 @@ auto from_json(const BasicJsonType& j, identity_tag<std::array<T, N>> tag)
 }

 template<typename BasicJsonType>
-inline void from_json(const BasicJsonType& j, typename json_type_of_t<BasicJsonType>::binary_t& bin)
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
    {
        throw_type_must_be("binary", j);
    }

-    bin = binary_value(j);
+    bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
 }

 template < typename BasicJsonType, typename CompatibleArrayType,
-           enable_if_t < is_compatible_binary_type<json_type_of_t<BasicJsonType>, CompatibleArrayType>::value,
+           enable_if_t < is_compatible_binary_type<BasicJsonType, CompatibleArrayType>::value,
                         int > = 0 >
 inline void from_json(const BasicJsonType& j, CompatibleArrayType& bin)
 {
    if (j.is_binary())
    {
-        bin = static_cast<CompatibleArrayType>(binary_value(j));
+        bin = static_cast<CompatibleArrayType>(*j.template get_ptr<const typename BasicJsonType::binary_t*>());
    }
    else if (j.is_array())
    {
@@ -540,47 +452,8 @@ void from_json_object_emplace(ConstructibleObjectType& obj, Key&& key, Value&& v
    obj.emplace(std::forward<Key>(key), std::forward<Value>(value));
 }

-// a member of a view's object: a later member with the same key replaces an
-// earlier one, as parse() keeps the last value of a repeated key (containers
-// without operator[] keep the first)
-template<typename ConstructibleObjectType, typename Key, typename Value>
-auto from_json_object_assign(ConstructibleObjectType& obj, Key&& key, Value&& value, priority_tag<1> /*unused*/)
-> decltype(obj[std::forward<Key>(key)] = std::forward<Value>(value), void())
-{
-    obj[std::forward<Key>(key)] = std::forward<Value>(value);
-}
-
-template<typename ConstructibleObjectType, typename Key, typename Value>
-void from_json_object_assign(ConstructibleObjectType& obj, Key&& key, Value&& value, priority_tag<0> /*unused*/)
-{
-    obj.emplace(std::forward<Key>(key), std::forward<Value>(value));
-}
-
-template < typename BasicJsonType, typename ConstructibleObjectType, enable_if_t < !is_json_view<BasicJsonType>::value, int > = 0 >
-void from_json_object_impl(const BasicJsonType& j, ConstructibleObjectType& ret)
-{
-    const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
-    reserve_if_possible(ret, inner_object->size(), priority_tag<1> {});
-    for (const auto& p : *inner_object)
-    {
-        from_json_object_emplace(ret, p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>(), priority_tag<1> {});
-    }
-}
-
-template<typename View, typename ConstructibleObjectType, enable_if_t<is_json_view<View>::value, int> = 0>
-void from_json_object_impl(const View& v, ConstructibleObjectType& ret)
-{
-    using string_t = typename View::basic_json_type::object_t::key_type;
-    reserve_if_possible(ret, v.size(), priority_tag<1> {});
-    for (const auto item : v.items())
-    {
-        const auto key = item.key();
-        from_json_object_assign(ret, string_t(key.data(), key.size()), item.value().template get<typename ConstructibleObjectType::mapped_type>(), priority_tag<1> {});
-    }
-}
-
 template<typename BasicJsonType, typename ConstructibleObjectType,
-         enable_if_t<is_constructible_object_type<json_type_of_t<BasicJsonType>, ConstructibleObjectType>::value, int> = 0>
+         enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
 inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
 {
    if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
@@ -589,7 +462,12 @@ inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
    }

    ConstructibleObjectType ret;
-    from_json_object_impl(j, ret);
+    const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
+    reserve_if_possible(ret, inner_object->size(), priority_tag<1> {});
+    for (const auto& p : *inner_object)
+    {
+        from_json_object_emplace(ret, p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>(), priority_tag<1> {});
+    }
    obj = std::move(ret);
 }

@@ -598,10 +476,10 @@ inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
 template < typename BasicJsonType, typename ArithmeticType,
           enable_if_t <
               std::is_arithmetic<ArithmeticType>::value&&
-               !std::is_same<ArithmeticType, typename json_type_of_t<BasicJsonType>::number_unsigned_t>::value&&
-               !std::is_same<ArithmeticType, typename json_type_of_t<BasicJsonType>::number_integer_t>::value&&
-               !std::is_same<ArithmeticType, typename json_type_of_t<BasicJsonType>::number_float_t>::value&&
-               !std::is_same<ArithmeticType, typename json_type_of_t<BasicJsonType>::boolean_t>::value,
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
               int > = 0 >
 inline void from_json(const BasicJsonType& j, ArithmeticType& val)
 {
@@ -615,7 +493,7 @@ inline void from_json(const BasicJsonType& j, ArithmeticType& val)
    {
        throw_type_must_be("number", j);
    }
-    val = static_cast<ArithmeticType>(boolean_value(j));
+    val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
 }

 template<typename BasicJsonType, typename Type>
@@ -625,7 +503,7 @@ detail::uncvref_t<Type> from_json_tuple_get_impl(BasicJsonType&& j, detail::iden
 }

 template<typename BasicJsonType, typename Type,
-         detail::enable_if_t<conjunction<is_basic_json<uncvref_t<BasicJsonType>>, is_compatible_reference_type<BasicJsonType, Type>>::value, int> = 0>
+         detail::enable_if_t<detail::is_compatible_reference_type<BasicJsonType, Type>::value, int> = 0>
 Type from_json_tuple_get_impl(BasicJsonType && j, detail::identity_tag<Type> /*unused*/, detail::priority_tag<1> /*unused*/)
 {
    return std::forward<BasicJsonType>(j).template get_ref<Type>();
@@ -669,7 +547,7 @@ inline void from_json_tuple_impl(const BasicJsonType& j, std::pair<A1, A2>& p, p
 template<typename BasicJsonType, typename... Args>
 std::tuple<Args...> from_json_tuple_impl(const BasicJsonType& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/)
 {
-    static_assert(conjunction<disjunction<negation<std::is_reference<Args>>, conjunction<is_basic_json<BasicJsonType>, is_compatible_reference_type<const BasicJsonType&, Args>>>...>::value,
+    static_assert(conjunction<disjunction<negation<std::is_reference<Args>>, is_compatible_reference_type<const BasicJsonType&, Args>>...>::value,
                  "Can not return a tuple containing references to types not contained in a Json, try Json::get_to()");
    return from_json_tuple_impl_base<1, Args...>(j, index_sequence_for<Args...> {});
 }
@@ -715,7 +593,7 @@ void from_json_pair_array_to_map(const BasicJsonType& j, MapType& m)
 // read a map with enum keys from an object, using the enum's own from_json for
 // the keys (e.g., from NLOHMANN_JSON_SERIALIZE_ENUM); this is the form written
 // with JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-template < typename BasicJsonType, typename Map, enable_if_t < !is_json_view<BasicJsonType>::value, int > = 0 >
+template<typename BasicJsonType, typename Map>
 inline bool from_json_enum_keyed_object(const BasicJsonType& j, Map& m, std::true_type /*key is enum*/)
 {
    if (!j.is_object())
@@ -730,24 +608,6 @@ inline bool from_json_enum_keyed_object(const BasicJsonType& j, Map& m, std::tru
    return true;
 }

-template<typename View, typename Map, enable_if_t<is_json_view<View>::value, int> = 0>
-inline bool from_json_enum_keyed_object(const View& v, Map& m, std::true_type /*key is enum*/)
-{
-    using json_t = typename View::basic_json_type;
-    if (!v.is_object())
-    {
-        return false;
-    }
-    m.clear();
-    for (const auto item : v.items())
-    {
-        const auto key = item.key();
-        from_json_object_assign(m, json_t(typename json_t::string_t(key.data(), key.size())).template get<typename Map::key_type>(),
-                                item.value().template get<typename Map::mapped_type>(), priority_tag<1> {});
-    }
-    return true;
-}
-
 template<typename BasicJsonType, typename Map>
 inline bool from_json_enum_keyed_object(const BasicJsonType& /*j*/, Map& /*m*/, std::false_type /*key is enum*/)
 {
@@ -756,7 +616,7 @@ inline bool from_json_enum_keyed_object(const BasicJsonType& /*j*/, Map& /*m*/,

 template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
           typename = enable_if_t < !std::is_constructible <
-                                        typename json_type_of_t<BasicJsonType>::string_t, Key >::value >>
+                                        typename BasicJsonType::string_t, Key >::value >>
 void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
 {
    // NOLINTNEXTLINE(modernize-type-traits) we use C++11
@@ -769,7 +629,7 @@ void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>&

 template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
           typename = enable_if_t < !std::is_constructible <
-                                        typename json_type_of_t<BasicJsonType>::string_t, Key >::value >>
+                                        typename BasicJsonType::string_t, Key >::value >>
 void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
 {
    // NOLINTNEXTLINE(modernize-type-traits) we use C++11
@@ -793,7 +653,7 @@ inline void from_json(const BasicJsonType& j, std_fs::path& p)
    {
        throw_type_must_be("string", j);
    }
-    const auto& s = string_value(j);
+    const auto& s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
    // Checking for C++20 standard or later can be insufficient in case the
    // library support for char8_t is either incomplete or was disabled
    // altogether. Use the __cpp_lib_char8_t feature test instead.
@@ -805,100 +665,17 @@ inline void from_json(const BasicJsonType& j, std_fs::path& p)
 }
 #endif

-namespace from_json_adl
-{
-// hides the library's from_json() overloads above (and the from_json object):
-// a call from this namespace finds only the from_json() functions of the
-// arguments' own namespaces and classes (ADL); the declaration is never viable
-// and never defined (not "= delete", which GCC before 6 reports as a use)
-struct hidden;
-void from_json(const hidden&);
-
-// a type no from_json() written for JSON values accepts: a from_json() that
-// accepts it is not constrained to them (see has_view_from_json; it lives
-// here, so that ADL finds no other from_json() for it)
-struct probe
-{};
-
-struct fn
-{
-    template<typename SourceType, typename T>
-    auto operator()(const SourceType& j, T&& val) const
-    noexcept(noexcept(from_json(j, std::forward<T>(val))))
-    -> decltype(from_json(j, std::forward<T>(val)))
-    {
-        return from_json(j, std::forward<T>(val));
-    }
-};
-}  // namespace from_json_adl
-
-// the sources whose from_json() is only looked up by ADL: the probe
-template<typename T>
-struct is_adl_only_from_json_source : std::is_same<T, from_json_adl::probe> {};
-
 struct from_json_fn
 {
-    template < typename BasicJsonType, typename T,
-               enable_if_t < !is_adl_only_from_json_source<BasicJsonType>::value, int > = 0 >
-    auto operator()(const BasicJsonType& j, T && val) const
+    template<typename BasicJsonType, typename T>
+    auto operator()(const BasicJsonType& j, T&& val) const
    noexcept(noexcept(from_json(j, std::forward<T>(val))))
    -> decltype(from_json(j, std::forward<T>(val)))
    {
        return from_json(j, std::forward<T>(val));
    }
-
-    template < typename SourceType, typename T,
-               enable_if_t < is_adl_only_from_json_source<SourceType>::value, int > = 0 >
-    auto operator()(const SourceType& j, T && val) const
-    noexcept(noexcept(from_json_adl::fn {}(j, std::forward<T>(val))))
-    -> decltype(from_json_adl::fn {}(j, std::forward<T>(val)))
-    {
-        return from_json_adl::fn {}(j, std::forward<T>(val));
-    }
 };

-// Whether JSONSerializer::from_json(view, T&) reads T from a view (of
-// <nlohmann/json_view.hpp>) directly: it must accept the view but not the
-// probe. An unconstrained from_json() template (written for basic_json, but
-// accepting anything) is thus not called with a view, nor are the library's
-// own conversions; the view converts such types through materialize().
-template<typename Serializer, typename SourceType, typename T>
-using serializer_from_json_t = decltype(Serializer::from_json(std::declval<const SourceType&>(), std::declval<T&>()));
-
-template<typename Serializer, typename View, typename T>
-struct has_view_from_json
-    : conjunction < is_detected<serializer_from_json_t, Serializer, View, T>,
-      negation<is_detected<serializer_from_json_t, Serializer, from_json_adl::probe, T>>> {};
-
-// the base part of a type of the NLOHMANN_DEFINE_DERIVED_TYPE_* macros: from a
-// view through its get_to(), which reads the base from the view where the
-// base's from_json() accepts views, and from materialize() otherwise
-template<typename BasicJsonType, typename T, enable_if_t<is_basic_json<BasicJsonType>::value, int> = 0>
-void from_json_base(const BasicJsonType& j, T& base)
-{
-    from_json_fn {}(j, base);
-}
-
-template<typename View, typename T, enable_if_t<is_json_view<View>::value, int> = 0>
-void from_json_base(const View& v, T& base)
-{
-    v.get_to(base);
-}
-
-// a value as an exception message shows it (invalid UTF-8 replaced; the
-// strings of a view are always valid UTF-8)
-template<typename BasicJsonType, enable_if_t<is_basic_json<BasicJsonType>::value, int> = 0>
-typename BasicJsonType::string_t from_json_dump(const BasicJsonType& j)
-{
-    return j.dump(-1, ' ', false, error_handler_t::replace);
-}
-
-template<typename View, enable_if_t<is_json_view<View>::value, int> = 0>
-typename View::string_t from_json_dump(const View& v)
-{
-    return v.dump();
-}
-
 }  // namespace detail

 #ifndef JSON_HAS_CPP_17
@@ -102,7 +102,7 @@ enum class exception_id : int
    type_not_serializable = 317, ///< a value cannot be serialized to the requested binary format
    enum_key_duplicate = 318, ///< an enum-keyed map has two keys that serialize to the same string
    document_binary_value = 319, ///< a binary value is stored in a json_document
-    document_image_unsupported = 320, ///< a discarded json_document cannot be saved as an image
+    document_image_unsupported = 320, ///< a json_document image cannot be saved or loaded (discarded document, big-endian target)
    discarded_value_used = 321, ///< a discarded value is used
    // out_of_range
    array_index_out_of_range = 401, ///< an array index is out of range
@@ -417,20 +417,6 @@ void templated_json_throw(ExceptionType exception)
    (void)exception;
 }

-// the context of an exception about j: j itself for a basic_json value (whose
-// path JSON_DIAGNOSTICS shows), none for a view of <nlohmann/json_view.hpp>
-template<typename BasicJsonType, enable_if_t<is_basic_json<BasicJsonType>::value, int> = 0>
-const BasicJsonType * exception_context(const BasicJsonType& j) noexcept
-{
-    return &j;
-}
-
-template<typename View, enable_if_t<is_json_view<View>::value, int> = 0>
-std::nullptr_t exception_context(const View& /*unused*/) noexcept
-{
-    return nullptr;
-}
-
 /*!
@brief throws because @a j does not have the type a conversion expects
@param[in] expected  the expected type(s), e.g. "array" or "binary or array"
@@ -442,7 +428,7 @@ JSON_HEDLEY_NO_RETURN JSON_HEDLEY_NEVER_INLINE void throw_type_must_be(const cha
 {
    static_cast<void>(expected); // unused when JSON_NOEXCEPTION is defined
    static_cast<void>(j);
-    JSON_THROW(type_error::create(exception_id::type_mismatch, concat("type must be ", expected, ", but is ", j.type_name()), exception_context(j)));
+    JSON_THROW(type_error::create(exception_id::type_mismatch, concat("type must be ", expected, ", but is ", j.type_name()), &j));
 }

 /*!
@@ -291,17 +291,15 @@
        });                                                                                     \
        j = ((it != std::end(m)) ? it : std::begin(m))->second;                                 \
    }                                                                                           \
-    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json_or_view<BasicJsonType>::value, int> = 0> \
+    template<typename BasicJsonType>                                                            \
    inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                 \
    {                                                                                           \
        /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */                                \
        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
-        /* (for a view, the table holds basic_json values, which compare with the view) */      \
-        using nlohmann_json_value_t = nlohmann::detail::json_type_of_t<BasicJsonType>;          \
        /* NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) we don't want to depend on <array> */ \
-        static const std::pair<ENUM_TYPE, nlohmann_json_value_t> m[] = __VA_ARGS__;             \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
        auto it = std::find_if(std::begin(m), std::end(m),                                      \
-                               [&j](const std::pair<ENUM_TYPE, nlohmann_json_value_t>& ej_pair) -> bool \
+                               [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
        {                                                                                       \
            return ej_pair.second == j;                                                         \
        });                                                                                     \
@@ -332,22 +330,20 @@
        if (it != std::end(m)) j = it->second;                                                  \
        else ::nlohmann::detail::templated_json_throw<nlohmann::detail::out_of_range>(nlohmann::detail::out_of_range::create(nlohmann::detail::exception_id::value_out_of_range,"enum value out of range for " #ENUM_TYPE, nullptr)); \
    }                                                                                           \
-    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json_or_view<BasicJsonType>::value, int> = 0> \
+    template<typename BasicJsonType>                                                            \
    inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                 \
    {                                                                                           \
        /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */                                \
        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
-        /* (for a view, the table holds basic_json values, which compare with the view) */      \
-        using nlohmann_json_value_t = nlohmann::detail::json_type_of_t<BasicJsonType>;          \
        /* NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) we don't want to depend on <array> */ \
-        static const std::pair<ENUM_TYPE, nlohmann_json_value_t> m[] = __VA_ARGS__;             \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
        auto it = std::find_if(std::begin(m), std::end(m),                                      \
-                               [&j](const std::pair<ENUM_TYPE, nlohmann_json_value_t>& ej_pair) -> bool \
+                               [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
        {                                                                                       \
            return ej_pair.second == j;                                                         \
        });                                                                                     \
        if (it != std::end(m)) e = it->first;                                                   \
-        else ::nlohmann::detail::templated_json_throw<nlohmann::detail::out_of_range>(nlohmann::detail::out_of_range::create(nlohmann::detail::exception_id::value_out_of_range, nlohmann::detail::concat("enum value out of range for " #ENUM_TYPE ": ", nlohmann::detail::from_json_dump(j)), nlohmann::detail::exception_context(j))); \
+        else ::nlohmann::detail::templated_json_throw<nlohmann::detail::out_of_range>(nlohmann::detail::out_of_range::create(nlohmann::detail::exception_id::value_out_of_range, nlohmann::detail::concat("enum value out of range for " #ENUM_TYPE ": ", j.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace)), &j)); \
    }

 // Ugly macros to avoid uglier copy-paste when specializing basic_json. They
@@ -607,8 +603,6 @@
 #define NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME(v1, v2) nlohmann_json_t.v2 = !nlohmann_json_j.is_null() ? nlohmann_json_j.value(v1, nlohmann_json_default_obj.v2) : nlohmann_json_default_obj.v2;

 #define NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(...) template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> __VA_ARGS__
-// from_json() also reads from the views of <nlohmann/json_view.hpp>
-#define NLOHMANN_JSON_FROM_TYPE_TEMPLATE(...) template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json_or_view<BasicJsonType>::value, int> = 0> __VA_ARGS__

 // Helpers used to dispatch the NLOHMANN_DEFINE_TYPE_*/NLOHMANN_DEFINE_DERIVED_TYPE_*
 // macros below between a zero-member and a one-or-more-member implementation
@@ -661,18 +655,18 @@
 */
 #define NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_MEMBERS(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })

 #define NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_EMPTY(Type)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type&) { nlohmann_json_j = BasicJsonType::object(); }) \
    /* NOLINTNEXTLINE(bugprone-macro-parentheses) Type is used as a declarator type, not in an expression */ \
-    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(friend void from_json(const BasicJsonType&, Type&) noexcept { })
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType&, Type&) noexcept { })

 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_TYPE_BODY(NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_, __VA_ARGS__)(__VA_ARGS__))

 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_NAMES(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })

 /*!
@brief macro
@@ -682,7 +676,7 @@
 */
 #define NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT_MEMBERS(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })

 // identical to NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_EMPTY: with no members there is nothing to default
 #define NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT_EMPTY(Type) NLOHMANN_JSON_DEFINE_TYPE_INTRUSIVE_EMPTY(Type)
@@ -691,7 +685,7 @@

 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT_WITH_NAMES(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })

 /*!
@brief macro
@@ -718,18 +712,18 @@
 */
 #define NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_MEMBERS(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })

 #define NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_EMPTY(Type)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type&) { nlohmann_json_j = BasicJsonType::object(); }) \
    /* NOLINTNEXTLINE(bugprone-macro-parentheses) Type is used as a declarator type, not in an expression */ \
-    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(void from_json(const BasicJsonType&, Type&) noexcept { })
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType&, Type&) noexcept { })

 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_TYPE_BODY(NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_, __VA_ARGS__)(__VA_ARGS__))

 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_NAMES(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })

 /*!
@brief macro
@@ -739,7 +733,7 @@
 */
 #define NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT_MEMBERS(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })

 // identical to NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_EMPTY: with no members there is nothing to default
 #define NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT_EMPTY(Type) NLOHMANN_JSON_DEFINE_TYPE_NON_INTRUSIVE_EMPTY(Type)
@@ -748,7 +742,7 @@

 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT_WITH_NAMES(Type, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })

 /*!
@brief macro
@@ -775,18 +769,18 @@
 */
 #define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_MEMBERS(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { ::nlohmann::detail::from_json_base(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })

 #define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_EMPTY(Type, BaseType)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); }) \
    /* NOLINTNEXTLINE(bugprone-macro-parentheses) Type/BaseType are used as declarator types, not in expressions */ \
-    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { ::nlohmann::detail::from_json_base(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); })
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); })

 #define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DERIVED_TYPE_BODY(NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_, __VA_ARGS__)(__VA_ARGS__))

 #define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_NAMES(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { ::nlohmann::detail::from_json_base(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })

 /*!
@brief macro
@@ -796,7 +790,7 @@
 */
 #define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT_MEMBERS(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { ::nlohmann::detail::from_json_base(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })

 // identical to NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_EMPTY: with no members there is nothing to default
 #define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT_EMPTY(Type, BaseType) NLOHMANN_JSON_DEFINE_DERIVED_TYPE_INTRUSIVE_EMPTY(Type, BaseType)
@@ -805,7 +799,7 @@

 #define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT_WITH_NAMES(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { ::nlohmann::detail::from_json_base(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })

 /*!
@brief macro
@@ -833,18 +827,18 @@
 */
 #define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_MEMBERS(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { ::nlohmann::detail::from_json_base(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) })

 #define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_EMPTY(Type, BaseType)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); }) \
    /* NOLINTNEXTLINE(bugprone-macro-parentheses) Type/BaseType are used as declarator types, not in expressions */ \
-    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { ::nlohmann::detail::from_json_base(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); })
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); })

 #define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DERIVED_TYPE_BODY(NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_, __VA_ARGS__)(__VA_ARGS__))

 #define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_NAMES(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { ::nlohmann::detail::from_json_base(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_NAME, __VA_ARGS__)) })

 /*!
@brief macro
@@ -854,7 +848,7 @@
 */
 #define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT_MEMBERS(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { ::nlohmann::detail::from_json_base(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) })

 // identical to NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_EMPTY: with no members there is nothing to default
 #define NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT_EMPTY(Type, BaseType) NLOHMANN_JSON_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_EMPTY(Type, BaseType)
@@ -863,7 +857,7 @@

 #define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT_WITH_NAMES(Type, BaseType, ...)  \
    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_TO_WITH_NAME, __VA_ARGS__)) }) \
-    NLOHMANN_JSON_FROM_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { ::nlohmann::detail::from_json_base(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })
+    NLOHMANN_JSON_BASIC_TYPE_TEMPLATE(void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_DOUBLE_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT_WITH_NAME, __VA_ARGS__)) })

 /*!
@brief macro
@@ -340,47 +340,6 @@ template<class B> struct negation : std::integral_constant < bool, !B::value > {

 #endif

-///////////////////////
-// json_view helpers //
-///////////////////////
-
-template<typename T>
-using basic_json_type_t = typename T::basic_json_type;
-
-template<typename T>
-using materialize_function_t = decltype(std::declval<const T&>().materialize());
-
-// a basic_json_view of <nlohmann/json_view.hpp> (detected by its member type
-// basic_json_type, a basic_json, and materialize() returning that type, so that
-// json.hpp needs no declaration of the view)
-template<typename T, typename = void>
-struct is_json_view : std::false_type {};
-
-template<typename T>
-struct is_json_view<T, enable_if_t<is_basic_json<detected_t<basic_json_type_t, T>>::value>>
-    : std::is_same<detected_t<materialize_function_t, T>, basic_json_type_t<T>> {};
-
-// the types from_json() functions of the NLOHMANN_DEFINE_TYPE_* and
-// NLOHMANN_JSON_SERIALIZE_ENUM macros read from
-template<typename T>
-struct is_basic_json_or_view : disjunction<is_basic_json<T>, is_json_view<T>> {};
-
-// the basic_json type of a basic_json value or of a view
-template<typename T, typename = void>
-struct json_type_of
-{
-    using type = T;
-};
-
-template<typename T>
-struct json_type_of<T, enable_if_t<is_json_view<T>::value>>
-{
-    using type = typename T::basic_json_type;
-};
-
-template<typename T>
-using json_type_of_t = typename json_type_of<T>::type;
-
 // Reimplementation of is_constructible and is_default_constructible, due to them being broken for
 // std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367).
 // This causes compile errors in e.g., Clang 3.5 or GCC 4.9.
@@ -978,7 +978,7 @@ indent_done:
            std::memcpy(reinterpret_cast<unsigned char*>(n), &first, 8);
            std::memcpy(reinterpret_cast<unsigned char*>(n) + 8, &second, 8);
 #else
-            n->kind = static_cast<node_kind>(k);
+            n->kind = static_cast<std::uint8_t>(k);
            n->flags = flags;
            n->extra = extra;
            n->off = static_cast<std::uint32_t>(off);
@@ -232,7 +232,7 @@ struct document_data
    /// following loads.
    static NLOHMANN_VIEW_ALWAYS_INLINE const node* deref(const node* n) noexcept
    {
-        return NLOHMANN_VIEW_LIKELY(n->kind != node_kind::link) ? n : follow_link(n);
+        return NLOHMANN_VIEW_LIKELY(n->kind != kind_link) ? n : follow_link(n);
    }

    static NLOHMANN_VIEW_NOINLINE const node* follow_link(const node* n) noexcept
@@ -26,10 +26,12 @@
 #include <nlohmann/detail/view/lookup.hpp>
 #include <nlohmann/detail/view/macro_scope.hpp>
 #include <nlohmann/detail/view/node.hpp>
-#include <nlohmann/detail/view/view_mode.hpp>

 NLOHMANN_JSON_NAMESPACE_BEGIN

+template<typename BasicJsonType, bool Editable>
+class basic_json_view;
+
 namespace detail
 {
 namespace view
@@ -118,13 +120,13 @@ class editor
    View set(const View& object, string_view_t key, V&& value)
    {
        node* const o = own(object);
-        if (o->kind != node_kind::object && o->kind != node_kind::null)
+        if (o->kind != static_cast<std::uint8_t>(value_t::object) && o->kind != static_cast<std::uint8_t>(value_t::null))
        {
            throw_type_error(exception_id::subscript_wrong_type, "cannot use operator[] with a string argument with ", object.type_name());
        }
        check_utf8(key.data(), key.size());
        const encoded e = encode(std::forward<V>(value));
-        if (o->kind == node_kind::null)
+        if (o->kind == static_cast<std::uint8_t>(value_t::null))
        {
            become_empty(o, value_t::object);
        }
@@ -169,7 +171,7 @@ class editor
    View set(const View& array, std::size_t idx, V&& value)
    {
        node* const a = own(array);
-        if (a->kind != node_kind::array)
+        if (a->kind != static_cast<std::uint8_t>(value_t::array))
        {
            throw_type_error(exception_id::subscript_wrong_type, "cannot use operator[] with a numeric argument with ", array.type_name());
        }
@@ -186,12 +188,12 @@ class editor
    View push_back(const View& array, V&& value)
    {
        node* const a = own(array);
-        if (a->kind != node_kind::array && a->kind != node_kind::null)
+        if (a->kind != static_cast<std::uint8_t>(value_t::array) && a->kind != static_cast<std::uint8_t>(value_t::null))
        {
            throw_type_error(exception_id::push_back_wrong_type, "cannot use push_back() with ", array.type_name());
        }
        const encoded e = encode(std::forward<V>(value));
-        if (a->kind == node_kind::null)
+        if (a->kind == static_cast<std::uint8_t>(value_t::null))
        {
            become_empty(a, value_t::array);
        }
@@ -210,7 +212,7 @@ class editor
    View insert(const View& array, std::size_t idx, V&& value)
    {
        node* const a = own(array);
-        if (a->kind != node_kind::array)
+        if (a->kind != static_cast<std::uint8_t>(value_t::array))
        {
            throw_type_error(exception_id::insert_wrong_type, "cannot use insert() with ", array.type_name());
        }
@@ -230,7 +232,7 @@ class editor
    std::size_t erase(const View& object, string_view_t key)
    {
        node* const o = own(object);
-        if (o->kind != node_kind::object)
+        if (o->kind != static_cast<std::uint8_t>(value_t::object))
        {
            throw_type_error(exception_id::erase_wrong_type, "cannot use erase() with ", object.type_name());
        }
@@ -248,7 +250,7 @@ class editor
    void erase(const View& array, std::size_t idx)
    {
        node* const a = own(array);
-        if (a->kind != node_kind::array)
+        if (a->kind != static_cast<std::uint8_t>(value_t::array))
        {
            throw_type_error(exception_id::erase_wrong_type, "cannot use erase() with ", array.type_name());
        }
@@ -326,7 +328,7 @@ class editor
    {
        const std::uint8_t linked = n->flags & node_flags::linked;
        *n = node{};
-        n->kind = static_cast<node_kind>(k);
+        n->kind = static_cast<std::uint8_t>(k);
        n->flags = static_cast<std::uint8_t>(node_flags::is_new | linked);
        n->next = 1;
    }
@@ -403,8 +405,8 @@ class editor
    template<typename T>
    struct is_view : std::false_type {};

-    template<typename J, view_mode M>
-    struct is_view<basic_json_view<J, M>> : std::true_type {};
+    template<typename J, bool E>
+    struct is_view<basic_json_view<J, E>> : std::true_type {};

    template<typename V>
    encoded encode(V&& v)
@@ -419,8 +421,8 @@ class editor
    }

    /// a view of any document (copied; nothing is shared with it)
-    template<typename J, view_mode M>
-    encoded encode_impl(const basic_json_view<J, M>& v, encode_tag<0> /*view*/)
+    template<typename J, bool E>
+    encoded encode_impl(const basic_json_view<J, E>& v, encode_tag<0> /*view*/)
    {
        if (NLOHMANN_VIEW_UNLIKELY(v.m_node == nullptr))
        {
@@ -432,8 +434,8 @@ class editor
            r.scalar = copy_scalar(*v.m_doc, *v.m_node);
            return r;
        }
-        r.region = alloc_nodes(m_doc, count_nodes<M == view_mode::editable>(*v.m_doc, v.m_node));
-        fill_nodes<M == view_mode::editable>(*v.m_doc, v.m_node, r.region);
+        r.region = alloc_nodes(m_doc, count_nodes<E>(*v.m_doc, v.m_node));
+        fill_nodes<E>(*v.m_doc, v.m_node, r.region);
        edit_state_of(m_doc).regions.emplace(r.region, nullptr);
        return r;
    }
@@ -494,7 +496,7 @@ class editor
    static node plain_node(value_t k) noexcept
    {
        node n{};
-        n.kind = static_cast<node_kind>(k);
+        n.kind = static_cast<std::uint8_t>(k);
        n.flags = node_flags::is_new;
        return n;
    }
@@ -679,7 +681,7 @@ class editor
            ++r;
            if (is_container(*n))
            {
-                open.push_back(frame{walk::first(d, n), walk::end(d, n), n->kind == node_kind::object});
+                open.push_back(frame{walk::first(d, n), walk::end(d, n), n->kind == static_cast<std::uint8_t>(value_t::object)});
            }
            // the next value: close finished containers, then step over the key
            for (;;)
@@ -728,7 +730,7 @@ class editor
                node* const self = out++;
                *self = plain_node(static_cast<value_t>(n->kind));
                self->len = n->len;
-                open.push_back(frame{walk::first(d, n), walk::end(d, n), n->kind == node_kind::object, self});
+                open.push_back(frame{walk::first(d, n), walk::end(d, n), n->kind == static_cast<std::uint8_t>(value_t::object), self});
            }
            else
            {
@@ -27,7 +27,7 @@
 // live in chunks that never move; strings and number tokens written by edits
 // live in the edit arena. An array/object whose elements change gets
 // node_flags::moved: its elements then live in a separate sequence (a header
-// node, then the entries), whose entries link to the values (node_kind::link).
+// node, then the entries), whose entries link to the values (kind_link).

 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
@@ -185,7 +185,7 @@ inline node* block_of(document_data& d, node* n, std::size_t extra)
        return nh;
    }
    reserve_moved(d); // (so that set_moved() below cannot throw: the links are marked before)
-    const bool object = n->kind == node_kind::object;
+    const bool object = n->kind == static_cast<std::uint8_t>(value_t::object);
    const std::size_t used = 1 + (static_cast<std::size_t>(n->len) * (object ? 2 : 1));
    const std::size_t cap = used + extra;
    node* const h = alloc_nodes(d, cap);
@@ -251,7 +251,7 @@ inline node* find_parent(const document_data& d, const node* target)
        {
            return nullptr; // LCOV_EXCL_LINE (the value is inside c)
        }
-        const bool object = c->kind == node_kind::object;
+        const bool object = c->kind == static_cast<std::uint8_t>(value_t::object);
        const node* down = nullptr;
        for (const node* p = d.first_child_edited(c), *e = d.child_end_edited(c); p != e;)
        {
@@ -117,7 +117,7 @@ inline void compact_nodes(const document_data& d, std::size_t arena_size, std::v
                r.off = (v->flags & (node_flags::moved | node_flags::is_new)) != 0 ? 0 : v->off;
                r.len = 0;  // counted below
                r.next = 0; // set when the container is complete
-                stack.push_back(frame{d.first_child_edited(v), d.child_end_edited(v), out.size(), 0, v->kind == node_kind::object});
+                stack.push_back(frame{d.first_child_edited(v), d.child_end_edited(v), out.size(), 0, v->kind == static_cast<std::uint8_t>(value_t::object)});
                break;
            case value_t::string:
                r = string_node(*v);
@@ -138,7 +138,7 @@ inline void compact_nodes(const document_data& d, std::size_t arena_size, std::v
                    if (t[0] == 'n' || t[0] == 'i' || (v->len > 1 && t[1] == 'i'))
                    {
                        r = node{}; // nan and infinity: null, as dump() writes them
-                        r.kind = node_kind::null;
+                        r.kind = static_cast<std::uint8_t>(value_t::null);
                        break;
                    }
                    r.off = static_cast<std::uint32_t>(d.size + text_tail.size());
@@ -182,10 +182,12 @@ inline void compact_nodes(const document_data& d, std::size_t arena_size, std::v
    }
 }

-#if NLOHMANN_VIEW_LITTLE_ENDIAN // (the image format is little-endian: no save() elsewhere)
 /// the document as an image
 inline std::vector<std::uint8_t> save_image(const document_data& d)
 {
+#if !NLOHMANN_VIEW_LITTLE_ENDIAN
+    throw_type_error(exception_id::document_image_unsupported, "json_document images need a little-endian target"); // LCOV_EXCL_LINE
+#endif
    const std::size_t arena_size = d.arena_size;
    std::vector<node> compacted;
    std::string text_tail;
@@ -219,7 +221,7 @@ inline std::vector<std::uint8_t> save_image(const document_data& d)
    // extra of an object, and the same document saves to the same bytes
    for (std::size_t i = 0; i < count; ++i)
    {
-        if (nodes[i].kind == node_kind::object && nodes[i].extra != 0)
+        if (nodes[i].kind == static_cast<std::uint8_t>(value_t::object) && nodes[i].extra != 0)
        {
            std::memset(o + (i * sizeof(node)) + offsetof(node, extra), 0, sizeof(nodes[i].extra));
        }
@@ -241,7 +243,6 @@ inline std::vector<std::uint8_t> save_image(const document_data& d)
    *o = 0;
    return image;
 }
-#endif

 /// the parts of a number token that the checks need
 struct number_token
@@ -336,7 +337,7 @@ inline bool float_token_finite(const unsigned char* s, std::size_t len, const nu
    if (static_cast<std::int64_t>(t.int_digits) + t.exponent > 300)
    {
        node n{};
-        n.kind = node_kind::number_float;
+        n.kind = static_cast<std::uint8_t>(value_t::number_float);
        n.len = static_cast<std::uint32_t>(len);
        const auto v = float_value<double>(reinterpret_cast<const char*>(s), n); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
        return v <= (std::numeric_limits<double>::max)() && v >= -(std::numeric_limits<double>::max)();
@@ -357,7 +358,7 @@ inline bool check_integer(const node& n, const unsigned char* text)
    }
    // the token's value is the stored one; number_integer nodes of edits can
    // be non-negative (as basic_json keeps the type of a value)
-    const bool integer = n.kind == node_kind::number_integer;
+    const bool integer = n.kind == static_cast<std::uint8_t>(value_t::number_integer);
    if (t.is_float || t.int_digits > 20 || (t.negative && !integer))
    {
        return false;
@@ -539,7 +540,7 @@ inline bool check_image(const node* nodes, std::size_t count, const unsigned cha
        {
            return false;
        }
-        if (n.kind != node_kind::number_float)
+        if (n.kind != static_cast<std::uint8_t>(value_t::number_float))
        {
            return (n.extra >> 8u) == 0;
        }
@@ -580,7 +581,7 @@ inline bool check_image(const node* nodes, std::size_t count, const unsigned cha
        const node& n = nodes[i];
        if (!stack.empty() && stack.back().object && stack.back().expect_key)
        {
-            if (n.kind != node_kind::string || !check_string(n))
+            if (n.kind != static_cast<std::uint8_t>(value_t::string) || !check_string(n))
            {
                return false;
            }
@@ -621,7 +622,7 @@ inline bool check_image(const node* nodes, std::size_t count, const unsigned cha
                {
                    // (the contents of float tokens are checked later; the token of an
                    // integer has at most 256 characters)
-                    if (n.kind == node_kind::number_float)
+                    if (n.kind == static_cast<std::uint8_t>(value_t::number_float))
                    {
                        floats.push_back(float_range{n.off, n.len, n.extra});
                    }
@@ -639,7 +640,7 @@ inline bool check_image(const node* nodes, std::size_t count, const unsigned cha
                {
                    return false;
                }
-                stack.push_back(frame{i + n.next, n.len, 0, n.kind == node_kind::object, true});
+                stack.push_back(frame{i + n.next, n.len, 0, n.kind == static_cast<std::uint8_t>(value_t::object), true});
                complete = false;
                break;
            }
@@ -662,11 +663,13 @@ inline bool check_image(const node* nodes, std::size_t count, const unsigned cha
    throw_parse_error(exception_id::invalid_document_image, concat("invalid json_document image: ", what));
 }

-#if NLOHMANN_VIEW_LITTLE_ENDIAN // (the image format is little-endian: no load() elsewhere)
 /// Read an image into d. The text and the decoded strings stay in the image;
 /// the nodes are copied (so that they are aligned, and edits can change them).
 inline void load_image(document_data& d, const std::uint8_t* image, std::size_t size, image_check check)
 {
+#if !NLOHMANN_VIEW_LITTLE_ENDIAN
+    throw_type_error(exception_id::document_image_unsupported, "json_document images need a little-endian target"); // LCOV_EXCL_LINE
+#endif
    if (image == nullptr || size < sizeof(image_header))
    {
        throw_invalid_image("too short");
@@ -726,7 +729,7 @@ inline void load_image(document_data& d, const std::uint8_t* image, std::size_t
    for (std::size_t i = 0; i < count; ++i)
    {
        const node& n = d.nodes[i];
-        if (n.kind == node_kind::object && n.len >= document_data::index_min_members)
+        if (n.kind == static_cast<std::uint8_t>(value_t::object) && n.len >= document_data::index_min_members)
        {
            d.large_objects.push_back(static_cast<std::uint32_t>(i));
        }
@@ -735,7 +738,6 @@ inline void load_image(document_data& d, const std::uint8_t* image, std::size_t
    std::vector<std::uint32_t>().swap(d.large_objects); // (only needed while building)
    d.discarded = false;
 }
-#endif

 }  // namespace view
 }  // namespace detail
@@ -182,7 +182,7 @@ const node* element_at(const document_data& d, const node* array, std::size_t id
 template<bool Editable>
 const node* last_child(const document_data& d, const node* container) noexcept
 {
-    const std::size_t value_offset = container->kind == node_kind::object ? 1 : 0;
+    const std::size_t value_offset = container->kind == static_cast<std::uint8_t>(value_t::object) ? 1 : 0;
    const node* const end = navigation<Editable>::end(d, container);
    const node* last = navigation<Editable>::first(d, container);
    if (value_offset == 0 && container->next == container->len + 1u && (!navigation<Editable>::editable() || (container->flags & node_flags::moved) == 0))
@@ -101,7 +101,7 @@ BasicJsonType materialize(const document_data& d, const node* n)
            case value_t::object:
            case value_t::array:
            {
-                const bool object = n->kind == node_kind::object;
+                const bool object = n->kind == static_cast<std::uint8_t>(value_t::object);
                if (object)
                {
                    sax.start_object(n->len);
@@ -41,21 +41,9 @@ struct node_flags
    static constexpr std::uint8_t linked = 32; ///< an entry of a moved sequence links to this value (editable documents): its extent in the parsed layout no longer matters
 };

-/// the kind of a node: the value_t of its value, or link
-enum class node_kind : std::uint8_t
-{
-    null = static_cast<std::uint8_t>(value_t::null),
-    object = static_cast<std::uint8_t>(value_t::object),
-    array = static_cast<std::uint8_t>(value_t::array),
-    string = static_cast<std::uint8_t>(value_t::string),
-    boolean = static_cast<std::uint8_t>(value_t::boolean),
-    number_integer = static_cast<std::uint8_t>(value_t::number_integer),
-    number_unsigned = static_cast<std::uint8_t>(value_t::number_unsigned),
-    number_float = static_cast<std::uint8_t>(value_t::number_float),
-    /// an entry of an edited sequence that stands for a value stored elsewhere
-    /// (the address of the value's node is kept in the len/next bytes)
-    link = static_cast<std::uint8_t>(value_t::discarded) + 1,
-};
+/// kind of an entry of an edited sequence that stands for a value stored
+/// elsewhere (the address of the value's node is kept in the len/next bytes)
+constexpr std::uint8_t kind_link = 10;

 /// One entry of the flat index, in document order. An object's members are
 /// stored as key node followed by the value's subtree. Integers keep their
@@ -63,7 +51,7 @@ enum class node_kind : std::uint8_t
 /// always the next one, and the token length follows from `extra`).
 struct node
 {
-    node_kind kind;      ///< value_t, or link
+    std::uint8_t kind;   ///< value_t, or kind_link
    std::uint8_t flags;  ///< node_flags
    std::uint16_t extra; ///< numbers: integer digits (low byte) and fraction digits (high byte), 255 = "many"; objects: number of the object's key hash index (1-based, 0 = none); otherwise 0
    std::uint32_t off;   ///< source offset (string content, number token, literal, bracket); arena offset if escaped/edited; number of the element sequence if moved
@@ -72,9 +60,8 @@ struct node
 };
 static_assert(sizeof(node) == 16, "node must stay 16 bytes");

-// the node kinds are value_t values, and images store them as bytes; the test
-// below (object and array are 1 and 2) and those of the number kinds depend
-// on this numbering
+// the node kinds are value_t values; the test below (object and array are 1
+// and 2) and those of the number kinds depend on this numbering
 static_assert(static_cast<std::uint8_t>(value_t::null) == 0 && static_cast<std::uint8_t>(value_t::object) == 1
              && static_cast<std::uint8_t>(value_t::array) == 2 && static_cast<std::uint8_t>(value_t::string) == 3
              && static_cast<std::uint8_t>(value_t::boolean) == 4 && static_cast<std::uint8_t>(value_t::number_integer) == 5
@@ -99,7 +86,7 @@ inline void make_link(node& n, node* target) noexcept
 {
    target->flags = static_cast<std::uint8_t>(target->flags | node_flags::linked);
    n = node{};
-    n.kind = node_kind::link;
+    n.kind = kind_link;
    std::memcpy(reinterpret_cast<unsigned char*>(&n) + 8, static_cast<const void*>(&target), sizeof(const node*)); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
 }

@@ -129,8 +116,8 @@ NLOHMANN_VIEW_ALWAYS_INLINE void set_integer_bits(node& n, std::uint64_t v) noex
 /// token length of a number node
 NLOHMANN_VIEW_ALWAYS_INLINE std::uint32_t number_length(const node& n) noexcept
 {
-    return n.kind == node_kind::number_float ? n.len
-           : (n.extra & 0xFFu) + (n.kind == node_kind::number_integer ? 1u : 0u);
+    return n.kind == static_cast<std::uint8_t>(value_t::number_float) ? n.len
+           : (n.extra & 0xFFu) + (n.kind == static_cast<std::uint8_t>(value_t::number_integer) ? 1u : 0u);
 }

 /// estimated number of nodes for an input of `size` bytes (one node per ~12
@@ -19,6 +19,7 @@
 #include <nlohmann/detail/view/macro_scope.hpp>
 #include <nlohmann/detail/view/node.hpp>
 #include <nlohmann/detail/view/scan.hpp>
+#include <nlohmann/detail/view/simd.hpp>

 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
@@ -103,12 +104,56 @@ NLOHMANN_VIEW_NOINLINE FloatType float_value(const char* first, const node& n)
    return convert_float<FloatType>(first, last, dot, mantissa_end);
 }

+#if NLOHMANN_VIEW_VECTOR
+/*!
+@brief the value of the first 16 digits of a run of digits with a point after
+int_digits of them (or none, if int_digits >= 16)
+
+The 17 bytes at p are read at once: the bytes after the point move down by one,
+then pairs, quadruples, and octets of digits are combined by multiplications
+(after simdjson). The bytes [p, p + 32) must be readable. Bytes that are not
+digits (only in a damaged image loaded with image_check::bounds) give a wrong
+value, but no undefined behavior.
+*/
+NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t sixteen_digits(const unsigned char* p, unsigned int_digits) noexcept
+{
+#if NLOHMANN_VIEW_NEON
+    const uint8x16_t low = vld1q_u8(p);
+    const uint8x16_t index = vcombine_u8(vcreate_u8(0x0706050403020100u), vcreate_u8(0x0F0E0D0C0B0A0908u));
+    const uint8x16_t before_point = vcltq_u8(index, vdupq_n_u8(static_cast<std::uint8_t>(int_digits)));
+    const uint8x16_t digits = vsubq_u8(vbslq_u8(before_point, low, vextq_u8(low, vld1q_u8(p + 16), 1)), vdupq_n_u8('0'));
+    const uint16x8_t twos = vpaddlq_u8(vmulq_u8(digits, vreinterpretq_u8_u16(vdupq_n_u16(0x010A))));
+    const uint32x4_t fours = vpaddlq_u16(vmulq_u16(twos, vreinterpretq_u16_u32(vdupq_n_u32(0x00010064))));
+    const uint64x2_t eights = vpaddlq_u32(vmulq_u32(fours, vreinterpretq_u32_u64(vdupq_n_u64(0x0000000100002710u))));
+    return (vgetq_lane_u64(eights, 0) * 100000000u) + vgetq_lane_u64(eights, 1);
+#else
+    // NOLINTBEGIN(portability-simd-intrinsics)
+    const __m128i low = _mm_loadu_si128(static_cast<const __m128i*>(static_cast<const void*>(p))); // NOLINT(bugprone-casting-through-void)
+    const __m128i high = _mm_loadu_si128(static_cast<const __m128i*>(static_cast<const void*>(p + 16))); // NOLINT(bugprone-casting-through-void)
+    const __m128i before_point = _mm_cmpgt_epi8(_mm_set1_epi8(static_cast<char>(int_digits)), _mm_setr_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15));
+    const __m128i moved = _mm_or_si128(_mm_srli_si128(low, 1), _mm_slli_si128(high, 15));
+    const __m128i digits = _mm_sub_epi8(_mm_or_si128(_mm_and_si128(before_point, low), _mm_andnot_si128(before_point, moved)), _mm_set1_epi8('0'));
+    // (16-bit lanes: SSE2 has no multiply-add of bytes)
+    const __m128i tens = _mm_setr_epi16(10, 1, 10, 1, 10, 1, 10, 1);
+    const __m128i twos = _mm_packs_epi32(_mm_madd_epi16(_mm_unpacklo_epi8(digits, _mm_setzero_si128()), tens),
+                                         _mm_madd_epi16(_mm_unpackhi_epi8(digits, _mm_setzero_si128()), tens));
+    const __m128i fours = _mm_madd_epi16(twos, _mm_setr_epi16(100, 1, 100, 1, 100, 1, 100, 1));
+    const __m128i eights = _mm_madd_epi16(_mm_packs_epi32(fours, fours), _mm_setr_epi16(10000, 1, 10000, 1, 10000, 1, 10000, 1));
+    const auto upper = static_cast<std::uint32_t>(_mm_cvtsi128_si32(eights));
+    const auto lower = static_cast<std::uint32_t>(_mm_cvtsi128_si32(_mm_srli_si128(eights, 4)));
+    // NOLINTEND(portability-simd-intrinsics)
+    return (std::uint64_t{upper} * 100000000u) + lower;
+#endif
+}
+#endif
+
 /*!
@brief the digits of a float token with at most 19 digits, from its layout

 The digit layout recorded while parsing says where the integer digits, the
 fraction digits, and the exponent are, so the digits are read eight at a
-time without scanning.
+time without scanning (with SIMD, a token of 16 to 19 digits sixteen at a
+time).

@param[in] p  first character of the token
@param[in] e  end of the token
@@ -118,15 +163,34 @@ NLOHMANN_VIEW_ALWAYS_INLINE float_significand layout_decimal(const unsigned char
 {
    const bool negative = *p == '-';
    p += negative ? 1 : 0;
-    std::uint64_t w = parse_upto19(p, int_digits, limit);
-    p += int_digits;
+    std::uint64_t w = 0;
    std::int64_t q = 0;
-    if (frac_digits != 0)
+#if NLOHMANN_VIEW_VECTOR
+    const unsigned count = int_digits + frac_digits;
+    if (count >= 16 && limit - p >= 32)
    {
-        w = (w * int_pow10(frac_digits)) + parse_upto19(p + 1, frac_digits, limit);
-        p += 1 + frac_digits;
+        // (the point, if any, follows the integer digits; the digits after
+        // the first 16 are at most three)
+        w = sixteen_digits(p, int_digits);
+        for (unsigned i = 16; i < count; ++i)
+        {
+            w = (w * 10) + static_cast<std::uint64_t>(p[i + (i >= int_digits ? 1 : 0)] - '0');
+        }
+        p += count + (frac_digits != 0 ? 1 : 0);
        q = -static_cast<std::int64_t>(frac_digits);
    }
+    else
+#endif
+    {
+        w = parse_upto19(p, int_digits, limit);
+        p += int_digits;
+        if (frac_digits != 0)
+        {
+            w = (w * int_pow10(frac_digits)) + parse_upto19(p + 1, frac_digits, limit);
+            p += 1 + frac_digits;
+            q = -static_cast<std::int64_t>(frac_digits);
+        }
+    }
    if (p != e)
    {
        // [eE][+-]digits; huge exponents saturate (the parser rejected
@@ -161,12 +225,22 @@ NLOHMANN_VIEW_ALWAYS_INLINE float_significand layout_decimal(const unsigned char
 The result is correctly rounded by the lexer's conversion
 (detail::decimal_to_float(): Clinger's fast path where both operands are
 exact, else the Eisel-Lemire algorithm, which needs no fallback for up to 19
-digits), so it is the value parse() produces.
+digits), so it is the value parse() produces. Tokens of 16 or more digits go
+to Eisel-Lemire directly: the fast path takes few of them (none of 17 digits),
+and its check is a branch that data like GeoJSON coordinates mispredicts.
 */
 template<typename FloatType>
 NLOHMANN_VIEW_ALWAYS_INLINE FloatType layout_float(const unsigned char* p, const unsigned char* e, unsigned int_digits, unsigned frac_digits, const unsigned char* limit) noexcept
 {
-    return decimal_to_float<FloatType>(layout_decimal(p, e, int_digits, frac_digits, limit));
+    const float_significand d = layout_decimal(p, e, int_digits, frac_digits, limit);
+    if (int_digits + frac_digits >= 16)
+    {
+        using format = ieee_binary_format<std::numeric_limits<FloatType>::digits>;
+        native_float_t<FloatType> value{};
+        float_from_bits(eisel_lemire<format>(d.exponent, d.w) | (d.negative ? (std::uint64_t{1} << format::sign_bit()) : 0u), value);
+        return value;
+    }
+    return decimal_to_float<FloatType>(d);
 }

 /// the value of a float set by an edit: its token (the shortest round-trip
@@ -185,6 +259,80 @@ NLOHMANN_VIEW_NOINLINE FloatType edited_float(const char* token, const node& n)
    return float_value<FloatType>(token, n);
 }

+#if NLOHMANN_VIEW_VECTOR
+/// eisel_lemire() for the token w * 10^q of coordinate_float()
+template<typename Format>
+NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t coordinate_bits(std::int64_t q, std::uint64_t w, Format /*format*/) noexcept
+{
+    return eisel_lemire<Format>(q, w);
+}
+
+/*!
+@brief (binary64) eisel_lemire() without the cases that tokens of 16 or 17
+digits with 5 or more after the point cannot reach: a value of 0, a
+subnormal, an infinity, or a tie (q < -4)
+*/
+NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t coordinate_bits(std::int64_t q, std::uint64_t w, ieee_binary_format<53> format) noexcept
+{
+    if (NLOHMANN_VIEW_UNLIKELY(w == 0 || q > -5))
+    {
+        return eisel_lemire<ieee_binary_format<53>>(q, w);
+    }
+    static_cast<void>(format);
+    const int lz = count_leading_zeros(w);
+    const std::uint64_t normalized = w << static_cast<unsigned>(lz);
+    const auto index = static_cast<std::size_t>(2 * (q - pow5_128_smallest_power));
+    const uint128_parts product = full_multiplication(normalized, pow5_128()[index]);
+    std::uint64_t high = product.high;
+    if (NLOHMANN_VIEW_UNLIKELY((high & 0x1FFu) == 0x1FFu))
+    {
+        // (the lower bits may carry into the result)
+        const std::uint64_t second = full_multiplication(normalized, pow5_128()[index + 1]).high;
+        high += product.low + second < product.low ? 1u : 0u;
+    }
+    const auto upperbit = static_cast<unsigned>(high >> 63u);
+    std::uint64_t mantissa = high >> (upperbit + 9);
+    std::uint64_t power2 = static_cast<std::uint64_t>(((217706 * q) >> 16) + 63 + static_cast<std::int64_t>(upperbit) - lz + 1023);
+    mantissa = (mantissa + (mantissa & 1u)) >> 1u;
+    const bool carry = mantissa >= (std::uint64_t{2} << 52u);
+    mantissa = carry ? (std::uint64_t{1} << 52u) : mantissa;
+    power2 += carry ? 1u : 0u;
+    return (mantissa & ~(std::uint64_t{1} << 52u)) | (power2 << 52u);
+}
+
+/*!
+@brief (binary32 and binary64) the value of a float token of the source with
+16 or 17 digits, a point, and no exponent, the shape of most coordinates
+written with full precision; whether the token of n has this shape
+
+These tokens skip the general layout of layout_decimal(): no digits beyond
+the 17th, no exponent (and Eisel-Lemire directly, as in layout_float()).
+*/
+template<typename FloatType>
+NLOHMANN_VIEW_ALWAYS_INLINE bool coordinate_float(const document_data& d, const node& n, FloatType& value) noexcept
+{
+    const unsigned int_digits = n.extra & 0xFFu;
+    const unsigned frac_digits = n.extra >> 8u;
+    const unsigned count = int_digits + frac_digits;
+    const auto* const first = reinterpret_cast<const unsigned char*>(d.src + n.off); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+    const unsigned negative = first[0] == '-' ? 1u : 0u;
+    if (count - 16u > 1u || frac_digits == 0 || n.len != negative + count + 1 || d.size - n.off < 33)
+    {
+        return false;
+    }
+    const unsigned char* const digits = first + negative;
+    const std::uint64_t w = sixteen_digits(digits, int_digits);
+    // (the 17th digit follows the point)
+    const std::uint64_t w17 = (w * 10) + static_cast<std::uint64_t>(digits[17] - '0');
+    using format = ieee_binary_format<std::numeric_limits<FloatType>::digits>;
+    native_float_t<FloatType> result{};
+    float_from_bits(coordinate_bits(-static_cast<std::int64_t>(frac_digits), count == 17 ? w17 : w, format{}) | (static_cast<std::uint64_t>(negative) << format::sign_bit()), result);
+    value = result;
+    return true;
+}
+
+#endif
+
 /// the value of the float token of a node, as parse() converts it; floats and
 /// doubles with at most 19 digits are converted from the digit layout
 template<typename FloatType>
@@ -200,6 +348,13 @@ FloatType float_value(const document_data& d, const node& n)
 template<typename FloatType>
 FloatType float_value(const document_data& d, const node& n, std::true_type /*binary32 or binary64*/)
 {
+#if NLOHMANN_VIEW_VECTOR
+    FloatType value {};
+    if (coordinate_float(d, n, value))
+    {
+        return value;
+    }
+#endif
    const unsigned int_digits = n.extra & 0xFFu;
    const unsigned frac_digits = n.extra >> 8u;
    if (NLOHMANN_VIEW_LIKELY(int_digits + frac_digits <= 19)) // (255 marks "many")
@@ -14,7 +14,9 @@
 #include <cstddef> // size_t
 #include <cstdint> // uint8_t, uint32_t
 #include <cstring> // memcpy, memset
+#include <functional> // less
 #include <limits> // numeric_limits
+#include <memory> // unique_ptr
 #include <type_traits> // integral_constant
 #include <vector> // vector

@@ -384,6 +386,127 @@ struct depth_counter<false>
    }
 };

+/*!
+@brief where the double x nearest to a token w * 10^q lies, for 10^15 <= w <
+10^17 and -17 <= q <= -1 (Eisel-Lemire, then a fixed-point position)
+
+dump() writes the shortest decimal in the rounding interval of x (the closest
+one if there are several, see zmij::to_shortest()). Its digits are those of a
+multiple of 10^g of the token's last digit, with g = dec_exp + 1 - q for x's
+decimal exponent dec_exp: the multiple of 10^g nearest to x if it lies in the
+interval (at most one does), else the multiple of 10^(g - 1) nearest to x
+(see token_digits_1() and token_digits_2()). For g <= 0, the token itself is
+in the interval.
+
+The position is exact in a 64-bit fixed-point number with 56 bits after the
+point (of the token's last digit): x / 10^q = 2c * 5^-q / 2^t for x = c * 2^e2
+and t = q + 1 - e2, with at most 56 bits after the point here, and |x / 10^q -
+w| is at most half the spacing of the doubles, below 12 units. So only the low
+64 bits of 2c * 5^-q are needed. c and e2 come from Eisel-Lemire's product
+directly (as eisel_lemire() rounds it: no tie is possible for q < -4, and its
+second product is added where it can carry into the result).
+
+@param[out] offset  x / 10^q - w + 32, with 56 bits after the point
+@param[out] radius  half the spacing of the doubles at x, likewise (+ 1 if
+                    the interval is closed)
+@return g; 3 if the digits are not decided here (a power of two, whose
+        interval is not symmetric, or out of range)
+*/
+NLOHMANN_VIEW_ALWAYS_INLINE int locate_token(std::uint64_t w, int q, std::uint64_t& offset, std::uint64_t& radius) noexcept
+{
+    const int lz = count_leading_zeros(w);
+    const std::uint64_t normalized = w << static_cast<unsigned>(lz);
+    const auto index = static_cast<std::size_t>(2 * (q - pow5_128_smallest_power));
+    const uint128_parts product = full_multiplication(normalized, pow5_128()[index]);
+    std::uint64_t high = product.high;
+    if (NLOHMANN_VIEW_UNLIKELY((high & 0x1FFu) == 0x1FFu))
+    {
+        // (as eisel_lemire(): the lower bits may carry into the result)
+        const std::uint64_t second = full_multiplication(normalized, pow5_128()[index + 1]).high;
+        high += product.low + second < product.low ? 1u : 0u;
+    }
+    const auto upperbit = static_cast<unsigned>(high >> 63u);
+    const std::uint64_t mantissa = high >> (upperbit + 9);
+    const std::uint64_t c = (mantissa + (mantissa & 1u)) >> 1u;
+    // e2 as eisel_lemire() computes the exponent (log2(10) ~ 217706 / 2^16)
+    const int e2 = static_cast<int>((217706 * static_cast<std::int64_t>(q)) >> 16) + 63 + static_cast<int>(upperbit) - lz - 52;
+    const int t = q + 1 - e2;
+    const int g = ((e2 * 315653) >> 20) + 1 - q; // (dec_exp as in zmij::to_shortest(), for a regular x)
+    static const std::array<std::uint64_t, 17> fives = {{1u, 5u, 25u, 125u, 625u, 3125u, 15625u, 78125u, 390625u, 1953125u, 9765625u, 48828125u, 244140625u, 1220703125u, 6103515625u, 30517578125u, 152587890625u}};
+    const std::uint64_t five = fives[static_cast<std::size_t>(-q)]; // 5^-q
+    const unsigned s = static_cast<unsigned>(56 - t) & 63u;
+    offset = ((2 * c * five) << s) - (w << 56u) + (std::uint64_t{32} << 56u);
+    radius = (five << s) + ((c & 1u) == 0 ? 1u : 0u);
+    // (c = 2^52: a power of two; c = 2^53: rounded up to one. With 8 to 16
+    // fraction digits, as the batch's tokens have, t is in [15, 40] and g at
+    // most 2. x lies halfway between two candidates only if its distance from
+    // the token is a whole unit (g == 2) or a half (g == 1): such tokens are
+    // left to the full conversion)
+    const bool decided = c - ((std::uint64_t{1} << 52u) + 1) < (std::uint64_t{1} << 52u) - 1
+                         && (offset & ((std::uint64_t{1} << 55u) - 1)) != 0;
+    return decided ? g : 3;
+}
+
+/// the distance of a position (see locate_token()) from the biased point 32
+NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t biased_distance(std::uint64_t position) noexcept
+{
+    constexpr std::uint64_t center = std::uint64_t{32} << 56u;
+    return position >= center ? position - center : center - position;
+}
+
+/*!
+@brief (g == 1) the digits dump() writes for a token, from the position of its
+double (see locate_token()): the multiple of 10 nearest to x if it is in the
+interval, else w rounded to x (an exact tie between two candidates, like
+754570942.33984373, whose double is 754570942.33984375, is excluded by
+locate_token())
+
+With |x - w| at most the radius, which is below half the spacing of the
+candidates, the multiple of 10 nearest to x is w - r10 or the one above it.
+*/
+NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t token_digits_1(std::uint64_t w, std::uint64_t offset, std::uint64_t radius, std::uint64_t r10) noexcept
+{
+    constexpr std::uint64_t one = std::uint64_t{1} << 56u;
+    const std::uint64_t from = offset + (r10 * one); // x - (w - r10) (+ 32)
+    const bool up = from > 37 * one;                  // (nearer to the multiple above)
+    const bool shorter = biased_distance(from - (up ? 10 * one : 0)) < radius;
+    const std::uint64_t a = w - r10 + (up ? 10u : 0u);
+    const std::uint64_t b = w + ((offset + (one / 2)) >> 56u) - 32;                // w rounded to x
+    return shorter ? a : b;
+}
+
+/*!
+@brief (g == 2) the digits dump() writes for a token, as token_digits_1(): the
+multiple of 100 nearest to x if it is in the interval, else the multiple of 10
+nearest to x
+*/
+NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t token_digits_2(std::uint64_t w, std::uint64_t offset, std::uint64_t radius, std::uint64_t r10, std::uint64_t r100) noexcept
+{
+    constexpr std::uint64_t one = std::uint64_t{1} << 56u;
+    const std::uint64_t from = offset + (r100 * one);
+    const bool up = from > 82 * one;
+    const bool shorter = biased_distance(from - (up ? 100 * one : 0)) < radius;
+    const std::uint64_t a = w - r100 + (up ? 100u : 0u);
+    // x - (w - r10), in [-12, 21]: the multiple of 10 nearest to x is that one,
+    // or one or two above, or one below
+    const std::uint64_t y = offset + (r10 * one);
+    const std::uint64_t steps = (y > 37 * one ? 1u : 0u) + (y > 47 * one ? 1u : 0u);
+    const bool down = y < 27 * one;
+    const std::uint64_t b = w - r10 + (10 * steps) - (down ? 10u : 0u);
+    return shorter ? a : b;
+}
+
+/// the four ASCII digits of x < 10^4, the first in the lowest byte (as
+/// little-endian memory holds them)
+NLOHMANN_VIEW_ALWAYS_INLINE std::uint32_t four_digit_text(std::uint32_t x) noexcept
+{
+    const std::uint32_t ab = (x * 5243u) >> 19u; // x / 100
+    std::uint32_t v = ab | ((x - (ab * 100u)) << 16u);
+    const std::uint32_t a = ((v * 103u) >> 10u) & 0x000F000Fu; // / 10 per 16-bit lane
+    v = a | ((v - (a * 10u)) << 8u);
+    return v + 0x30303030u;
+}
+
 /// how the view's dump() writes a value
 struct dump_style
 {
@@ -711,6 +834,7 @@ class view_serializer
        std::array<frame, 32> buffer; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
        std::vector<frame> heap;
        small_stack<frame> stack(buffer.data(), buffer.size(), heap);
+        float_batch batch;
        const char* const src = m_doc.src;
        const char* const src_end = src + m_doc.size;
        char* w = m_out.cursor();
@@ -850,7 +974,7 @@ class view_serializer
                    else if (enabled(fast_double::value))
                    {
                        room(64);
-                        w = write_double_at(w, *n);
+                        w = write_double_ahead(w, src, n, batch);
                    }
                    else
                    {
@@ -874,7 +998,21 @@ class view_serializer
                case value_t::object:
                case value_t::array:
                {
-                    const bool object = n->kind == node_kind::object;
+                    const bool object = n->kind == static_cast<std::uint8_t>(value_t::object);
+                    // (read-only documents, compact output) a pair of floats,
+                    // like the coordinates of GeoJSON, without a frame
+                    if (enabled(!Editable && !Pretty && !SourceNumbers && fast_double::value) && n->next == 3 && n->len == 2
+                            && n[1].kind == static_cast<std::uint8_t>(value_t::number_float) && n[2].kind == static_cast<std::uint8_t>(value_t::number_float))
+                    {
+                        room(2 * 64);
+                        *w++ = '[';
+                        w = write_double_ahead(w, src, n + 1, batch);
+                        *w++ = ',';
+                        w = write_double_ahead(w, src, n + 2, batch);
+                        *w++ = ']';
+                        n += 2; // (the element before the next node)
+                        break;
+                    }
                    room(8);
                    if (n->len == 0)
                    {
@@ -984,6 +1122,247 @@ class view_serializer
        }
    }

+    /// (float_batch) the mark of digits whose rounding carried beyond the
+    /// token's last four (see mark())
+    static constexpr std::uint64_t carried() noexcept
+    {
+        return std::uint64_t{1} << 63u;
+    }
+
+    /// floats of 16 or 17 digits ahead of the walk, converted together (see
+    /// convert_ahead()), with their digits as mark() keeps them
+    struct float_batch
+    {
+        static constexpr std::size_t capacity() noexcept
+        {
+            return 256;
+        }
+        /// (on the heap, allocated by the first conversion: a frame of more
+        /// than a page made every dump of a small document slower)
+        struct entries
+        {
+            std::array<const node*, 256> at; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
+            std::array<std::uint64_t, 256> digits; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
+        };
+        std::unique_ptr<entries> storage{};
+        const node** at = nullptr;
+        std::uint64_t* digits = nullptr;
+        std::size_t count = 0;
+        std::size_t next = 0;
+        const node* scanned = nullptr; ///< where the last scan of the node array ended
+    };
+
+    /// (doubles) the float at n as dump() writes it, at w (64 bytes of room):
+    /// from the batch if it holds n
+    NLOHMANN_VIEW_ALWAYS_INLINE char* write_double_ahead(char* w, const char* src, const node* n, float_batch& batch)
+    {
+#if NLOHMANN_VIEW_VECTOR && NLOHMANN_VIEW_LITTLE_ENDIAN
+        // (digits 0: not written by the batch; carried(): rounding carried
+        // beyond the last four digits)
+        if (batch.next != batch.count && batch.at[batch.next] == n && batch.digits[batch.next] - 1 < carried() - 1)
+        {
+            return write_token_digits(w, src, *n, batch.digits[batch.next++]);
+        }
+        return write_double_beside(w, n, batch);
+#else
+        static_cast<void>(src);
+        static_cast<void>(batch);
+        return write_double_at(w, *n);
+#endif
+    }
+
+#if NLOHMANN_VIEW_VECTOR && NLOHMANN_VIEW_LITTLE_ENDIAN
+    /// write_double_ahead() for a float that is not the batch's next one (out
+    /// of line: the walk is faster with less code in its loop)
+    NLOHMANN_VIEW_NOINLINE char* write_double_beside(char* w, const node* n, float_batch& batch)
+    {
+        // (an editable document's walk can skip nodes of the array)
+        const std::less<const node*> before;
+        while (batch.next != batch.count && before(batch.at[batch.next], n))
+        {
+            ++batch.next;
+        }
+        if ((batch.next != batch.count && batch.at[batch.next] == n) || convert_ahead(n, batch))
+        {
+            const std::uint64_t digits = batch.digits[batch.next++];
+            if ((digits & carried()) != 0)
+            {
+                return write_carried_digits(w, *n, digits & ~carried());
+            }
+            if (digits != 0)
+            {
+                return write_token_digits(w, m_doc.src, *n, digits);
+            }
+        }
+        return write_double_at(w, *n);
+    }
+
+    /*!
+    @brief convert the floats of 16 or 17 digits among the next nodes of the
+    array at once; whether n is the first of them
+
+    Such tokens (like the coordinates of GeoJSON, written with 17 digits) are
+    written as the token with its last four digits replaced
+    (write_token_digits()). Each step (the digits, locate_token(),
+    token_digits_1/2()) is a long chain of dependent operations; one loop per
+    step over many floats lets the processor overlap the floats, which it does
+    not across the steps of one float (on Apple M1, one loop for the digits and
+    locate_token() made the dump of canada.json 12 % slower). Each node of the array
+    is scanned once; a node that the walk does not reach in order (in an
+    editable document) is written without the batch.
+    */
+    NLOHMANN_VIEW_NOINLINE bool convert_ahead(const node* n, float_batch& batch)
+    {
+        const std::less<const node*> before;
+        const node* const last = m_doc.nodes + m_doc.node_count;
+        if (before(n, batch.scanned) || before(n, m_doc.nodes) || !before(n, last))
+        {
+            return false;
+        }
+        const char* const src = m_doc.src;
+        const char* const src_end = src + m_doc.size;
+        const node* const stop = last - n > 1024 ? n + 1024 : last;
+        batch.count = 0;
+        batch.next = 0;
+        // the digits of each token (and its last four from the text)
+        std::array<std::uint64_t, 256> digits;     // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
+        std::array<int, 256> exponent;             // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
+        std::array<std::uint32_t, 256> last_four;  // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
+        const node* p = n;
+        if (!batch.storage)
+        {
+            batch.storage.reset(new typename float_batch::entries); // NOLINT(cppcoreguidelines-owning-memory,modernize-make-unique): C++11
+            batch.at = batch.storage->at.data();
+            batch.digits = batch.storage->digits.data();
+        }
+        for (; p != stop && batch.count != float_batch::capacity(); ++p)
+        {
+            // a token of the source: 16 or 17 digits, at least 8 after the
+            // point, no exponent, 32 bytes to read
+            const unsigned frac_digits = p->extra >> 8u;
+            const unsigned int_digits = p->extra & 0xFFu;
+            const unsigned count = int_digits + frac_digits;
+            if (p->kind == static_cast<std::uint8_t>(value_t::number_float) && (p->flags & node_flags::storage) == 0
+                    && count - 16u <= 1u && frac_digits >= 8 && src_end - (src + p->off) >= 33)
+            {
+                const auto* const token = reinterpret_cast<const unsigned char*>(src + p->off); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+                const unsigned sign = token[0] == '-' ? 1 : 0;
+                const unsigned char* const first = token + sign;
+                const std::uint64_t w = sixteen_digits(first, int_digits);
+                // (the 17th digit follows the point; a token with an exponent
+                // gets digits outside the range of locate_token(), and is not
+                // written by the batch. A token 0.xxx with 16 significant
+                // digits is: its double is written as "0." and its digits too)
+                const std::uint64_t w17 = (w * 10) + static_cast<std::uint64_t>(first[17] - '0');
+                const std::size_t i = batch.count++;
+                batch.at[i] = p;
+                digits[i] = p->len != sign + count + 1 ? 0 : (count == 17 ? w17 : w);
+                exponent[i] = -static_cast<int>(frac_digits);
+                // (byte 0: the last digit, byte 1: the last two, bits 16-29: the last four)
+                std::uint32_t four = 0;
+                std::memcpy(&four, token + p->len - 4, 4);
+                four -= 0x30303030u;
+                const std::uint32_t pairs = ((four & 0x0F0F0F0Fu) * 2561u) >> 8u; // (byte 0, 2: the pairs)
+                last_four[i] = (four >> 24u) | ((pairs >> 16u & 0xFFu) << 8u) | ((((pairs & 0x00FF00FFu) * 6553601u) >> 16u) << 16u);
+            }
+        }
+        batch.scanned = p;
+        // the position of each double, and the floats of either kind
+        std::array<std::uint64_t, 256> offset; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
+        std::array<std::uint64_t, 256> radius; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
+        std::array<std::uint8_t, 256> kind_1;  // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
+        std::array<std::uint8_t, 256> kind_2;  // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
+        std::size_t count_1 = 0;
+        std::size_t count_2 = 0;
+        for (std::size_t i = 0; i != batch.count; ++i)
+        {
+            const std::uint64_t w = digits[i];
+            // (the range excludes the values of bytes that are not digits, only
+            // in a damaged image loaded with image_check::bounds)
+            const int g = w - 1000000000000000u < 99000000000000000u ? locate_token(w, exponent[i], offset[i], radius[i]) : 3;
+            batch.digits[i] = g <= 0 ? (last_four[i] >> 16u) + 1 : 0;
+            kind_1[count_1] = static_cast<std::uint8_t>(i);
+            count_1 += g == 1 ? 1 : 0;
+            kind_2[count_2] = static_cast<std::uint8_t>(i);
+            count_2 += g == 2 ? 1 : 0;
+        }
+        // the digits to write, in one loop per kind (see mark())
+        for (std::size_t k = 0; k != count_1; ++k)
+        {
+            const std::size_t i = kind_1[k];
+            const std::uint64_t s = token_digits_1(digits[i], offset[i], radius[i], last_four[i] & 0xFFu);
+            batch.digits[i] = mark(digits[i], s, last_four[i] >> 16u);
+        }
+        for (std::size_t k = 0; k != count_2; ++k)
+        {
+            const std::size_t i = kind_2[k];
+            const std::uint64_t s = token_digits_2(digits[i], offset[i], radius[i], last_four[i] & 0xFFu, (last_four[i] >> 8u) & 0xFFu);
+            batch.digits[i] = mark(digits[i], s, last_four[i] >> 16u);
+        }
+        return batch.count != 0 && batch.at[0] == n;
+    }
+
+    /*!
+    @brief a float token of 16 or 17 digits as dump() writes it, at w (64 bytes
+    of room), from the digits of its double (see locate_token()) whose
+    rounding carried beyond the token's last four digits
+
+    (like 43.42027299999999 -> 43.420273): the digits go to the writer of
+    Zmij's results as its 15 or 16 leading digits and one more, which omits
+    the trailing zeros.
+    */
+    NLOHMANN_VIEW_NOINLINE char* write_carried_digits(char* w, const node& n, std::uint64_t digits) const noexcept
+    {
+        const int exponent = -(n.extra >> 8u);
+        const std::uint64_t leading = digits / 10;
+        const auto last = static_cast<unsigned char>(digits - (leading * 10));
+        const bool seventeen = digits >= 10000000000000000u;
+        *w = '-';
+        w += m_doc.src[n.off] == '-' ? 1 : 0;
+        return ::nlohmann::detail::dtoa_impl::write_shortest(w, seventeen ? ::nlohmann::detail::zmij::shortest_decimal{leading, exponent, last, last != 0}
+                : ::nlohmann::detail::zmij::shortest_decimal{digits, exponent - 1, 0, false});
+    }
+
+    /// the digits s of a token with the digits w and the last four digits
+    /// r4, as the batch keeps them: the new last four digits + 1 (only those
+    /// are written over the token's), or s marked if it differs from w beyond
+    /// them (0 stays for a float the batch does not write)
+    static std::uint64_t mark(std::uint64_t w, std::uint64_t s, std::uint64_t r4) noexcept
+    {
+        const std::uint64_t last = s - (w - r4);
+        return last < 10000 ? last + 1 : s | carried();
+    }
+
+    /*!
+    @brief a float token of 16 or 17 digits as dump() writes it, at w (64 bytes
+    of room): the token with its last four digits replaced by digits - 1 (see
+    mark(); the others are the token's), and without trailing zeros after the
+    point, but one
+    */
+    char* write_token_digits(char* w, const char* src, const node& n, std::uint64_t digits)
+    {
+        const char* const token = src + n.off;
+        std::memcpy(w, token, 32);
+        char* const end = w + n.len;
+        const std::uint32_t last = four_digit_text(static_cast<std::uint32_t>(digits - 1));
+        std::memcpy(end - 4, &last, 4);
+        // (the token's text before the new digits, from the source: reading
+        // the output back would wait for the stores)
+        std::uint64_t before = 0;
+        std::memcpy(&before, token + n.len - 12, 8);
+        const std::uint32_t last_zeros = last ^ 0x30303030u;
+        const std::uint64_t before_zeros = before ^ 0x3030303030303030u;
+        if (NLOHMANN_VIEW_UNLIKELY(last_zeros == 0 && before_zeros == 0))
+        {
+            return write_double_at(w, n); // (twelve or more trailing zeros)
+        }
+        const unsigned zeros = last_zeros != 0 ? static_cast<unsigned>(count_leading_zeros(last_zeros)) / 8 - 4
+                               : 4 + (static_cast<unsigned>(count_leading_zeros(before_zeros)) / 8);
+        const unsigned frac_digits = n.extra >> 8u;
+        return end - (zeros < frac_digits ? zeros : frac_digits - 1);
+    }
+#endif
+
    /// a float node as dump() writes it
    void write_float_node(const node& n)
    {
@@ -24,25 +24,25 @@
 // with different flags would have different definitions of the same inline
 // functions): the check is compiled for SSSE3 with a function attribute and
 // used where the CPU has SSSE3 (all x86-64 CPUs since about 2011), else the
-// portable check. Code compiled for SSSE3 anyway (-mssse3 or more) skips the
-// CPU check. JSON_NO_SIMD selects the portable code, as in the lexer.
+// portable check. JSON_VIEW_USE_SSSE3 skips the CPU check (for code compiled
+// for SSSE3 anyway); JSON_VIEW_NO_SIMD selects the portable code.
 // NLOHMANN_VIEW_NO_TARGET_ATTRIBUTE (set by the GCC module interface, where GCC
 // ignores the target attribute and then rejects the SSSE3 intrinsics) keeps the
 // check portable without disabling the SSE2 code.
-#if !defined(JSON_NO_SIMD) && defined(__aarch64__) && (defined(__GNUC__) || defined(__clang__)) && NLOHMANN_VIEW_LITTLE_ENDIAN
+#if !defined(JSON_VIEW_NO_SIMD) && defined(__aarch64__) && (defined(__GNUC__) || defined(__clang__)) && NLOHMANN_VIEW_LITTLE_ENDIAN
    #include <arm_neon.h>
    #define NLOHMANN_VIEW_NEON 1
 #else
    #define NLOHMANN_VIEW_NEON 0
 #endif
 // (x86 only: other targets can define __SSE2__ as well, e.g., WebAssembly with -msse2, but have no <cpuid.h>)
-#if !defined(JSON_NO_SIMD) && !NLOHMANN_VIEW_NEON && (defined(__x86_64__) || defined(__i386__) || defined(_M_X64) || defined(_M_IX86)) && (defined(__SSE2__) || defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 2))
+#if !defined(JSON_VIEW_NO_SIMD) && !NLOHMANN_VIEW_NEON && (defined(__x86_64__) || defined(__i386__) || defined(_M_X64) || defined(_M_IX86)) && (defined(__SSE2__) || defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 2))
    #include <emmintrin.h>
    #define NLOHMANN_VIEW_SSE2 1
 #else
    #define NLOHMANN_VIEW_SSE2 0
 #endif
-#if NLOHMANN_VIEW_SSE2 && defined(__SSSE3__)
+#if NLOHMANN_VIEW_SSE2 && defined(JSON_VIEW_USE_SSSE3)
    #include <tmmintrin.h>
    #define NLOHMANN_VIEW_SSSE3 1 // NOLINT(cppcoreguidelines-macro-to-enum,modernize-macro-to-enum)
 #else
@@ -130,16 +130,14 @@ struct is_direct_value : std::integral_constant < bool,
 template<typename Traits, typename Alloc, typename BasicJsonType, typename View>
 struct is_direct_value<std::basic_string<char, Traits, Alloc>, BasicJsonType, View> : std::true_type {};

-// (vectors of these, which are faster than through from_json(), and containers
-// of views; other containers are read by the library's from_json())
 template<typename U, typename A, typename BasicJsonType, typename View>
-struct is_direct_value<std::vector<U, A>, BasicJsonType, View> : is_direct_value<U, BasicJsonType, View> {};
+struct is_direct_value<std::vector<U, A>, BasicJsonType, View> : std::true_type {};

-template<typename K, typename C, typename A, typename BasicJsonType, typename View>
-struct is_direct_value<std::map<K, View, C, A>, BasicJsonType, View> : is_string_key<K> {};
+template<typename K, typename V, typename C, typename A, typename BasicJsonType, typename View>
+struct is_direct_value<std::map<K, V, C, A>, BasicJsonType, View> : is_string_key<K> {};

-template<typename K, typename H, typename E, typename A, typename BasicJsonType, typename View>
-struct is_direct_value<std::unordered_map<K, View, H, E, A>, BasicJsonType, View> : is_string_key<K> {};
+template<typename K, typename V, typename H, typename E, typename A, typename BasicJsonType, typename View>
+struct is_direct_value<std::unordered_map<K, V, H, E, A>, BasicJsonType, View> : is_string_key<K> {};

 }  // namespace view
 }  // namespace detail
@@ -1,27 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <cstdint> // uint8_t
-
-#include <nlohmann/json.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-
-/// whether a basic_json_document and its views can be edited
-enum class view_mode : std::uint8_t
-{
-    read_only, ///< parsed once, then only read (the default)
-    editable,  ///< also has set(), push_back(), insert(), and erase()
-};
-
-template<typename BasicJsonType, view_mode Mode>
-class basic_json_view;
-
-NLOHMANN_JSON_NAMESPACE_END
@@ -84,7 +84,6 @@
 #include <nlohmann/detail/view/serializer.hpp>
 #include <nlohmann/detail/view/string_ref.hpp>
 #include <nlohmann/detail/view/value.hpp>
-#include <nlohmann/detail/view/view_mode.hpp>

 NLOHMANN_JSON_NAMESPACE_BEGIN

@@ -94,20 +93,15 @@ NLOHMANN_JSON_NAMESPACE_BEGIN
 Trivially copyable (two pointers). Valid as long as the document is alive and
 has not been re-parsed, and as long as a borrowed source text is alive.
 */
-template<typename BasicJsonType, view_mode Mode = view_mode::read_only>
+template<typename BasicJsonType, bool Editable = false>
 class basic_json_view
 {
-    /// whether this is a view of an editable document
-    static constexpr bool is_editable = Mode == view_mode::editable;
-
    using node = detail::view::node;
    using document_data = detail::view::document_data;
    /// how the index is walked (with edits only for editable documents)
-    using navigation = detail::view::navigation<is_editable>;
+    using navigation = detail::view::navigation<Editable>;

  public:
-    /// the basic_json type of the document (it also marks views for is_json_view)
-    using basic_json_type = BasicJsonType;
    using value_t = detail::value_t;
    using string_t = typename BasicJsonType::string_t;
    using number_integer_t = typename BasicJsonType::number_integer_t;
@@ -452,7 +446,7 @@ class basic_json_view
        if (is_structured() && m_node->len != 0)
        {
            return unedited() ? basic_json_view(m_doc, detail::view::last_child<false>(*m_doc, m_node) + (is_object() ? 1 : 0))
-                   : basic_json_view(m_doc, navigation::value(detail::view::last_child<is_editable>(*m_doc, m_node) + (is_object() ? 1 : 0)));
+                   : basic_json_view(m_doc, navigation::value(detail::view::last_child<Editable>(*m_doc, m_node) + (is_object() ? 1 : 0)));
        }
        return front();
    }
@@ -510,7 +504,7 @@ class basic_json_view
    /// more than once); 0 if this is not an object
    size_type count(string_view_t key) const
    {
-        return is_object() ? detail::view::count_members<is_editable>(*m_doc, m_node, key.data(), key.size()) : 0;
+        return is_object() ? detail::view::count_members<Editable>(*m_doc, m_node, key.data(), key.size()) : 0;
    }

    size_type count(const char* key) const
@@ -569,10 +563,8 @@ class basic_json_view

    /// the value converted to T, as BasicJsonType::get<T>(): arithmetic types,
    /// strings (string_view_t without a copy), std::nullptr_t, std::vector,
-    /// maps with string keys, and views are converted directly; types whose
-    /// from_json() accepts views (those of the NLOHMANN_DEFINE_TYPE_* and
-    /// NLOHMANN_JSON_SERIALIZE_ENUM macros, say) read the view; other types
-    /// go through materialize().get<T>()
+    /// maps with string keys, and views are converted directly; other types
+    /// through materialize().get<T>()
    template<typename T>
    NLOHMANN_VIEW_ALWAYS_INLINE T get() const
    {
@@ -580,12 +572,11 @@ class basic_json_view
    }

    /// as BasicJsonType::get_to(): the types get<T>() converts directly are
-    /// assigned, all others are passed to from_json with v as it is (with
-    /// the view if from_json() accepts views, else with materialize())
+    /// assigned, all others are passed to from_json with v as it is
    template<typename T>
    T& get_to(T& v) const
    {
-        get_to_impl(v, get_to_kind<T> {});
+        get_to_impl(v, detail::view::is_direct_value<T, BasicJsonType, basic_json_view> {});
        return v;
    }

@@ -655,7 +646,7 @@ class basic_json_view
        }
        else
        {
-            detail::view::view_serializer<BasicJsonType, is_editable>(*m_doc, out, estimate, style).dump(m_node);
+            detail::view::view_serializer<BasicJsonType, Editable>(*m_doc, out, estimate, style).dump(m_node);
        }
        return out;
    }
@@ -691,14 +682,14 @@ class basic_json_view
    }

    /// a view of an editable document compares with one of a read-only document
-    template < view_mode M, typename std::enable_if < M != Mode, int >::type = 0 >
-    friend bool operator==(const basic_json_view& a, const basic_json_view<BasicJsonType, M>& b)
+    template < bool E, typename std::enable_if < E != Editable, int >::type = 0 >
+    friend bool operator==(const basic_json_view& a, const basic_json_view<BasicJsonType, E>& b)
    {
-        return detail::view::equal<BasicJsonType>(side(a), detail::view::view_side<BasicJsonType, basic_json_view<BasicJsonType, M>>(b));
+        return detail::view::equal<BasicJsonType>(side(a), detail::view::view_side<BasicJsonType, basic_json_view<BasicJsonType, E>>(b));
    }

-    template < view_mode M, typename std::enable_if < M != Mode, int >::type = 0 >
-    friend bool operator!=(const basic_json_view& a, const basic_json_view<BasicJsonType, M>& b)
+    template < bool E, typename std::enable_if < E != Editable, int >::type = 0 >
+    friend bool operator!=(const basic_json_view& a, const basic_json_view<BasicJsonType, E>& b)
    {
        return !(a == b);
    }
@@ -736,7 +727,7 @@ class basic_json_view
        {
            return BasicJsonType(value_t::discarded);
        }
-        return unedited() ? detail::view::materialize<BasicJsonType, false>(*m_doc, m_node) : detail::view::materialize<BasicJsonType, is_editable>(*m_doc, m_node);
+        return unedited() ? detail::view::materialize<BasicJsonType, false>(*m_doc, m_node) : detail::view::materialize<BasicJsonType, Editable>(*m_doc, m_node);
    }

    /// byte offset of this value in the source text (for strings: of the
@@ -749,8 +740,8 @@ class basic_json_view
    }

  private:
-    template<typename, view_mode> friend class basic_json_document;
-    template<typename, view_mode> friend class basic_json_view;
+    template<typename, bool> friend class basic_json_document;
+    template<typename, bool> friend class basic_json_view;
    template<typename, typename> friend class detail::view::editor;
    friend iterator;

@@ -766,11 +757,11 @@ class basic_json_view
    }

    /// the template argument as a runtime condition: testing it directly in
-    /// `is_editable && ...` makes the condition constant, which MSVC reports as
+    /// `Editable && ...` makes the condition constant, which MSVC reports as
    /// C4127
    static bool editable() noexcept
    {
-        return is_editable;
+        return Editable;
    }

    /// the number of source bytes of this value (estimated for values with
@@ -819,7 +810,7 @@ class basic_json_view
            const node* const k = detail::view::find_member<false>(*m_doc, m_node, key.data(), key.size());
            return k != nullptr ? basic_json_view(m_doc, k + 1) : basic_json_view();
        }
-        const node* const k = detail::view::find_member<is_editable>(*m_doc, m_node, key.data(), key.size());
+        const node* const k = detail::view::find_member<Editable>(*m_doc, m_node, key.data(), key.size());
        return k != nullptr ? basic_json_view(m_doc, navigation::value(k + 1)) : basic_json_view();
    }

@@ -833,7 +824,7 @@ class basic_json_view
    /// the member of this object with @a key (the last one if the key occurs more than once), or nullptr
    NLOHMANN_VIEW_ALWAYS_INLINE const node* find_key(string_view_t key) const
    {
-        return find_key(key, std::integral_constant<bool, is_editable> {});
+        return find_key(key, std::integral_constant<bool, Editable> {});
    }

    NLOHMANN_VIEW_ALWAYS_INLINE const node* find_key(string_view_t key, std::true_type /*editable*/) const
@@ -855,7 +846,7 @@ class basic_json_view
        {
            return basic_json_view(m_doc, detail::view::element_at<false>(*m_doc, m_node, idx));
        }
-        return basic_json_view(m_doc, navigation::value(detail::view::element_at<is_editable>(*m_doc, m_node, idx)));
+        return basic_json_view(m_doc, navigation::value(detail::view::element_at<Editable>(*m_doc, m_node, idx)));
    }

    // --- get() dispatch ---
@@ -910,45 +901,22 @@ class basic_json_view
        return *this;
    }

-    /// vectors of the types converted directly (faster than the library's
-    /// from_json()) and containers of views (no from_json() reads them: a view
-    /// is no value of BasicJsonType); other containers are read by from_json()
-    template < typename U, typename A, typename std::enable_if < detail::view::is_direct_value<U, BasicJsonType, basic_json_view>::value, int >::type = 0 >
+    template<typename U, typename A>
    std::vector<U, A> get_impl(detail::view::value_tag<std::vector<U, A>> /*unused*/, detail::priority_tag<2> /*unused*/) const
    {
        return detail::view::vector_value<basic_json_view, U, A>(*this);
    }

-    template<typename K, typename C, typename A, typename std::enable_if<detail::view::is_string_key<K>::value, int>::type = 0>
-    std::map<K, basic_json_view, C, A> get_impl(detail::view::value_tag<std::map<K, basic_json_view, C, A>> /*unused*/, detail::priority_tag<2> /*unused*/) const
+    template<typename K, typename V, typename C, typename A, typename std::enable_if<detail::view::is_string_key<K>::value, int>::type = 0>
+    std::map<K, V, C, A> get_impl(detail::view::value_tag<std::map<K, V, C, A>> /*unused*/, detail::priority_tag<2> /*unused*/) const
    {
-        return detail::view::map_value<std::map<K, basic_json_view, C, A>>(*this);
+        return detail::view::map_value<std::map<K, V, C, A>>(*this);
    }

-    template<typename K, typename H, typename E, typename A, typename std::enable_if<detail::view::is_string_key<K>::value, int>::type = 0>
-    std::unordered_map<K, basic_json_view, H, E, A> get_impl(detail::view::value_tag<std::unordered_map<K, basic_json_view, H, E, A>> /*unused*/, detail::priority_tag<2> /*unused*/) const
+    template<typename K, typename V, typename H, typename E, typename A, typename std::enable_if<detail::view::is_string_key<K>::value, int>::type = 0>
+    std::unordered_map<K, V, H, E, A> get_impl(detail::view::value_tag<std::unordered_map<K, V, H, E, A>> /*unused*/, detail::priority_tag<2> /*unused*/) const
    {
-        return detail::view::map_value<std::unordered_map<K, basic_json_view, H, E, A>>(*this);
-    }
-
-    /// whether the from_json() of T's serializer reads views (see
-    /// detail::has_view_from_json)
-    template<typename T>
-    using reads_view = detail::has_view_from_json<typename BasicJsonType::template json_serializer<T, void>, basic_json_view, T>;
-
-    /// how get_to() converts: 2 directly, 1 with a from_json() that reads
-    /// views, 0 through materialize()
-    template<typename T>
-    using get_to_kind = std::integral_constant < int, detail::view::is_direct_value<T, BasicJsonType, basic_json_view>::value
-                        ? 2 : static_cast<int>(reads_view<T>::value) >;
-
-    /// types whose from_json() reads views, without materialize()
-    template < typename T, typename std::enable_if < reads_view<T>::value && std::is_default_constructible<T>::value, int >::type = 0 >
-    T get_impl(detail::view::value_tag<T> /*unused*/, detail::priority_tag<1> /*unused*/) const
-    {
-        auto v = T();
-        BasicJsonType::template json_serializer<T, void>::from_json(*this, v);
-        return v;
+        return detail::view::map_value<std::unordered_map<K, V, H, E, A>>(*this);
    }

    /// everything else through the BasicJsonType value (from_json included)
@@ -961,20 +929,14 @@ class basic_json_view
    // --- get_to() dispatch ---

    template<typename T>
-    void get_to_impl(T& v, std::integral_constant<int, 2> /*direct*/) const
+    void get_to_impl(T& v, std::true_type /*direct*/) const
    {
        v = get<T>();
    }

    /// from_json may keep parts of v (members a JSON object lacks, say)
    template<typename T>
-    void get_to_impl(T& v, std::integral_constant<int, 1> /*from_json reads views*/) const
-    {
-        BasicJsonType::template json_serializer<T, void>::from_json(*this, v);
-    }
-
-    template<typename T>
-    void get_to_impl(T& v, std::integral_constant<int, 0> /*through materialize()*/) const
+    void get_to_impl(T& v, std::false_type /*direct*/) const
    {
        materialize().get_to(v);
    }
@@ -990,19 +952,16 @@ Borrowed parses keep a pointer to the caller's text, which must outlive the
 document. Owned parses (parse_copy, rvalue std::string, streams, and inputs
 that are not contiguous byte ranges) keep their own copy.
 */
-template<typename BasicJsonType, view_mode Mode = view_mode::read_only>
+template<typename BasicJsonType, bool Editable = false>
 class basic_json_document
 {
-    /// whether the document can be edited
-    static constexpr bool is_editable = Mode == view_mode::editable;
-
    using document_data = detail::view::document_data;

    static_assert(sizeof(typename BasicJsonType::number_integer_t) == 8 && sizeof(typename BasicJsonType::number_unsigned_t) == 8,
                  "json_view supports 64-bit integer types only");

  public:
-    using view_type = basic_json_view<BasicJsonType, Mode>;
+    using view_type = basic_json_view<BasicJsonType, Editable>;
    using value_t = detail::value_t;

    /// an empty (discarded) document
@@ -1216,10 +1175,6 @@ class basic_json_document
    /// how load() checks an image (full, bounds, or none)
    using image_check = detail::view::image_check;

-#if NLOHMANN_VIEW_LITTLE_ENDIAN
-    // (the image format is little-endian: big-endian targets have no save()
-    // and load(), so that a call fails to compile instead of always throwing)
-
    /// The document as an image that load() reads without parsing: the node
    /// index, the text, and the decoded strings. An edited document is
    /// written in its current state (floats that are not finite become null,
@@ -1261,7 +1216,6 @@ class basic_json_document
        detail::view::load_image(*d.m_data, d.m_data->owned_image.data(), d.m_data->owned_image.size(), check);
        return d;
    }
-#endif

    ///////////
    // edits //
@@ -1403,7 +1357,7 @@ class basic_json_document

    detail::view::editor<BasicJsonType, view_type> editor()
    {
-        static_assert(is_editable, "only an editable document can be edited: use basic_json_document<BasicJsonType, view_mode::editable> (json_editable_document)");
+        static_assert(Editable, "only an editable document can be edited: use basic_json_document<BasicJsonType, true> (json_editable_document)");
        if (NLOHMANN_VIEW_UNLIKELY(!m_data || m_data->discarded))
        {
            detail::view::throw_invalid_iterator(detail::exception_id::iterator_from_other_value, "view does not belong to this document");
@@ -1679,15 +1633,6 @@ class basic_json_document
    std::unique_ptr<document_data, document_data::deleter> m_data{}; // NOLINT(readability-redundant-member-init)
 };

-/*!
-@brief whether T is a basic_json_view (of any BasicJsonType and view_mode)
-
-For constraining templates that accept views, e.g. a from_json() written for
-both basic_json values and views.
-*/
-template<typename T>
-struct is_json_view : detail::is_json_view<T> {};
-
 /// a parsed JSON text for json
 using json_document = basic_json_document<json>;
 /// a value of a json_document
@@ -1697,13 +1642,13 @@ using ordered_json_document = basic_json_document<ordered_json>;
 /// a value of an ordered_json_document
 using ordered_json_view = basic_json_view<ordered_json>;
 /// an editable parsed JSON text for json
-using json_editable_document = basic_json_document<json, view_mode::editable>;
+using json_editable_document = basic_json_document<json, true>;
 /// a value of a json_editable_document
-using json_editable_view = basic_json_view<json, view_mode::editable>;
+using json_editable_view = basic_json_view<json, true>;
 /// an editable parsed JSON text for ordered_json
-using ordered_json_editable_document = basic_json_document<ordered_json, view_mode::editable>;
+using ordered_json_editable_document = basic_json_document<ordered_json, true>;
 /// a value of an ordered_json_editable_document
-using ordered_json_editable_view = basic_json_view<ordered_json, view_mode::editable>;
+using ordered_json_editable_view = basic_json_view<ordered_json, true>;

 NLOHMANN_JSON_NAMESPACE_END

@@ -145,14 +145,26 @@
    #define NLOHMANN_JSON_ABI_TAG_NO_SIMD
 #endif

+#ifdef JSON_VIEW_NO_SIMD
+    #define NLOHMANN_JSON_ABI_TAG_VIEW_NO_SIMD _vns
+#else
+    #define NLOHMANN_JSON_ABI_TAG_VIEW_NO_SIMD
+#endif
+
+#ifdef JSON_VIEW_USE_SSSE3
+    #define NLOHMANN_JSON_ABI_TAG_VIEW_USE_SSSE3 _vssse3
+#else
+    #define NLOHMANN_JSON_ABI_TAG_VIEW_USE_SSSE3
+#endif
+
 #ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
    #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
 #endif

 // Construct the namespace ABI tags component
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h, i, j, k) json_abi ## a ## b ## c ## d ## e ## f ## g ## h ## i ## j ## k
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g, h, i, j, k) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h, i, j, k)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h, i, j, k, l, m) json_abi ## a ## b ## c ## d ## e ## f ## g ## h ## i ## j ## k ## l ## m
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g, h, i, j, k, l, m) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h, i, j, k, l, m)

 #define NLOHMANN_JSON_ABI_TAGS                                       \
    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
@@ -166,7 +178,9 @@
            NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS,       \
            NLOHMANN_JSON_ABI_TAG_DISABLE_STREAM_BULK_SCAN,          \
            NLOHMANN_JSON_ABI_TAG_DISABLE_UNLOCKED_FILE_IO,          \
-            NLOHMANN_JSON_ABI_TAG_NO_SIMD)
+            NLOHMANN_JSON_ABI_TAG_NO_SIMD,                           \
+            NLOHMANN_JSON_ABI_TAG_VIEW_NO_SIMD,                      \
+            NLOHMANN_JSON_ABI_TAG_VIEW_USE_SSSE3)

 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
@@ -420,9 +420,9 @@ json_test_add_test_for(src/unit-file_input.cpp
 )

 # the json_view parser again with the portable string scanning instead of
-# NEON/SSE2 (JSON_NO_SIMD), and on x86-64 compiled for SSSE3 (no CPU check)
+# NEON/SSE2, and on x86-64 with the SSSE3 UTF-8 check (JSON_VIEW_USE_SSSE3)
 json_test_set_test_options(test-json_view_builder_portable
-    COMPILE_DEFINITIONS JSON_NO_SIMD
+    COMPILE_DEFINITIONS JSON_VIEW_NO_SIMD
 )
 json_test_add_test_for(src/unit-json_view_builder.cpp
    NAME test-json_view_builder_portable
@@ -430,6 +430,7 @@ json_test_add_test_for(src/unit-json_view_builder.cpp
 )
 if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64|amd64)$" AND NOT MSVC)
    json_test_set_test_options(test-json_view_builder_ssse3
+        COMPILE_DEFINITIONS JSON_VIEW_USE_SSSE3
        COMPILE_OPTIONS -mssse3
    )
    json_test_add_test_for(src/unit-json_view_builder.cpp
@@ -24,7 +24,9 @@ foreach(test default noversion)
        JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1
        JSON_DISABLE_STREAM_BULK_SCAN=1
        JSON_DISABLE_UNLOCKED_FILE_IO=1
-        JSON_NO_SIMD)
+        JSON_NO_SIMD
+        JSON_VIEW_NO_SIMD
+        JSON_VIEW_USE_SSSE3)
    target_link_libraries(abi_config_${test}_all_tags PRIVATE abi_compat_main)
    add_test(
        NAME test-abi_config_${test}_all_tags
@@ -64,6 +64,14 @@ TEST_CASE("default namespace")
        expected += "_ns";
 #endif

+#ifdef JSON_VIEW_NO_SIMD
+        expected += "_vns";
+#endif
+
+#ifdef JSON_VIEW_USE_SSSE3
+        expected += "_vssse3";
+#endif
+
        expected += "_v" STRINGIZE(NLOHMANN_JSON_VERSION_MAJOR);
        expected += "_" STRINGIZE(NLOHMANN_JSON_VERSION_MINOR);
        expected += "_" STRINGIZE(NLOHMANN_JSON_VERSION_PATCH) "::basic_json";
@@ -65,6 +65,14 @@ TEST_CASE("default namespace without version component")
        expected += "_ns";
 #endif

+#ifdef JSON_VIEW_NO_SIMD
+        expected += "_vns";
+#endif
+
+#ifdef JSON_VIEW_USE_SSSE3
+        expected += "_vssse3";
+#endif
+
        expected += "::basic_json";

        // fallback for Clang
@@ -59,12 +59,6 @@ An editable `json_document` edits in place; yyjson copies its immutable document
 (`yyjson_doc_mut_copy`); Boost.JSON and `json::parse` build mutable DOMs; simdjson cannot edit a document. All
 outputs are checked to describe the same value.

-`bench_decode.cpp` measures decoding into structs whose `from_json()` comes from the `NLOHMANN_DEFINE_TYPE_*` macros
-(twitter statuses, citm_catalog performances, and 20,000 synthetic records): `get<T>()` on a view, which reads the
-view directly, against `materialize().get<T>()`, `json::parse` plus `get<T>()`, and `get<T>()` on an already parsed
-`json` value. Only nlohmann/json takes part, as the other libraries have no comparable mapping; all engines are
-checked to decode the same values.
-
 Before anything is timed, all engines must accept each document and agree on the traversal: the number of values, the
 bytes of all strings and keys, and the sum of all numbers. All engines run interleaved in every round, and the best
 round is reported, as time and as a factor of the `json_view` time (below 1 means faster than `json_view`). Each timed
@@ -1,312 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// Decoding into structs: the same types, with from_json() generated by the
-// NLOHMANN_DEFINE_TYPE_* macros, read three ways. Only nlohmann/json takes
-// part; the other libraries have no comparable mapping.
-//
-//   view           json_document::parse, then get<T>() on the view (from_json reads the view)
-//   materialize    json_document::parse, then materialize().get<T>() (a json value first)
-//   json::parse    json::parse, then get<T>()
-//   json::get      get<T>() on an already parsed json value (the decoding alone)
-//
-// Documents: twitter (the statuses with their users and hashtags), citm_catalog
-// (the performances with their seat categories), and a synthetic document of
-// 20,000 nested records.
-//
-// Build: see README.md (same flags as bench_view.cpp).
-#include <nlohmann/json_view.hpp>
-
-#include <algorithm>
-#include <chrono>
-#include <cstdint>
-#include <cstdio>
-#include <cstdlib>
-#include <fstream>
-#include <functional>
-#include <sstream>
-#include <string>
-#include <utility>
-#include <vector>
-
-using nlohmann::json;
-using nlohmann::json_document;
-
-static volatile std::size_t g_sink;
-
-namespace twitter
-{
-struct hashtag
-{
-    std::string text;
-    std::vector<int> indices;
-};
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(hashtag, text, indices)
-
-struct entities
-{
-    std::vector<hashtag> hashtags;
-};
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(entities, hashtags)
-
-struct user
-{
-    std::uint64_t id = 0;
-    std::string screen_name;
-    std::string description;
-    std::int64_t followers_count = 0;
-};
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(user, id, screen_name, description, followers_count)
-
-struct status
-{
-    std::uint64_t id = 0;
-    std::string text;
-    user user;
-    entities entities;
-    std::int64_t retweet_count = 0;
-    std::int64_t favorite_count = 0;
-};
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(status, id, text, user, entities, retweet_count, favorite_count)
-
-struct document
-{
-    std::vector<status> statuses;
-};
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(document, statuses)
-
-std::size_t digest(const document& d)
-{
-    std::size_t n = 0;
-    for (const auto& s : d.statuses)
-    {
-        n += s.text.size() + s.user.screen_name.size() + s.entities.hashtags.size() + static_cast<std::size_t>(s.retweet_count);
-    }
-    return n;
-}
-}  // namespace twitter
-
-namespace citm
-{
-struct area
-{
-    std::int64_t areaId = 0;
-    std::vector<std::int64_t> blockIds;
-};
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(area, areaId, blockIds)
-
-struct seat_category
-{
-    std::vector<area> areas;
-    std::int64_t seatCategoryId = 0;
-};
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(seat_category, areas, seatCategoryId)
-
-struct performance
-{
-    std::int64_t id = 0;
-    std::int64_t eventId = 0;
-    std::vector<seat_category> seatCategories;
-    std::int64_t start = 0;
-    std::string venueCode;
-};
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(performance, id, eventId, seatCategories, start, venueCode)
-
-struct document
-{
-    std::vector<performance> performances;
-};
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(document, performances)
-
-std::size_t digest(const document& d)
-{
-    std::size_t n = 0;
-    for (const auto& p : d.performances)
-    {
-        n += p.seatCategories.size() + p.venueCode.size() + static_cast<std::size_t>(p.start % 1000);
-        for (const auto& c : p.seatCategories)
-        {
-            n += c.areas.size();
-        }
-    }
-    return n;
-}
-}  // namespace citm
-
-namespace synthetic
-{
-struct position
-{
-    double x = 0;
-    double y = 0;
-};
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(position, x, y)
-
-struct child
-{
-    std::int64_t id = 0;
-    std::string label;
-    bool active = false;
-};
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(child, id, label, active)
-
-struct record
-{
-    std::int64_t id = 0;
-    std::string name;
-    std::vector<std::string> tags;
-    position pos;
-    std::vector<child> children;
-};
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(record, id, name, tags, pos, children)
-
-struct document
-{
-    std::vector<record> records;
-};
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(document, records)
-
-std::string make_text(std::size_t n)
-{
-    std::string s = "{\"records\":[";
-    for (std::size_t i = 0; i < n; ++i)
-    {
-        const std::string id = std::to_string(i);
-        s += (i == 0 ? "" : ",");
-        s += "{\"id\":" + id + ",\"name\":\"record number " + id + "\",\"tags\":[\"alpha\",\"beta\",\"gamma\"],";
-        s += "\"pos\":{\"x\":" + id + ".25,\"y\":-" + id + ".5},\"children\":[";
-        for (std::size_t k = 0; k < 3; ++k)
-        {
-            s += (k == 0 ? "" : ",");
-            s += "{\"id\":" + std::to_string(i * 3 + k) + ",\"label\":\"child " + std::to_string(k) + "\",\"active\":" + (k % 2 == 0 ? "true" : "false") + "}";
-        }
-        s += "]}";
-    }
-    s += "]}";
-    return s;
-}
-
-std::size_t digest(const document& d)
-{
-    std::size_t n = 0;
-    for (const auto& r : d.records)
-    {
-        n += r.name.size() + r.tags.size() + r.children.size() + static_cast<std::size_t>(r.pos.x);
-    }
-    return n;
-}
-}  // namespace synthetic
-
-namespace
-{
-std::string read_file(const std::string& p)
-{
-    std::ifstream f(p, std::ios::binary);
-    if (!f)
-    {
-        std::fprintf(stderr, "cannot open %s\n", p.c_str());
-        std::exit(1);
-    }
-    std::stringstream ss;
-    ss << f.rdbuf();
-    return ss.str();
-}
-
-double time_ns(const std::function<void()>& f)
-{
-    const auto t0 = std::chrono::steady_clock::now();
-    f();
-    const auto t1 = std::chrono::steady_clock::now();
-    return static_cast<double>(std::chrono::duration_cast<std::chrono::nanoseconds>(t1 - t0).count());
-}
-
-struct engine
-{
-    std::string name;
-    std::function<std::size_t()> run;
-};
-
-template<typename Document>
-std::vector<engine> engines(const std::string& text, const json& parsed)
-{
-    return
-    {
-        {"view", [&text] { const json_document d = json_document::parse(text); return digest(d.root().get<Document>()); }},
-        {"materialize", [&text] { const json_document d = json_document::parse(text); return digest(d.root().materialize().get<Document>()); }},
-        {"json::parse", [&text] { return digest(json::parse(text).get<Document>()); }},
-        {"json::get", [&parsed] { return digest(parsed.get<Document>()); }},
-    };
-}
-}  // namespace
-
-int main(int argc, char** argv)
-{
-    if (argc < 2)
-    {
-        std::fprintf(stderr, "usage: %s <json_test_data directory> [rounds]\n", argv[0]);
-        return 1;
-    }
-    const std::string dir = argv[1];
-    const int rounds = argc > 2 ? std::max(1, std::atoi(argv[2])) : 30;
-
-    struct document_case
-    {
-        std::string name;
-        std::string text;
-        json parsed;
-        std::vector<engine> engines;
-    };
-    std::vector<document_case> cases;
-    cases.push_back({"twitter", read_file(dir + "/nativejson-benchmark/twitter.json"), json(), {}});
-    cases.push_back({"citm_catalog", read_file(dir + "/nativejson-benchmark/citm_catalog.json"), json(), {}});
-    cases.push_back({"synthetic", synthetic::make_text(20000), json(), {}});
-    for (auto& c : cases)
-    {
-        c.parsed = json::parse(c.text);
-    }
-    cases[0].engines = engines<twitter::document>(cases[0].text, cases[0].parsed);
-    cases[1].engines = engines<citm::document>(cases[1].text, cases[1].parsed);
-    cases[2].engines = engines<synthetic::document>(cases[2].text, cases[2].parsed);
-
-    std::FILE* csv = std::fopen("bench_decode.csv", "w");
-    if (csv == nullptr)
-    {
-        std::perror("bench_decode.csv");
-        return 1;
-    }
-    std::fprintf(csv, "doc,bytes,engine,ns\n");
-    for (const auto& c : cases)
-    {
-        // all engines must decode the same values
-        const std::size_t expected = c.engines[0].run();
-        bool ok = true;
-        for (const auto& e : c.engines)
-        {
-            ok = ok && e.run() == expected;
-        }
-        std::vector<double> best(c.engines.size(), 1e300);
-        for (int r = 0; r < rounds; ++r)
-        {
-            for (std::size_t k = 0; k < c.engines.size(); ++k)
-            {
-                g_sink = c.engines[k].run(); // untimed: see bench_view.cpp
-                best[k] = std::min(best[k], time_ns([&] { g_sink = c.engines[k].run(); }));
-            }
-        }
-        std::printf("%-13s %-7s %s", c.name.c_str(), "decode", ok ? "" : "[MISMATCH] ");
-        for (std::size_t k = 0; k < c.engines.size(); ++k)
-        {
-            const double us = best[k] / 1000.0;
-            std::printf("  %s %.*fus (%.2fx)", c.engines[k].name.c_str(), us < 10 ? 3 : (us < 1000 ? 1 : 0), us, best[k] / best[0]);
-            std::fprintf(csv, "%s,%zu,%s,%.1f\n", c.name.c_str(), c.text.size(), c.engines[k].name.c_str(), best[k]);
-        }
-        std::printf("\n");
-    }
-    std::fclose(csv);
-    return 0;
-}
@@ -9,7 +9,7 @@

 """Compare json_view with yyjson, simdjson, Boost.JSON, and json::parse.

-Builds bench_view.cpp, bench_corpus.cpp, bench_edit.cpp, and bench_decode.cpp against the include/ directory of
+Builds bench_view.cpp, bench_corpus.cpp, and bench_edit.cpp against the include/ directory of
 this checkout, runs them, and writes the results with everything needed to
 reproduce them (date, commit, CPU, OS, compiler, library versions, flags) to
 results/<date>-<host>.md and .csv next to this script.
@@ -283,7 +283,7 @@ def main():
            objects.append(obj)

    binaries = {}
-    for bench in ['bench_view', 'bench_corpus', 'bench_edit', 'bench_decode']:
+    for bench in ['bench_view', 'bench_corpus', 'bench_edit']:
        exe = os.path.join(args.build_dir, bench)
        run(cxx + flags + include + [os.path.join(HERE, bench + '.cpp')] + objects + link + ['-o', exe])
        binaries[bench] = exe
@@ -297,8 +297,6 @@ def main():
                                  capture_output=True, text=True).stdout
    outputs['bench_edit'] = run([binaries['bench_edit'], args.data, str(max(1, args.rounds // 2))], cwd=args.build_dir,
                                capture_output=True, text=True).stdout
-    outputs['bench_decode'] = run([binaries['bench_decode'], args.data, str(max(1, args.rounds // 2))], cwd=args.build_dir,
-                                  capture_output=True, text=True).stdout
    for name, text in outputs.items():
        print(text)

@@ -332,7 +330,7 @@ def main():
            f.write(f'\n## {name}\n\n```\n{text.rstrip()}\n```\n')
    with open(stem + '.csv', 'w', encoding='utf-8') as out:
        out.write(''.join(f'# {key}: {value}\n' for key, value in meta))
-        for name in ['bench_view', 'bench_corpus', 'bench_edit', 'bench_decode']:
+        for name in ['bench_view', 'bench_corpus', 'bench_edit']:
            path = os.path.join(args.build_dir, name + '.csv')
            if os.path.isfile(path):
                with open(path, encoding='utf-8') as f:
@@ -592,7 +592,7 @@ TEST_CASE("json_view node integer bits")
                })
        {
            CAPTURE(v)
-            n.kind = static_cast<nlohmann::detail::view::node_kind>(0x5A);
+            n.kind = 0x5A;
            n.flags = 0xA5;
            n.extra = 0x1234;
            n.off = 0x89ABCDEFu;
@@ -601,7 +601,7 @@ TEST_CASE("json_view node integer bits")
            CHECK(n.len == static_cast<std::uint32_t>(v));
            CHECK(n.next == static_cast<std::uint32_t>(v >> 32));
            // the other fields are untouched
-            CHECK(static_cast<std::uint8_t>(n.kind) == 0x5A);
+            CHECK(n.kind == 0x5A);
            CHECK(n.flags == 0xA5);
            CHECK(n.extra == 0x1234);
            CHECK(n.off == 0x89ABCDEFu);
@@ -35,9 +35,9 @@ using json_view_test::has_duplicate_keys;
 #include <string>
 #include <vector>

-// These tests were split off unit-json_view.cpp, whose object file got too large
-// for the MinGW linker (see json_view_test_helpers.hpp). Like that file, this one
-// is also built with C++17, as it mentions JSON_HAS_CPP_17.
+// These tests were split off unit-json_view.cpp, whose object file got too large for the MinGW
+// linker (see json_view_test_helpers.hpp). Like that file, this one is also built
+// with C++17, as it mentions JSON_HAS_CPP_17.

 TEST_CASE("json_view dump")
 {
@@ -150,6 +150,71 @@ TEST_CASE("json_view dump")
            CHECK(many_doc.root().dump() == json::parse(many_tokens).dump());
        }

+        // tokens of 16 and 17 digits without an exponent (like GeoJSON
+        // coordinates), which dump() converts in batches: doubles exactly
+        // halfway between two candidates for the shortest digits, random
+        // digits, and digits near a shorter decimal (...99999997,
+        // ...00000003), whose rounding carries; in pairs and among other
+        // values, so that the batches are interrupted; the last token near the
+        // end of the text
+        {
+            std::mt19937_64 tokens(5627); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
+            const auto draw = [&tokens](std::size_t n)
+            {
+                const std::uint64_t r = tokens() % n;
+                return static_cast<std::size_t>(r);
+            };
+            std::string coordinates = "[754570942.33984373,257769445.56835938,858106901.94921875,97944964.876953125,"
+                                      "[0.5,1e-7],[1.5,-0.0,2.5],[1E2,12.5,0.1,3.25,4.5,5.75,6.125,7.0,8.5],[],[1.5],[1,2.5],[2.5,\"x\"],[[1.5],2.5],";
+            for (int i = 0; i < 20000; ++i)
+            {
+                const std::size_t length = 16 + draw(2);
+                std::string digits(1, static_cast<char>('1' + draw(9)));
+                const std::size_t kept = draw(3) == 0 ? length : 2 + draw(length - 3);
+                for (std::size_t k = 1; k < kept; ++k)
+                {
+                    digits += static_cast<char>('0' + draw(10));
+                }
+                digits += std::string(length - kept, draw(2) == 0 ? '9' : '0');
+                digits.back() = static_cast<char>('0' + draw(10));
+                const std::size_t point = 1 + draw(9);
+                const std::string token = (draw(2) == 0 ? "-" : "") + digits.substr(0, point) + "." + digits.substr(point);
+                coordinates += (i != 0 ? "," : "") + (draw(8) == 0 ? "{\"x\":" + token + ",\"s\":\"a\"}" : "[" + token + "," + token + "]");
+            }
+            coordinates += ",-65.613616999999977]";
+            const json_document parsed = json_document::parse(coordinates);
+            const ordered_json j = ordered_json::parse(coordinates);
+            CHECK(parsed.root().dump() == j.dump());
+            CHECK(parsed.root().dump(1) == j.dump(1));
+            CHECK(parsed.root().dump(-1, ' ', true) == j.dump(-1, ' ', true));
+            CHECK(parsed.root().back().get<double>() == j.back().get<double>());
+            CHECK(parsed.root().back().dump() == "-65.61361699999998");
+            std::size_t i = 0;
+            for (const json_view v : parsed.root())
+            {
+                const ordered_json& e = j[i++];
+                CHECK(v.dump() == e.dump());
+                if (v.is_array() && v.size() != 0 && v[0].is_number())
+                {
+                    CHECK(v[0].get<double>() == e[0].get<double>());
+                }
+            }
+
+            // an editable document: edits move some arrays, so that the walk
+            // leaves the order of the parsed nodes
+            ordered_json_editable_document editable = ordered_json_editable_document::parse(coordinates);
+            ordered_json expected = j;
+            for (std::size_t k = 0; k < 20000; k += 97)
+            {
+                if (expected[k].is_array())
+                {
+                    editable.push_back(editable.root()[k], ordered_json(1.5));
+                    expected[k].push_back(1.5);
+                }
+            }
+            CHECK(editable.root().dump() == expected.dump());
+        }
+
        // random doubles, written as parse() and dump() would
        std::mt19937_64 rng(1170); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
        std::string many = "[";
@@ -171,768 +236,4 @@ TEST_CASE("json_view dump")
        const nlohmann::basic_json_document<json_float> float_document = nlohmann::basic_json_document<json_float>::parse("[0.1, 1.5e10, 3.4028235e38]");
        CHECK(float_document.root().dump() == json_float::parse("[0.1, 1.5e10, 3.4028235e38]").dump());
    }
-
-    SECTION("members in document order, all of them")
-    {
-        const json_document d = json_document::parse(R"({"b": 1, "a": 2, "b": 3})");
-        CHECK(d.root().dump() == R"({"b":1,"a":2,"b":3})");
-        CHECK(d.root().dump(1) == "{\n \"b\": 1,\n \"a\": 2,\n \"b\": 3\n}");
-        // dump() writes all members, though the lookup finds the first
-        CHECK(d.root()["b"].dump() == "1");
-    }
-
-    SECTION("deep nesting")
-    {
-        const std::string deep = std::string(100000, '[') + std::string(100000, ']');
-        const json_document deep_document = json_document::parse(deep);
-        CHECK(deep_document.root().dump() == deep);
-    }
-
-    SECTION("ensure_ascii: a character that needs an escape at each position of a string")
-    {
-        // string lengths around the width of the vector steps, in a string value, a key, and a value near the end of the text
-        for (const char* const special :
-                {
-                    "\xC3\xA9", "\xE4\xB8\xAD", "\xF0\x9F\x98\x80", "\x7F", "\\n", "\\u0001", "\\\"", "\\\\"
-                })
-        {
-            for (std::size_t length = 0; length <= 40; ++length)
-            {
-                for (std::size_t position = 0; position <= length; ++position)
-                {
-                    std::string content(length, 'a');
-                    content.insert(position, special);
-                    const std::array<std::string, 3> texts =
-                    {
-                        {
-                            "\"" + content + "\"",
-                            "[\"" + content + "\"]",
-                            "{\"" + content + "\":1}",
-                        }
-                    };
-                    for (const std::string& text : texts)
-                    {
-                        CAPTURE(text)
-                        const ordered_json_document d = ordered_json_document::parse(text);
-                        const ordered_json j = ordered_json::parse(text);
-                        CHECK(d.root().dump(-1, ' ', true) == j.dump(-1, ' ', true));
-                        CHECK(d.root().dump(2, ' ', true) == j.dump(2, ' ', true));
-                        CHECK(d.root().dump() == j.dump());
-                    }
-                }
-            }
-        }
-    }
-
-    SECTION("ensure_ascii: every character of the Basic Multilingual Plane and some beyond")
-    {
-        // (the two- and three-byte sequences, including the ranges that need a check: E0, ED, EF BF BF)
-        std::string text = "[";
-        std::size_t in_chunk = 0;
-        const auto append = [&](std::uint32_t cp)
-        {
-            if (cp < 0x80)
-            {
-                if (cp < 0x20 || cp == '"' || cp == '\\')
-                {
-                    return;
-                }
-                text += static_cast<char>(cp);
-            }
-            else if (cp < 0x800)
-            {
-                text += static_cast<char>(0xC0 | (cp >> 6));
-                text += static_cast<char>(0x80 | (cp & 0x3F));
-            }
-            else if (cp < 0x10000)
-            {
-                text += static_cast<char>(0xE0 | (cp >> 12));
-                text += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
-                text += static_cast<char>(0x80 | (cp & 0x3F));
-            }
-            else
-            {
-                text += static_cast<char>(0xF0 | (cp >> 18));
-                text += static_cast<char>(0x80 | ((cp >> 12) & 0x3F));
-                text += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
-                text += static_cast<char>(0x80 | (cp & 0x3F));
-            }
-        };
-        for (std::uint32_t cp = 0x20; cp < 0x10400; ++cp)
-        {
-            if (cp >= 0xD800 && cp < 0xE000)
-            {
-                continue;
-            }
-            if (in_chunk == 0)
-            {
-                text += text.size() > 1 ? ",\"" : "\"";
-            }
-            append(cp);
-            if (++in_chunk == 37)
-            {
-                text += "\"";
-                in_chunk = 0;
-            }
-        }
-        text += in_chunk != 0 ? "\"]" : "]";
-        const ordered_json_document d = ordered_json_document::parse(text);
-        const ordered_json j = ordered_json::parse(text);
-        CHECK(d.root().dump(-1, ' ', true) == j.dump(-1, ' ', true));
-        CHECK(d.root().dump(2, ' ', true) == j.dump(2, ' ', true));
-        CHECK(d.root().dump() == j.dump());
-        CHECK(d.root().dump(2) == j.dump(2));
-    }
-
-    SECTION("deep nesting, indented")
-    {
-        // indentations of up to and beyond the width of the writer's fixed-size copy
-        for (const int depth :
-                {
-                    1, 5, 20, 70, 300
-                })
-        {
-            std::string text;
-            for (int i = 0; i < depth; ++i)
-            {
-                text += i % 2 == 0 ? "[1," : R"({"k":2,"\u00e9":)";
-            }
-            text += "[]";
-            for (int i = depth - 1; i >= 0; --i)
-            {
-                text += i % 2 == 0 ? "]" : "}";
-            }
-            const ordered_json_document d = ordered_json_document::parse(text);
-            const ordered_json j = ordered_json::parse(text);
-            for (const int indent :
-                    {
-                        0, 1, 2, 3, 8
-                    })
-            {
-                CHECK(d.root().dump(indent) == j.dump(indent));
-                CHECK(d.root().dump(indent, '\t') == j.dump(indent, '\t'));
-            }
-        }
-    }
-
-    SECTION("the output buffer of a small value is small")
-    {
-        // an escaped key after the value: its node lies in the arena, so the
-        // source extent of the value cannot be read from the next node
-        const std::string big(100000, 'a');
-        const std::string text = R"({"small":1,"list":[1,2,3],"k\n":")" + big + R"("})";
-        const json_document d = json_document::parse(text);
-        const auto small = d.root()["small"].dump();
-        CHECK(small == "1");
-        CHECK(small.capacity() < 4096);
-        const auto list = d.root()["list"].dump();
-        CHECK(list == "[1,2,3]");
-        CHECK(list.capacity() < 4096);
-        CHECK(d.root()["list"].dump(2).capacity() < 4096);
-
-        // the whole document and the large value are unaffected
-        CHECK(d.root().dump() == ordered_json::parse(text).dump());
-        CHECK(d.root()["k\n"].dump() == "\"" + big + "\"");
-    }
-
-    SECTION("output that outgrows the estimate")
-    {
-        // ensure_ascii writes six bytes for each two-byte character
-        std::string chars;
-        for (int i = 0; i < 5000; ++i)
-        {
-            chars += "\xC3\xA9";
-        }
-        const json_document d = json_document::parse(R"({"a":")" + chars + R"(","k\n":1})");
-        const json expected = json::parse("\"" + chars + "\"");
-        CHECK(d.root()["a"].dump(-1, ' ', true) == expected.dump(-1, ' ', true));
-        CHECK(d.root()["a"].dump(-1, ' ', true).size() == 2 + (5000 * 6));
-    }
-
-    SECTION("ensure_ascii with strings of the source, decoded strings, and edited strings")
-    {
-        // plain ASCII, non-ASCII, escaped (decoded), and mixed strings, as values and as keys;
-        // the second text has a DEL, which ensure_ascii writes as an escape
-        for (const char* const del :
-                {"", "\x7F"
-                })
-        {
-            const std::string text = std::string("{\"plain\":\"abc\",\"caf\xC3\xA9\":\"\xC3\xA9\xE2\x82\xAC\xF0\x9F\x98\x80\",")
-                                     + "\"esc\\n\\\"\":\"a\\tb\\u00e4\\ud83d\\ude00\",\"del\":\"a" + del + "b\",\"\":\"\"," // NOLINT(modernize-raw-string-literal)
-                                     + "\"list\":[\"x\",\"\xC3\xBC\",\"\\\\\",\"long ASCII string with more than thirty-two bytes in it\","
-                                     + "\"long string with more than thirty-two bytes and one non-ASCII byte \xC3\xB6\"],"
-                                     + "\"n\":[1,2.5,-0,true,null]}";
-            const ordered_json j = ordered_json::parse(text);
-            const ordered_json_document d = ordered_json_document::parse(text);
-            CHECK(d.root().dump(-1, ' ', true) == j.dump(-1, ' ', true));
-            CHECK(d.root().dump(4, ' ', true) == j.dump(4, ' ', true));
-            CHECK(d.root().dump() == j.dump());
-            CHECK(d.root()["list"].dump(-1, ' ', true) == j["list"].dump(-1, ' ', true));
-            CHECK(d.root()["del"].dump(-1, ' ', true) == j["del"].dump(-1, ' ', true));
-
-            // strings that an edit wrote (the source strings that they replace were plain)
-            ordered_json_editable_document e = ordered_json_editable_document::parse(text);
-            ordered_json k = j;
-            e.set(e.root()["plain"], std::string("\xC3\xA4gypten"));
-            k["plain"] = "\xC3\xA4gypten";
-            e.set(e.root()["list"][0], std::string("ascii after edit"));
-            k["list"][0] = "ascii after edit";
-            e.set(e.root()["list"][1], std::string("\xC3\xA4"));
-            k["list"][1] = "\xC3\xA4";
-            e.set(e.root()["del"], std::string("tab\there"));
-            k["del"] = "tab\there";
-            CHECK(e.root().dump(-1, ' ', true) == k.dump(-1, ' ', true));
-            CHECK(e.root().dump(2, ' ', true) == k.dump(2, ' ', true));
-            CHECK(e.root().dump() == k.dump());
-
-            // strings that were edited from or to ASCII text
-            e.set(e.root()["list"][2], std::string("\xC3\xA4"));
-            k["list"][2] = "\xC3\xA4";
-            e.set(e.root()["list"][4], std::string("plain again"));
-            k["list"][4] = "plain again";
-            CHECK(e.root().dump(-1, ' ', true) == k.dump(-1, ' ', true));
-        }
-    }
-
-    SECTION("ensure_ascii with DEL or a non-ASCII character at every position")
-    {
-        // the check whether a string of the source has no byte >= 0x7F reads
-        // eight bytes at a time and then the rest one by one
-        for (std::size_t length = 1; length <= 20; ++length)
-        {
-            for (std::size_t pos = 0; pos < length; ++pos)
-            {
-                for (const char* const c :
-                        {
-                            "\x7F", "\x7E", "\xC3\xA4", "\xC3\xBF" // NOLINT(modernize-raw-string-literal)
-                        })
-                {
-                    const std::string s = std::string(pos, 'a') + c + std::string(length - pos - 1, 'b');
-                    std::string text = "[\"";
-                    text.append(s).append("\",{\"").append(s).append("\":1}]");
-                    const json_document d = json_document::parse(text);
-                    const json j = json::parse(text);
-                    CHECK(d.root().dump(-1, ' ', true) == j.dump(-1, ' ', true));
-                    CHECK(d.root().dump(1, ' ', true) == j.dump(1, ' ', true));
-                }
-            }
-        }
-    }
-
-    SECTION("streams and discarded views")
-    {
-        const json_document d = json_document::parse(R"({"a": [1, 2]})");
-        std::ostringstream compact;
-        compact << d.root();
-        CHECK(compact.str() == R"({"a":[1,2]})");
-        std::ostringstream pretty;
-        pretty << std::setw(2) << std::setfill('.') << d.root() << d.root()["a"];
-        CHECK(pretty.str() == "{\n..\"a\": [\n....1,\n....2\n..]\n}[1,2]");
-        CHECK(json_view().dump() == json(json::value_t::discarded).dump());
-    }
-}
-
-TEST_CASE("json_view comparison")
-{
-    SECTION("equality of the values parse() produces")
-    {
-        generator g;
-        std::vector<std::string> texts;
-        for (int i = 0; i < 600; ++i)
-        {
-            std::string text;
-            g.value(text, 0);
-            texts.push_back(text);
-            // the same value written differently: sorted keys, canonical numbers
-            texts.push_back(json::parse(text).dump(1));
-        }
-        for (std::size_t i = 0; i + 2 < texts.size(); ++i)
-        {
-            for (std::size_t k = i; k < i + 3; ++k)
-            {
-                CAPTURE(texts[i])
-                CAPTURE(texts[k])
-                const json_document a = json_document::parse(texts[i]);
-                const json_document b = json_document::parse(texts[k]);
-                const json ja = json::parse(texts[i]);
-                const json jb = json::parse(texts[k]);
-                CHECK((a.root() == b.root()) == (ja == jb));
-                CHECK((a.root() != b.root()) == (ja != jb));
-                CHECK((a.root() == jb) == (ja == jb));
-                CHECK((jb == a.root()) == (ja == jb));
-                CHECK((a.root() != jb) == (ja != jb));
-                CHECK((jb != a.root()) == (ja != jb));
-
-                // ordered_json compares members in order
-                const ordered_json_document oa = ordered_json_document::parse(texts[i]);
-                const ordered_json_document ob = ordered_json_document::parse(texts[k]);
-                const ordered_json oja = ordered_json::parse(texts[i]);
-                const ordered_json ojb = ordered_json::parse(texts[k]);
-                CHECK((oa.root() == ob.root()) == (oja == ojb));
-                CHECK((oa.root() == ojb) == (oja == ojb));
-            }
-        }
-    }
-
-    SECTION("numbers, duplicate keys, member order")
-    {
-        const auto same = [](const char* x, const char* y)
-        {
-            const json_document dx = json_document::parse(x);
-            const json_document dy = json_document::parse(y);
-            return dx.root() == dy.root();
-        };
-        CHECK(same("1", "1.0"));
-        CHECK(same("[1, -1, 2.5]", "[1.0, -1.0, 25e-1]"));
-        CHECK(!same("1", "1.5"));
-        CHECK(same("18446744073709551615", "18446744073709551615"));
-        CHECK(same(R"({"a": 1, "a": 2})", R"({"a": 2})"));
-        CHECK(!same(R"({"a": 1, "a": 2})", R"({"a": 1})"));
-        CHECK(same(R"({"a": 1, "b": 2})", R"({"b": 2, "a": 1})"));
-        CHECK(!same(R"({"a": 1})", R"({"a": 1, "b": 2})"));
-        CHECK(!same("[1, 2]", "[2, 1]"));
-        CHECK(!same("\"a\"", "\"b\""));
-        CHECK(same("\"\\u00e9\"", "\"\xc3\xa9\""));
-        CHECK(!same("null", "false"));
-        CHECK(!same("[]", "{}"));
-        const ordered_json_document dup = ordered_json_document::parse(R"({"a": 1, "b": 2, "a": 3})");
-        const ordered_json_document last = ordered_json_document::parse(R"({"a": 3, "b": 2})");
-        CHECK(dup.root() == last.root());
-        // (== compares as parse() resolves duplicates, a lookup finds the first)
-        CHECK(dup.root()["a"].materialize() == 1);
-        CHECK(dup.root()["a"] != last.root()["a"]);
-        const ordered_json_document ab = ordered_json_document::parse(R"({"a": 1, "b": 2})");
-        const ordered_json_document ba = ordered_json_document::parse(R"({"b": 2, "a": 1})");
-        CHECK(ab.root() != ba.root());
-
-        // discarded values compare as basic_json's do
-        const json discarded(json::value_t::discarded);
-        CHECK((json_view() == json_view()) == (discarded == discarded)); // NOLINT(readability-container-size-empty): operator== is tested
-        CHECK((json_view() == discarded) == (discarded == discarded)); // NOLINT(readability-container-size-empty)
-        const json_document null_document = json_document::parse("null");
-        CHECK(!(json_view() == null_document.root())); // NOLINT(readability-container-size-empty)
-        CHECK(!(null_document.root() == discarded));
-    }
-
-    SECTION("deep nesting")
-    {
-        const std::string deep = std::string(100000, '[') + std::string(100000, ']');
-        const json_document a = json_document::parse(deep);
-        const json_document b = json_document::parse(deep);
-        CHECK(a.root() == b.root());
-        CHECK(a.root() == json::parse(deep));
-        const std::string other = std::string(100000, '[') + "1" + std::string(100000, ']');
-        const json_document c = json_document::parse(other);
-        CHECK(a.root() != c.root());
-    }
-}
-
-TEST_CASE("json_view large objects")
-{
-    // objects with 128 members or more are looked up with a hash index
-    for (const std::size_t members :
-            {
-                127u, 128u, 129u, 10000u
-            })
-    {
-        CAPTURE(members)
-        std::string text = "{";
-        for (std::size_t i = 0; i < members; ++i)
-        {
-            text += (i != 0 ? ",\"" : "\"") + std::string(i % 23, 'k') + std::to_string(i) + (i % 7 == 0 ? "\\n" : "") + "\":" + std::to_string(i);
-        }
-        text += R"(,"":"empty key","k1":"a duplicate of an earlier key"})";
-        const json_document d = json_document::parse(text);
-        const json_view v = d.root();
-        const json j = json::parse(text);
-        for (std::size_t i = 0; i < members; ++i)
-        {
-            const std::string key = std::string(i % 23, 'k') + std::to_string(i) + (i % 7 == 0 ? "\n" : "");
-            CHECK(v[key].get<std::size_t>() == i);
-            CHECK(v.contains(key));
-            CHECK(v.find(key).key() == key);
-            CHECK(v.at(key).get<std::size_t>() == i);
-            CHECK(!v.contains(key + "x"));
-        }
-        CHECK(v[""].get_string() == "empty key");
-        CHECK(v["k1"].get<int>() == 1); // the first of duplicate keys, as for small objects
-        CHECK(!v.contains("missing"));
-        CHECK_THROWS_WITH_AS(v.at("missing"), "[json.exception.out_of_range.403] key 'missing' not found", json::out_of_range&);
-        CHECK(v == j);
-        CHECK(v.materialize() == j);
-    }
-
-    SECTION("duplicate keys: the first member wins, with and without a table")
-    {
-        // an object of `total` members: the keys "k0".."k<n-1>" in order, then
-        // three keys repeated twice more (one copy in the middle, one at the
-        // end), and two keys repeated once; the value of a member is its
-        // position, so that the first member of a key can be told apart
-        struct member
-        {
-            std::string key;
-            std::size_t position;
-        };
-        const auto make_members = [](std::size_t total)
-        {
-            std::vector<std::string> keys;
-            for (std::size_t i = 0; i + 8 < total; ++i)
-            {
-                keys.push_back("k" + std::to_string(i));
-            }
-            const std::size_t n = keys.size();
-            const std::array<std::size_t, 3> triple = {{3, 17, n - 1}};
-            const std::array<std::size_t, 2> twice = {{5, n / 2}};
-            std::vector<std::string> ordered = keys;
-            for (const std::size_t i : triple)
-            {
-                ordered.insert(ordered.begin() + static_cast<std::ptrdiff_t>(ordered.size() / 2), keys[i]);
-            }
-            for (const std::size_t i : twice)
-            {
-                ordered.insert(ordered.begin() + static_cast<std::ptrdiff_t>(ordered.size() / 3), keys[i]);
-            }
-            for (const std::size_t i : triple)
-            {
-                ordered.push_back(keys[i]);
-            }
-            std::vector<member> result;
-            result.reserve(ordered.size());
-            for (std::size_t i = 0; i < ordered.size(); ++i)
-            {
-                result.push_back({ordered[i], i});
-            }
-            return result;
-        };
-
-        // 100 and 127 members: no table; 128 members and more: a table
-        for (const std::size_t total :
-                {
-                    100u, 127u, 128u, 200u, 5000u
-                })
-        {
-            CAPTURE(total)
-            const std::vector<member> members = make_members(total);
-            REQUIRE(members.size() >= total);
-            REQUIRE(members.size() >= 100);
-            std::string text = "{";
-            std::map<std::string, std::size_t> first;
-            std::map<std::string, std::size_t> last;
-            std::map<std::string, std::size_t> occurrences;
-            for (const member& m : members)
-            {
-                text += (text.size() > 1 ? ",\"" : "\"") + m.key + "\":" + std::to_string(m.position);
-                first.insert({m.key, m.position});
-                last[m.key] = m.position;
-                ++occurrences[m.key];
-            }
-            text += '}';
-            REQUIRE(first.size() < members.size());
-
-            const json_document d = json_document::parse(text);
-            const json_view v = d.root();
-            const json j = json::parse(text);
-            CHECK(v.size() == members.size()); // every occurrence is visited
-            const json m = v.materialize();
-            for (const auto& entry : first)
-            {
-                CAPTURE(entry.first)
-                const std::size_t expected = entry.second;
-                CHECK(v[entry.first].get<std::size_t>() == expected);
-                CHECK(v.at(entry.first).get<std::size_t>() == expected);
-                CHECK(v.find(entry.first).value().get<std::size_t>() == expected);
-                CHECK(v.value(entry.first, std::size_t{0}) == expected);
-                CHECK(v.contains(entry.first));
-                CHECK(v.count(entry.first) == occurrences[entry.first]);
-                const std::string pointer = "/" + entry.first;
-                CHECK(v[json::json_pointer(pointer)].get<std::size_t>() == expected);
-                CHECK(v.at(json::json_pointer(pointer)).get<std::size_t>() == expected);
-                CHECK(v.value(json::json_pointer(pointer), std::size_t{0}) == expected);
-                CHECK(v.contains(json::json_pointer(pointer)));
-                // materialize() and parse() keep the last value instead
-                CHECK(j[entry.first].get<std::size_t>() == last.at(entry.first));
-                CHECK(m[entry.first].get<std::size_t>() == last.at(entry.first));
-            }
-            CHECK(!v.contains("k"));
-            CHECK(v["missing"].is_discarded());
-            CHECK(v.materialize() == j);
-            CHECK(v == j);
-        }
-    }
-
-    SECTION("colliding keys")
-    {
-        // the hash is not seeded, so keys that all land in one place must not
-        // make the table build quadratic: such an object gets no table and is
-        // searched linearly
-        constexpr std::size_t members = 300;
-        constexpr std::size_t table_size = 1024; // the table size for 300 members: the next power of two >= 600
-        std::vector<std::string> colliding;
-        std::vector<std::string> spread;
-        for (std::uint64_t counter = 0; colliding.size() < members || spread.size() < members; ++counter)
-        {
-            std::string key(8, 'a');
-            std::uint64_t x = counter;
-            for (std::size_t i = 0; i < 8; ++i, x /= 26)
-            {
-                key[i] = static_cast<char>('a' + (x % 26));
-            }
-            const bool lands_in_slot_zero = (nlohmann::detail::view::key_hash(key.data(), key.size()) & (table_size - 1)) == 0;
-            if (lands_in_slot_zero && colliding.size() < members)
-            {
-                colliding.push_back(key);
-            }
-            else if (!lands_in_slot_zero && spread.size() < members)
-            {
-                spread.push_back(key);
-            }
-        }
-
-        const auto make_text = [](const std::vector<std::string>& keys)
-        {
-            std::string text = "{";
-            for (std::size_t i = 0; i < keys.size(); ++i)
-            {
-                text += (i != 0 ? ",\"" : "\"") + keys[i] + "\":" + std::to_string(i % 10);
-            }
-            return text + "}";
-        };
-        const std::string colliding_text = make_text(colliding);
-        const std::string spread_text = make_text(spread);
-
-        json_document with_collisions = json_document::parse(colliding_text);
-        json_document without_collisions = json_document::parse(spread_text);
-        for (const auto* pair :
-                {
-                    &colliding, &spread
-                })
-        {
-            const json_view v = (pair == &colliding ? with_collisions : without_collisions).root();
-            for (std::size_t i = 0; i < members; ++i)
-            {
-                CAPTURE(i)
-                CHECK(v[(*pair)[i]].get<std::size_t>() == i % 10);
-                CHECK(v.at((*pair)[i]).get<std::size_t>() == i % 10);
-                CHECK(v.find((*pair)[i]).key() == (*pair)[i]);
-                CHECK(!v.contains((*pair)[i] + "x"));
-            }
-            CHECK(!v.contains("missing"));
-        }
-        CHECK(with_collisions.root() == json::parse(colliding_text));
-
-        // only the object with the spread keys got a table (both texts have the
-        // same length, so the tables are the only difference)
-        with_collisions.shrink_to_fit();
-        without_collisions.shrink_to_fit();
-        CHECK(without_collisions.memory_usage() >= with_collisions.memory_usage() + (table_size * sizeof(std::uint32_t)));
-    }
-
-    SECTION("keys that differ in their last bytes are spread over the table")
-    {
-        // The hash must spread the usual families of keys (numbered names, hex
-        // strings, dates, short names): a key farther than index_max_displacement
-        // from its home slot would leave the object without a table. The keys
-        // are placed with linear probing, as the table does.
-        const auto max_displacement = [](const std::vector<std::string>& keys)
-        {
-            std::size_t slots = 16;
-            while (slots < 2 * keys.size())
-            {
-                slots *= 2;
-            }
-            std::vector<bool> used(slots, false);
-            std::size_t farthest = 0;
-            for (const std::string& key : keys)
-            {
-                std::size_t i = nlohmann::detail::conditional_static_cast<std::size_t>(nlohmann::detail::view::key_hash(key.data(), key.size())) & (slots - 1);
-                std::size_t distance = 0;
-                while (used[i])
-                {
-                    i = (i + 1) & (slots - 1);
-                    ++distance;
-                }
-                used[i] = true;
-                farthest = (std::max)(farthest, distance);
-            }
-            return farthest;
-        };
-        // the keys of a printf-like pattern with one %d, %0Nd or %0Nx, formatted with a stream
-        // (a format string that is not a literal is a Flawfinder error)
-        const auto numbered = [](const char* format, int count, int step)
-        {
-            const std::string pattern(format);
-            const std::size_t percent = pattern.find('%');
-            std::size_t conversion = percent + 1;
-            std::size_t width = 0;
-            while (pattern[conversion] >= '0' && pattern[conversion] <= '9')
-            {
-                width = (width * 10) + static_cast<std::size_t>(pattern[conversion] - '0');
-                ++conversion;
-            }
-            const bool hex = pattern[conversion] == 'x';
-            std::vector<std::string> keys;
-            for (int i = 0; i < count; ++i)
-            {
-                std::ostringstream key;
-                key << pattern.substr(0, percent) << std::setfill('0') << std::setw(static_cast<int>(width))
-                    << (hex ? std::hex : std::dec) << (i * step) << pattern.substr(conversion + 1);
-                keys.push_back(key.str());
-            }
-            return keys;
-        };
-        for (const char* format :
-                {"key%d", "%d", "item_%04d", "a%05d", "%03dxyz", "id%d", "user_%d", "%d_suffix", "0x%04x", "A%07d", "12345678%d", "1234567%d", "123456789%d",
-                 "configuration_parameter_value_%04d_extra", "2026-01-%02dT00:00:00Z"
-                })
-        {
-            CAPTURE(format)
-            CHECK(max_displacement(numbered(format, std::string(format).find("%02d") != std::string::npos ? 60 : 1000, 1)) < nlohmann::detail::view::index_max_displacement); // NOLINT(abseil-string-find-str-contains)
-            CHECK(max_displacement(numbered(format, 600, 7)) < nlohmann::detail::view::index_max_displacement);
-        }
-        std::mt19937_64 rng(7); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
-        for (const std::size_t length :
-                {
-                    std::size_t{1}, std::size_t{2}, std::size_t{3}, std::size_t{5}, std::size_t{7}, std::size_t{8}, std::size_t{9}, std::size_t{12}, std::size_t{16}, std::size_t{17}, std::size_t{33}
-                })
-        {
-            CAPTURE(length)
-            std::set<std::string> distinct;
-            // (there are 26 and 676 keys of one and two letters)
-            std::size_t wanted = 700;
-            if (length == 1)
-            {
-                wanted = 26;
-            }
-            else if (length == 2)
-            {
-                wanted = 500;
-            }
-            while (distinct.size() < wanted)
-            {
-                std::string key(length, 'a');
-                for (char& c : key)
-                {
-                    c = static_cast<char>('a' + (rng() % 26));
-                }
-                distinct.insert(key);
-            }
-            CHECK(max_displacement(std::vector<std::string>(distinct.begin(), distinct.end())) < nlohmann::detail::view::index_max_displacement);
-        }
-    }
-
-    SECTION("keys of every length that differ in one byte")
-    {
-        // In a large object, a key is found by comparing its bytes with those of the member the
-        // table points to: up to 16 bytes as two overlapping words, longer ones with memcmp.
-        // Keys of every length from 0 to 40, and keys that differ from them in one byte.
-        std::mt19937_64 rng(2026); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
-        std::vector<std::string> keys;
-        std::set<std::string> distinct;
-        for (std::size_t length = 0; length <= 40; ++length)
-        {
-            for (int copy = 0; copy < 5; ++copy)
-            {
-                std::string key(length, 'a');
-                for (char& c : key)
-                {
-                    c = static_cast<char>('a' + (rng() % 26));
-                }
-                if (distinct.insert(key).second)
-                {
-                    keys.push_back(key);
-                }
-            }
-        }
-        std::string text = "{";
-        for (std::size_t i = 0; i < keys.size(); ++i)
-        {
-            text += (i != 0 ? ",\"" : "\"") + keys[i] + "\":" + std::to_string(i);
-        }
-        text += "}";
-        REQUIRE(keys.size() >= 128); // (a table is built for 128 members)
-        const json_document d = json_document::parse(text);
-        const json_view v = d.root();
-        for (std::size_t i = 0; i < keys.size(); ++i)
-        {
-            CAPTURE(keys[i])
-            CHECK(v[keys[i]].get<std::size_t>() == i);
-            CHECK(v.at(keys[i]).get<std::size_t>() == i);
-            CHECK(v.contains(keys[i]));
-            for (std::size_t at = 0; at < keys[i].size(); ++at)
-            {
-                std::string other = keys[i];
-                other[at] = other[at] == 'z' ? 'y' : 'z';
-                CAPTURE(other)
-                CHECK(v.contains(other) == (distinct.count(other) != 0));
-            }
-            CHECK(v.contains(keys[i] + "a") == (distinct.count(keys[i] + "a") != 0));
-            if (!keys[i].empty())
-            {
-                CHECK(v.contains(keys[i].substr(1)) == (distinct.count(keys[i].substr(1)) != 0));
-            }
-        }
-    }
-
-    SECTION("shrink_to_fit releases the tables' spare capacity")
-    {
-        const auto make_text = [](int objects, int members)
-        {
-            std::string text = "[";
-            for (int object = 0; object < objects; ++object)
-            {
-                text += object != 0 ? ",{" : "{";
-                for (int i = 0, n = members + object; i < n; ++i)
-                {
-                    text += (i != 0 ? ",\"" : "\"") + std::to_string(i) + "\":" + std::to_string(i);
-                }
-                text += '}';
-            }
-            return text + "]";
-        };
-        const std::string small_text = make_text(5, 150);
-        const std::string big_text = make_text(40, 400);
-
-        // reading a big text, and then a small one, leaves the spare capacity
-        // of the big one: shrink_to_fit() brings the document to the size of
-        // one parsed from the small text alone
-        json_document d = json_document::parse(big_text);
-        const std::size_t big = d.memory_usage();
-        d.read(small_text);
-        CHECK(d.memory_usage() >= big);
-        d.shrink_to_fit();
-        json_document fresh = json_document::parse(small_text);
-        fresh.shrink_to_fit();
-        CHECK(d.memory_usage() == fresh.memory_usage());
-        CHECK(d.memory_usage() < big / 2);
-        CHECK(d.root() == json::parse(small_text));
-        for (int object = 0; object < 5; ++object)
-        {
-            const json_view v = d.root()[static_cast<std::size_t>(object)];
-            for (int i = 0, n = 150 + object; i < n; ++i)
-            {
-                CHECK(v[std::to_string(i)].get<int>() == i);
-            }
-        }
-    }
-
-    SECTION("nested, reused, and in arrays")
-    {
-        std::string inner = "{";
-        for (int i = 0; i < 300; ++i)
-        {
-            inner += (i != 0 ? ",\"m" : "\"m") + std::to_string(i) + "\":" + std::to_string(i);
-        }
-        inner += '}';
-        const std::string text = "[" + inner + ",{\"x\":" + inner + "}," + inner + "]";
-        json_document d = json_document::parse(text);
-        CHECK(d.root()[0]["m299"].get<int>() == 299);
-        CHECK(d.root()[1]["x"]["m150"].get<int>() == 150);
-        CHECK(d.root()[2]["m0"].get<int>() == 0);
-        const std::size_t with_index = d.memory_usage();
-        d.read(std::string("{\"small\": 1}"));
-        CHECK(d.root()["small"].get<int>() == 1);
-        d.read(text);
-        CHECK(d.root()[2]["m7"].get<int>() == 7);
-        CHECK(d.memory_usage() >= with_index / 2);
-    }
 }
@@ -0,0 +1,302 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#include "doctest_compatibility.h"
+
+#include <nlohmann/json_view.hpp>
+using nlohmann::json;
+using nlohmann::ordered_json;
+using nlohmann::json_document;
+using nlohmann::ordered_json_editable_document;
+using nlohmann::json_view;
+using nlohmann::ordered_json_document;
+using nlohmann::ordered_json_view;
+
+#include "json_view_test_helpers.hpp"
+using json_view_test::generator;
+using json_view_test::has_duplicate_keys;
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <iomanip>
+#include <map>
+#include <random>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+
+// These tests were split off unit-json_view_dump.cpp, whose object file got too large for the MinGW
+// linker (see json_view_test_helpers.hpp). Like that file, this one is also built
+// with C++17, as it mentions JSON_HAS_CPP_17.
+
+TEST_CASE("json_view dump: escaping, nesting, and output buffers")
+{
+    SECTION("members in document order, all of them")
+    {
+        const json_document d = json_document::parse(R"({"b": 1, "a": 2, "b": 3})");
+        CHECK(d.root().dump() == R"({"b":1,"a":2,"b":3})");
+        CHECK(d.root().dump(1) == "{\n \"b\": 1,\n \"a\": 2,\n \"b\": 3\n}");
+        // dump() writes all members, though the lookup finds the first
+        CHECK(d.root()["b"].dump() == "1");
+    }
+
+    SECTION("deep nesting")
+    {
+        const std::string deep = std::string(100000, '[') + std::string(100000, ']');
+        const json_document deep_document = json_document::parse(deep);
+        CHECK(deep_document.root().dump() == deep);
+    }
+
+    SECTION("ensure_ascii: a character that needs an escape at each position of a string")
+    {
+        // string lengths around the width of the vector steps, in a string value, a key, and a value near the end of the text
+        for (const char* const special :
+                {
+                    "\xC3\xA9", "\xE4\xB8\xAD", "\xF0\x9F\x98\x80", "\x7F", "\\n", "\\u0001", "\\\"", "\\\\"
+                })
+        {
+            for (std::size_t length = 0; length <= 40; ++length)
+            {
+                for (std::size_t position = 0; position <= length; ++position)
+                {
+                    std::string content(length, 'a');
+                    content.insert(position, special);
+                    const std::array<std::string, 3> texts =
+                    {
+                        {
+                            "\"" + content + "\"",
+                            "[\"" + content + "\"]",
+                            "{\"" + content + "\":1}",
+                        }
+                    };
+                    for (const std::string& text : texts)
+                    {
+                        CAPTURE(text)
+                        const ordered_json_document d = ordered_json_document::parse(text);
+                        const ordered_json j = ordered_json::parse(text);
+                        CHECK(d.root().dump(-1, ' ', true) == j.dump(-1, ' ', true));
+                        CHECK(d.root().dump(2, ' ', true) == j.dump(2, ' ', true));
+                        CHECK(d.root().dump() == j.dump());
+                    }
+                }
+            }
+        }
+    }
+
+    SECTION("ensure_ascii: every character of the Basic Multilingual Plane and some beyond")
+    {
+        // (the two- and three-byte sequences, including the ranges that need a check: E0, ED, EF BF BF)
+        std::string text = "[";
+        std::size_t in_chunk = 0;
+        const auto append = [&](std::uint32_t cp)
+        {
+            if (cp < 0x80)
+            {
+                if (cp < 0x20 || cp == '"' || cp == '\\')
+                {
+                    return;
+                }
+                text += static_cast<char>(cp);
+            }
+            else if (cp < 0x800)
+            {
+                text += static_cast<char>(0xC0 | (cp >> 6));
+                text += static_cast<char>(0x80 | (cp & 0x3F));
+            }
+            else if (cp < 0x10000)
+            {
+                text += static_cast<char>(0xE0 | (cp >> 12));
+                text += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
+                text += static_cast<char>(0x80 | (cp & 0x3F));
+            }
+            else
+            {
+                text += static_cast<char>(0xF0 | (cp >> 18));
+                text += static_cast<char>(0x80 | ((cp >> 12) & 0x3F));
+                text += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
+                text += static_cast<char>(0x80 | (cp & 0x3F));
+            }
+        };
+        for (std::uint32_t cp = 0x20; cp < 0x10400; ++cp)
+        {
+            if (cp >= 0xD800 && cp < 0xE000)
+            {
+                continue;
+            }
+            if (in_chunk == 0)
+            {
+                text += text.size() > 1 ? ",\"" : "\"";
+            }
+            append(cp);
+            if (++in_chunk == 37)
+            {
+                text += "\"";
+                in_chunk = 0;
+            }
+        }
+        text += in_chunk != 0 ? "\"]" : "]";
+        const ordered_json_document d = ordered_json_document::parse(text);
+        const ordered_json j = ordered_json::parse(text);
+        CHECK(d.root().dump(-1, ' ', true) == j.dump(-1, ' ', true));
+        CHECK(d.root().dump(2, ' ', true) == j.dump(2, ' ', true));
+        CHECK(d.root().dump() == j.dump());
+        CHECK(d.root().dump(2) == j.dump(2));
+    }
+
+    SECTION("deep nesting, indented")
+    {
+        // indentations of up to and beyond the width of the writer's fixed-size copy
+        for (const int depth :
+                {
+                    1, 5, 20, 70, 300
+                })
+        {
+            std::string text;
+            for (int i = 0; i < depth; ++i)
+            {
+                text += i % 2 == 0 ? "[1," : R"({"k":2,"\u00e9":)";
+            }
+            text += "[]";
+            for (int i = depth - 1; i >= 0; --i)
+            {
+                text += i % 2 == 0 ? "]" : "}";
+            }
+            const ordered_json_document d = ordered_json_document::parse(text);
+            const ordered_json j = ordered_json::parse(text);
+            for (const int indent :
+                    {
+                        0, 1, 2, 3, 8
+                    })
+            {
+                CHECK(d.root().dump(indent) == j.dump(indent));
+                CHECK(d.root().dump(indent, '\t') == j.dump(indent, '\t'));
+            }
+        }
+    }
+
+    SECTION("the output buffer of a small value is small")
+    {
+        // an escaped key after the value: its node lies in the arena, so the
+        // source extent of the value cannot be read from the next node
+        const std::string big(100000, 'a');
+        const std::string text = R"({"small":1,"list":[1,2,3],"k\n":")" + big + R"("})";
+        const json_document d = json_document::parse(text);
+        const auto small = d.root()["small"].dump();
+        CHECK(small == "1");
+        CHECK(small.capacity() < 4096);
+        const auto list = d.root()["list"].dump();
+        CHECK(list == "[1,2,3]");
+        CHECK(list.capacity() < 4096);
+        CHECK(d.root()["list"].dump(2).capacity() < 4096);
+
+        // the whole document and the large value are unaffected
+        CHECK(d.root().dump() == ordered_json::parse(text).dump());
+        CHECK(d.root()["k\n"].dump() == "\"" + big + "\"");
+    }
+
+    SECTION("output that outgrows the estimate")
+    {
+        // ensure_ascii writes six bytes for each two-byte character
+        std::string chars;
+        for (int i = 0; i < 5000; ++i)
+        {
+            chars += "\xC3\xA9";
+        }
+        const json_document d = json_document::parse(R"({"a":")" + chars + R"(","k\n":1})");
+        const json expected = json::parse("\"" + chars + "\"");
+        CHECK(d.root()["a"].dump(-1, ' ', true) == expected.dump(-1, ' ', true));
+        CHECK(d.root()["a"].dump(-1, ' ', true).size() == 2 + (5000 * 6));
+    }
+
+    SECTION("ensure_ascii with strings of the source, decoded strings, and edited strings")
+    {
+        // plain ASCII, non-ASCII, escaped (decoded), and mixed strings, as values and as keys;
+        // the second text has a DEL, which ensure_ascii writes as an escape
+        for (const char* const del :
+                {"", "\x7F"
+                })
+        {
+            const std::string text = std::string("{\"plain\":\"abc\",\"caf\xC3\xA9\":\"\xC3\xA9\xE2\x82\xAC\xF0\x9F\x98\x80\",")
+                                     + "\"esc\\n\\\"\":\"a\\tb\\u00e4\\ud83d\\ude00\",\"del\":\"a" + del + "b\",\"\":\"\"," // NOLINT(modernize-raw-string-literal)
+                                     + "\"list\":[\"x\",\"\xC3\xBC\",\"\\\\\",\"long ASCII string with more than thirty-two bytes in it\","
+                                     + "\"long string with more than thirty-two bytes and one non-ASCII byte \xC3\xB6\"],"
+                                     + "\"n\":[1,2.5,-0,true,null]}";
+            const ordered_json j = ordered_json::parse(text);
+            const ordered_json_document d = ordered_json_document::parse(text);
+            CHECK(d.root().dump(-1, ' ', true) == j.dump(-1, ' ', true));
+            CHECK(d.root().dump(4, ' ', true) == j.dump(4, ' ', true));
+            CHECK(d.root().dump() == j.dump());
+            CHECK(d.root()["list"].dump(-1, ' ', true) == j["list"].dump(-1, ' ', true));
+            CHECK(d.root()["del"].dump(-1, ' ', true) == j["del"].dump(-1, ' ', true));
+
+            // strings that an edit wrote (the source strings that they replace were plain)
+            ordered_json_editable_document e = ordered_json_editable_document::parse(text);
+            ordered_json k = j;
+            e.set(e.root()["plain"], std::string("\xC3\xA4gypten"));
+            k["plain"] = "\xC3\xA4gypten";
+            e.set(e.root()["list"][0], std::string("ascii after edit"));
+            k["list"][0] = "ascii after edit";
+            e.set(e.root()["list"][1], std::string("\xC3\xA4"));
+            k["list"][1] = "\xC3\xA4";
+            e.set(e.root()["del"], std::string("tab\there"));
+            k["del"] = "tab\there";
+            CHECK(e.root().dump(-1, ' ', true) == k.dump(-1, ' ', true));
+            CHECK(e.root().dump(2, ' ', true) == k.dump(2, ' ', true));
+            CHECK(e.root().dump() == k.dump());
+
+            // strings that were edited from or to ASCII text
+            e.set(e.root()["list"][2], std::string("\xC3\xA4"));
+            k["list"][2] = "\xC3\xA4";
+            e.set(e.root()["list"][4], std::string("plain again"));
+            k["list"][4] = "plain again";
+            CHECK(e.root().dump(-1, ' ', true) == k.dump(-1, ' ', true));
+        }
+    }
+
+    SECTION("ensure_ascii with DEL or a non-ASCII character at every position")
+    {
+        // the check whether a string of the source has no byte >= 0x7F reads
+        // eight bytes at a time and then the rest one by one
+        for (std::size_t length = 1; length <= 20; ++length)
+        {
+            for (std::size_t pos = 0; pos < length; ++pos)
+            {
+                for (const char* const c :
+                        {
+                            "\x7F", "\x7E", "\xC3\xA4", "\xC3\xBF" // NOLINT(modernize-raw-string-literal)
+                        })
+                {
+                    const std::string s = std::string(pos, 'a') + c + std::string(length - pos - 1, 'b');
+                    std::string text = "[\"";
+                    text.append(s).append("\",{\"").append(s).append("\":1}]");
+                    const json_document d = json_document::parse(text);
+                    const json j = json::parse(text);
+                    CHECK(d.root().dump(-1, ' ', true) == j.dump(-1, ' ', true));
+                    CHECK(d.root().dump(1, ' ', true) == j.dump(1, ' ', true));
+                }
+            }
+        }
+    }
+
+    SECTION("streams and discarded views")
+    {
+        const json_document d = json_document::parse(R"({"a": [1, 2]})");
+        std::ostringstream compact;
+        compact << d.root();
+        CHECK(compact.str() == R"({"a":[1,2]})");
+        std::ostringstream pretty;
+        pretty << std::setw(2) << std::setfill('.') << d.root() << d.root()["a"];
+        CHECK(pretty.str() == "{\n..\"a\": [\n....1,\n....2\n..]\n}[1,2]");
+        CHECK(json_view().dump() == json(json::value_t::discarded).dump());
+    }
+}
@@ -26,79 +26,12 @@ using nlohmann::json_editable_view;
 #include <limits>
 #include <map>
 #include <string>
-#include <type_traits>
 #include <utility>
 #include <vector>

 // These tests were split off unit-json_view_edit.cpp, whose object file got too
 // large for the MinGW linker (see json_view_test_helpers.hpp).

-namespace
-{
-// the three ways a function can accept views: editable ones, read-only ones, or both
-template<typename BasicJsonType>
-int accepts_editable(nlohmann::basic_json_view<BasicJsonType, nlohmann::view_mode::editable> /*unused*/)
-{
-    return 1;
-}
-
-template<typename BasicJsonType>
-int accepts_read_only(nlohmann::basic_json_view<BasicJsonType, nlohmann::view_mode::read_only> /*unused*/)
-{
-    return 2;
-}
-
-template<typename BasicJsonType, nlohmann::view_mode Mode>
-int accepts_any(nlohmann::basic_json_view<BasicJsonType, Mode> /*unused*/)
-{
-    return Mode == nlohmann::view_mode::editable ? 3 : 4;
-}
-
-template<typename View>
-auto overload(View v) -> decltype(accepts_editable(v))
-{
-    return accepts_editable(v);
-}
-
-template<typename View>
-auto overload(View v) -> decltype(accepts_read_only(v))
-{
-    return accepts_read_only(v);
-}
-} // namespace
-
-TEST_CASE("json_view modes")
-{
-    using nlohmann::basic_json_document;
-    using nlohmann::basic_json_view;
-    using nlohmann::ordered_json;
-    using nlohmann::view_mode;
-
-    SECTION("read-only is the default, and the shortcuts name the modes")
-    {
-        static_assert(std::is_same<basic_json_view<json>, basic_json_view<json, view_mode::read_only>>::value, "default mode");
-        static_assert(std::is_same<basic_json_document<json>, basic_json_document<json, view_mode::read_only>>::value, "default mode");
-        static_assert(std::is_same<nlohmann::json_view, basic_json_view<json, view_mode::read_only>>::value, "json_view");
-        static_assert(std::is_same<json_editable_view, basic_json_view<json, view_mode::editable>>::value, "json_editable_view");
-        static_assert(std::is_same<json_editable_document, basic_json_document<json, view_mode::editable>>::value, "json_editable_document");
-        static_assert(std::is_same<nlohmann::ordered_json_editable_view, basic_json_view<ordered_json, view_mode::editable>>::value, "ordered_json_editable_view");
-        static_assert(std::is_same<json_editable_document::view_type, json_editable_view>::value, "view_type");
-        static_assert(std::is_same<json_document::view_type, nlohmann::json_view>::value, "view_type");
-    }
-
-    SECTION("a function template selects views by their mode")
-    {
-        const json_document d = json_document::parse("[1]");
-        const json_editable_document e = json_editable_document::parse("[1]");
-        const nlohmann::ordered_json_editable_document o = nlohmann::ordered_json_editable_document::parse("[1]");
-        CHECK(overload(e.root()) == 1);
-        CHECK(overload(o.root()) == 1);
-        CHECK(overload(d.root()) == 2);
-        CHECK(accepts_any(e.root()) == 3);
-        CHECK(accepts_any(d.root()) == 4);
-    }
-}
-
 TEST_CASE("json_view edits: views and values")
 {
    SECTION("a value that is no longer part of the document")
@@ -167,7 +100,7 @@ TEST_CASE("json_view edits: views and values")
        // doubles have their own path to the output; other float types are
        // written as basic_json writes them, non-finite values as null
        using json_float = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, float>;
-        using document_float = nlohmann::basic_json_document<json_float, nlohmann::view_mode::editable>;
+        using document_float = nlohmann::basic_json_document<json_float, true>;
        document_float d = document_float::parse("[1.5]");
        d.push_back(d.root(), std::numeric_limits<float>::quiet_NaN());
        d.push_back(d.root(), -std::numeric_limits<float>::infinity());
@@ -1,449 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json_view.hpp>
-using nlohmann::json;
-using nlohmann::json_document;
-using nlohmann::json_view;
-using nlohmann::json_editable_document;
-using nlohmann::ordered_json_document;
-
-#include "json_view_test_helpers.hpp"
-#if !defined(JSON_NOEXCEPTION)
-    using json_view_test::exception_of_call;
-#endif
-
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <deque>
-#include <forward_list>
-#include <list>
-#include <map>
-#include <set>
-#include <string>
-#include <tuple>
-#include <type_traits>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <valarray>
-#include <vector>
-
-#ifdef JSON_HAS_CPP_17
-    #include <optional>
-#endif
-
-// The from_json() functions of the NLOHMANN_DEFINE_TYPE_* and
-// NLOHMANN_JSON_SERIALIZE_ENUM macros read views directly; other from_json()
-// functions get the value of materialize().
-
-namespace view_from_json
-{
-struct point
-{
-    int x = 0;
-    int y = 0;
-    NLOHMANN_DEFINE_TYPE_INTRUSIVE(point, x, y)
-
-    friend bool operator==(const point& a, const point& b)
-    {
-        return a.x == b.x && a.y == b.y;
-    }
-};
-
-struct shape
-{
-    std::string name;
-    std::vector<point> points;
-    point center;
-    std::map<std::string, point> named;
-    NLOHMANN_DEFINE_TYPE_INTRUSIVE(shape, name, points, center, named)
-};
-
-struct with_defaults
-{
-    int a = 1;
-    std::string b = "default";
-    std::vector<int> c = {1, 2};
-};
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(with_defaults, a, b, c)
-
-struct with_names
-{
-    int value = 0;
-    std::string text;
-};
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_NAMES(with_names, "Value", value, "Text", text)
-
-struct empty
-{
-    NLOHMANN_DEFINE_TYPE_INTRUSIVE(empty)
-};
-
-enum class color
-{
-    red,
-    green,
-    blue
-};
-NLOHMANN_JSON_SERIALIZE_ENUM(color,
-{
-    {color::red, "red"},
-    {color::green, "green"},
-    {color::blue, nullptr},
-})
-
-enum class strict_color
-{
-    red,
-    green
-};
-NLOHMANN_JSON_SERIALIZE_ENUM_STRICT(strict_color,
-{
-    {strict_color::red, "red"},
-    {strict_color::green, 1},
-})
-
-struct base
-{
-    int id = 0;
-    NLOHMANN_DEFINE_TYPE_INTRUSIVE(base, id)
-};
-
-struct derived : base
-{
-    color c = color::red;
-    NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(derived, base, c)
-};
-
-struct derived_with_defaults : base
-{
-    std::string label = "none";
-    NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(derived_with_defaults, base, label)
-};
-
-// a base whose from_json() is written for json only: the derived type reads
-// its own members from the view and the base part from materialize()
-struct legacy_base
-{
-    int id = 0;
-};
-// NOLINTNEXTLINE(misc-use-internal-linkage): found by ADL, like the from_json() functions of users
-inline void from_json(const json& j, legacy_base& b)
-{
-    b.id = j.at("id").get<int>();
-}
-
-struct derived_from_legacy : legacy_base
-{
-    int extra = 0;
-};
-NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(derived_from_legacy, legacy_base, extra)
-
-// from_json() for json only: converted through materialize()
-struct legacy
-{
-    int v = 0;
-};
-// NOLINTNEXTLINE(misc-use-internal-linkage): found by ADL, like the from_json() functions of users
-inline void from_json(const json& j, legacy& l)
-{
-    l.v = j.at("v").get<int>();
-}
-
-// an unconstrained from_json() template, as in the documentation of
-// arbitrary type conversions: converted through materialize()
-struct unconstrained
-{
-    int v = 0;
-};
-template<typename BasicJsonType>
-// NOLINTNEXTLINE(misc-use-internal-linkage): found by ADL, like the from_json() functions of users
-void from_json(const BasicJsonType& j, unconstrained& u)
-{
-    u.v = j.at("v").template get<int>();
-}
-
-// a from_json() constrained by the user to views and json: reads the view
-struct constrained
-{
-    int v = 0;
-};
-template < typename J, typename std::enable_if < nlohmann::is_json_view<J>::value || std::is_same<J, json>::value, int >::type = 0 >
-// NOLINTNEXTLINE(misc-use-internal-linkage): found by ADL, like the from_json() functions of users
-void from_json(const J& j, constrained& c)
-{
-    c.v = j.at("v").template get<int>();
-}
-}  // namespace view_from_json
-
-namespace
-{
-template<typename T, typename View = json_view>
-struct reads_view : nlohmann::detail::has_view_from_json<nlohmann::adl_serializer<T, void>, View, T> {};
-
-// whether a member converts to the same T from the view and from the materialized value
-template<typename T>
-bool same(const json_view& v, const json& j, const char* key)
-{
-    return v[key].get<T>() == j[key].get<T>();
-}
-}  // namespace
-
-TEST_CASE("json_view from_json")
-{
-    using namespace view_from_json; // NOLINT(google-build-using-namespace)
-
-    SECTION("which from_json() functions read views")
-    {
-        static_assert(reads_view<point>::value, "macro types read views");
-        static_assert(reads_view<shape>::value, "macro types read views");
-        static_assert(reads_view<with_defaults>::value, "macro types read views");
-        static_assert(reads_view<with_names>::value, "macro types read views");
-        static_assert(reads_view<empty>::value, "macro types read views");
-        static_assert(reads_view<derived>::value, "macro types read views");
-        static_assert(reads_view<derived_from_legacy>::value, "macro types read views");
-        static_assert(reads_view<color>::value, "enum macro types read views");
-        static_assert(reads_view<strict_color>::value, "enum macro types read views");
-        static_assert(reads_view<constrained>::value, "constrained from_json() reads views");
-        static_assert(reads_view<point, nlohmann::json_editable_view>::value, "editable views as well");
-        static_assert(reads_view<point, nlohmann::ordered_json_view>::value, "views of ordered_json as well");
-        static_assert(!reads_view<legacy>::value, "from_json() for json");
-        static_assert(!reads_view<legacy_base>::value, "from_json() for json");
-        static_assert(!reads_view<unconstrained>::value, "unconstrained from_json()");
-
-        static_assert(nlohmann::is_json_view<json_view>::value, "is_json_view");
-        static_assert(nlohmann::is_json_view<nlohmann::ordered_json_editable_view>::value, "is_json_view");
-        static_assert(!nlohmann::is_json_view<json>::value, "is_json_view");
-        static_assert(!nlohmann::is_json_view<json_document>::value, "is_json_view");
-        static_assert(!nlohmann::is_json_view<int>::value, "is_json_view");
-    }
-
-    SECTION("the library's own conversions read views")
-    {
-        static_assert(reads_view<std::list<int>>::value, "std types");
-        static_assert(reads_view<std::deque<point>>::value, "std types");
-        static_assert(reads_view<std::set<std::string>>::value, "std types");
-        static_assert(reads_view<std::unordered_set<int>>::value, "std types");
-        static_assert(reads_view<std::forward_list<int>>::value, "std types");
-        static_assert(reads_view<std::valarray<double>>::value, "std types");
-        static_assert(reads_view<std::array<int, 3>>::value, "std types");
-        static_assert(reads_view<std::pair<int, std::string>>::value, "std types");
-        static_assert(reads_view<std::tuple<int, bool, point>>::value, "std types");
-        static_assert(reads_view<std::map<int, int>>::value, "std types");
-        static_assert(reads_view<std::unordered_map<int, point>>::value, "std types");
-        static_assert(reads_view<std::map<color, int>>::value, "std types");
-        static_assert(reads_view<std::map<std::string, int>>::value, "std types");
-        static_assert(reads_view<std::vector<point>>::value, "std types");
-        static_assert(reads_view<std::vector<bool>>::value, "std types");
-        static_assert(reads_view<std::vector<std::uint8_t>>::value, "std types");
-        static_assert(reads_view<std::string>::value, "std types");
-        static_assert(reads_view<int>::value, "std types");
-        static_assert(reads_view<bool>::value, "std types");
-        static_assert(reads_view<double>::value, "std types");
-        static_assert(reads_view<std::nullptr_t>::value, "std types");
-        static_assert(!reads_view<json>::value, "get<BasicJsonType>() is materialize()");
-        static_assert(reads_view<json::binary_t>::value, "std types");
-#ifdef JSON_HAS_CPP_17
-        static_assert(reads_view<std::optional<point>>::value, "std types");
-#endif
-        CHECK(true);
-    }
-
-    SECTION("std types: the same values as from the materialized value")
-    {
-        const json_document d = json_document::parse(R"({"ints": [3, 1, 2, 1], "strings": ["b", "a", "b"], "pairs": [[1, "x"], [2, "y"]],
-            "points": [{"x": 1, "y": 2}, {"x": 3, "y": 4}], "object": {"b": 1, "a": 2}, "triple": [1, true, {"x": 5, "y": 6}],
-            "colors": {"green": 1, "red": 2}, "bytes": [1, 2, 255], "nested": [[1, 2], [3]], "number": 1.5, "flag": true,
-            "text": "hello", "nothing": null, "mixed": [1, 2.5, -3, 4], "flags": [true, false, true]})");
-        const json j = d.root().materialize();
-        const json_view v = d.root();
-        CHECK(same<std::list<int>>(v, j, "ints"));
-        CHECK(same<std::deque<int>>(v, j, "ints"));
-        CHECK(same<std::set<int>>(v, j, "ints"));
-        CHECK(same<std::multiset<int>>(v, j, "ints"));
-        CHECK(same<std::unordered_set<std::string>>(v, j, "strings"));
-        CHECK(same<std::forward_list<int>>(v, j, "ints"));
-        CHECK(same<std::array<int, 4>>(v, j, "ints"));
-        CHECK(same<std::array<double, 4>>(v, j, "mixed"));
-        CHECK((v["pairs"][0].get<std::pair<int, std::string>>() == j["pairs"][0].get<std::pair<int, std::string>>()));
-        CHECK(same<std::vector<std::pair<int, std::string>>>(v, j, "pairs"));
-        CHECK(same<std::tuple<int, bool, point>>(v, j, "triple"));
-        CHECK(same<std::map<int, std::string>>(v, j, "pairs"));
-        CHECK(same<std::unordered_map<int, std::string>>(v, j, "pairs"));
-        CHECK(same<std::map<std::string, int>>(v, j, "object"));
-        CHECK(same<std::unordered_map<std::string, int>>(v, j, "object"));
-        CHECK(same<std::map<color, int>>(v, j, "colors"));
-        CHECK(same<std::vector<point>>(v, j, "points"));
-        CHECK(same<std::vector<int>>(v, j, "ints"));
-        CHECK(same<std::vector<bool>>(v, j, "flags"));
-        CHECK(same<std::vector<std::uint8_t>>(v, j, "bytes"));
-        CHECK(same<std::vector<std::vector<int>>>(v, j, "nested"));
-        CHECK(same<std::vector<json>>(v, j, "mixed"));
-        CHECK(same<double>(v, j, "number"));
-        CHECK(same<bool>(v, j, "flag"));
-        CHECK(same<std::string>(v, j, "text"));
-        CHECK(same<std::nullptr_t>(v, j, "nothing"));
-        CHECK(same<json>(v, j, "object"));
-        const std::valarray<int> va = v["ints"].get<std::valarray<int>>();
-        CHECK(va.size() == 4);
-        CHECK(va[0] == 3);
-        int c_array[2][2] = {{0, 0}, {0, 0}}; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays): the conversion to C arrays
-        v["nested"][0].get_to(c_array[0]);
-        CHECK(c_array[0][1] == 2);
-#ifdef JSON_HAS_CPP_17
-        CHECK(v["points"][0].get<std::optional<point>>()->y == 2);
-        CHECK(!v["nothing"].get<std::optional<point>>().has_value());
-#endif
-        // containers of views keep views of the elements
-        const std::vector<json_view> views = v["points"].get<std::vector<json_view>>();
-        CHECK(views.size() == 2);
-        CHECK(views[1]["x"].get<int>() == 3);
-        CHECK(v["object"].get<std::map<std::string, json_view>>().at("a").get<int>() == 2);
-    }
-
-    SECTION("std types: duplicate keys keep the last value, as from the materialized value")
-    {
-        const json_document d = json_document::parse(R"({"a": 1, "b": 2, "a": 3})");
-        CHECK((d.root().get<std::map<std::string, int>>() == d.root().materialize().get<std::map<std::string, int>>()));
-        CHECK(d.root().get<std::map<std::string, int>>().at("a") == 3);
-        CHECK(d.root().get<std::unordered_map<std::string, int>>().at("a") == 3);
-    }
-
-#if !defined(JSON_NOEXCEPTION) && !JSON_DIAGNOSTICS
-    SECTION("std types: the same errors as from the materialized value")
-    {
-        const json_document d = json_document::parse(R"([[1, "x"], {"a": 1}, "text", [1], 5, null])");
-        const json j = d.root().materialize();
-        for (std::size_t i = 0; i < 6; ++i)
-        {
-            CAPTURE(i)
-            const json_view v = d.root()[i];
-            CHECK(exception_of_call([&] { static_cast<void>(v.get<std::list<int>>()); }) == exception_of_call([&] { static_cast<void>(j[i].get<std::list<int>>()); }));
-            CHECK(exception_of_call([&] { static_cast<void>(v.get<std::forward_list<int>>()); }) == exception_of_call([&] { static_cast<void>(j[i].get<std::forward_list<int>>()); }));
-            CHECK(exception_of_call([&] { static_cast<void>(v.get<std::array<int, 2>>()); }) == exception_of_call([&] { static_cast<void>(j[i].get<std::array<int, 2>>()); }));
-            CHECK(exception_of_call([&] { static_cast<void>(v.get<std::pair<int, std::string>>()); }) == exception_of_call([&] { static_cast<void>(j[i].get<std::pair<int, std::string>>()); }));
-            CHECK(exception_of_call([&] { static_cast<void>(v.get<std::map<std::string, int>>()); }) == exception_of_call([&] { static_cast<void>(j[i].get<std::map<std::string, int>>()); }));
-            CHECK(exception_of_call([&] { static_cast<void>(v.get<std::map<int, int>>()); }) == exception_of_call([&] { static_cast<void>(j[i].get<std::map<int, int>>()); }));
-            CHECK(exception_of_call([&] { static_cast<void>(v.get<std::vector<std::uint8_t>>()); }) == exception_of_call([&] { static_cast<void>(j[i].get<std::vector<std::uint8_t>>()); }));
-            CHECK(exception_of_call([&] { static_cast<void>(v.get<json::binary_t>()); }) == exception_of_call([&] { static_cast<void>(j[i].get<json::binary_t>()); }));
-            CHECK(exception_of_call([&] { static_cast<void>(v.get<std::valarray<int>>()); }) == exception_of_call([&] { static_cast<void>(j[i].get<std::valarray<int>>()); }));
-        }
-    }
-#endif
-
-    SECTION("macro types")
-    {
-        const json_document d = json_document::parse(R"({"name": "s", "points": [{"x": 1, "y": 2}, {"x": 3, "y": 4}],
-            "center": {"x": 5, "y": 6}, "named": {"a": {"x": 7, "y": 8}}})");
-        const shape s = d.root().get<shape>();
-        CHECK(s.name == "s");
-        CHECK(s.points.size() == 2);
-        CHECK(s.points[1].y == 4);
-        CHECK(s.center.x == 5);
-        CHECK(s.named.at("a").y == 8);
-
-        point p;
-        d.root()["center"].get_to(p);
-        CHECK(p.x == 5);
-        CHECK(p.y == 6);
-
-        static_cast<void>(d.root()["center"].get<empty>());
-    }
-
-    SECTION("defaults and names")
-    {
-        const json_document d = json_document::parse(R"({"a": 5, "Value": 3, "Text": "t"})");
-        const with_defaults w = d.root().get<with_defaults>();
-        CHECK(w.a == 5);
-        CHECK(w.b == "default");
-        CHECK(w.c == std::vector<int> {1, 2});
-        const json_document null_document = json_document::parse("null");
-        CHECK(null_document.root().get<with_defaults>().a == 1);
-        const with_names n = d.root().get<with_names>();
-        CHECK(n.value == 3);
-        CHECK(n.text == "t");
-    }
-
-    SECTION("enums")
-    {
-        const json_document d = json_document::parse(R"(["green", null, "purple", 1, "red"])");
-        CHECK(d.root()[0].get<color>() == color::green);
-        CHECK(d.root()[1].get<color>() == color::blue);
-        CHECK(d.root()[2].get<color>() == color::red); // unknown values map to the first entry
-        CHECK(d.root()[3].get<strict_color>() == strict_color::green);
-        CHECK(d.root()[4].get<strict_color>() == strict_color::red);
-#if !defined(JSON_NOEXCEPTION)
-        const json j = d.root().materialize();
-        CHECK(exception_of_call([&] { static_cast<void>(d.root()[2].get<strict_color>()); }) == "[json.exception.out_of_range.410] enum value out of range for strict_color: \"purple\"");
-#if !JSON_DIAGNOSTICS
-        CHECK(exception_of_call([&] { static_cast<void>(d.root()[2].get<strict_color>()); }) == exception_of_call([&] { static_cast<void>(j[2].get<strict_color>()); }));
-#endif
-#endif
-    }
-
-    SECTION("derived types")
-    {
-        const json_document d = json_document::parse(R"({"id": 7, "c": "green", "extra": 3})");
-        const derived x = d.root().get<derived>();
-        CHECK(x.id == 7);
-        CHECK(x.c == color::green);
-        const derived_with_defaults y = d.root().get<derived_with_defaults>();
-        CHECK(y.id == 7);
-        CHECK(y.label == "none");
-        const derived_from_legacy z = d.root().get<derived_from_legacy>();
-        CHECK(z.id == 7);
-        CHECK(z.extra == 3);
-    }
-
-    SECTION("other from_json() functions get the value of materialize()")
-    {
-        const json_document d = json_document::parse(R"({"v": 4})");
-        CHECK(d.root().get<legacy>().v == 4);
-        CHECK(d.root().get<unconstrained>().v == 4);
-        CHECK(d.root().get<constrained>().v == 4);
-        legacy l;
-        d.root().get_to(l);
-        CHECK(l.v == 4);
-    }
-
-    SECTION("duplicate keys: members are looked up in the view, where the first one wins")
-    {
-        const json_document d = json_document::parse(R"({"x": 1, "y": 2, "x": 3})");
-        CHECK(d.root().get<point>().x == 1);
-        // materialize() keeps the last value, like parse()
-        CHECK(d.root().materialize().get<point>().x == 3);
-    }
-
-    SECTION("editable documents and ordered_json")
-    {
-        json_editable_document e = json_editable_document::parse(R"({"x": 1, "y": 2})");
-        e.set(e.root(), "x", 10);
-        CHECK(e.root().get<point>().x == 10);
-        const ordered_json_document o = ordered_json_document::parse(R"({"name": "o", "points": [], "center": {"x": 1, "y": 2}, "named": {}})");
-        CHECK(o.root().get<shape>().center.y == 2);
-    }
-
-#if !defined(JSON_NOEXCEPTION) && !JSON_DIAGNOSTICS
-    SECTION("errors are those of the same conversion of a json value")
-    {
-        // (with JSON_DIAGNOSTICS, those of json name the path of the value)
-        const json_document d = json_document::parse(R"([{"x": 1}, {"x": "1", "y": 2}, [1, 2], {"id": "7", "c": "red"}])");
-        const json j = d.root().materialize();
-        for (std::size_t i = 0; i < 3; ++i)
-        {
-            CAPTURE(i)
-            CHECK(exception_of_call([&] { static_cast<void>(d.root()[i].get<point>()); }) == exception_of_call([&] { static_cast<void>(j[i].get<point>()); }));
-        }
-        CHECK(exception_of_call([&] { static_cast<void>(d.root()[3].get<derived>()); }) == exception_of_call([&] { static_cast<void>(j[3].get<derived>()); }));
-    }
-#endif
-}
@@ -28,25 +28,11 @@ using nlohmann::detail::view::node;
 #include <random>
 #include <sstream>
 #include <string>
-#include <type_traits>
 #include <utility>
 #include <vector>

 #include <test_data.hpp>

-namespace json_view_image_test
-{
-// whether a document type has save() and load() (only on little-endian targets)
-template<typename T, typename = void>
-struct has_save : std::false_type {};
-template<typename T>
-struct has_save<T, decltype(static_cast<void>(std::declval<const T&>().save()))> : std::true_type {};
-template<typename T, typename = void>
-struct has_load : std::false_type {};
-template<typename T>
-struct has_load<T, decltype(static_cast<void>(T::load(std::declval<const std::vector<std::uint8_t>&>())))> : std::true_type {};
-} // namespace json_view_image_test
-
 #if !(defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)

 namespace
@@ -185,9 +171,6 @@ std::uint32_t rng()

 TEST_CASE("json_view images: round trips")
 {
-    static_assert(json_view_image_test::has_save<json_document>::value && json_view_image_test::has_load<json_document>::value, "save() and load() on a little-endian target");
-    static_assert(json_view_image_test::has_save<ordered_json_editable_document>::value && json_view_image_test::has_load<ordered_json_editable_document>::value, "save() and load() on a little-endian target");
-
    SECTION("small documents")
    {
        for (const char* text :
@@ -497,7 +480,7 @@ TEST_CASE("json_view images: edited documents")
            {
                CAPTURE(i)
                CHECK((node_at(image, i).flags & nlohmann::detail::view::node_flags::linked) == 0);
-                CHECK((node_at(image, i).kind != nlohmann::detail::view::node_kind::link));
+                CHECK(node_at(image, i).kind != nlohmann::detail::view::kind_link);
            }
            for (const image_check check :
                    {
@@ -827,13 +810,13 @@ TEST_CASE("json_view images: check")
        {
            rejected(corrupted(image, 12, [&](node & n)
            {
-                n.kind = static_cast<nlohmann::detail::view::node_kind>(kind);
+                n.kind = kind;
            }), true);
        }
        // a key that is not a string
        rejected(corrupted(image, 1, [](node & n)
        {
-            n.kind = nlohmann::detail::view::node_kind::null;
+            n.kind = 0;
            n.len = 0;
            n.off = 0;
        }), true);
@@ -977,11 +960,11 @@ TEST_CASE("json_view images: check")
        }), true);
        rejected(corrupted(image, 0, [](node & n)
        {
-            n.kind = nlohmann::detail::view::node_kind::array; // an array: the "keys" are values, and the counts do not match
+            n.kind = 2; // an array: the "keys" are values, and the counts do not match
        }), true);
        const std::vector<std::uint8_t> as_array = corrupted(image, 16, [](node & n)
        {
-            n.kind = nlohmann::detail::view::node_kind::array; // {} as []: fine
+            n.kind = 2; // {} as []: fine
        });
        CHECK(load_result(as_array, image_check::full).empty());
        const std::string expected_dump = R"({"s":"x\"y","i":-12,"u":7,"f":1.5e+300,"b":true,"n":null,"a":["t",[]]})";
@@ -1030,13 +1013,13 @@ TEST_CASE("json_view images: check")
        rejected(at_token(u6, 0, '8'), false);      // 8 != 7
        rejected(corrupted(image, 4, [](node & n)
        {
-            n.kind = nlohmann::detail::view::node_kind::number_unsigned; // "-12" as unsigned: a sign
+            n.kind = 6; // "-12" as unsigned: a sign
            n.extra = 3;
        }), false);
        // a non-negative number_integer (as edits write it): fine
        const std::vector<std::uint8_t> positive = corrupted(image, 6, [](node & n)
        {
-            n.kind = nlohmann::detail::view::node_kind::number_integer;
+            n.kind = 5;
            n.extra = 0;
        });
        CHECK(load_result(positive, image_check::full).empty());
@@ -1044,7 +1027,7 @@ TEST_CASE("json_view images: check")
        CHECK(pos.root()["u"].is_number_integer());
        rejected(corrupted(image, 8, [](node & n)
        {
-            n.kind = nlohmann::detail::view::node_kind::number_unsigned; // a float token as integer
+            n.kind = 6; // a float token as integer
            n.extra = 7;
        }), false);
    }
@@ -1214,7 +1197,7 @@ TEST_CASE("json_view images: check")
        {
            std::vector<std::uint8_t> b = img;
            node n = node_at(b, i);
-            n.kind = static_cast<nlohmann::detail::view::node_kind>(kind);
+            n.kind = kind;
            n.extra = extra;
            set_node(b, i, n);
            return load_result(b, image_check::full);
@@ -1292,12 +1275,8 @@ TEST_CASE("json_view images: damaged images")

 TEST_CASE("json_view images: big-endian targets")
 {
-    // the image format is little-endian: save() and load() do not exist here
-    static_assert(!json_view_image_test::has_save<json_document>::value, "no save() on a big-endian target");
-    static_assert(!json_view_image_test::has_load<json_document>::value, "no load() on a big-endian target");
-    static_assert(!json_view_image_test::has_save<json_editable_document>::value, "no save() on a big-endian target");
    const json_document d = json_document::parse("[1]");
-    CHECK(d.root().size() == 1);
+    CHECK_THROWS_WITH_AS(d.save(), "[json.exception.type_error.320] json_document images need a little-endian target", json::type_error&);
 }

 #endif
@@ -0,0 +1,545 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#include "doctest_compatibility.h"
+
+#include <nlohmann/json_view.hpp>
+using nlohmann::json;
+using nlohmann::ordered_json;
+using nlohmann::json_document;
+using nlohmann::ordered_json_editable_document;
+using nlohmann::json_view;
+using nlohmann::ordered_json_document;
+using nlohmann::ordered_json_view;
+
+#include "json_view_test_helpers.hpp"
+using json_view_test::generator;
+using json_view_test::has_duplicate_keys;
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <iomanip>
+#include <map>
+#include <random>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+
+// These tests were split off unit-json_view_dump.cpp, whose object file got too large for the MinGW
+// linker (see json_view_test_helpers.hpp). Like that file, this one is also built
+// with C++17, as it mentions JSON_HAS_CPP_17.
+
+TEST_CASE("json_view comparison")
+{
+    SECTION("equality of the values parse() produces")
+    {
+        generator g;
+        std::vector<std::string> texts;
+        for (int i = 0; i < 600; ++i)
+        {
+            std::string text;
+            g.value(text, 0);
+            texts.push_back(text);
+            // the same value written differently: sorted keys, canonical numbers
+            texts.push_back(json::parse(text).dump(1));
+        }
+        for (std::size_t i = 0; i + 2 < texts.size(); ++i)
+        {
+            for (std::size_t k = i; k < i + 3; ++k)
+            {
+                CAPTURE(texts[i])
+                CAPTURE(texts[k])
+                const json_document a = json_document::parse(texts[i]);
+                const json_document b = json_document::parse(texts[k]);
+                const json ja = json::parse(texts[i]);
+                const json jb = json::parse(texts[k]);
+                CHECK((a.root() == b.root()) == (ja == jb));
+                CHECK((a.root() != b.root()) == (ja != jb));
+                CHECK((a.root() == jb) == (ja == jb));
+                CHECK((jb == a.root()) == (ja == jb));
+                CHECK((a.root() != jb) == (ja != jb));
+                CHECK((jb != a.root()) == (ja != jb));
+
+                // ordered_json compares members in order
+                const ordered_json_document oa = ordered_json_document::parse(texts[i]);
+                const ordered_json_document ob = ordered_json_document::parse(texts[k]);
+                const ordered_json oja = ordered_json::parse(texts[i]);
+                const ordered_json ojb = ordered_json::parse(texts[k]);
+                CHECK((oa.root() == ob.root()) == (oja == ojb));
+                CHECK((oa.root() == ojb) == (oja == ojb));
+            }
+        }
+    }
+
+    SECTION("numbers, duplicate keys, member order")
+    {
+        const auto same = [](const char* x, const char* y)
+        {
+            const json_document dx = json_document::parse(x);
+            const json_document dy = json_document::parse(y);
+            return dx.root() == dy.root();
+        };
+        CHECK(same("1", "1.0"));
+        CHECK(same("[1, -1, 2.5]", "[1.0, -1.0, 25e-1]"));
+        CHECK(!same("1", "1.5"));
+        CHECK(same("18446744073709551615", "18446744073709551615"));
+        CHECK(same(R"({"a": 1, "a": 2})", R"({"a": 2})"));
+        CHECK(!same(R"({"a": 1, "a": 2})", R"({"a": 1})"));
+        CHECK(same(R"({"a": 1, "b": 2})", R"({"b": 2, "a": 1})"));
+        CHECK(!same(R"({"a": 1})", R"({"a": 1, "b": 2})"));
+        CHECK(!same("[1, 2]", "[2, 1]"));
+        CHECK(!same("\"a\"", "\"b\""));
+        CHECK(same("\"\\u00e9\"", "\"\xc3\xa9\""));
+        CHECK(!same("null", "false"));
+        CHECK(!same("[]", "{}"));
+        const ordered_json_document dup = ordered_json_document::parse(R"({"a": 1, "b": 2, "a": 3})");
+        const ordered_json_document last = ordered_json_document::parse(R"({"a": 3, "b": 2})");
+        CHECK(dup.root() == last.root());
+        // (== compares as parse() resolves duplicates, a lookup finds the first)
+        CHECK(dup.root()["a"].materialize() == 1);
+        CHECK(dup.root()["a"] != last.root()["a"]);
+        const ordered_json_document ab = ordered_json_document::parse(R"({"a": 1, "b": 2})");
+        const ordered_json_document ba = ordered_json_document::parse(R"({"b": 2, "a": 1})");
+        CHECK(ab.root() != ba.root());
+
+        // discarded values compare as basic_json's do
+        const json discarded(json::value_t::discarded);
+        CHECK((json_view() == json_view()) == (discarded == discarded)); // NOLINT(readability-container-size-empty): operator== is tested
+        CHECK((json_view() == discarded) == (discarded == discarded)); // NOLINT(readability-container-size-empty)
+        const json_document null_document = json_document::parse("null");
+        CHECK(!(json_view() == null_document.root())); // NOLINT(readability-container-size-empty)
+        CHECK(!(null_document.root() == discarded));
+    }
+
+    SECTION("deep nesting")
+    {
+        const std::string deep = std::string(100000, '[') + std::string(100000, ']');
+        const json_document a = json_document::parse(deep);
+        const json_document b = json_document::parse(deep);
+        CHECK(a.root() == b.root());
+        CHECK(a.root() == json::parse(deep));
+        const std::string other = std::string(100000, '[') + "1" + std::string(100000, ']');
+        const json_document c = json_document::parse(other);
+        CHECK(a.root() != c.root());
+    }
+}
+
+TEST_CASE("json_view large objects")
+{
+    // objects with 128 members or more are looked up with a hash index
+    for (const std::size_t members :
+            {
+                127u, 128u, 129u, 10000u
+            })
+    {
+        CAPTURE(members)
+        std::string text = "{";
+        for (std::size_t i = 0; i < members; ++i)
+        {
+            text += (i != 0 ? ",\"" : "\"") + std::string(i % 23, 'k') + std::to_string(i) + (i % 7 == 0 ? "\\n" : "") + "\":" + std::to_string(i);
+        }
+        text += R"(,"":"empty key","k1":"a duplicate of an earlier key"})";
+        const json_document d = json_document::parse(text);
+        const json_view v = d.root();
+        const json j = json::parse(text);
+        for (std::size_t i = 0; i < members; ++i)
+        {
+            const std::string key = std::string(i % 23, 'k') + std::to_string(i) + (i % 7 == 0 ? "\n" : "");
+            CHECK(v[key].get<std::size_t>() == i);
+            CHECK(v.contains(key));
+            CHECK(v.find(key).key() == key);
+            CHECK(v.at(key).get<std::size_t>() == i);
+            CHECK(!v.contains(key + "x"));
+        }
+        CHECK(v[""].get_string() == "empty key");
+        CHECK(v["k1"].get<int>() == 1); // the first of duplicate keys, as for small objects
+        CHECK(!v.contains("missing"));
+        CHECK_THROWS_WITH_AS(v.at("missing"), "[json.exception.out_of_range.403] key 'missing' not found", json::out_of_range&);
+        CHECK(v == j);
+        CHECK(v.materialize() == j);
+    }
+
+    SECTION("duplicate keys: the first member wins, with and without a table")
+    {
+        // an object of `total` members: the keys "k0".."k<n-1>" in order, then
+        // three keys repeated twice more (one copy in the middle, one at the
+        // end), and two keys repeated once; the value of a member is its
+        // position, so that the first member of a key can be told apart
+        struct member
+        {
+            std::string key;
+            std::size_t position;
+        };
+        const auto make_members = [](std::size_t total)
+        {
+            std::vector<std::string> keys;
+            for (std::size_t i = 0; i + 8 < total; ++i)
+            {
+                keys.push_back("k" + std::to_string(i));
+            }
+            const std::size_t n = keys.size();
+            const std::array<std::size_t, 3> triple = {{3, 17, n - 1}};
+            const std::array<std::size_t, 2> twice = {{5, n / 2}};
+            std::vector<std::string> ordered = keys;
+            for (const std::size_t i : triple)
+            {
+                ordered.insert(ordered.begin() + static_cast<std::ptrdiff_t>(ordered.size() / 2), keys[i]);
+            }
+            for (const std::size_t i : twice)
+            {
+                ordered.insert(ordered.begin() + static_cast<std::ptrdiff_t>(ordered.size() / 3), keys[i]);
+            }
+            for (const std::size_t i : triple)
+            {
+                ordered.push_back(keys[i]);
+            }
+            std::vector<member> result;
+            result.reserve(ordered.size());
+            for (std::size_t i = 0; i < ordered.size(); ++i)
+            {
+                result.push_back({ordered[i], i});
+            }
+            return result;
+        };
+
+        // 100 and 127 members: no table; 128 members and more: a table
+        for (const std::size_t total :
+                {
+                    100u, 127u, 128u, 200u, 5000u
+                })
+        {
+            CAPTURE(total)
+            const std::vector<member> members = make_members(total);
+            REQUIRE(members.size() >= total);
+            REQUIRE(members.size() >= 100);
+            std::string text = "{";
+            std::map<std::string, std::size_t> first;
+            std::map<std::string, std::size_t> last;
+            std::map<std::string, std::size_t> occurrences;
+            for (const member& m : members)
+            {
+                text += (text.size() > 1 ? ",\"" : "\"") + m.key + "\":" + std::to_string(m.position);
+                first.insert({m.key, m.position});
+                last[m.key] = m.position;
+                ++occurrences[m.key];
+            }
+            text += '}';
+            REQUIRE(first.size() < members.size());
+
+            const json_document d = json_document::parse(text);
+            const json_view v = d.root();
+            const json j = json::parse(text);
+            CHECK(v.size() == members.size()); // every occurrence is visited
+            const json m = v.materialize();
+            for (const auto& entry : first)
+            {
+                CAPTURE(entry.first)
+                const std::size_t expected = entry.second;
+                CHECK(v[entry.first].get<std::size_t>() == expected);
+                CHECK(v.at(entry.first).get<std::size_t>() == expected);
+                CHECK(v.find(entry.first).value().get<std::size_t>() == expected);
+                CHECK(v.value(entry.first, std::size_t{0}) == expected);
+                CHECK(v.contains(entry.first));
+                CHECK(v.count(entry.first) == occurrences[entry.first]);
+                const std::string pointer = "/" + entry.first;
+                CHECK(v[json::json_pointer(pointer)].get<std::size_t>() == expected);
+                CHECK(v.at(json::json_pointer(pointer)).get<std::size_t>() == expected);
+                CHECK(v.value(json::json_pointer(pointer), std::size_t{0}) == expected);
+                CHECK(v.contains(json::json_pointer(pointer)));
+                // materialize() and parse() keep the last value instead
+                CHECK(j[entry.first].get<std::size_t>() == last.at(entry.first));
+                CHECK(m[entry.first].get<std::size_t>() == last.at(entry.first));
+            }
+            CHECK(!v.contains("k"));
+            CHECK(v["missing"].is_discarded());
+            CHECK(v.materialize() == j);
+            CHECK(v == j);
+        }
+    }
+
+    SECTION("colliding keys")
+    {
+        // the hash is not seeded, so keys that all land in one place must not
+        // make the table build quadratic: such an object gets no table and is
+        // searched linearly
+        constexpr std::size_t members = 300;
+        constexpr std::size_t table_size = 1024; // the table size for 300 members: the next power of two >= 600
+        std::vector<std::string> colliding;
+        std::vector<std::string> spread;
+        for (std::uint64_t counter = 0; colliding.size() < members || spread.size() < members; ++counter)
+        {
+            std::string key(8, 'a');
+            std::uint64_t x = counter;
+            for (std::size_t i = 0; i < 8; ++i, x /= 26)
+            {
+                key[i] = static_cast<char>('a' + (x % 26));
+            }
+            const bool lands_in_slot_zero = (nlohmann::detail::view::key_hash(key.data(), key.size()) & (table_size - 1)) == 0;
+            if (lands_in_slot_zero && colliding.size() < members)
+            {
+                colliding.push_back(key);
+            }
+            else if (!lands_in_slot_zero && spread.size() < members)
+            {
+                spread.push_back(key);
+            }
+        }
+
+        const auto make_text = [](const std::vector<std::string>& keys)
+        {
+            std::string text = "{";
+            for (std::size_t i = 0; i < keys.size(); ++i)
+            {
+                text += (i != 0 ? ",\"" : "\"") + keys[i] + "\":" + std::to_string(i % 10);
+            }
+            return text + "}";
+        };
+        const std::string colliding_text = make_text(colliding);
+        const std::string spread_text = make_text(spread);
+
+        json_document with_collisions = json_document::parse(colliding_text);
+        json_document without_collisions = json_document::parse(spread_text);
+        for (const auto* pair :
+                {
+                    &colliding, &spread
+                })
+        {
+            const json_view v = (pair == &colliding ? with_collisions : without_collisions).root();
+            for (std::size_t i = 0; i < members; ++i)
+            {
+                CAPTURE(i)
+                CHECK(v[(*pair)[i]].get<std::size_t>() == i % 10);
+                CHECK(v.at((*pair)[i]).get<std::size_t>() == i % 10);
+                CHECK(v.find((*pair)[i]).key() == (*pair)[i]);
+                CHECK(!v.contains((*pair)[i] + "x"));
+            }
+            CHECK(!v.contains("missing"));
+        }
+        CHECK(with_collisions.root() == json::parse(colliding_text));
+
+        // only the object with the spread keys got a table (both texts have the
+        // same length, so the tables are the only difference)
+        with_collisions.shrink_to_fit();
+        without_collisions.shrink_to_fit();
+        CHECK(without_collisions.memory_usage() >= with_collisions.memory_usage() + (table_size * sizeof(std::uint32_t)));
+    }
+
+    SECTION("keys that differ in their last bytes are spread over the table")
+    {
+        // The hash must spread the usual families of keys (numbered names, hex
+        // strings, dates, short names): a key farther than index_max_displacement
+        // from its home slot would leave the object without a table. The keys
+        // are placed with linear probing, as the table does.
+        const auto max_displacement = [](const std::vector<std::string>& keys)
+        {
+            std::size_t slots = 16;
+            while (slots < 2 * keys.size())
+            {
+                slots *= 2;
+            }
+            std::vector<bool> used(slots, false);
+            std::size_t farthest = 0;
+            for (const std::string& key : keys)
+            {
+                std::size_t i = nlohmann::detail::conditional_static_cast<std::size_t>(nlohmann::detail::view::key_hash(key.data(), key.size())) & (slots - 1);
+                std::size_t distance = 0;
+                while (used[i])
+                {
+                    i = (i + 1) & (slots - 1);
+                    ++distance;
+                }
+                used[i] = true;
+                farthest = (std::max)(farthest, distance);
+            }
+            return farthest;
+        };
+        // the keys of a printf-like pattern with one %d, %0Nd or %0Nx, formatted with a stream
+        // (a format string that is not a literal is a Flawfinder error)
+        const auto numbered = [](const char* format, int count, int step)
+        {
+            const std::string pattern(format);
+            const std::size_t percent = pattern.find('%');
+            std::size_t conversion = percent + 1;
+            std::size_t width = 0;
+            while (pattern[conversion] >= '0' && pattern[conversion] <= '9')
+            {
+                width = (width * 10) + static_cast<std::size_t>(pattern[conversion] - '0');
+                ++conversion;
+            }
+            const bool hex = pattern[conversion] == 'x';
+            std::vector<std::string> keys;
+            for (int i = 0; i < count; ++i)
+            {
+                std::ostringstream key;
+                key << pattern.substr(0, percent) << std::setfill('0') << std::setw(static_cast<int>(width))
+                    << (hex ? std::hex : std::dec) << (i * step) << pattern.substr(conversion + 1);
+                keys.push_back(key.str());
+            }
+            return keys;
+        };
+        for (const char* format :
+                {"key%d", "%d", "item_%04d", "a%05d", "%03dxyz", "id%d", "user_%d", "%d_suffix", "0x%04x", "A%07d", "12345678%d", "1234567%d", "123456789%d",
+                 "configuration_parameter_value_%04d_extra", "2026-01-%02dT00:00:00Z"
+                })
+        {
+            CAPTURE(format)
+            CHECK(max_displacement(numbered(format, std::string(format).find("%02d") != std::string::npos ? 60 : 1000, 1)) < nlohmann::detail::view::index_max_displacement); // NOLINT(abseil-string-find-str-contains)
+            CHECK(max_displacement(numbered(format, 600, 7)) < nlohmann::detail::view::index_max_displacement);
+        }
+        std::mt19937_64 rng(7); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
+        for (const std::size_t length :
+                {
+                    std::size_t{1}, std::size_t{2}, std::size_t{3}, std::size_t{5}, std::size_t{7}, std::size_t{8}, std::size_t{9}, std::size_t{12}, std::size_t{16}, std::size_t{17}, std::size_t{33}
+                })
+        {
+            CAPTURE(length)
+            std::set<std::string> distinct;
+            // (there are 26 and 676 keys of one and two letters)
+            std::size_t wanted = 700;
+            if (length == 1)
+            {
+                wanted = 26;
+            }
+            else if (length == 2)
+            {
+                wanted = 500;
+            }
+            while (distinct.size() < wanted)
+            {
+                std::string key(length, 'a');
+                for (char& c : key)
+                {
+                    c = static_cast<char>('a' + (rng() % 26));
+                }
+                distinct.insert(key);
+            }
+            CHECK(max_displacement(std::vector<std::string>(distinct.begin(), distinct.end())) < nlohmann::detail::view::index_max_displacement);
+        }
+    }
+
+    SECTION("keys of every length that differ in one byte")
+    {
+        // In a large object, a key is found by comparing its bytes with those of the member the
+        // table points to: up to 16 bytes as two overlapping words, longer ones with memcmp.
+        // Keys of every length from 0 to 40, and keys that differ from them in one byte.
+        std::mt19937_64 rng(2026); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
+        std::vector<std::string> keys;
+        std::set<std::string> distinct;
+        for (std::size_t length = 0; length <= 40; ++length)
+        {
+            for (int copy = 0; copy < 5; ++copy)
+            {
+                std::string key(length, 'a');
+                for (char& c : key)
+                {
+                    c = static_cast<char>('a' + (rng() % 26));
+                }
+                if (distinct.insert(key).second)
+                {
+                    keys.push_back(key);
+                }
+            }
+        }
+        std::string text = "{";
+        for (std::size_t i = 0; i < keys.size(); ++i)
+        {
+            text += (i != 0 ? ",\"" : "\"") + keys[i] + "\":" + std::to_string(i);
+        }
+        text += "}";
+        REQUIRE(keys.size() >= 128); // (a table is built for 128 members)
+        const json_document d = json_document::parse(text);
+        const json_view v = d.root();
+        for (std::size_t i = 0; i < keys.size(); ++i)
+        {
+            CAPTURE(keys[i])
+            CHECK(v[keys[i]].get<std::size_t>() == i);
+            CHECK(v.at(keys[i]).get<std::size_t>() == i);
+            CHECK(v.contains(keys[i]));
+            for (std::size_t at = 0; at < keys[i].size(); ++at)
+            {
+                std::string other = keys[i];
+                other[at] = other[at] == 'z' ? 'y' : 'z';
+                CAPTURE(other)
+                CHECK(v.contains(other) == (distinct.count(other) != 0));
+            }
+            CHECK(v.contains(keys[i] + "a") == (distinct.count(keys[i] + "a") != 0));
+            if (!keys[i].empty())
+            {
+                CHECK(v.contains(keys[i].substr(1)) == (distinct.count(keys[i].substr(1)) != 0));
+            }
+        }
+    }
+
+    SECTION("shrink_to_fit releases the tables' spare capacity")
+    {
+        const auto make_text = [](int objects, int members)
+        {
+            std::string text = "[";
+            for (int object = 0; object < objects; ++object)
+            {
+                text += object != 0 ? ",{" : "{";
+                for (int i = 0, n = members + object; i < n; ++i)
+                {
+                    text += (i != 0 ? ",\"" : "\"") + std::to_string(i) + "\":" + std::to_string(i);
+                }
+                text += '}';
+            }
+            return text + "]";
+        };
+        const std::string small_text = make_text(5, 150);
+        const std::string big_text = make_text(40, 400);
+
+        // reading a big text, and then a small one, leaves the spare capacity
+        // of the big one: shrink_to_fit() brings the document to the size of
+        // one parsed from the small text alone
+        json_document d = json_document::parse(big_text);
+        const std::size_t big = d.memory_usage();
+        d.read(small_text);
+        CHECK(d.memory_usage() >= big);
+        d.shrink_to_fit();
+        json_document fresh = json_document::parse(small_text);
+        fresh.shrink_to_fit();
+        CHECK(d.memory_usage() == fresh.memory_usage());
+        CHECK(d.memory_usage() < big / 2);
+        CHECK(d.root() == json::parse(small_text));
+        for (int object = 0; object < 5; ++object)
+        {
+            const json_view v = d.root()[static_cast<std::size_t>(object)];
+            for (int i = 0, n = 150 + object; i < n; ++i)
+            {
+                CHECK(v[std::to_string(i)].get<int>() == i);
+            }
+        }
+    }
+
+    SECTION("nested, reused, and in arrays")
+    {
+        std::string inner = "{";
+        for (int i = 0; i < 300; ++i)
+        {
+            inner += (i != 0 ? ",\"m" : "\"m") + std::to_string(i) + "\":" + std::to_string(i);
+        }
+        inner += '}';
+        const std::string text = "[" + inner + ",{\"x\":" + inner + "}," + inner + "]";
+        json_document d = json_document::parse(text);
+        CHECK(d.root()[0]["m299"].get<int>() == 299);
+        CHECK(d.root()[1]["x"]["m150"].get<int>() == 150);
+        CHECK(d.root()[2]["m0"].get<int>() == 0);
+        const std::size_t with_index = d.memory_usage();
+        d.read(std::string("{\"small\": 1}"));
+        CHECK(d.root()["small"].get<int>() == 1);
+        d.read(text);
+        CHECK(d.root()[2]["m7"].get<int>() == 7);
+        CHECK(d.memory_usage() >= with_index / 2);
+    }
+}
@@ -34,11 +34,11 @@ version other than the one in `abi_macros.hpp`.
 | Option            | Description                                                                                                                                                                                                                                         |
 |-------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | `--list-tags`     | Print every ABI tag (in namespace order) with the macro that enables it and the `NLOHMANN_JSON_ABI_TAG_*` identifier, then exit.                                                                                                                    |
-| `--abi-tags TAGS` | Add the namespaces of one configuration, given as a comma-separated list of ABI tags (`_diag,_dp,_ns`; the leading underscore is optional, and the order does not matter). Can be repeated for several configurations. Unknown tags are an error. |
+| `--abi-tags TAGS` | Add the namespaces of one configuration, given as a comma-separated list of ABI tags (`_diag,_dp,_vns`; the leading underscore is optional, and the order does not matter). Can be repeated for several configurations. Unknown tags are an error. |
 | `--all`           | Generate the namespaces for every combination of ABI tags. The file size doubles with each tag (about 60 MB for 12 tags). Cannot be combined with `--abi-tags`.                                                                                    |
 | `--output FILE`   | Write the Natvis file to `FILE` instead of `nlohmann_json.natvis` in the repository root.                                                                                                                                                           |

-Each configuration gets both the versioned (`json_abi_diag_dp_ns_v3_12_0`) and the unversioned (`json_abi_diag_dp_ns`,
+Each configuration gets both the versioned (`json_abi_diag_dp_vns_v3_12_0`) and the unversioned (`json_abi_diag_dp_vns`,
 used with `NLOHMANN_JSON_NAMESPACE_NO_VERSION`) namespace. The default namespaces (up to two ABI tags) are always
 included, so a generated file can replace the checked-in one.

@@ -52,10 +52,10 @@ included, so a generated file can replace the checked-in one.
   ```

 3. Generate a Natvis file with them, for example for `JSON_DIAGNOSTICS`, `JSON_DIAGNOSTIC_POSITIONS`, and
-   `JSON_NO_SIMD`:
+   `JSON_VIEW_NO_SIMD`:

   ```shell
-   make natvis NATVIS_ARGS="--abi-tags _diag,_dp,_ns --output my_nlohmann_json.natvis"
+   make natvis NATVIS_ARGS="--abi-tags _diag,_dp,_vns --output my_nlohmann_json.natvis"
   ```

 4. Use `my_nlohmann_json.natvis` instead of the shipped `nlohmann_json.natvis`, for example by adding it to your Visual
@@ -91,7 +91,7 @@ if __name__ == '__main__':
                              'include/nlohmann/detail/abi_macros.hpp below "repo_root")')
    selection = parser.add_mutually_exclusive_group()
    selection.add_argument('--abi-tags', action='append', default=[], metavar='TAGS',
-                           help='Comma-separated list of ABI tags (e.g. "_diag,_dp,_ns", leading underscores are '
+                           help='Comma-separated list of ABI tags (e.g. "_diag,_dp,_vns", leading underscores are '
                                'optional) of one configuration to add to the default namespaces; can be repeated')
    selection.add_argument('--all', action='store_true',
                           help='Generate the namespaces for every combination of ABI tags; the file size doubles '