docs: make the diff() and patch() documentation accurate; add tests

Document the exceptions to the diff round-trip invariant (NaN, discarded
values, number types), the path parameter, non-minimal patches, array and
object operation order, the ordered_json fallback, binary values in
serialized patches, the real complexity, duplicate member names in
operations, test on missing paths, and the exact out_of_range.403 message.
Add tests for these behaviors.

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

.clang-tidy

@@ -1,3 +1,33 @@
+# Style or vendor rule sets that do not fit a header-only library:
+#   altera-*, fuchsia-*, llvmlibc-*, android-cloexec-fopen, boost-use-ranges, llvm-header-guard,
+#   llvm-include-order, llvm-prefer-static-over-anonymous-namespace, llvm-use-ranges,
+#   misc-use-anonymous-namespace, google-runtime-float, google-runtime-int, hicpp-signed-bitwise,
+#   bugprone-signed-bitwise, hicpp-explicit-conversions, google-explicit-constructor,
+#   cppcoreguidelines-explicit-constructor, misc-explicit-constructor (implicit conversions are the
+#   API), readability-trailing-comma,
+#   hicpp-avoid-goto / cppcoreguidelines-avoid-goto, hicpp-no-array-decay,
+#   hicpp-uppercase-literal-suffix, readability-uppercase-literal-suffix, modernize-use-trailing-return-type.
+# Constructs the library needs on purpose (the library supports C++11 and legacy compilers):
+#   cppcoreguidelines-macro-usage, cppcoreguidelines-avoid-do-while (macros),
+#   cppcoreguidelines-pro-bounds-*, cppcoreguidelines-pro-type-reinterpret-cast,
+#   cppcoreguidelines-pro-type-union-access (parsers, serializers, basic_json's value union),
+#   cppcoreguidelines-avoid-const-or-ref-data-members, cppcoreguidelines-rvalue-reference-param-not-moved,
+#   cppcoreguidelines-avoid-non-const-global-variables, misc-non-private-member-variables-in-classes,
+#   misc-no-recursion (value walks are recursive, bounded by detail::recursion_depth_limit()),
+#   modernize-type-traits, modernize-use-constraints, modernize-use-ranges, modernize-use-std-numbers,
+#   modernize-use-designated-initializers, modernize-use-nodiscard, modernize-concat-nested-namespaces,
+#   readability-redundant-typename, readability-redundant-parentheses,
+#   readability-redundant-access-specifiers, readability-simplify-boolean-expr,
+#   readability-use-concise-preprocessor-directives, modernize-use-string-view,
+#   modernize-use-integer-sign-comparison (needs std::cmp_less; the flagged
+#   static_cast<std::size_t>(end - pos) < n comparisons are deliberate)
+#   (all need a newer standard or compiler than C++11, or would change macro-generated or
+#   deliberately explicit code).
+# Too noisy to be useful (numeric parsing/formatting code, doctest, tests):
+#   bugprone-easily-swappable-parameters, cppcoreguidelines-avoid-magic-numbers, readability-magic-numbers,
+#   readability-identifier-length, readability-function-cognitive-complexity, performance-enum-size,
+#   concurrency-mt-unsafe, misc-confusable-identifiers, misc-include-cleaner (run on its own for
+#   the consumer headers in cmake/ci.cmake).
 # portability-avoid-pragma-once: kept disabled on purpose. #pragma once is accepted
 # by every supported compiler, and tools/amalgamate/amalgamate.py strips it from
 # single_include, so there is nothing left to fix here.
@@ -10,14 +40,14 @@ Checks: '*,
          -android-cloexec-fopen,
          -boost-use-ranges,
          -bugprone-easily-swappable-parameters,
-         -cert-err58-cpp,
-         -clang-analyzer-webkit.NoUncountedMemberChecker,
+         -bugprone-signed-bitwise,
          -concurrency-mt-unsafe,
          -cppcoreguidelines-avoid-const-or-ref-data-members,
          -cppcoreguidelines-avoid-do-while,
          -cppcoreguidelines-avoid-goto,
          -cppcoreguidelines-avoid-magic-numbers,
          -cppcoreguidelines-avoid-non-const-global-variables,
+         -cppcoreguidelines-explicit-constructor,
          -cppcoreguidelines-macro-usage,
          -cppcoreguidelines-pro-bounds-avoid-unchecked-container-access,
          -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
@@ -26,19 +56,15 @@ Checks: '*,
          -cppcoreguidelines-pro-type-reinterpret-cast,
          -cppcoreguidelines-pro-type-union-access,
          -cppcoreguidelines-rvalue-reference-param-not-moved,
-         -cppcoreguidelines-virtual-class-destructor,
          -fuchsia-default-arguments-calls,
          -fuchsia-default-arguments-declarations,
          -fuchsia-overloaded-operator,
          -google-explicit-constructor,
-         -google-readability-function-size,
          -google-runtime-float,
          -google-runtime-int,
          -hicpp-avoid-goto,
          -hicpp-explicit-conversions,
-         -hicpp-function-size,
          -hicpp-no-array-decay,
-         -hicpp-no-assembler,
          -hicpp-signed-bitwise,
          -hicpp-uppercase-literal-suffix,
          -llvm-header-guard,
@@ -48,6 +74,7 @@ Checks: '*,
          -llvmlibc-*,
          -misc-use-anonymous-namespace,
          -misc-confusable-identifiers,
+         -misc-explicit-constructor,
          -misc-include-cleaner,
          -misc-no-recursion,
          -misc-non-private-member-variables-in-classes,
@@ -55,20 +82,22 @@ Checks: '*,
          -modernize-type-traits,
          -modernize-use-constraints,
          -modernize-use-designated-initializers,
+         -modernize-use-integer-sign-comparison,
          -modernize-use-nodiscard,
          -modernize-use-ranges,
+         -modernize-use-string-view,
          -modernize-use-std-numbers,
          -modernize-use-trailing-return-type,
          -performance-enum-size,
          -portability-avoid-pragma-once,
          -readability-function-cognitive-complexity,
-         -readability-function-size,
          -readability-identifier-length,
          -readability-magic-numbers,
          -readability-redundant-access-specifiers,
          -readability-redundant-parentheses,
          -readability-redundant-typename,
          -readability-simplify-boolean-expr,
+         -readability-trailing-comma,
          -readability-uppercase-literal-suffix,
          -readability-use-concise-preprocessor-directives'
 

.github/workflows/flawfinder.yml

@@ -43,7 +43,8 @@ jobs:
       - name: flawfinder_scan
         uses: david-a-wheeler/flawfinder@c4216b74cf2639ffa98503768bd6e4299b5440c9 # v2.0.20
         with:
-          arguments: '--sarif ./'
+          # single_include/ is omitted: it is generated from include/ and would report every finding twice
+          arguments: '--sarif ./cmake ./docs ./include ./src ./tests ./tools'
           output: 'flawfinder_results.sarif'
 
       - name: Upload analysis results to GitHub Security tab

BUILD.bazel

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

README.md

@@ -151,7 +151,7 @@ The `json` class provides an API for manipulating a JSON value. To create a `jso
 ```cpp
 #include <fstream>
 #include <nlohmann/json.hpp>
-using json = nlohmann::json;
+using nlohmann::json;
 
 // ...
 
@@ -164,7 +164,7 @@ If using modules (enabled with `NLOHMANN_JSON_BUILD_MODULES`), this example beco
 import std;
 import nlohmann.json;
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 // ...
 
@@ -842,7 +842,7 @@ assert(p == p2);
 To make this work with one of your types, you only need to provide two functions:
 
 ```cpp
-using json = nlohmann::json;
+using nlohmann::json;
 
 namespace ns {
     void to_json(json& j, const person& p) {
@@ -1257,7 +1257,7 @@ See the page [quality assurance](https://json.nlohmann.me/community/quality_assu
 #include <nlohmann/json.hpp>
 
 // for convenience
-using json = nlohmann::json;
+using nlohmann::json;
 ```
 
 to the files you want to process JSON and set the necessary switches to enable C++11 (e.g., `-std=c++11` for GCC and Clang).

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

@@ -2,17 +2,27 @@
 
 ```cpp
 static basic_json diff(const basic_json& source,
-                       const basic_json& target);
+                       const basic_json& target,
+                       const string_t& path = "");
 ```
 
 Creates a [JSON Patch](http://jsonpatch.com) so that value `source` can be changed into the value `target` by calling
 [`patch`](patch.md) function.
 
-For two JSON values `source` and `target`, the following code always yields `#!cpp true`:
+For two JSON values `source` and `target`, the following code yields `#!cpp true`:
 ```cpp
 source.patch(diff(source, target)) == target;
 ```
 
+The equality holds up to [`operator==`](operator_eq.md), so it has the following exceptions:
+
+- A value that is not equal to itself cannot round-trip. This applies to `NaN` (also nested in an array or object) and
+  to [discarded](is_discarded.md) values: `diff` emits a `replace` operation for them. A `NaN` in the patch is
+  serialized as `#!json null`, so a patch that was dumped and parsed again would set `#!json null`.
+- Numbers that compare equal produce no operation, even if their types or signs differ: `diff(1, 1.0)`,
+  `diff(1u, 1)` (unsigned and signed integer) and `diff(0.0, -0.0)` all return `#!json []`. The patched value is then
+  the `source` and keeps its number type.
+
 ## Parameters
 
 `source` (in)
@@ -21,6 +31,12 @@ source.patch(diff(source, target)) == target;
 `target` (in)
 :   JSON value to compare against
 
+`path` (in)
+:   a prefix that is put verbatim in front of the `path` member of every operation (default: `""`, which addresses the
+    root of the value). The prefix is neither escaped nor validated: `#!cpp diff(1, 2, "abc")` yields an operation with
+    the `path` `abc`, which is not a valid JSON Pointer. Use it with a valid JSON Pointer such as `/root` and escape
+    `~` and `/` in its reference tokens (see [JSON Pointer](../../features/json_pointer.md)).
+
 ## Return value
 
 a JSON patch to convert the `source` to `target`
@@ -31,11 +47,32 @@ Strong guarantee: `source` and `target` are never modified.
 
 ## Complexity
 
-Linear in the lengths of `source` and `target`.
+Linear in the total number of values (including nested ones) in `source` and `target`, times the cost of a key-based
+object operation (looking up a key in an object): logarithmic for [`json`](../json.md), and linear for
+[`ordered_json`](../ordered_json.md) (see [`ordered_map` complexity](../ordered_map.md#complexity)). For
+`ordered_json`, diffing two objects with `n` and `m` members therefore takes O((n+m)²) when their keys do not line up
+(e.g., a key was added or the keys are in a different order). The size of the patch is proportional to the number of
+operations times the length of their paths, so a small change deep inside a value yields a long `path`.
 
 ## Notes
 
-Currently, only `remove`, `add`, and `replace` operations are generated.
+- Currently, only `remove`, `add`, and `replace` operations are generated.
+- The patch is correct, but not guaranteed to be minimal. For instance, `diff([1,2,3], [0,1,2,3])` yields three
+  `replace` operations and one `add` operation instead of a single insertion.
+- Differences between two arrays are reported index by index. Elements that were added at the end of the array are added
+  with `add` operations on the path `/-` (appended in order), and elements that were removed are removed with `remove`
+  operations from the highest index down to the lowest, so that the remaining indices stay valid.
+- For objects, the operations for the members of `source` come first (`replace`, `remove`, or the operations for nested
+  values, in the iteration order of `source`), followed by `add` operations for the members that only `target` has.
+- For [`ordered_json`](../ordered_json.md), objects with the same keys in a different order are different. As a patch
+  cannot reorder members, `diff` removes all keys of the `source` object and adds them again in the order of the
+  `target`.
+- If `source` and `target` differ as a whole (e.g., different types), the patch consists of a single `replace`
+  operation for the root of the value, i.e., with the `path` `""` (or the given `path` prefix).
+- The `value` members of the patch hold copies of values of `target`. A [binary](../../features/binary_values.md) value
+  has no JSON representation: when a patch that contains one is serialized, it becomes an object such as
+  `#!json {"bytes":[1,3],"subtype":null}`, so a parsed patch no longer holds a binary value (and would set that object
+  instead).
           
 ## Examples
 

docs/mkdocs/docs/api/basic_json/get_ptr.md

@@ -45,7 +45,7 @@ Constant.
     #include <iostream>
     #include <nlohmann/json.hpp>
     
-    using json = nlohmann::json;
+    using nlohmann::json;
     
     int main()
     {

docs/mkdocs/docs/api/basic_json/patch.md

@@ -40,7 +40,7 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
   where an existing element is required (the "path" of "replace", the "from" of "move" and "copy"); example:
   `"array index '-' (3) is out of range"`.
 - Throws [`out_of_range.403`](../../home/exceptions.md#jsonexceptionout_of_range403) if a JSON pointer inside the patch
-  could not be resolved successfully in the current JSON value; example: `"key baz not found"`.
+  could not be resolved successfully in the current JSON value; example: `"key 'baz' not found"`.
 - Throws [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) if a reference token of a JSON
   pointer inside the patch cannot be resolved, e.g., `-` in a "remove" operation or `1a` for an array; example:
   `"unresolved reference token '-'"`.
@@ -53,7 +53,10 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [`out_of_range.414`](../../home/exceptions.md#jsonexceptionout_of_range414) if a "move" operation's "from"
   location is a proper prefix of its "path" location.
 - Throws [`other_error.501`](../../home/exceptions.md#jsonexceptionother_error501) if "test" operation was
-  unsuccessful.
+  unsuccessful. A "test" operation whose "path" does not exist is unsuccessful, too: the failed lookup is reported as a
+  failed test, even if the operation has no "value" member (which would otherwise be
+  [`parse_error.105`](../../home/exceptions.md#jsonexceptionparse_error105)). Which of the two errors is reported for
+  this combination depends on the order in which the operands of a comparison are evaluated, so do not rely on it.
 
 ## Complexity
 
@@ -65,6 +68,10 @@ the JSON value, the complexity can usually be neglected.
 The application of a patch is atomic: Either all operations succeed and the patched document is returned or an exception
 is thrown. In any case, the original value is not changed: the patch is applied to a copy of the value.
 
+Duplicate member names inside an operation object are resolved by the parser before the patch is applied (the last one
+is kept, see [`object_t`](object_t.md#behavior)), so `#!json {"op": "add", "op": "remove", "path": "/a"}` is a
+`remove` operation.
+
 ## Examples
 
 ??? example "Example: apply a JSON patch"
@@ -108,6 +115,7 @@ is thrown. In any case, the original value is not changed: the patch is applied
 - Added in version 2.0.0.
 - Added [`out_of_range.411`](../../home/exceptions.md#jsonexceptionout_of_range411) and stopped relying on an internal assertion when an "add" operation's
   target location has a non-object/non-array parent in version 3.13.0.
+  This includes a `null` parent, which was previously silently converted to an object, in version 3.13.0.
 - Added [`out_of_range.413`](../../home/exceptions.md#jsonexceptionout_of_range413) and stopped silently ignoring a "remove" operation whose target
   location has a non-object/non-array parent in version 3.13.0.
 - Added [`out_of_range.414`](../../home/exceptions.md#jsonexceptionout_of_range414) and rejected a "move" operation whose "from" location is a proper

docs/mkdocs/docs/api/basic_json/patch_inplace.md

@@ -36,7 +36,7 @@ No guarantees, value may be corrupted by an unsuccessful patch operation.
   where an existing element is required (the "path" of "replace", the "from" of "move" and "copy"); example:
   `"array index '-' (3) is out of range"`.
 - Throws [`out_of_range.403`](../../home/exceptions.md#jsonexceptionout_of_range403) if a JSON pointer inside the patch
-  could not be resolved successfully in the current JSON value; example: `"key baz not found"`.
+  could not be resolved successfully in the current JSON value; example: `"key 'baz' not found"`.
 - Throws [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) if a reference token of a JSON
   pointer inside the patch cannot be resolved, e.g., `-` in a "remove" operation or `1a` for an array; example:
   `"unresolved reference token '-'"`.
@@ -49,7 +49,10 @@ No guarantees, value may be corrupted by an unsuccessful patch operation.
 - Throws [`out_of_range.414`](../../home/exceptions.md#jsonexceptionout_of_range414) if a "move" operation's "from"
   location is a proper prefix of its "path" location.
 - Throws [`other_error.501`](../../home/exceptions.md#jsonexceptionother_error501) if "test" operation was
-  unsuccessful.
+  unsuccessful. A "test" operation whose "path" does not exist is unsuccessful, too: the failed lookup is reported as a
+  failed test, even if the operation has no "value" member (which would otherwise be
+  [`parse_error.105`](../../home/exceptions.md#jsonexceptionparse_error105)). Which of the two errors is reported for
+  this combination depends on the order in which the operands of a comparison are evaluated, so do not rely on it.
 
 ## Complexity
 
@@ -62,6 +65,10 @@ Unlike [`patch`](patch.md), `patch_inplace` applies the operation "in place" and
 That makes it faster for large documents by avoiding the copy. However, the JSON value might be corrupted if the
 function throws an exception.
 
+Duplicate member names inside an operation object are resolved by the parser before the patch is applied (the last one
+is kept, see [`object_t`](object_t.md#behavior)), so `#!json {"op": "add", "op": "remove", "path": "/a"}` is a
+`remove` operation.
+
 ## Examples
 
 ??? example "Example: apply a JSON patch in place"
@@ -106,6 +113,7 @@ function throws an exception.
 - Added in version 3.11.0.
 - Added [`out_of_range.411`](../../home/exceptions.md#jsonexceptionout_of_range411) and stopped relying on an internal assertion when an "add" operation's
   target location has a non-object/non-array parent in version 3.13.0.
+  This includes a `null` parent, which was previously silently converted to an object, in version 3.13.0.
 - Added [`out_of_range.413`](../../home/exceptions.md#jsonexceptionout_of_range413) and stopped silently ignoring a "remove" operation whose target
   location has a non-object/non-array parent in version 3.13.0.
 - Added [`out_of_range.414`](../../home/exceptions.md#jsonexceptionout_of_range414) and rejected a "move" operation whose "from" location is a proper

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

docs/mkdocs/docs/api/json_document.md

@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 
 ```cpp
-using json_document = basic_json_document<json, view_mode::read_only>;
+using json_document = basic_json_document<json>;
 ```
 
 This type is a [`basic_json_document`](basic_json_document/index.md) of the default [`json`](json.md)

docs/mkdocs/docs/api/json_editable_document.md

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

docs/mkdocs/docs/api/json_editable_view.md

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

docs/mkdocs/docs/api/json_view.md

@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 
 ```cpp
-using json_view = basic_json_view<json, view_mode::read_only>;
+using json_view = basic_json_view<json>;
 ```
 
 This type is a [`basic_json_view`](basic_json_view/index.md) of a value of a [`json_document`](json_document.md).

docs/mkdocs/docs/api/macros/json_assert.md

@@ -38,7 +38,7 @@ Therefore, assertions can be switched off by defining `NDEBUG`.
     ```cpp
     #include <nlohmann/json.hpp>
     
-    using json = nlohmann::json;
+    using nlohmann::json;
     
     int main()
     {
@@ -64,7 +64,7 @@ Therefore, assertions can be switched off by defining `NDEBUG`.
     
     #include <nlohmann/json.hpp>
     
-    using json = nlohmann::json;
+    using nlohmann::json;
     
     int main()
     {

docs/mkdocs/docs/api/macros/json_brace_init_copy_semantics.md

@@ -79,7 +79,7 @@ The default value is `0` (disabled — existing behavior is preserved).
     ```cpp
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     int main()
     {
@@ -98,7 +98,7 @@ The default value is `0` (disabled — existing behavior is preserved).
     #define JSON_BRACE_INIT_COPY_SEMANTICS 1
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     int main()
     {

docs/mkdocs/docs/api/macros/json_delete_deprecated_functions.md

@@ -54,7 +54,7 @@ The default value is `0` (disabled, the deprecated functions can still be called
     ```cpp
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     int main()
     {
@@ -72,7 +72,7 @@ The default value is `0` (disabled, the deprecated functions can still be called
     #define JSON_DELETE_DEPRECATED_FUNCTIONS 1
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     int main()
     {

docs/mkdocs/docs/api/macros/json_disable_enum_serialization.md

@@ -39,7 +39,7 @@ The default value is `0`.
     #define JSON_DISABLE_ENUM_SERIALIZATION 1
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     enum class Choice
     {
@@ -66,7 +66,7 @@ The default value is `0`.
     #define JSON_DISABLE_ENUM_SERIALIZATION 1
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     enum class Choice
     {
@@ -99,7 +99,7 @@ The default value is `0`.
     #define JSON_DISABLE_ENUM_SERIALIZATION 1
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     enum class Choice
     {

docs/mkdocs/docs/api/macros/json_disable_stream_bulk_scan.md

@@ -92,7 +92,7 @@ The default value is `0`: streams are scanned in bulk.
     #include <sstream>
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     int main()
     {
@@ -115,7 +115,7 @@ The default value is `0`: streams are scanned in bulk.
     #include <sstream>
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     int main()
     {

docs/mkdocs/docs/api/macros/json_disable_tuple_reference_conversion.md

@@ -72,7 +72,7 @@ The default value is `0` (disabled — existing behavior is preserved).
     ```cpp
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     int main()
     {
@@ -89,7 +89,7 @@ The default value is `0` (disabled — existing behavior is preserved).
     #define JSON_DISABLE_TUPLE_REFERENCE_CONVERSION 1
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     int main()
     {

docs/mkdocs/docs/api/macros/json_disable_unlocked_file_io.md

@@ -73,7 +73,7 @@ The default value is `0`: the file is locked once and read with the unlocked std
     #include <cstdio>
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     int main()
     {
@@ -92,7 +92,7 @@ The default value is `0`: the file is locked once and read with the unlocked std
     #include <cstdio>
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     int main()
     {

docs/mkdocs/docs/api/macros/json_no_simd.md

@@ -61,7 +61,7 @@ By default, `#!cpp JSON_NO_SIMD` is not defined, and vector instructions are use
     #include <iostream>
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     int main()
     {

docs/mkdocs/docs/api/macros/json_precise_stream_position.md

@@ -94,7 +94,7 @@ The default value is `0` (disabled — existing behavior is preserved).
     #include <sstream>
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     int main()
     {
@@ -115,7 +115,7 @@ The default value is `0` (disabled — existing behavior is preserved).
     #include <sstream>
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     int main()
     {

docs/mkdocs/docs/api/macros/json_strict_binary_utf8.md

@@ -64,7 +64,7 @@ The default value is `0` (disabled, the behavior of version 3.12.0 and earlier i
     ```cpp
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     int main()
     {
@@ -81,7 +81,7 @@ The default value is `0` (disabled, the behavior of version 3.12.0 and earlier i
     #define JSON_STRICT_BINARY_UTF8 1
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     int main()
     {

docs/mkdocs/docs/api/macros/json_strict_nul_handling.md

@@ -92,7 +92,7 @@ The default value is `0` (disabled — existing behavior is preserved).
     ```cpp
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     int main()
     {
@@ -109,7 +109,7 @@ The default value is `0` (disabled — existing behavior is preserved).
     #define JSON_STRICT_NUL_HANDLING 1
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     int main()
     {

docs/mkdocs/docs/api/macros/json_use_objects_for_enum_keyed_maps.md

@@ -77,7 +77,7 @@ The default value is `0` (disabled — existing behavior is preserved).
     #include <map>
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     enum TaskState { TS_STOPPED, TS_RUNNING, TS_COMPLETED };
 
@@ -105,7 +105,7 @@ The default value is `0` (disabled — existing behavior is preserved).
     #include <map>
     #include <nlohmann/json.hpp>
 
-    using json = nlohmann::json;
+    using nlohmann::json;
 
     enum TaskState { TS_STOPPED, TS_RUNNING, TS_COMPLETED };
 

docs/mkdocs/docs/api/ordered_json_document.md

@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 
 ```cpp
-using ordered_json_document = basic_json_document<ordered_json, view_mode::read_only>;
+using ordered_json_document = basic_json_document<ordered_json>;
 ```
 
 This type is a [`basic_json_document`](basic_json_document/index.md) of the [`ordered_json`](ordered_json.md)

docs/mkdocs/docs/api/ordered_json_editable_document.md

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

docs/mkdocs/docs/api/ordered_json_editable_view.md

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

docs/mkdocs/docs/api/ordered_json_view.md

@@ -3,7 +3,7 @@
 <small>Defined in header `<nlohmann/json_view.hpp>`</small>
 
 ```cpp
-using ordered_json_view = basic_json_view<ordered_json, view_mode::read_only>;
+using ordered_json_view = basic_json_view<ordered_json>;
 ```
 
 This type is a [`basic_json_view`](basic_json_view/index.md) of a value of an

docs/mkdocs/docs/api/view_mode.md

@@ -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 a compile-time property of the document's and the view's type, not a setting of a call, 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.

docs/mkdocs/docs/community/quality_assurance.md

@@ -188,10 +188,13 @@ Note: Some modern features (like C++20 ranges or filesystem support) may be disa
         ```
 
 - [x] The code is checked with the latest [Cppcheck](https://cppcheck.sourceforge.io) with all warnings enabled.
-- [x] The code is checked with the latest [Clang Static Analyzer](https://clang-analyzer.llvm.org) with 89 enabled
-  rules.
+- [x] The code is checked with the latest [Clang Static Analyzer](https://clang-analyzer.llvm.org) with 52 enabled
+  checkers.
 - [x] The code is checked with [Infer](https://fbinfer.com).
 - [x] The code is checked with [Codacy](https://app.codacy.com/gh/nlohmann/json/dashboard).
+- [x] The code is scanned with [CodeQL](https://codeql.github.com), [Semgrep](https://semgrep.dev), and
+  [Flawfinder](https://dwheeler.com/flawfinder/) on every push and pull request and on a schedule; the findings are
+  reported to GitHub's code scanning.
 
 ## Dynamic analysis
 
@@ -204,6 +207,8 @@ Note: Some modern features (like C++20 ranges or filesystem support) may be disa
 - [x] The test suite is executed with [Valgrind](https://valgrind.org) (Memcheck) to detect memory leaks.
 - [x] The test suite is executed with [Sanitizers](https://github.com/google/sanitizers) (address sanitizer, undefined
   behavior sanitizer, integer overflow detection, nullability violations).
+- [x] The fuzz targets are run with [CIFuzz](https://google.github.io/oss-fuzz/getting-started/continuous-integration/)
+  on every pull request to catch regressions before they are merged.
 
 ## Dependencies
 
@@ -223,6 +228,8 @@ Note: Some modern features (like C++20 ranges or filesystem support) may be disa
   No release is made while such an alert is open.
 - [x] Third-party code included in the repository for testing, such as [doctest](https://github.com/doctest/doctest),
   is updated manually.
+- [x] The repository is evaluated with the [OpenSSF Scorecard](https://securityscorecards.dev) on a schedule and on
+  every push to the default branch, and the results are reported to GitHub's code scanning.
 
 ## Style check
 
@@ -258,4 +265,21 @@ Note: Some modern features (like C++20 ranges or filesystem support) may be disa
 - [x] The library is tested against relevant CMake versions:
   - CMake 3.5 (the earliest supported)
   - CMake 3.31.6 (the latest 3.x release)
-  - CMake 4.0.0 (a very recent release)
+  - CMake 4.0.0 (the first 4.x release)
+!!! success "Requirement: Other build systems"
+
+    The library can be used with build systems and package managers other than CMake.
+
+- [x] The library can be consumed with [Meson](https://json.nlohmann.me/integration/package_managers/) and the Swift
+  Package Manager; the installation with Meson and the resolution of `Package.swift` are tested in the CI.
+
+!!! success "Requirement: Reproducible and verifiable builds"
+
+    The library can be built and tested without network access or a Git checkout, and its licensing is machine-readable.
+
+- [x] The test suite is executed from an exported source tree without the `.git` directory and with the test data
+  being available offline.
+- [x] The test suite is executed without the tests that change installed files to check that builds are reproducible.
+- [x] The repository is checked for compliance with the [REUSE specification](https://reuse.software) so that the
+  license and copyright of every file is machine-readable.
+- [x] The documentation is built with warnings treated as errors, and its links are checked regularly.

docs/mkdocs/docs/examples/README.cpp

@@ -2,7 +2,7 @@
 #include <iomanip>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {

docs/mkdocs/docs/examples/accept__iterator_pair.cpp

@@ -2,7 +2,7 @@
 #include <vector>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {

docs/mkdocs/docs/examples/accept__string.cpp

@@ -2,19 +2,19 @@
 #include <iomanip>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {
     // a valid JSON text
-    auto valid_text = R"(
+    const auto* valid_text = R"(
     {
         "numbers": [1, 2, 3]
     }
     )";
 
     // an invalid JSON text
-    auto invalid_text = R"(
+    const auto* invalid_text = R"(
     {
         "strings": ["extra", "comma", ]
     }

docs/mkdocs/docs/examples/accept__wide_string.cpp

@@ -2,7 +2,7 @@
 #include <string>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {

docs/mkdocs/docs/examples/array.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {

docs/mkdocs/docs/examples/array_t.cpp

@@ -2,9 +2,9 @@
 #include <iomanip>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {
-    std::cout << std::boolalpha << std::is_same<std::vector<json>, json::array_t>::value << std::endl;
+    std::cout << std::boolalpha << std::is_same<std::vector<json>, json::array_t>::value << '\n';
 }

docs/mkdocs/docs/examples/at__json_pointer.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 using namespace nlohmann::literals;
 
 int main()

docs/mkdocs/docs/examples/at__json_pointer_const.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 using namespace nlohmann::literals;
 
 int main()

docs/mkdocs/docs/examples/at__keytype.c++17.cpp

@@ -3,7 +3,7 @@
 #include <nlohmann/json.hpp>
 
 using namespace std::string_view_literals;
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {

docs/mkdocs/docs/examples/at__keytype_const.c++17.cpp

@@ -3,7 +3,7 @@
 #include <nlohmann/json.hpp>
 
 using namespace std::string_view_literals;
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {

docs/mkdocs/docs/examples/at__object_t_key_type.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {

docs/mkdocs/docs/examples/at__object_t_key_type_const.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {

docs/mkdocs/docs/examples/at__size_type.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {

docs/mkdocs/docs/examples/at__size_type_const.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {

docs/mkdocs/docs/examples/back.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json__BasicJsonType.cpp

@@ -1,8 +1,8 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
-using ordered_json = nlohmann::ordered_json;
+using nlohmann::json;
+using nlohmann::ordered_json;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json__CompatibleType.cpp

@@ -8,7 +8,7 @@
 #include <valarray>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json__InputIt_InputIt.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json__basic_json.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json__copyassignment.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json__list_init_t.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json__moveconstructor.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json__nullptr_t.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json__size_type_basic_json.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json__value_t.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 
-using json = nlohmann::json;
+using nlohmann::json;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_document__accept.cpp

@@ -2,7 +2,7 @@
 #include <nlohmann/json.hpp>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_document__basic_json_document.cpp

@@ -2,7 +2,7 @@
 #include <utility>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_document__erase.cpp

@@ -1,9 +1,9 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json = nlohmann::json;
-using json_editable_document = nlohmann::json_editable_document;
-using json_editable_view = nlohmann::json_editable_view;
+using nlohmann::json;
+using nlohmann::json_editable_document;
+using nlohmann::json_editable_view;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_document__insert.cpp

@@ -1,9 +1,9 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json = nlohmann::json;
-using json_editable_document = nlohmann::json_editable_document;
-using json_editable_view = nlohmann::json_editable_view;
+using nlohmann::json;
+using nlohmann::json_editable_document;
+using nlohmann::json_editable_view;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_document__is_discarded.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_document__load.cpp

@@ -4,8 +4,8 @@
 #include <vector>
 #include <nlohmann/json_view.hpp>
 
-using json = nlohmann::json;
-using json_document = nlohmann::json_document;
+using nlohmann::json;
+using nlohmann::json_document;
 using image_check = json_document::image_check;
 
 int main()

docs/mkdocs/docs/examples/basic_json_document__memory_usage.cpp

@@ -2,7 +2,7 @@
 #include <string>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_document__node_count.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_document__owns_source.cpp

@@ -2,7 +2,7 @@
 #include <string>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_document__parse.cpp

@@ -3,7 +3,7 @@
 #include <nlohmann/json.hpp>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_document__parse_copy.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 json_document parse_from_temporary_buffer()
 {

docs/mkdocs/docs/examples/basic_json_document__parse_iterator_pair.cpp

@@ -2,7 +2,7 @@
 #include <vector>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_document__push_back.cpp

@@ -1,8 +1,8 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json = nlohmann::json;
-using json_editable_document = nlohmann::json_editable_document;
+using nlohmann::json;
+using nlohmann::json_editable_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_document__read.cpp

@@ -3,7 +3,7 @@
 #include <vector>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_document__root.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_document__save.cpp

@@ -4,7 +4,7 @@
 #include <vector>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_document__set.cpp

@@ -1,9 +1,9 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json = nlohmann::json;
-using json_editable_document = nlohmann::json_editable_document;
-using json_editable_view = nlohmann::json_editable_view;
+using nlohmann::json;
+using nlohmann::json_editable_document;
+using nlohmann::json_editable_view;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_document__shrink_to_fit.cpp

@@ -3,7 +3,7 @@
 #include <string>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_document__source.cpp

@@ -2,7 +2,7 @@
 #include <string>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_view__at.cpp

@@ -1,8 +1,8 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
-using json_view = nlohmann::json_view;
+using nlohmann::json_document;
+using nlohmann::json_view;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_view__at_json_pointer.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 using json_pointer = nlohmann::json::json_pointer;
 
 int main()

docs/mkdocs/docs/examples/basic_json_view__back.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_view__begin.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_view__cbegin.cpp

@@ -2,8 +2,8 @@
 #include <numeric>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
-using json_view = nlohmann::json_view;
+using nlohmann::json_document;
+using nlohmann::json_view;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_view__cend.cpp

@@ -2,8 +2,8 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
-using json_view = nlohmann::json_view;
+using nlohmann::json_document;
+using nlohmann::json_view;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_view__contains.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_view__contains_json_pointer.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 using json_pointer = nlohmann::json::json_pointer;
 
 int main()

docs/mkdocs/docs/examples/basic_json_view__count.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_view__dump.cpp

@@ -1,8 +1,8 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
-using json_view = nlohmann::json_view;
+using nlohmann::json_document;
+using nlohmann::json_view;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_view__end.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_view__find.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_view__front.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_view__get.cpp

@@ -3,8 +3,8 @@
 #include <string>
 #include <vector>
 
-using json_document = nlohmann::json_document;
-using json_view = nlohmann::json_view;
+using nlohmann::json_document;
+using nlohmann::json_view;
 
 // address has no direct conversion in get<T>(), so get<address>() falls back
 // to materialize().get<address>() -- a real nlohmann::json value is built

docs/mkdocs/docs/examples/basic_json_view__get_string.cpp

@@ -2,8 +2,8 @@
 #include <nlohmann/json_view.hpp>
 #include <string>
 
-using json_document = nlohmann::json_document;
-using json_view = nlohmann::json_view;
+using nlohmann::json_document;
+using nlohmann::json_view;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_view__get_to.cpp

@@ -2,8 +2,8 @@
 #include <nlohmann/json_view.hpp>
 #include <string>
 
-using json_document = nlohmann::json_document;
-using json_view = nlohmann::json_view;
+using nlohmann::json_document;
+using nlohmann::json_view;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_view__items.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {

docs/mkdocs/docs/examples/basic_json_view__materialize.cpp

@@ -2,7 +2,7 @@
 #include <iostream>
 #include <nlohmann/json_view.hpp>
 
-using json_document = nlohmann::json_document;
+using nlohmann::json_document;
 
 int main()
 {