Merge commit 'a28dbbf733e264fe214ac6167dd7c33d296e6474' into dev

external/json/docs/mkdocs/docs/api/basic_json/accept.md

@@ -29,9 +29,9 @@ Unlike the [`parse`](parse.md) function, this function neither throws an excepti
 :   A compatible input, for instance:
     
     - an `std::istream` object
-    - a `FILE` pointer (must not be null)
+    - a `FILE` pointer (throws if null)
     - a C-style array of characters
-    - a pointer to a null-terminated string of single byte characters
+    - a pointer to a null-terminated string of single byte characters (throws if null)
     - a `std::string`
     - an object `obj` for which `begin(obj)` and `end(obj)` produces a valid pair of iterators.
 
@@ -64,18 +64,17 @@ Whether the input is valid JSON.
 
 Strong guarantee: if an exception is thrown, there are no changes in the JSON value.
 
+## Exceptions
+
+Throws [`parse_error.101`](../../home/exceptions.md#jsonexceptionparse_error101) in case of an empty input like a null `FILE*` or `char*` pointer.
+
 ## Complexity
 
 Linear in the length of the input. The parser is a predictive LL(1) parser.
 
 ## Notes
 
-(1) A UTF-8 byte order mark is silently ignored.
-
-!!! danger "Runtime assertion"
-
-    The precondition that a passed `#!cpp FILE` pointer must not be null is enforced with a
-    [runtime assertion](../../features/assertions.md).
+A UTF-8 byte order mark is silently ignored.
 
 ## Examples
 
@@ -102,6 +101,7 @@ Linear in the length of the input. The parser is a predictive LL(1) parser.
 
 - Added in version 3.0.0.
 - Ignoring comments via `ignore_comments` added in version 3.9.0.
+- Changed [runtime assertion](../../features/assertions.md) in case of `FILE*` null pointers to exception in version 3.11.4.
 
 !!! warning "Deprecation"
 

external/json/docs/mkdocs/docs/api/basic_json/emplace.md

@@ -14,6 +14,11 @@ created from `args`.
 `Args`
 :   compatible types to create a `basic_json` object
 
+## Iterator invalidation
+
+For [`ordered_json`](../ordered_json.md), adding a value to an object can yield a reallocation, in which case all
+iterators (including the `end()` iterator) and all references to the elements are invalidated.
+
 ## Parameters
 
 `args` (in)

external/json/docs/mkdocs/docs/api/basic_json/emplace_back.md

@@ -13,6 +13,12 @@ Creates a JSON value from the passed parameters `args` to the end of the JSON va
 `Args`
 :   compatible types to create a `basic_json` object
 
+## Iterator invalidation
+
+By adding an element to the end of the array, a reallocation can happen, in which case all iterators (including the
+[`end()`](end.md) iterator) and all references to the elements are invalidated. Otherwise, only the [`end()`](end.md)
+iterator is invalidated.
+
 ## Parameters
 
 `args` (in)
@@ -48,6 +54,11 @@ Amortized constant.
     --8<-- "examples/emplace_back.output"
     ```
 
+## See also
+
+- [operator+=](operator+=.md) add a value to an array/object
+- [push_back](push_back.md) add a value to an array/object
+
 ## Version history
 
 - Since version 2.0.8.

external/json/docs/mkdocs/docs/api/basic_json/exception.md

@@ -8,24 +8,36 @@ This class is an extension of [`std::exception`](https://en.cppreference.com/w/c
 member `id` for exception ids. It is used as the base class for all exceptions thrown by the `basic_json` class. This
 class can hence be used as "wildcard" to catch exceptions, see example below.
 
-```plantuml
-std::exception <|-- basic_json::exception
-basic_json::exception <|-- basic_json::parse_error
-basic_json::exception <|-- basic_json::invalid_iterator
-basic_json::exception <|-- basic_json::type_error
-basic_json::exception <|-- basic_json::out_of_range
-basic_json::exception <|-- basic_json::other_error
+```mermaid
+classDiagram
+  direction LR
+  
+    class std_exception ["std::exception"] {
+        <<interface>>
+    }
 
-interface std::exception {}
+    class json_exception ["basic_json::exception"] {
+        +const int id
+        +const char* what() const
+    }
+    
+    class json_parse_error ["basic_json::parse_error"] {
+        +const std::size_t byte
+    }
 
-class basic_json::exception #FFFF00 {
-    + const int id
-    + const char* what() const
-}
+    class json_invalid_iterator ["basic_json::invalid_iterator"]
+    class json_type_error ["basic_json::type_error"]
+    class json_out_of_range ["basic_json::out_of_range"]
+    class json_other_error ["basic_json::other_error"]
 
-class basic_json::parse_error {
-    + const std::size_t byte
-}
+    std_exception <|-- json_exception
+    json_exception <|-- json_parse_error
+    json_exception <|-- json_invalid_iterator
+    json_exception <|-- json_type_error
+    json_exception <|-- json_out_of_range
+    json_exception <|-- json_other_error
+
+    style json_exception fill:#CCCCFF
 ```
 
 Subclasses:

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

@@ -35,7 +35,37 @@ Constant.
 
 !!! danger "Undefined behavior"
 
-    Writing data to the pointee of the result yields an undefined state.
+    The pointer becomes invalid if the underlying JSON object changes.
+
+    Consider the following example code where the pointer `ptr` changes after the array is resized. As a result,
+    reading or writing to `ptr` after the array change would be undefined behavior. The address of the first array
+    element changes, because the underlying `std::vector` is resized after adding a fifth element.
+
+    ```cpp
+    #include <iostream>
+    #include <nlohmann/json.hpp>
+    
+    using json = nlohmann::json;
+    
+    int main()
+    {
+        json j = {1, 2, 3, 4};
+        auto* ptr = j[0].get_ptr<std::int64_t*>();
+        std::cout << "value at " << ptr << " is " << *ptr << std::endl;
+    
+        j.push_back(5);
+    
+        ptr = j[0].get_ptr<std::int64_t*>();
+        std::cout << "value at " << ptr << " is " << *ptr << std::endl;
+    }
+    ```
+
+    Output:
+
+    ```
+    value at 0x6000012fc1c8 is 1
+    value at 0x6000029fc088 is 1
+    ```
 
 ## Examples
 
@@ -54,6 +84,10 @@ Constant.
     --8<-- "examples/get_ptr.output"
     ```
 
+## See also
+
+- [get_ref()](get_ref.md) get a reference value
+
 ## Version history
 
 - Added in version 1.0.0.

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

@@ -40,7 +40,7 @@ Constant.
 
 !!! danger "Undefined behavior"
 
-    Writing data to the referee of the result yields an undefined state.
+    The reference becomes invalid if the underlying JSON object changes.
 
 ## Examples
 
@@ -58,6 +58,10 @@ Constant.
     --8<-- "examples/get_ref.output"
     ```
 
+## See also
+
+- [get_ptr()](get_ptr.md) get a pointer value
+
 ## Version history
 
 - Added in version 1.1.0.

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

@@ -42,7 +42,15 @@ class basic_json;
 
 ## Iterator invalidation
 
-Todo
+All operations that add values to an **array** ([`push_back`](push_back.md) , [`operator+=`](operator+=.md),
+[`emplace_back`](emplace_back.md), [`insert`](insert.md), and [`operator[]`](operator%5B%5D.md) for a non-existing
+index) can yield a reallocation, in which case all iterators (including the [`end()`](end.md) iterator) and all
+references to the elements are invalidated.
+
+For [`ordered_json`](../ordered_json.md), also all operations that add a value to an **object**
+([`push_back`](push_back.md), [`operator+=`](operator+=.md), [`emplace`](emplace.md), [`insert`](insert.md),
+[`update`](update.md), and [`operator[]`](operator%5B%5D.md) for a non-existing key) can yield a reallocation, in
+which case all iterators (including the [`end()`](end.md) iterator) and all references to the elements are invalidated.
 
 ## Requirements
 

external/json/docs/mkdocs/docs/api/basic_json/insert.md

@@ -24,6 +24,17 @@ void insert(const_iterator first, const_iterator last);
 4. Inserts elements from initializer list `ilist` into array before iterator `pos`.
 5. Inserts elements from range `[first, last)` into object.
 
+## Iterator invalidation
+
+For all cases where an element is added to an **array**, a reallocation can happen, in which case all iterators
+(including the [`end()`](end.md) iterator) and all references to the elements are invalidated. Otherwise, only the
+[`end()`](end.md) iterator is invalidated. Also, any iterator or reference after the insertion point will point to the
+same index which is now a different value.
+
+For [`ordered_json`](../ordered_json.md), also adding an element to an **object** can yield a reallocation which again
+invalidates all iterators and all references. Also, any iterator or reference after the insertion point will point to
+the same index which is now a different value.
+
 ## Parameters
 
 `pos` (in)

external/json/docs/mkdocs/docs/api/basic_json/invalid_iterator.md

@@ -8,26 +8,36 @@ This exception is thrown if iterators passed to a library function do not match
 
 Exceptions have ids 2xx (see [list of iterator errors](../../home/exceptions.md#iterator-errors)).
 
-```plantuml
-std::exception <|-- basic_json::exception
-basic_json::exception <|-- basic_json::parse_error
-basic_json::exception <|-- basic_json::invalid_iterator
-basic_json::exception <|-- basic_json::type_error
-basic_json::exception <|-- basic_json::out_of_range
-basic_json::exception <|-- basic_json::other_error
+```mermaid
+classDiagram
+  direction LR
+  
+    class std_exception ["std::exception"] {
+        <<interface>>
+    }
 
-interface std::exception {}
+    class json_exception ["basic_json::exception"] {
+        +const int id
+        +const char* what() const
+    }
+    
+    class json_parse_error ["basic_json::parse_error"] {
+        +const std::size_t byte
+    }
 
-class basic_json::exception {
-    + const int id
-    + const char* what() const
-}
+    class json_invalid_iterator ["basic_json::invalid_iterator"]
+    class json_type_error ["basic_json::type_error"]
+    class json_out_of_range ["basic_json::out_of_range"]
+    class json_other_error ["basic_json::other_error"]
 
-class basic_json::parse_error {
-    + const std::size_t byte
-}
+    std_exception <|-- json_exception
+    json_exception <|-- json_parse_error
+    json_exception <|-- json_invalid_iterator
+    json_exception <|-- json_type_error
+    json_exception <|-- json_out_of_range
+    json_exception <|-- json_other_error
 
-class basic_json::invalid_iterator #FFFF00 {}
+    style json_invalid_iterator fill:#CCCCFF
 ```
 
 ## Member functions

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

@@ -21,7 +21,7 @@ Constant.
 ## Possible implementation
 
 ```cpp
-constexpr bool is_primitive() const noexcept
+constexpr bool is_structured() const noexcept
 {
     return is_array() || is_object();
 }

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

@@ -66,7 +66,7 @@ When iterating over an array, `key()` will return the index of the element as st
 !!! danger "Lifetime issues"
 
     Using `items()` on temporary objects is dangerous. Make sure the object's lifetime exceeds the iteration. See
-    <https://github.com/nlohmann/json/issues/2040> for more information.
+    [#2040](https://github.com/nlohmann/json/issues/2040) for more information.
 
 ## Examples
 

external/json/docs/mkdocs/docs/api/basic_json/operator+=.md

@@ -27,6 +27,15 @@ reference operator+=(initializer_list_t init);
     `init` is converted into an object element and added using `operator+=(const typename object_t::value_type&)`.
     Otherwise, `init` is converted to a JSON value and added using `operator+=(basic_json&&)`.
 
+## Iterator invalidation
+
+For all cases where an element is added to an **array**, a reallocation can happen, in which case all iterators (including
+the [`end()`](end.md) iterator) and all references to the elements are invalidated. Otherwise, only the
+[`end()`](end.md) iterator is invalidated.
+
+For [`ordered_json`](../ordered_json.md), also adding an element to an **object** can yield a reallocation which again
+invalidates all iterators and all references.
+
 ## Parameters
 
 `val` (in)
@@ -103,6 +112,11 @@ interpreted as `object_t::value_type` or `std::initializer_list<basic_json>`, se
     --8<-- "examples/push_back__initializer_list.output"
     ```
 
+## See also
+
+- [emplace_back](emplace_back.md) add a value to an array
+- [push_back](push_back.md) add a value to an array/object
+
 ## Version history
 
 1. Since version 1.0.0.

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

@@ -34,6 +34,15 @@ const_reference operator[](const json_pointer& ptr) const;
     [`string_t`](string_t.md) using  [`object_comparator_t`](object_comparator_t.md).
     This can also be a string view (C++17).
 
+## Iterator invalidation
+
+For the non-const versions 1. and 4., when passing an **array** index that does not exist, it is created and filled with
+a `#!json null` value before a reference to it is returned. For this, a reallocation can happen, in which case all
+iterators (including the [`end()`](end.md) iterator) and all references to the elements are invalidated.
+
+For [`ordered_json`](../ordered_json.md), also passing an **object key** to the non-const versions 2., 3., and 4., a
+reallocation can happen which again invalidates all iterators and all references.
+
 ## Parameters
 
 `idx` (in)

external/json/docs/mkdocs/docs/api/basic_json/operator_gt.md

@@ -17,7 +17,7 @@ bool operator>(ScalarType lhs, const const_reference rhs) noexcept;  // (2)
       operand is `NaN` and the other operand is either `NaN` or any other number.
     - Otherwise, returns the result of `#!cpp !(lhs <= rhs)` (see [**operator<=**](operator_le.md)).
 
-2. Compares wether a JSON value is greater than a scalar or a scalar is greater than a JSON value by
+2. Compares whether a JSON value is greater than a scalar or a scalar is greater than a JSON value by
    converting the scalar to a JSON value and comparing both JSON values according to 1.
 
 ## Template parameters

external/json/docs/mkdocs/docs/api/basic_json/operator_le.md

@@ -17,7 +17,7 @@ bool operator<=(ScalarType lhs, const const_reference rhs) noexcept;  // (2)
       operand is `NaN` and the other operand is either `NaN` or any other number.
     - Otherwise, returns the result of `#!cpp !(rhs < lhs)` (see [**operator<**](operator_lt.md)).
 
-1. Compares wether a JSON value is less than or equal to a scalar or a scalar is less than or equal
+1. Compares whether a JSON value is less than or equal to a scalar or a scalar is less than or equal
    to a JSON value by converting the scalar to a JSON value and comparing both JSON values according
    to 1.
 

external/json/docs/mkdocs/docs/api/basic_json/operator_lt.md

@@ -27,7 +27,7 @@ bool operator<(ScalarType lhs, const const_reference rhs) noexcept;  // (2)
         7. binary
       For instance, any boolean value is considered less than any string.
 
-2. Compares wether a JSON value is less than a scalar or a scalar is less than a JSON value by converting
+2. Compares whether a JSON value is less than a scalar or a scalar is less than a JSON value by converting
    the scalar to a JSON value and comparing both JSON values according to 1.
 
 ## Template parameters

external/json/docs/mkdocs/docs/api/basic_json/other_error.md

@@ -8,26 +8,36 @@ This exception is thrown in case of errors that cannot be classified with the ot
 
 Exceptions have ids 5xx (see [list of other errors](../../home/exceptions.md#further-exceptions)).
 
-```plantuml
-std::exception <|-- basic_json::exception
-basic_json::exception <|-- basic_json::parse_error
-basic_json::exception <|-- basic_json::invalid_iterator
-basic_json::exception <|-- basic_json::type_error
-basic_json::exception <|-- basic_json::out_of_range
-basic_json::exception <|-- basic_json::other_error
+```mermaid
+classDiagram
+  direction LR
+  
+    class std_exception ["std::exception"] {
+        <<interface>>
+    }
 
-interface std::exception {}
+    class json_exception ["basic_json::exception"] {
+        +const int id
+        +const char* what() const
+    }
+    
+    class json_parse_error ["basic_json::parse_error"] {
+        +const std::size_t byte
+    }
 
-class basic_json::exception {
-    + const int id
-    + const char* what() const
-}
+    class json_invalid_iterator ["basic_json::invalid_iterator"]
+    class json_type_error ["basic_json::type_error"]
+    class json_out_of_range ["basic_json::out_of_range"]
+    class json_other_error ["basic_json::other_error"]
 
-class basic_json::parse_error {
-    + const std::size_t byte
-}
+    std_exception <|-- json_exception
+    json_exception <|-- json_parse_error
+    json_exception <|-- json_invalid_iterator
+    json_exception <|-- json_type_error
+    json_exception <|-- json_out_of_range
+    json_exception <|-- json_other_error
 
-class basic_json::other_error #FFFF00 {}
+    style json_other_error fill:#CCCCFF
 ```
 
 ## Member functions

external/json/docs/mkdocs/docs/api/basic_json/out_of_range.md

@@ -9,26 +9,36 @@ instance in case of array indices or nonexisting object keys.
 
 Exceptions have ids 4xx (see [list of out-of-range errors](../../home/exceptions.md#out-of-range)).
 
-```plantuml
-std::exception <|-- basic_json::exception
-basic_json::exception <|-- basic_json::parse_error
-basic_json::exception <|-- basic_json::invalid_iterator
-basic_json::exception <|-- basic_json::type_error
-basic_json::exception <|-- basic_json::out_of_range
-basic_json::exception <|-- basic_json::other_error
+```mermaid
+classDiagram
+  direction LR
+  
+    class std_exception ["std::exception"] {
+        <<interface>>
+    }
 
-interface std::exception {}
+    class json_exception ["basic_json::exception"] {
+        +const int id
+        +const char* what() const
+    }
+    
+    class json_parse_error ["basic_json::parse_error"] {
+        +const std::size_t byte
+    }
 
-class basic_json::exception {
-    + const int id
-    + const char* what() const
-}
+    class json_invalid_iterator ["basic_json::invalid_iterator"]
+    class json_type_error ["basic_json::type_error"]
+    class json_out_of_range ["basic_json::out_of_range"]
+    class json_other_error ["basic_json::other_error"]
 
-class basic_json::parse_error {
-    + const std::size_t byte
-}
+    std_exception <|-- json_exception
+    json_exception <|-- json_parse_error
+    json_exception <|-- json_invalid_iterator
+    json_exception <|-- json_type_error
+    json_exception <|-- json_out_of_range
+    json_exception <|-- json_other_error
 
-class basic_json::out_of_range #FFFF00 {}
+    style json_out_of_range fill:#CCCCFF
 ```
 
 ## Member functions

external/json/docs/mkdocs/docs/api/basic_json/parse.md

@@ -28,9 +28,9 @@ static basic_json parse(IteratorType first, IteratorType last,
 :   A compatible input, for instance:
     
     - an `std::istream` object
-    - a `FILE` pointer (must not be null)
+    - a `FILE` pointer (throws if null)
     - a C-style array of characters
-    - a pointer to a null-terminated string of single byte characters
+    - a pointer to a null-terminated string of single byte characters (throws if null)
     - a `std::string`
     - an object `obj` for which `begin(obj)` and `end(obj)` produces a valid pair of iterators.
 
@@ -73,10 +73,11 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 
 ## Exceptions
 
-- Throws [`parse_error.101`](../../home/exceptions.md#jsonexceptionparse_error101) in case of an unexpected token.
-- Throws [`parse_error.102`](../../home/exceptions.md#jsonexceptionparse_error102) if to_unicode fails or surrogate
+- Throws [`parse_error.101`](../../home/exceptions.md#jsonexceptionparse_error101) in case of an unexpected token, or
+  empty input like a null `FILE*` or `char*` pointer.
+- Throws [`parse_error.102`](../../home/exceptions.md#jsonexceptionparse_error102) if `to_unicode` fails or surrogate
   error.
-- Throws [`parse_error.103`](../../home/exceptions.md#jsonexceptionparse_error103) if to_unicode fails.
+- Throws [`parse_error.103`](../../home/exceptions.md#jsonexceptionparse_error103) if `to_unicode` fails.
 
 ## Complexity
 
@@ -86,12 +87,7 @@ super-linear complexity.
 
 ## Notes
 
-(1) A UTF-8 byte order mark is silently ignored.
-
-!!! danger "Runtime assertion"
-
-    The precondition that a passed `#!cpp FILE` pointer must not be null is enforced with a
-    [runtime assertion](../../features/assertions.md).
+A UTF-8 byte order mark is silently ignored.
 
 ## Examples
 
@@ -203,6 +199,7 @@ super-linear complexity.
 - Added in version 1.0.0.
 - Overload for contiguous containers (1) added in version 2.0.3.
 - Ignoring comments via `ignore_comments` added in version 3.9.0.
+- Changed [runtime assertion](../../features/assertions.md) in case of `FILE*` null pointers to exception in version 3.11.4.
 
 !!! warning "Deprecation"
 

external/json/docs/mkdocs/docs/api/basic_json/parse_error.md

@@ -11,24 +11,36 @@ Member `byte` holds the byte index of the last read character in the input file
 
 Exceptions have ids 1xx (see [list of parse errors](../../home/exceptions.md#parse-errors)).
 
-```plantuml
-std::exception <|-- basic_json::exception
-basic_json::exception <|-- basic_json::parse_error
-basic_json::exception <|-- basic_json::invalid_iterator
-basic_json::exception <|-- basic_json::type_error
-basic_json::exception <|-- basic_json::out_of_range
-basic_json::exception <|-- basic_json::other_error
+```mermaid
+classDiagram
+  direction LR
+  
+    class std_exception ["std::exception"] {
+        <<interface>>
+    }
 
-interface std::exception {}
+    class json_exception ["basic_json::exception"] {
+        +const int id
+        +const char* what() const
+    }
+    
+    class json_parse_error ["basic_json::parse_error"] {
+        +const std::size_t byte
+    }
 
-class basic_json::exception {
-    + const int id
-    + const char* what() const
-}
+    class json_invalid_iterator ["basic_json::invalid_iterator"]
+    class json_type_error ["basic_json::type_error"]
+    class json_out_of_range ["basic_json::out_of_range"]
+    class json_other_error ["basic_json::other_error"]
 
-class basic_json::parse_error #FFFF00 {
-    + const std::size_t byte
-}
+    std_exception <|-- json_exception
+    json_exception <|-- json_parse_error
+    json_exception <|-- json_invalid_iterator
+    json_exception <|-- json_type_error
+    json_exception <|-- json_out_of_range
+    json_exception <|-- json_other_error
+
+    style json_parse_error fill:#CCCCFF
 ```
 
 ## Member functions

external/json/docs/mkdocs/docs/api/basic_json/push_back.md

@@ -27,6 +27,15 @@ void push_back(initializer_list_t init);
     `init` is converted into an object element and added using `push_back(const typename object_t::value_type&)`.
     Otherwise, `init` is converted to a JSON value and added using `push_back(basic_json&&)`.
 
+## Iterator invalidation
+
+For all cases where an element is added to an **array**, a reallocation can happen, in which case all iterators (including
+the [`end()`](end.md) iterator) and all references to the elements are invalidated. Otherwise, only the
+[`end()`](end.md) iterator is invalidated.
+
+For [`ordered_json`](../ordered_json.md), also adding an element to an **object** can yield a reallocation which again
+invalidates all iterators and all references.
+
 ## Parameters
 
 `val` (in)
@@ -99,6 +108,11 @@ All functions can throw the following exception:
     --8<-- "examples/push_back__initializer_list.output"
     ```
 
+## See also
+
+- [emplace_back](emplace_back.md) add a value to an array
+- [operator+=](operator+=.md) add a value to an array/object
+
 ## Version history
 
 1. Since version 1.0.0.

external/json/docs/mkdocs/docs/api/basic_json/type_error.md

@@ -9,26 +9,36 @@ does not match the expected semantics.
 
 Exceptions have ids 3xx (see [list of type errors](../../home/exceptions.md#type-errors)).
 
-```plantuml
-std::exception <|-- basic_json::exception
-basic_json::exception <|-- basic_json::parse_error
-basic_json::exception <|-- basic_json::invalid_iterator
-basic_json::exception <|-- basic_json::type_error
-basic_json::exception <|-- basic_json::out_of_range
-basic_json::exception <|-- basic_json::other_error
+```mermaid
+classDiagram
+  direction LR
+  
+    class std_exception ["std::exception"] {
+        <<interface>>
+    }
 
-interface std::exception {}
+    class json_exception ["basic_json::exception"] {
+        +const int id
+        +const char* what() const
+    }
+    
+    class json_parse_error ["basic_json::parse_error"] {
+        +const std::size_t byte
+    }
 
-class basic_json::exception {
-    + const int id
-    + const char* what() const
-}
+    class json_invalid_iterator ["basic_json::invalid_iterator"]
+    class json_type_error ["basic_json::type_error"]
+    class json_out_of_range ["basic_json::out_of_range"]
+    class json_other_error ["basic_json::other_error"]
 
-class basic_json::parse_error {
-    + const std::size_t byte
-}
+    std_exception <|-- json_exception
+    json_exception <|-- json_parse_error
+    json_exception <|-- json_invalid_iterator
+    json_exception <|-- json_type_error
+    json_exception <|-- json_out_of_range
+    json_exception <|-- json_other_error
 
-class basic_json::type_error #FFFF00 {}
+    style json_type_error fill:#CCCCFF
 ```
 
 ## Member functions

external/json/docs/mkdocs/docs/api/basic_json/update.md

@@ -17,6 +17,11 @@ recursively merges objects with common keys.
 The function is motivated by Python's [dict.update](https://docs.python.org/3.6/library/stdtypes.html#dict.update)
 function.
 
+## Iterator invalidation
+
+For [`ordered_json`](../ordered_json.md), adding a value to an object can yield a reallocation, in which case all
+iterators (including the `end()` iterator) and all references to the elements are invalidated.
+
 ## Parameters
 
 `j` (in)
@@ -139,4 +144,4 @@ function.
 ## Version history
 
 - Added in version 3.0.0.
-- Added `merge_objects` parameter in 3.10.4.
+- Added `merge_objects` parameter in 3.10.5.

external/json/docs/mkdocs/docs/api/macros/index.md

@@ -42,7 +42,6 @@ header. See also the [macro overview page](../../features/macros.md).
 - [**JSON_DISABLE_ENUM_SERIALIZATION**](json_disable_enum_serialization.md) - switch off default serialization/deserialization functions for enums
 - [**JSON_USE_IMPLICIT_CONVERSIONS**](json_use_implicit_conversions.md) - control implicit conversions
 
-<!-- comment-->
 ## Comparison behavior
 
 - [**JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON**](json_use_legacy_discarded_value_comparison.md) -
@@ -50,6 +49,20 @@ header. See also the [macro overview page](../../features/macros.md).
 
 ## Serialization/deserialization macros
 
+- Enum: [**NLOHMANN_JSON_SERIALIZE_ENUM**](nlohmann_json_serialize_enum.md)
+- Class/struct:
+    - Do you need to serialize private variables?
+        - Yes? Do you only need serialization?
+            - Yes? `NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE`
+            - No? Allow deserialization of JSON values with missing values?
+                - Yes? `NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT`
+                - No? `NLOHMANN_DEFINE_TYPE_INTRUSIVE`
+        - No? Do you only need serialization?
+            - Yes? `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE`
+            - No? Allow deserialization of JSON values with missing values?
+                - Yes? `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT`
+                - No? `NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE`
+
 - [**NLOHMANN_DEFINE_TYPE_INTRUSIVE(type, member...)**<br>**NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(type, member...)**
 <br>**NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(type, member...)**][DefInt]
   \- serialization/deserialization of types _with_ access to private variables

external/json/docs/mkdocs/docs/api/macros/json_diagnostic_positions.md

@@ -0,0 +1,61 @@
+# JSON_DIAGNOSTIC_POSITIONS
+
+```cpp
+#define JSON_DIAGNOSTIC_POSITIONS /* value */
+```
+
+This macro enables position diagnostics for generated JSON objects.
+
+When enabled, two new properties: `start_pos()` and `end_pos()` are added to `nlohmann::basic_json` objects and fields. `start_pos()` returns the start 
+position of that JSON object/field in the original string the object was parsed from. Likewise, `end_pos()` returns the end position of that JSON
+object/field in the original string the object was parsed from.
+
+`start_pos()` returns the first character of a given element in the original JSON string, while `end_pos()` returns the character following the last
+character. For objects and arrays, the first and last characters correspond to the opening or closing braces/brackets, respectively. For fields, the first
+and last character represent the opening and closing quotes or the first and last character of the field's numerical or predefined value
+(true/false/null), respectively.
+
+Given the above, `end_pos() - start_pos()` for an object or field provides the length of the string representation for that object or field, including the
+opening or closing braces, brackets, or quotes.
+
+`start_pos()` and `end_pos()` are only set if the JSON object was parsed using `parse()`. For all other cases, `std::string::npos` will be returned.
+
+Note that enabling this macro increases the size of every JSON value by two `std::size_t` fields and adds
+slight runtime overhead.
+
+## Default definition
+
+The default value is `0` (position diagnostics are switched off).
+
+```cpp
+#define JSON_DIAGNOSTIC_POSITIONS 0
+```
+
+When the macro is not defined, the library will define it to its default value.
+
+## Notes
+
+!!! hint "CMake option"
+
+    Diagnostic messages can also be controlled with the CMake option
+    [`JSON_Diagnostic_Positions`](../../integration/cmake.md#json_diagnostic_positions) (`OFF` by default)
+    which defines `JSON_DIAGNOSTIC_POSITIONS` accordingly.
+
+## Examples
+
+??? example "Example 1: retrieving positions"
+
+    ```cpp
+    --8<-- "examples/diagnostic_positions.cpp"
+    ```
+    
+    Output:
+
+    ```
+    --8<-- "examples/diagnostic_positions.output"
+    ```
+
+    The output shows the start/end positions of all the objects and fields in the JSON string.
+
+## Version history
+

external/json/docs/mkdocs/docs/api/macros/json_has_static_rtti.md

@@ -28,4 +28,4 @@ When the macro is not defined, the library will define it to its default value.
     
 ## Version history
 
-- Added in version ?.
+- Added in version 3.11.3.

external/json/docs/mkdocs/docs/api/macros/json_use_implicit_conversions.md

@@ -27,7 +27,7 @@ By default, implicit conversions are enabled.
 !!! hint "CMake option"
 
     Implicit conversions can also be controlled with the CMake option
-    [`JSON_ImplicitConversions`](../../integration/cmake.md#json_legacydiscardedvaluecomparison)
+    [`JSON_ImplicitConversions`](../../integration/cmake.md#json_implicitconversions)
     (`ON` by default) which defines `JSON_USE_IMPLICIT_CONVERSIONS` accordingly.
 
 ## Examples

external/json/docs/mkdocs/docs/api/macros/json_use_legacy_discarded_value_comparison.md

@@ -56,7 +56,7 @@ When the macro is not defined, the library will define it to its default value.
 !!! hint "CMake option"
 
     Legacy comparison can also be controlled with the CMake option
-    [`JSON_LegacyDiscardedValueComparison`](../../integration/cmake.md#json_legacydiscardedvaluecomparison)
+    [`JSON_LegacyDiscardedValueComparison`](../../integration/cmake.md#json_implicitconversions)
     (`OFF` by default) which defines `JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON` accordingly.
 
 ## Examples

external/json/docs/mkdocs/docs/api/macros/nlohmann_define_derived_type.md

@@ -0,0 +1,137 @@
+<h1>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</h1>
+
+```cpp
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(type, base_type, member...)                    // (1)
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(type, base_type, member...)       // (2)
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE(type, base_type, member...)     // (3)
+
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(type, base_type, member...)                // (4)
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(type, base_type, member...)   // (5)
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(type, base_type, member...) // (6)
+```
+
+These macros can be used to simplify the serialization/deserialization of derived types if you want to use a JSON
+object as serialization and want to use the member variable names as object keys in that object.
+
+- Macros 1, 2 and 3 are to be defined **inside** the class/struct to create code for.
+Like [`NLOHMANN_DEFINE_TYPE_INTRUSIVE`](nlohmann_define_type_intrusive.md), they can access private members.
+- Macros 4, 5 and 6 are to be defined **outside** the class/struct to create code for, but **inside** its namespace.
+Like [`NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE`](nlohmann_define_type_non_intrusive.md),
+they **cannot** access private members.
+
+The first  parameter is the name of the derived class/struct,
+the second parameter is the name of the base class/struct and all remaining parameters name the members.
+The base type **must** be already serializable/deserializable.
+
+- Macros 1 and 3 will use [`at`](../basic_json/at.md) during deserialization and will throw
+  [`out_of_range.403`](../../home/exceptions.md#jsonexceptionout_of_range403) if a key is missing in the JSON object.
+- Macros 2 and 4 will use [`value`](../basic_json/value.md) during deserialization and fall back to the default value for the
+   respective type of the member variable if a key in the JSON object is missing. The generated `from_json()` function
+   default constructs an object and uses its values as the defaults when calling the `value` function.
+
+## Parameters
+
+`type` (in)
+:   name of the type (class, struct) to serialize/deserialize
+
+`base_type` (in)
+:   name of the base type (class, struct) `type` is derived from
+
+`member` (in)
+:   name of the member variable to serialize/deserialize; up to 64 members can be given as comma-separated list
+
+## Default definition
+
+Macros 1 and 2 add two friend functions to the class which take care of the serialization and deserialization:
+
+```cpp
+friend void to_json(nlohmann::json&, const type&);
+friend void from_json(const nlohmann::json&, type&);
+```
+
+Macros 4 and 5 add two functions to the namespace which take care of the serialization and deserialization:
+
+```cpp
+void to_json(nlohmann::json&, const type&);
+void from_json(const nlohmann::json&, type&);
+```
+
+Macros 3 and 6 add one function to the namespace which take care of the serialization only:
+
+```cpp
+void to_json(nlohmann::json&, const type&);
+```
+
+In first two cases cases they call the `to_json`/`from_json` functions of the base type
+before serializing/deserializing the members of the derived type:
+
+```cpp
+class A { /* ... */ };
+class B : public A { /* ... */ };
+
+void to_json(nlohmann::json& j, const B& b) {
+    nlohmann::to_json(j, static_cast<const A&>(b));
+    // ...
+}
+
+void from_json(const nlohmann::json& j, B& b) {
+    nlohmann::from_json(j, static_cast<A&>(b));
+    // ...
+}
+```
+
+In the third case only `to_json` will be called:
+
+```cpp
+class A { /* ... */ };
+class B : public A { /* ... */ };
+
+void to_json(nlohmann::json& j, const B& b) {
+    nlohmann::to_json(j, static_cast<const A&>(b));
+    // ...
+}
+```
+
+## Notes
+
+!!! info "Prerequisites"
+
+    - Macros 1, 2 and 3 have the same prerequisites of NLOHMANN_DEFINE_TYPE_INTRUSIVE. 
+    - Macros 4, 5 and 6 have the same prerequisites of NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE.
+    - Serialization/deserialization of base types must be defined.
+
+!!! warning "Implementation limits"
+
+    - See Implementation limits for NLOHMANN_DEFINE_TYPE_INTRUSIVE and NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE.
+
+## Examples
+
+Example of `NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE` usage:
+
+```cpp
+class A {
+  double Aa;
+  double Ab;
+  NLOHMANN_DEFINE_TYPE_INTRUSIVE(A, Aa, Ab)
+};
+
+class B : public A {
+  int Ba;
+  int Bb;
+  NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(B, A, Ba, Bb)
+};
+```
+
+## See also
+
+- [NLOHMANN_DEFINE_TYPE_INTRUSIVE / NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT](nlohmann_define_type_intrusive.md)
+  for similar macros that can be defined _inside_ a non-derived type.
+- [NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE / NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT](nlohmann_define_type_non_intrusive.md)
+  for similar macros that can be defined _outside_ a non-derived type.
+- [Arbitrary Type Conversions](../../features/arbitrary_types.md) for an overview.
+
+## Version history
+
+1. Added in version 3.11.x.

external/json/docs/mkdocs/docs/api/operator_literal_json.md

@@ -17,7 +17,7 @@ using namespace nlohmann;
 ```
 
 This is suggested to ease migration to the next major version release of the library. See
-['JSON_USE_GLOBAL_UDLS`](macros/json_use_global_udls.md#notes) for details.
+[`JSON_USE_GLOBAL_UDLS`](macros/json_use_global_udls.md#notes) for details.
 
 ## Parameters
 

external/json/docs/mkdocs/docs/api/operator_literal_json_pointer.md

@@ -16,7 +16,7 @@ using namespace nlohmann::literals::json_literals;
 using namespace nlohmann;
 ```
 This is suggested to ease migration to the next major version release of the library. See
-['JSON_USE_GLOBAL_UDLS`](macros/json_use_global_udls.md#notes) for details.
+[`JSON_USE_GLOBAL_UDLS`](macros/json_use_global_udls.md#notes) for details.
 
 ## Parameters
 

external/json/docs/mkdocs/docs/api/ordered_json.md

@@ -6,6 +6,13 @@ using ordered_json = basic_json<ordered_map>;
 
 This type preserves the insertion order of object keys.
 
+## Iterator invalidation
+
+The type is based on [`ordered_map`](ordered_map.md) which in turn uses a `std::vector` to store object elements.
+Therefore, adding object elements can yield a reallocation in which case all iterators (including the
+[`end()`](basic_json/end.md) iterator) and all references to the elements are invalidated. Also, any iterator or
+reference after the insertion point will point to the same index which is now a different value.
+
 ## Examples
 
 ??? example

external/json/docs/mkdocs/docs/api/ordered_map.md

@@ -23,6 +23,11 @@ A minimal map-like container that preserves insertion order for use within [`nlo
 `Allocator`
 :   allocator type
 
+## Iterator invalidation
+
+The type uses a `std::vector` to store object elements. Therefore, adding elements can yield a reallocation in which
+case all iterators (including the `end()` iterator) and all references to the elements are invalidated.
+
 ## Member types
 
 - **key_type** - key type (`Key`)