deploy: 4e294f4b18

api/basic_json.md

@@ -85,7 +85,7 @@ The class satisfies the following concept requirements:
 - [EqualityComparable](https://en.cppreference.com/w/cpp/named_req/EqualityComparable): JSON values can be compared with
   `==`, see [`operator==`](operator_eq.md).
 - [LessThanComparable](https://en.cppreference.com/w/cpp/named_req/LessThanComparable): JSON values can be compared with
-  `<`, see [`operator<`](operator_le.md).
+  `<`, see [`operator<`](operator_lt.md).
 - [Swappable](https://en.cppreference.com/w/cpp/named_req/Swappable): Any JSON lvalue or rvalue of can be swapped with
   any lvalue or rvalue of other compatible types, using unqualified function `swap`.
 - [NullablePointer](https://en.cppreference.com/w/cpp/named_req/NullablePointer): JSON values can be compared against

api/basic_json/array_t.md

@@ -27,7 +27,7 @@ To store objects in C++, a type is defined by the template parameters explained
 
 ### Default type
 
-With the default values for `ArrayType` (`std::vector`) and `AllocatorType` (`std::allocator`), the default value for
+With the default values for `ArrayType` (`std::vector`) and `AllocatorType` (`std::allocator`), the default type for
 `array_t` is:
 
 ```cpp

api/basic_json/array_t/index.md

@@ -22,7 +22,7 @@ To store objects in C++, a type is defined by the template parameters explained
 
 ### Default type
 
-With the default values for `ArrayType` (`std::vector`) and `AllocatorType` (`std::allocator`), the default value for `array_t` is:
+With the default values for `ArrayType` (`std::vector`) and `AllocatorType` (`std::allocator`), the default type for `array_t` is:
 
 ```
 std::vector<

api/basic_json/boolean_t.md

@@ -23,7 +23,7 @@ To store boolean values in C++, a type is defined by the template parameter  `Bo
 
 ### Default type
 
-With the default values for `BooleanType` (`#!cpp bool`), the default value for `boolean_t` is `#!cpp bool`.
+With the default values for `BooleanType` (`#!cpp bool`), the default type for `boolean_t` is `#!cpp bool`.
 
 ### Storage
 

api/basic_json/boolean_t/index.md

@@ -18,7 +18,7 @@ To store boolean values in C++, a type is defined by the template parameter `Boo
 
 ### Default type
 
-With the default values for `BooleanType` (`bool`), the default value for `boolean_t` is `bool`.
+With the default values for `BooleanType` (`bool`), the default type for `boolean_t` is `bool`.
 
 ### Storage
 

api/basic_json/dump.md

@@ -62,6 +62,9 @@ Linear.
 
 ## Notes
 
+Floating-point numbers are written with the fewest digits that read back as the same value (for `#!cpp double`; see
+[number handling](../../features/types/number_handling.md#number-serialization)).
+
 Binary values are serialized as an object containing two keys:
 
 - "bytes": an array of bytes as integers
@@ -200,3 +203,5 @@ Binary values are serialized as an object containing two keys:
 - Error handlers added in version 3.4.0.
 - Serialization of binary values added in version 3.8.0.
 - Error handler `keep` added in version 3.13.0.
+- Doubles are written with the shortest digits (Żmij instead of Grisu2) since version 3.13.0; about 0.1% of doubles are
+  written differently, most of them with fewer digits.

api/basic_json/dump/index.md

@@ -43,6 +43,8 @@ Linear.
 
 ## Notes
 
+Floating-point numbers are written with the fewest digits that read back as the same value (for `double`; see [number handling](https://json.nlohmann.me/features/types/number_handling/#number-serialization)).
+
 Binary values are serialized as an object containing two keys:
 
 - "bytes": an array of bytes as integers
@@ -178,3 +180,4 @@ string with ignored invalid characters: "äü"
 - Error handlers added in version 3.4.0.
 - Serialization of binary values added in version 3.8.0.
 - Error handler `keep` added in version 3.13.0 unreleased.
+- Doubles are written with the shortest digits (Żmij instead of Grisu2) since version 3.13.0 unreleased; about 0.1% of doubles are written differently, most of them with fewer digits.

api/basic_json/index.md

@@ -68,7 +68,7 @@ The class satisfies the following concept requirements:
 ### Library-wide
 
 - [EqualityComparable](https://en.cppreference.com/w/cpp/named_req/EqualityComparable): JSON values can be compared with `==`, see [`operator==`](https://json.nlohmann.me/api/basic_json/operator_eq/index.md).
-- [LessThanComparable](https://en.cppreference.com/w/cpp/named_req/LessThanComparable): JSON values can be compared with `<`, see [`operator<`](https://json.nlohmann.me/api/basic_json/operator_le/index.md).
+- [LessThanComparable](https://en.cppreference.com/w/cpp/named_req/LessThanComparable): JSON values can be compared with `<`, see [`operator<`](https://json.nlohmann.me/api/basic_json/operator_lt/index.md).
 - [Swappable](https://en.cppreference.com/w/cpp/named_req/Swappable): Any JSON lvalue or rvalue of can be swapped with any lvalue or rvalue of other compatible types, using unqualified function `swap`.
 - [NullablePointer](https://en.cppreference.com/w/cpp/named_req/NullablePointer): JSON values can be compared against `std::nullptr_t` objects which are used to model the `null` value.
 

api/basic_json/merge_diff.md

@@ -11,7 +11,7 @@ added members with their new values, and removed members with the value `#!json
 member by member; any other value that differs, including an array, is replaced as a whole.
 
 For two JSON values `source` and `target`, where `target` contains no object member whose value is `#!json null`, the
-following code always yields `#!cpp true`:
+following code always yields `#!cpp true` (for [`ordered_json`](../ordered_json.md), see the notes below):
 ```cpp
 basic_json patched = source;
 patched.merge_patch(merge_diff(source, target));

api/basic_json/merge_diff/index.md

@@ -7,7 +7,7 @@ static basic_json merge_diff(const basic_json& source,
 
 Creates a [JSON Merge Patch](https://tools.ietf.org/html/rfc7396) so that value `source` can be changed into the value `target` by calling the [`merge_patch`](https://json.nlohmann.me/api/basic_json/merge_patch/index.md) function. The patch contains only what differs: changed and added members with their new values, and removed members with the value `null`. Nested objects are compared member by member; any other value that differs, including an array, is replaced as a whole.
 
-For two JSON values `source` and `target`, where `target` contains no object member whose value is `null`, the following code always yields `true`:
+For two JSON values `source` and `target`, where `target` contains no object member whose value is `null`, the following code always yields `true` (for [`ordered_json`](https://json.nlohmann.me/api/ordered_json/index.md), see the notes below):
 
 ```
 basic_json patched = source;

api/basic_json/number_float_t.md

@@ -23,9 +23,10 @@ type to use.
 ## Template parameters
 
 `NumberFloatType`
-:   the type to store floating-point numbers. Parsing and serialization are implemented in terms of
-    `#!cpp std::strtof`/`#!cpp std::strtod`/`#!cpp std::strtold` and `#!cpp std::snprintf`, so the type must be
-    `#!cpp float`, `#!cpp double`, or `#!cpp long double`. The
+:   the type to store floating-point numbers. The type must be `#!cpp float`, `#!cpp double`, or
+    `#!cpp long double`. The parser converts `#!cpp float`, `#!cpp double`, and a `#!cpp long double` that is IEEE 754
+    binary64 itself. It converts other `#!cpp long double` formats with `#!cpp std::from_chars` where available, or
+    with `#!cpp std::strtold` otherwise. Serialization falls back to `#!cpp std::snprintf`. The
     [binary formats](../../features/binary_formats/index.md) additionally require `#!cpp float` or `#!cpp double`,
     because they have no encoding for `#!cpp long double`. See
     [Template Parameter Requirements](../../features/types/template_parameters.md#numberfloattype).
@@ -34,7 +35,7 @@ type to use.
 
 ### Default type
 
-With the default values for `NumberFloatType` (`double`), the default value for `number_float_t` is `#!cpp double`.
+With the default values for `NumberFloatType` (`double`), the default type for `number_float_t` is `#!cpp double`.
 
 ### Default behavior
 
@@ -51,9 +52,11 @@ With the default values for `NumberFloatType` (`double`), the default value for
 > interoperability can be achieved by implementations that expect no more precision or range than these provide, in the
 > sense that implementations will approximate JSON numbers within the expected precision.
 
-This implementation does exactly follow this approach, as it uses double precision floating-point numbers. Note values
-smaller than `-1.79769313486232e+308` and values greater than `1.79769313486232e+308` will be stored as NaN internally
-and be serialized to `null`.
+This implementation does exactly follow this approach, as it uses double precision floating-point numbers by default.
+Note that with the default `double`, numbers smaller than `-1.79769313486232e+308` or greater than
+`1.79769313486232e+308` are rejected during parsing with
+[`out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406). Non-finite values (NaN and infinity) can
+only be stored by assigning them directly and are serialized to `null`.
 
 During deserialization (from JSON text or any of the binary formats), a finite number that does not fit into
 `number_float_t` is rejected with [`out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406), for

api/basic_json/number_float_t/index.md

@@ -16,13 +16,13 @@ To store floating-point numbers in C++, a type is defined by the template parame
 
 ## Template parameters
 
-`NumberFloatType` : the type to store floating-point numbers. Parsing and serialization are implemented in terms of `std::strtof`/`std::strtod`/`std::strtold` and `std::snprintf`, so the type must be `float`, `double`, or `long double`. The [binary formats](https://json.nlohmann.me/features/binary_formats/index.md) additionally require `float` or `double`, because they have no encoding for `long double`. See [Template Parameter Requirements](https://json.nlohmann.me/features/types/template_parameters/#numberfloattype).
+`NumberFloatType` : the type to store floating-point numbers. The type must be `float`, `double`, or `long double`. The parser converts `float`, `double`, and a `long double` that is IEEE 754 binary64 itself. It converts other `long double` formats with `std::from_chars` where available, or with `std::strtold` otherwise. Serialization falls back to `std::snprintf`. The [binary formats](https://json.nlohmann.me/features/binary_formats/index.md) additionally require `float` or `double`, because they have no encoding for `long double`. See [Template Parameter Requirements](https://json.nlohmann.me/features/types/template_parameters/#numberfloattype).
 
 ## Notes
 
 ### Default type
 
-With the default values for `NumberFloatType` (`double`), the default value for `number_float_t` is `double`.
+With the default values for `NumberFloatType` (`double`), the default type for `number_float_t` is `double`.
 
 ### Default behavior
 
@@ -35,7 +35,7 @@ With the default values for `NumberFloatType` (`double`), the default value for
 
 > This specification allows implementations to set limits on the range and precision of numbers accepted. Since software that implements IEEE 754-2008 binary64 (double precision) numbers is generally available and widely used, good interoperability can be achieved by implementations that expect no more precision or range than these provide, in the sense that implementations will approximate JSON numbers within the expected precision.
 
-This implementation does exactly follow this approach, as it uses double precision floating-point numbers. Note values smaller than `-1.79769313486232e+308` and values greater than `1.79769313486232e+308` will be stored as NaN internally and be serialized to `null`.
+This implementation does exactly follow this approach, as it uses double precision floating-point numbers by default. Note that with the default `double`, numbers smaller than `-1.79769313486232e+308` or greater than `1.79769313486232e+308` are rejected during parsing with [`out_of_range.406`](https://json.nlohmann.me/home/exceptions/#jsonexceptionout_of_range406). Non-finite values (NaN and infinity) can only be stored by assigning them directly and are serialized to `null`.
 
 During deserialization (from JSON text or any of the binary formats), a finite number that does not fit into `number_float_t` is rejected with [`out_of_range.406`](https://json.nlohmann.me/home/exceptions/#jsonexceptionout_of_range406), for example a double-precision number in a binary format when `number_float_t` is `float`.
 

api/basic_json/number_integer_t.md

@@ -31,7 +31,7 @@ to use.
 
 ### Default type
 
-With the default values for `NumberIntegerType` (`std::int64_t`), the default value for `number_integer_t` is
+With the default values for `NumberIntegerType` (`std::int64_t`), the default type for `number_integer_t` is
 `#!cpp std::int64_t`.
 
 ### Default behavior

api/basic_json/number_integer_t/index.md

@@ -22,7 +22,7 @@ To store integer numbers in C++, a type is defined by the template parameter `Nu
 
 ### Default type
 
-With the default values for `NumberIntegerType` (`std::int64_t`), the default value for `number_integer_t` is `std::int64_t`.
+With the default values for `NumberIntegerType` (`std::int64_t`), the default type for `number_integer_t` is `std::int64_t`.
 
 ### Default behavior
 

api/basic_json/number_unsigned_t.md

@@ -32,7 +32,7 @@ the type to use.
 
 ### Default type
 
-With the default values for `NumberUnsignedType` (`std::uint64_t`), the default value for `number_unsigned_t` is
+With the default values for `NumberUnsignedType` (`std::uint64_t`), the default type for `number_unsigned_t` is
 `#!cpp std::uint64_t`.
 
 ### Default behavior

api/basic_json/number_unsigned_t/index.md

@@ -22,7 +22,7 @@ To store unsigned integer numbers in C++, a type is defined by the template para
 
 ### Default type
 
-With the default values for `NumberUnsignedType` (`std::uint64_t`), the default value for `number_unsigned_t` is `std::uint64_t`.
+With the default values for `NumberUnsignedType` (`std::uint64_t`), the default type for `number_unsigned_t` is `std::uint64_t`.
 
 ### Default behavior
 

api/basic_json/object_t.md

@@ -36,7 +36,7 @@ To store objects in C++, a type is defined by the template parameters described
 ### Default type
 
 With the default values for `ObjectType` (`std::map`), `StringType` (`std::string`), and `AllocatorType`
-(`std::allocator`), the default value for `object_t` is:
+(`std::allocator`), the default type for `object_t` is:
 
 ```cpp
 // until C++14

api/basic_json/object_t/index.md

@@ -27,7 +27,7 @@ To store objects in C++, a type is defined by the template parameters described
 
 ### Default type
 
-With the default values for `ObjectType` (`std::map`), `StringType` (`std::string`), and `AllocatorType` (`std::allocator`), the default value for `object_t` is:
+With the default values for `ObjectType` (`std::map`), `StringType` (`std::string`), and `AllocatorType` (`std::allocator`), the default type for `object_t` is:
 
 ```
 // until C++14

api/basic_json/operator_eq.md

@@ -20,7 +20,8 @@ bool operator==(ScalarType rhs) const noexcept(/* see below */); // (2)
 1. Compares two JSON values for equality according to the following rules:
     - Two JSON values are equal if (1) neither value is discarded, and (2) they are of the same type and their stored
       values are the same according to their respective `operator==`.
-    - Integer and floating-point numbers are automatically converted before comparison.
+    - Integer and floating-point numbers are compared by their exact values, without converting the integer to
+      floating-point. For instance, `9007199254740993` and `9007199254740992.0` are not equal.
 
 2. Compares a JSON value and a scalar or a scalar and a JSON value for equality by converting the
    scalar to a JSON value and comparing both JSON values according to 1.

api/basic_json/operator_eq/index.md

@@ -20,7 +20,7 @@ bool operator==(ScalarType rhs) const noexcept(/* see below */); // (2)
 1. Compares two JSON values for equality according to the following rules:
 
    - Two JSON values are equal if (1) neither value is discarded, and (2) they are of the same type and their stored values are the same according to their respective `operator==`.
-   - Integer and floating-point numbers are automatically converted before comparison.
+   - Integer and floating-point numbers are compared by their exact values, without converting the integer to floating-point. For instance, `9007199254740993` and `9007199254740992.0` are not equal.
 
 1. Compares a JSON value and a scalar or a scalar and a JSON value for equality by converting the scalar to a JSON value and comparing both JSON values according to 1.
 

api/basic_json/operator_lt.md

@@ -15,7 +15,8 @@ bool operator<(ScalarType lhs, const const_reference rhs) noexcept(/* see below
   following rules:
     - If either operand is discarded, the comparison yields `#!cpp false`.
     - If both operands have the same type, the values are compared using their respective `operator<`.
-    - Integer and floating-point numbers are automatically converted before comparison.
+    - Integer and floating-point numbers are compared by their exact values, without converting the integer to
+      floating-point. For instance, `9007199254740992.0` is less than `9007199254740993`.
     - In case `lhs` and `rhs` have different types, the values are ignored and the order of the types
       is considered, which is:
         1. null

api/basic_json/operator_lt/index.md

@@ -15,7 +15,7 @@ bool operator<(ScalarType lhs, const const_reference rhs) noexcept(/* see below
 
    - If either operand is discarded, the comparison yields `false`.
    - If both operands have the same type, the values are compared using their respective `operator<`.
-   - Integer and floating-point numbers are automatically converted before comparison.
+   - Integer and floating-point numbers are compared by their exact values, without converting the integer to floating-point. For instance, `9007199254740992.0` is less than `9007199254740993`.
    - In case `lhs` and `rhs` have different types, the values are ignored and the order of the types is considered, which is:
      1. null
      1. boolean

api/basic_json/operator_spaceship.md

@@ -12,10 +12,8 @@ std::partial_ordering operator<=>(const ScalarType rhs) const noexcept(/* see be
     - Two JSON values compare with a result of `std::partial_ordering::unordered` if either value is discarded.
     - If both JSON values are of the same type, the result is produced by 3-way comparing their stored values using
       their respective `operator<=>`.
-    - Integer and floating-point numbers are converted to their common type and then 3-way compared using their
-      respective `operator<=>`.
-      For instance, comparing an integer and a floating-point value will 3-way compare the first value converted to
-      floating-point with the second value.
+    - Integer and floating-point numbers are 3-way compared by their exact values, without converting the integer to
+      floating-point. For instance, `9007199254740993` compares greater than `9007199254740992.0`.
     - Otherwise, yields a result by comparing the type (see [`value_t`](value_t.md)).
   
 2. 3-way compares a JSON value and a scalar or a scalar and a JSON value by converting the scalar to a JSON value and

api/basic_json/operator_spaceship/index.md

@@ -12,7 +12,7 @@ std::partial_ordering operator<=>(const ScalarType rhs) const noexcept(/* see be
 
    - Two JSON values compare with a result of `std::partial_ordering::unordered` if either value is discarded.
    - If both JSON values are of the same type, the result is produced by 3-way comparing their stored values using their respective `operator<=>`.
-   - Integer and floating-point numbers are converted to their common type and then 3-way compared using their respective `operator<=>`. For instance, comparing an integer and a floating-point value will 3-way compare the first value converted to floating-point with the second value.
+   - Integer and floating-point numbers are 3-way compared by their exact values, without converting the integer to floating-point. For instance, `9007199254740993` compares greater than `9007199254740992.0`.
    - Otherwise, yields a result by comparing the type (see [`value_t`](https://json.nlohmann.me/api/basic_json/value_t/index.md)).
 
 1. 3-way compares a JSON value and a scalar or a scalar and a JSON value by converting the scalar to a JSON value and 3-way comparing both JSON values (see 1).

api/basic_json/patch.md

@@ -45,7 +45,7 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
   pointer inside the patch cannot be resolved, e.g., `-` in a "remove" operation or `1a` for an array; example:
   `"unresolved reference token '-'"`.
 - Throws [`out_of_range.405`](../../home/exceptions.md#jsonexceptionout_of_range405) if JSON pointer has no parent
-  ("add", "remove", "move")
+  ("remove", "move")
 - Throws [`out_of_range.411`](../../home/exceptions.md#jsonexceptionout_of_range411) if an "add" operation's target
   location has a parent that is neither an object nor an array.
 - Throws [`out_of_range.413`](../../home/exceptions.md#jsonexceptionout_of_range413) if a "remove" operation's target

api/basic_json/patch/index.md

@@ -30,7 +30,7 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [`out_of_range.402`](https://json.nlohmann.me/home/exceptions/#jsonexceptionout_of_range402) if the array index `-` is used 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`](https://json.nlohmann.me/home/exceptions/#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"`.
 - Throws [`out_of_range.404`](https://json.nlohmann.me/home/exceptions/#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 '-'"`.
-- Throws [`out_of_range.405`](https://json.nlohmann.me/home/exceptions/#jsonexceptionout_of_range405) if JSON pointer has no parent ("add", "remove", "move")
+- Throws [`out_of_range.405`](https://json.nlohmann.me/home/exceptions/#jsonexceptionout_of_range405) if JSON pointer has no parent ("remove", "move")
 - Throws [`out_of_range.411`](https://json.nlohmann.me/home/exceptions/#jsonexceptionout_of_range411) if an "add" operation's target location has a parent that is neither an object nor an array.
 - Throws [`out_of_range.413`](https://json.nlohmann.me/home/exceptions/#jsonexceptionout_of_range413) if a "remove" operation's target location has a parent that is neither an object nor an array.
 - Throws [`out_of_range.414`](https://json.nlohmann.me/home/exceptions/#jsonexceptionout_of_range414) if a "move" operation's "from" location is a proper prefix of its "path" location.

api/basic_json/patch_inplace.md

@@ -41,7 +41,7 @@ No guarantees, value may be corrupted by an unsuccessful patch operation.
   pointer inside the patch cannot be resolved, e.g., `-` in a "remove" operation or `1a` for an array; example:
   `"unresolved reference token '-'"`.
 - Throws [`out_of_range.405`](../../home/exceptions.md#jsonexceptionout_of_range405) if JSON pointer has no parent
-  ("add", "remove", "move")
+  ("remove", "move")
 - Throws [`out_of_range.411`](../../home/exceptions.md#jsonexceptionout_of_range411) if an "add" operation's target
   location has a parent that is neither an object nor an array.
 - Throws [`out_of_range.413`](../../home/exceptions.md#jsonexceptionout_of_range413) if a "remove" operation's target

api/basic_json/patch_inplace/index.md

@@ -26,7 +26,7 @@ No guarantees, value may be corrupted by an unsuccessful patch operation.
 - Throws [`out_of_range.402`](https://json.nlohmann.me/home/exceptions/#jsonexceptionout_of_range402) if the array index `-` is used 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`](https://json.nlohmann.me/home/exceptions/#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"`.
 - Throws [`out_of_range.404`](https://json.nlohmann.me/home/exceptions/#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 '-'"`.
-- Throws [`out_of_range.405`](https://json.nlohmann.me/home/exceptions/#jsonexceptionout_of_range405) if JSON pointer has no parent ("add", "remove", "move")
+- Throws [`out_of_range.405`](https://json.nlohmann.me/home/exceptions/#jsonexceptionout_of_range405) if JSON pointer has no parent ("remove", "move")
 - Throws [`out_of_range.411`](https://json.nlohmann.me/home/exceptions/#jsonexceptionout_of_range411) if an "add" operation's target location has a parent that is neither an object nor an array.
 - Throws [`out_of_range.413`](https://json.nlohmann.me/home/exceptions/#jsonexceptionout_of_range413) if a "remove" operation's target location has a parent that is neither an object nor an array.
 - Throws [`out_of_range.414`](https://json.nlohmann.me/home/exceptions/#jsonexceptionout_of_range414) if a "move" operation's "from" location is a proper prefix of its "path" location.

api/basic_json/string_t.md

@@ -32,7 +32,7 @@ JSON class into byte-sized characters during deserialization.
 
 ### Default type
 
-With the default values for `StringType` (`std::string`), the default value for `string_t` is `#!cpp std::string`.
+With the default values for `StringType` (`std::string`), the default type for `string_t` is `#!cpp std::string`.
 
 ### Encoding
 

api/basic_json/string_t/index.md

@@ -32,7 +32,7 @@ for the string types that are known to work.
 
 ### Default type
 
-With the default values for `StringType` (`std::string`), the default value for `string_t` is `std::string`.
+With the default values for `StringType` (`std::string`), the default type for `string_t` is `std::string`.
 
 ### Encoding
 

api/macros/json_use_legacy_discarded_value_comparison.md

@@ -18,7 +18,8 @@ When enabled, comparisons involving at least one discarded JSON value yield resu
 | `>=`         | `#!cpp true`  |
 | `>`          | `#!cpp false` |
 
-Otherwise, comparisons involving at least one discarded JSON value always yield `#!cpp false`.
+Otherwise, comparisons involving at least one discarded JSON value yield `#!cpp false`, except for `!=`, which is the
+negation of `==` and yields `#!cpp true`.
 
 ## Default definition
 

api/macros/json_use_legacy_discarded_value_comparison/index.md

@@ -17,7 +17,7 @@ When enabled, comparisons involving at least one discarded JSON value yield resu
 | `>=`         | `true`     |
 | `>`          | `false`    |
 
-Otherwise, comparisons involving at least one discarded JSON value always yield `false`.
+Otherwise, comparisons involving at least one discarded JSON value yield `false`, except for `!=`, which is the negation of `==` and yields `true`.
 
 ## Default definition
 

assets/external/img.shields.io/badge/dynamic/json.451e3950.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="110" height="20" role="img" aria-label="msys2: v3.12.0-1"><title>msys2: v3.12.0-1</title><filter id="blur"><feGaussianBlur stdDeviation="16"/></filter><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="110" height="20" rx="3"/></clipPath><g clip-path="url(#r)"><rect width="45" height="20" fill="#555"/><rect x="45" width="65" height="20" fill="#007ec6"/><rect width="110" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="235" y="150" fill-opacity=".8" filter="url(#blur)" textLength="350">msys2</text><text x="235" y="150" fill-opacity=".3" textLength="350">msys2</text></g><text x="235" y="140" textLength="350">msys2</text></g><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="765" y="150" fill-opacity=".8" filter="url(#blur)" textLength="550">v3.12.0-1</text><text x="765" y="150" fill-opacity=".3" textLength="550">v3.12.0-1</text></g><text x="765" y="140" textLength="550">v3.12.0-1</text></g></g></svg>

assets/external/img.shields.io/cocoapods/v/nlohmann_json.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="76" height="20" role="img" aria-label="pod: v3.7.3"><title>pod: v3.7.3</title><filter id="blur"><feGaussianBlur stdDeviation="16"/></filter><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="76" height="20" rx="3"/></clipPath><g clip-path="url(#r)"><rect width="31" height="20" fill="#555"/><rect x="31" width="45" height="20" fill="#007ec6"/><rect width="76" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="165" y="150" fill-opacity=".8" filter="url(#blur)" textLength="210">pod</text><text x="165" y="150" fill-opacity=".3" textLength="210">pod</text></g><text x="165" y="140" textLength="210">pod</text></g><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="525" y="150" fill-opacity=".8" filter="url(#blur)" textLength="350">v3.7.3</text><text x="525" y="150" fill-opacity=".3" textLength="350">v3.7.3</text></g><text x="525" y="140" textLength="350">v3.7.3</text></g></g></svg>

assets/external/img.shields.io/conan/v/nlohmann_json.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="96" height="20" role="img" aria-label="conan: v3.12.0"><title>conan: v3.12.0</title><filter id="blur"><feGaussianBlur stdDeviation="16"/></filter><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="96" height="20" rx="3"/></clipPath><g clip-path="url(#r)"><rect width="43" height="20" fill="#555"/><rect x="43" width="53" height="20" fill="#007ec6"/><rect width="96" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="225" y="150" fill-opacity=".8" filter="url(#blur)" textLength="330">conan</text><text x="225" y="150" fill-opacity=".3" textLength="330">conan</text></g><text x="225" y="140" textLength="330">conan</text></g><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="685" y="150" fill-opacity=".8" filter="url(#blur)" textLength="430">v3.12.0</text><text x="685" y="150" fill-opacity=".3" textLength="430">v3.12.0</text></g><text x="685" y="140" textLength="430">v3.12.0</text></g></g></svg>

assets/external/img.shields.io/conda/v/conda-forge/nlohmann_json.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="176" height="20" role="img" aria-label="conda | conda-forge: v3.12.0"><title>conda | conda-forge: v3.12.0</title><filter id="blur"><feGaussianBlur stdDeviation="16"/></filter><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="176" height="20" rx="3"/></clipPath><g clip-path="url(#r)"><rect width="123" height="20" fill="#555"/><rect x="123" width="53" height="20" fill="#007ec6"/><rect width="176" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="625" y="150" fill-opacity=".8" filter="url(#blur)" textLength="1130">conda | conda-forge</text><text x="625" y="150" fill-opacity=".3" textLength="1130">conda | conda-forge</text></g><text x="625" y="140" textLength="1130">conda | conda-forge</text></g><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="1485" y="150" fill-opacity=".8" filter="url(#blur)" textLength="430">v3.12.0</text><text x="1485" y="150" fill-opacity=".3" textLength="430">v3.12.0</text></g><text x="1485" y="140" textLength="430">v3.12.0</text></g></g></svg>

assets/external/img.shields.io/homebrew/v/nlohmann-json.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="120" height="20" role="img" aria-label="homebrew: v3.12.0"><title>homebrew: v3.12.0</title><filter id="blur"><feGaussianBlur stdDeviation="16"/></filter><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="120" height="20" rx="3"/></clipPath><g clip-path="url(#r)"><rect width="67" height="20" fill="#555"/><rect x="67" width="53" height="20" fill="#007ec6"/><rect width="120" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="345" y="150" fill-opacity=".8" filter="url(#blur)" textLength="570">homebrew</text><text x="345" y="150" fill-opacity=".3" textLength="570">homebrew</text></g><text x="345" y="140" textLength="570">homebrew</text></g><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="925" y="150" fill-opacity=".8" filter="url(#blur)" textLength="430">v3.12.0</text><text x="925" y="150" fill-opacity=".3" textLength="430">v3.12.0</text></g><text x="925" y="140" textLength="430">v3.12.0</text></g></g></svg>

assets/external/img.shields.io/macports/v/nlohmann-json.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="114" height="20" role="img" aria-label="macports: v3.12.0"><title>macports: v3.12.0</title><filter id="blur"><feGaussianBlur stdDeviation="16"/></filter><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="114" height="20" rx="3"/></clipPath><g clip-path="url(#r)"><rect width="61" height="20" fill="#555"/><rect x="61" width="53" height="20" fill="#007ec6"/><rect width="114" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="315" y="150" fill-opacity=".8" filter="url(#blur)" textLength="510">macports</text><text x="315" y="150" fill-opacity=".3" textLength="510">macports</text></g><text x="315" y="140" textLength="510">macports</text></g><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="865" y="150" fill-opacity=".8" filter="url(#blur)" textLength="430">v3.12.0</text><text x="865" y="150" fill-opacity=".3" textLength="430">v3.12.0</text></g><text x="865" y="140" textLength="430">v3.12.0</text></g></g></svg>

assets/external/img.shields.io/spack/v/nlohmann-json.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="94" height="20" role="img" aria-label="spack: v3.12.0"><title>spack: v3.12.0</title><filter id="blur"><feGaussianBlur stdDeviation="16"/></filter><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="94" height="20" rx="3"/></clipPath><g clip-path="url(#r)"><rect width="41" height="20" fill="#555"/><rect x="41" width="53" height="20" fill="#007ec6"/><rect width="94" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="215" y="150" fill-opacity=".8" filter="url(#blur)" textLength="310">spack</text><text x="215" y="150" fill-opacity=".3" textLength="310">spack</text></g><text x="215" y="140" textLength="310">spack</text></g><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="665" y="150" fill-opacity=".8" filter="url(#blur)" textLength="430">v3.12.0</text><text x="665" y="150" fill-opacity=".3" textLength="430">v3.12.0</text></g><text x="665" y="140" textLength="430">v3.12.0</text></g></g></svg>

assets/external/img.shields.io/vcpkg/v/nlohmann-json.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="96" height="20" role="img" aria-label="vcpkg: v3.12.0"><title>vcpkg: v3.12.0</title><filter id="blur"><feGaussianBlur stdDeviation="16"/></filter><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="96" height="20" rx="3"/></clipPath><g clip-path="url(#r)"><rect width="43" height="20" fill="#555"/><rect x="43" width="53" height="20" fill="#007ec6"/><rect width="96" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="225" y="150" fill-opacity=".8" filter="url(#blur)" textLength="330">vcpkg</text><text x="225" y="150" fill-opacity=".3" textLength="330">vcpkg</text></g><text x="225" y="140" textLength="330">vcpkg</text></g><g transform="scale(.1)"><g aria-hidden="true" fill="#010101"><text x="685" y="150" fill-opacity=".8" filter="url(#blur)" textLength="430">v3.12.0</text><text x="685" y="150" fill-opacity=".3" textLength="430">v3.12.0</text></g><text x="685" y="140" textLength="430">v3.12.0</text></g></g></svg>

community/assurance_case.md

@@ -54,10 +54,9 @@ flowchart LR
   user code. The destructor does not recurse, so destroying a deeply nested value does not exhaust the stack.
 - **Bounded recursion.** The JSON parser and the binary readers keep their state in explicit stacks instead of
   recursing per nesting level. Operations that walk a value, such as [`dump`](../api/basic_json/dump.md), copying,
-  comparison, hashing, and [`merge_patch`](../api/basic_json/merge_patch.md), recurse only up to a fixed depth and
-  continue with an explicit stack below it. Some operations, such as [`diff`](../api/basic_json/diff.md),
-  [`flatten`](../api/basic_json/flatten.md), and the binary writers, still recurse once per nesting level; work on them
-  is in progress. Applications that process untrusted input can limit its nesting depth with a
+  comparison, hashing, [`merge_patch`](../api/basic_json/merge_patch.md), [`diff`](../api/basic_json/diff.md),
+  [`flatten`](../api/basic_json/flatten.md), and the binary writers, recurse only up to a fixed depth and continue with
+  an explicit stack below it. Applications that process untrusted input can limit its nesting depth with a
   [parser callback](../features/parsing/parser_callbacks.md).
 - **Invariants are checked.** The class invariant (for instance, that the pointer for the stored type is never null) is
   checked with runtime assertions throughout the test suite.

community/assurance_case/index.md

@@ -34,7 +34,7 @@ flowchart LR
 - **Strict parsing.** The parser accepts exactly the JSON grammar of [RFC 8259](https://datatracker.ietf.org/doc/html/rfc8259). Extensions such as [comments](https://json.nlohmann.me/features/comments/index.md) and [trailing commas](https://json.nlohmann.me/features/trailing_commas/index.md) must be enabled explicitly. Invalid UTF-8 is rejected.
 - **Errors are reported, not ignored.** Malformed input results in a [`parse_error`](https://json.nlohmann.me/home/exceptions/#parse-errors) with the byte position of the error. Binary readers do not trust announced sizes: strings and binary values grow only as bytes are actually read, arrays reserve at most a fixed number of elements up front, and sizes that no container can hold are rejected.
 - **Memory is owned by values.** Each `basic_json` value owns its content, and there is no manual memory management in user code. The destructor does not recurse, so destroying a deeply nested value does not exhaust the stack.
-- **Bounded recursion.** The JSON parser and the binary readers keep their state in explicit stacks instead of recursing per nesting level. Operations that walk a value, such as [`dump`](https://json.nlohmann.me/api/basic_json/dump/index.md), copying, comparison, hashing, and [`merge_patch`](https://json.nlohmann.me/api/basic_json/merge_patch/index.md), recurse only up to a fixed depth and continue with an explicit stack below it. Some operations, such as [`diff`](https://json.nlohmann.me/api/basic_json/diff/index.md), [`flatten`](https://json.nlohmann.me/api/basic_json/flatten/index.md), and the binary writers, still recurse once per nesting level; work on them is in progress. Applications that process untrusted input can limit its nesting depth with a [parser callback](https://json.nlohmann.me/features/parsing/parser_callbacks/index.md).
+- **Bounded recursion.** The JSON parser and the binary readers keep their state in explicit stacks instead of recursing per nesting level. Operations that walk a value, such as [`dump`](https://json.nlohmann.me/api/basic_json/dump/index.md), copying, comparison, hashing, [`merge_patch`](https://json.nlohmann.me/api/basic_json/merge_patch/index.md), [`diff`](https://json.nlohmann.me/api/basic_json/diff/index.md), [`flatten`](https://json.nlohmann.me/api/basic_json/flatten/index.md), and the binary writers, recurse only up to a fixed depth and continue with an explicit stack below it. Applications that process untrusted input can limit its nesting depth with a [parser callback](https://json.nlohmann.me/features/parsing/parser_callbacks/index.md).
 - **Invariants are checked.** The class invariant (for instance, that the pointer for the stored type is never null) is checked with runtime assertions throughout the test suite.
 
 ## Common weaknesses

features/binary_values.md

@@ -267,9 +267,10 @@ unsigned 8-bit integer. If no subtype is given, the generic binary subtype 0x00
 
 ### CBOR
 
-[CBOR](binary_formats/cbor.md) supports binary values, but no subtypes. Subtypes will be serialized as tags. Any binary
-value will be serialized as byte strings. The library will choose the smallest representation using the length of the
-byte array.
+[CBOR](binary_formats/cbor.md) supports binary values and subtypes. Any binary value will be serialized as a byte
+string; a subtype is serialized as a tag preceding it. When parsing, tags are only read back as subtypes with
+`cbor_tag_handler_t::store` (see [`from_cbor`](../api/basic_json/from_cbor.md)). The library will choose the smallest
+representation using the length of the byte array.
 
 ??? example "Example: serialize a binary value to CBOR"
 

features/binary_values/index.md

@@ -250,7 +250,7 @@ Note that the serialization preserves the subtype, and deserializing `v` would y
 
 ### CBOR
 
-[CBOR](https://json.nlohmann.me/features/binary_formats/cbor/index.md) supports binary values, but no subtypes. Subtypes will be serialized as tags. Any binary value will be serialized as byte strings. The library will choose the smallest representation using the length of the byte array.
+[CBOR](https://json.nlohmann.me/features/binary_formats/cbor/index.md) supports binary values and subtypes. Any binary value will be serialized as a byte string; a subtype is serialized as a tag preceding it. When parsing, tags are only read back as subtypes with `cbor_tag_handler_t::store` (see [`from_cbor`](https://json.nlohmann.me/api/basic_json/from_cbor/index.md)). The library will choose the smallest representation using the length of the byte array.
 
 Example: serialize a binary value to CBOR
 

features/macros.md

@@ -243,9 +243,9 @@ See [full documentation of `JSON_USE_GLOBAL_UDLS`](../api/macros/json_use_global
 
 ## `JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`
 
-When defined to `1`, the library restores the legacy behavior in which a discarded value compared equal to itself. This
-behavior is [deprecated](../integration/migration_guide.md#miscellaneous-functions) and switched off (`0`) by
-default.
+When defined to `1`, the library restores the legacy behavior in which comparing a discarded value with `<=` or `>=`
+yields `#!cpp true` instead of `#!cpp false`. This behavior is
+[deprecated](../integration/migration_guide.md#miscellaneous-functions) and switched off (`0`) by default.
 
 See [full documentation of `JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](../api/macros/json_use_legacy_discarded_value_comparison.md).
 

features/macros/index.md

@@ -184,7 +184,7 @@ See [full documentation of `JSON_USE_GLOBAL_UDLS`](https://json.nlohmann.me/api/
 
 ## `JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`
 
-When defined to `1`, the library restores the legacy behavior in which a discarded value compared equal to itself. This behavior is [deprecated](https://json.nlohmann.me/integration/migration_guide/#miscellaneous-functions) and switched off (`0`) by default.
+When defined to `1`, the library restores the legacy behavior in which comparing a discarded value with `<=` or `>=` yields `true` instead of `false`. This behavior is [deprecated](https://json.nlohmann.me/integration/migration_guide/#miscellaneous-functions) and switched off (`0`) by default.
 
 See [full documentation of `JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](https://json.nlohmann.me/api/macros/json_use_legacy_discarded_value_comparison/index.md).
 

features/merge_patch.md

@@ -1,6 +1,6 @@
 # JSON Merge Patch
 
-The library supports JSON Merge Patch ([RFC 7386](https://tools.ietf.org/html/rfc7386)) as a patch format.
+The library supports JSON Merge Patch ([RFC 7396](https://tools.ietf.org/html/rfc7396)) as a patch format.
 The merge patch format is primarily intended for use with the HTTP PATCH method as a means of describing a set of
 modifications to a target resource's content. This function applies a merge patch to the current JSON value.
 

features/merge_patch/index.md

@@ -1,6 +1,6 @@
 # JSON Merge Patch
 
-The library supports JSON Merge Patch ([RFC 7386](https://tools.ietf.org/html/rfc7386)) as a patch format. The merge patch format is primarily intended for use with the HTTP PATCH method as a means of describing a set of modifications to a target resource's content. This function applies a merge patch to the current JSON value.
+The library supports JSON Merge Patch ([RFC 7396](https://tools.ietf.org/html/rfc7396)) as a patch format. The merge patch format is primarily intended for use with the HTTP PATCH method as a means of describing a set of modifications to a target resource's content. This function applies a merge patch to the current JSON value.
 
 Instead of using [JSON Pointer](https://json.nlohmann.me/features/json_pointer/index.md) to specify values to be manipulated, it describes the changes using a syntax that closely mimics the document being modified. Unlike [JSON Patch](https://json.nlohmann.me/features/json_patch/index.md), a JSON Merge Patch cannot express every kind of change (e.g., it cannot reorder array elements or remove a specific array element), but it is easier to read and write for object-shaped documents.
 

features/modifying_values.md

@@ -107,7 +107,7 @@ config.update(user_settings, true);
 // {"log":{"file":"app.log","level":"debug"},"retries":3}
 ```
 
-[JSON Merge Patch](merge_patch.md) ([RFC 7386](https://tools.ietf.org/html/rfc7386)) also merges objects recursively,
+[JSON Merge Patch](merge_patch.md) ([RFC 7396](https://tools.ietf.org/html/rfc7396)) also merges objects recursively,
 but it is a different tool: a `#!json null` in the patch means "remove this key". It is meant for applying merge patch
 documents (e.g., received via HTTP PATCH). To merge configuration-like objects, use `#!cpp update(..., true)`. To apply
 a sequence of well-defined edit operations, see [JSON Patch](json_patch.md).
@@ -131,6 +131,6 @@ a.erase(1);             // [1,3,4]  (erase by index)
 - [`push_back`](../api/basic_json/push_back.md) / [`emplace_back`](../api/basic_json/emplace_back.md) - append to an array
 - [`emplace`](../api/basic_json/emplace.md) - insert into an object if the key is absent
 - [`update`](../api/basic_json/update.md) - merge objects (shallow, or recursive with `merge_objects`)
-- [`merge_patch`](../api/basic_json/merge_patch.md) - apply an RFC 7386 merge patch
+- [`merge_patch`](../api/basic_json/merge_patch.md) - apply an RFC 7396 merge patch
 - [`erase`](../api/basic_json/erase.md) / [`clear`](../api/basic_json/clear.md) - remove elements
 - [JSON Patch and Diff](json_patch.md) and [JSON Merge Patch](merge_patch.md) - structured modifications

features/modifying_values/index.md

@@ -97,7 +97,7 @@ config.update(user_settings, true);
 // {"log":{"file":"app.log","level":"debug"},"retries":3}
 ```
 
-[JSON Merge Patch](https://json.nlohmann.me/features/merge_patch/index.md) ([RFC 7386](https://tools.ietf.org/html/rfc7386)) also merges objects recursively, but it is a different tool: a `null` in the patch means "remove this key". It is meant for applying merge patch documents (e.g., received via HTTP PATCH). To merge configuration-like objects, use `update(..., true)`. To apply a sequence of well-defined edit operations, see [JSON Patch](https://json.nlohmann.me/features/json_patch/index.md).
+[JSON Merge Patch](https://json.nlohmann.me/features/merge_patch/index.md) ([RFC 7396](https://tools.ietf.org/html/rfc7396)) also merges objects recursively, but it is a different tool: a `null` in the patch means "remove this key". It is meant for applying merge patch documents (e.g., received via HTTP PATCH). To merge configuration-like objects, use `update(..., true)`. To apply a sequence of well-defined edit operations, see [JSON Patch](https://json.nlohmann.me/features/json_patch/index.md).
 
 ## Removing elements
 
@@ -116,6 +116,6 @@ a.erase(1);             // [1,3,4]  (erase by index)
 - [`push_back`](https://json.nlohmann.me/api/basic_json/push_back/index.md) / [`emplace_back`](https://json.nlohmann.me/api/basic_json/emplace_back/index.md) - append to an array
 - [`emplace`](https://json.nlohmann.me/api/basic_json/emplace/index.md) - insert into an object if the key is absent
 - [`update`](https://json.nlohmann.me/api/basic_json/update/index.md) - merge objects (shallow, or recursive with `merge_objects`)
-- [`merge_patch`](https://json.nlohmann.me/api/basic_json/merge_patch/index.md) - apply an RFC 7386 merge patch
+- [`merge_patch`](https://json.nlohmann.me/api/basic_json/merge_patch/index.md) - apply an RFC 7396 merge patch
 - [`erase`](https://json.nlohmann.me/api/basic_json/erase/index.md) / [`clear`](https://json.nlohmann.me/api/basic_json/clear/index.md) - remove elements
 - [JSON Patch and Diff](https://json.nlohmann.me/features/json_patch/index.md) and [JSON Merge Patch](https://json.nlohmann.me/features/merge_patch/index.md) - structured modifications

features/parsing/untrusted_input.md

@@ -50,19 +50,13 @@ stack, however deeply it is nested.
 
 Once a value has been parsed, operations that walk it recursively -- serializing it with
 [`dump`](../../api/basic_json/dump.md), hashing it, copying it, comparing two values with `#!cpp ==`, `#!cpp <`, or (in
-C++20) `#!cpp <=>`, merging with [`update`](../../api/basic_json/update.md), and applying a
-[`merge_patch`](../../api/basic_json/merge_patch.md) -- descend at most 128 levels on the call stack and continue
+C++20) `#!cpp <=>`, merging with [`update`](../../api/basic_json/update.md), applying a
+[`merge_patch`](../../api/basic_json/merge_patch.md), creating a patch with [`diff`](../../api/basic_json/diff.md) or
+[`merge_diff`](../../api/basic_json/merge_diff.md), [`flatten`](../../api/basic_json/flatten.md), and the binary
+writers (`to_cbor`, `to_msgpack`, ...) -- descend at most 128 levels on the call stack and continue
 below that with an explicit stack instead, so none of them can exhaust the stack either, however deeply the value is
 nested. Destroying a value (its destructor) never recurses at all, regardless of nesting depth, for the same reason.
 
-!!! note "Not every operation is bounded yet"
-
-    [`diff`](../../api/basic_json/diff.md), [`flatten`](../../api/basic_json/flatten.md), and the binary writers
-    (`to_cbor`, `to_msgpack`, ...) still recurse once per nesting level; this is called out as work in progress in the
-    [assurance case](../../community/assurance_case.md#secure-design). A value deep enough to matter for these
-    operations would typically first have to survive parsing without hitting a self-imposed depth limit, as described
-    above.
-
 ## Input size
 
 The library does not limit the overall size of a JSON text; a value nested or wide enough will use memory

features/parsing/untrusted_input/index.md

@@ -22,11 +22,7 @@ No built-in depth limit while parsing
 
 Neither the parser nor the binary readers impose a limit on how deep the input may nest. An attacker can still exhaust memory (though not the call stack) with a sufficiently deep document. If you need to reject over-deep untrusted input outright, track the depth yourself, either with a [parser callback](https://json.nlohmann.me/features/parsing/parser_callbacks/#recipe-max-nesting-depth-via-a-callback) for the JSON parser, or by counting `start_object`/`start_array` and `end_object`/`end_array` calls in a [SAX handler](https://json.nlohmann.me/features/parsing/sax_interface/index.md) (for the JSON parser or a binary format alike) and throwing once your limit is exceeded.
 
-Once a value has been parsed, operations that walk it recursively -- serializing it with [`dump`](https://json.nlohmann.me/api/basic_json/dump/index.md), hashing it, copying it, comparing two values with `==`, `<`, or (in C++20) `<=>`, merging with [`update`](https://json.nlohmann.me/api/basic_json/update/index.md), and applying a [`merge_patch`](https://json.nlohmann.me/api/basic_json/merge_patch/index.md) -- descend at most 128 levels on the call stack and continue below that with an explicit stack instead, so none of them can exhaust the stack either, however deeply the value is nested. Destroying a value (its destructor) never recurses at all, regardless of nesting depth, for the same reason.
-
-Not every operation is bounded yet
-
-[`diff`](https://json.nlohmann.me/api/basic_json/diff/index.md), [`flatten`](https://json.nlohmann.me/api/basic_json/flatten/index.md), and the binary writers (`to_cbor`, `to_msgpack`, ...) still recurse once per nesting level; this is called out as work in progress in the [assurance case](https://json.nlohmann.me/community/assurance_case/#secure-design). A value deep enough to matter for these operations would typically first have to survive parsing without hitting a self-imposed depth limit, as described above.
+Once a value has been parsed, operations that walk it recursively -- serializing it with [`dump`](https://json.nlohmann.me/api/basic_json/dump/index.md), hashing it, copying it, comparing two values with `==`, `<`, or (in C++20) `<=>`, merging with [`update`](https://json.nlohmann.me/api/basic_json/update/index.md), applying a [`merge_patch`](https://json.nlohmann.me/api/basic_json/merge_patch/index.md), creating a patch with [`diff`](https://json.nlohmann.me/api/basic_json/diff/index.md) or [`merge_diff`](https://json.nlohmann.me/api/basic_json/merge_diff/index.md), [`flatten`](https://json.nlohmann.me/api/basic_json/flatten/index.md), and the binary writers (`to_cbor`, `to_msgpack`, ...) -- descend at most 128 levels on the call stack and continue below that with an explicit stack instead, so none of them can exhaust the stack either, however deeply the value is nested. Destroying a value (its destructor) never recurses at all, regardless of nesting depth, for the same reason.
 
 ## Input size
 

features/serialization.md

@@ -155,7 +155,7 @@ with `\uXXXX` sequences, so that the output contains only ASCII characters:
 ```cpp
 json j = "苹果";
 j.dump();               // "苹果"
-j.dump(-1, ' ', true);  // "苹果"
+j.dump(-1, ' ', true);  // "\u82f9\u679c"
 ```
 
 ## Handling invalid UTF-8

features/serialization/index.md

@@ -144,7 +144,7 @@ Strings are stored and serialized as UTF-8 (see [types](https://json.nlohmann.me
 ```
 json j = "苹果";
 j.dump();               // "苹果"
-j.dump(-1, ' ', true);  // "苹果"
+j.dump(-1, ' ', true);  // "\u82f9\u679c"
 ```
 
 ## Handling invalid UTF-8

features/types.md

@@ -120,7 +120,7 @@ requirements are collected in [Template Parameter Requirements](template_paramet
 
 ### Default type
 
-With the default values for *ObjectType* (`std::map`), *StringType* (`std::string`), and *AllocatorType* (`std::allocator`), the default value for `object_t` is:
+With the default values for *ObjectType* (`std::map`), *StringType* (`std::string`), and *AllocatorType* (`std::allocator`), the default type for `object_t` is:
 
 ```cpp
 std::map<
@@ -177,7 +177,7 @@ json j = m;
 
 ### Default type
 
-With the default values for *ArrayType* (`std::vector`) and *AllocatorType* (`std::allocator`), the default value for `array_t` is:
+With the default values for *ArrayType* (`std::vector`) and *AllocatorType* (`std::allocator`), the default type for `array_t` is:
 
 ```cpp
 std::vector<
@@ -209,7 +209,7 @@ Unicode values are split by the JSON class into byte-sized characters during des
 
 ### Default type
 
-With the default values for *StringType* (`std::string`), the default value for `string_t` is `#!cpp std::string`.
+With the default values for *StringType* (`std::string`), the default type for `string_t` is `#!cpp std::string`.
 
 ### Encoding
 
@@ -234,7 +234,7 @@ String values are stored as pointers in a `basic_json` type. That is, for any ac
 
 ### Default type
 
-With the default values for *BooleanType* (`#!cpp bool`), the default value for `boolean_t` is `#!cpp bool`.
+With the default values for *BooleanType* (`#!cpp bool`), the default type for `boolean_t` is `#!cpp bool`.
 
 ### Storage
 
@@ -252,9 +252,9 @@ This description includes both integer and floating-point numbers. However, C++
 
 ### Default types
 
-With the default values for *NumberIntegerType* (`std::int64_t`), the default value for `number_integer_t` is `std::int64_t`.
-With the default values for *NumberUnsignedType* (`std::uint64_t`), the default value for `number_unsigned_t` is `std::uint64_t`.
-With the default values for *NumberFloatType* (`#!cpp double`), the default value for `number_float_t` is `#!cpp double`.
+With the default values for *NumberIntegerType* (`std::int64_t`), the default type for `number_integer_t` is `std::int64_t`.
+With the default values for *NumberUnsignedType* (`std::uint64_t`), the default type for `number_unsigned_t` is `std::uint64_t`.
+With the default values for *NumberFloatType* (`#!cpp double`), the default type for `number_float_t` is `#!cpp double`.
 
 ### Default behavior
 
@@ -281,7 +281,7 @@ As this range is a subrange of the exactly supported range [`INT64_MIN`, `INT64_
 
 > This specification allows implementations to set limits on the range and precision of numbers accepted. Since software that implements IEEE 754-2008 binary64 (double precision) numbers is generally available and widely used, good interoperability can be achieved by implementations that expect no more precision or range than these provide, in the sense that implementations will approximate JSON numbers within the expected precision.
 
-This implementation does exactly follow this approach, as it uses double precision floating-point numbers. Note values smaller than `#!c -1.79769313486232e+308` and values greater than `#!c 1.79769313486232e+308` will be stored as NaN internally and be serialized to `#!json null`.
+This implementation does exactly follow this approach, as it uses double precision floating-point numbers by default (see *NumberFloatType* above). Note that with the default `#!cpp double`, numbers smaller than `#!c -1.79769313486232e+308` or greater than `#!c 1.79769313486232e+308` are rejected during parsing with [`out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406). Non-finite values (NaN and infinity) can only be stored by assigning them directly and are serialized to `#!json null`.
 
 ### Storage
 

features/types/index.md

@@ -117,7 +117,7 @@ Not every type can be passed for these template arguments: the library uses the
 
 ### Default type
 
-With the default values for *ObjectType* (`std::map`), *StringType* (`std::string`), and *AllocatorType* (`std::allocator`), the default value for `object_t` is:
+With the default values for *ObjectType* (`std::map`), *StringType* (`std::string`), and *AllocatorType* (`std::allocator`), the default type for `object_t` is:
 
 ```
 std::map<
@@ -171,7 +171,7 @@ json j = m;
 
 ### Default type
 
-With the default values for *ArrayType* (`std::vector`) and *AllocatorType* (`std::allocator`), the default value for `array_t` is:
+With the default values for *ArrayType* (`std::vector`) and *AllocatorType* (`std::allocator`), the default type for `array_t` is:
 
 ```
 std::vector<
@@ -202,7 +202,7 @@ Unicode values are split by the JSON class into byte-sized characters during des
 
 ### Default type
 
-With the default values for *StringType* (`std::string`), the default value for `string_t` is `std::string`.
+With the default values for *StringType* (`std::string`), the default type for `string_t` is `std::string`.
 
 ### Encoding
 
@@ -226,7 +226,7 @@ String values are stored as pointers in a `basic_json` type. That is, for any ac
 
 ### Default type
 
-With the default values for *BooleanType* (`bool`), the default value for `boolean_t` is `bool`.
+With the default values for *BooleanType* (`bool`), the default type for `boolean_t` is `bool`.
 
 ### Storage
 
@@ -244,7 +244,7 @@ This description includes both integer and floating-point numbers. However, C++
 
 ### Default types
 
-With the default values for *NumberIntegerType* (`std::int64_t`), the default value for `number_integer_t` is `std::int64_t`. With the default values for *NumberUnsignedType* (`std::uint64_t`), the default value for `number_unsigned_t` is `std::uint64_t`. With the default values for *NumberFloatType* (`double`), the default value for `number_float_t` is `double`.
+With the default values for *NumberIntegerType* (`std::int64_t`), the default type for `number_integer_t` is `std::int64_t`. With the default values for *NumberUnsignedType* (`std::uint64_t`), the default type for `number_unsigned_t` is `std::uint64_t`. With the default values for *NumberFloatType* (`double`), the default type for `number_float_t` is `double`.
 
 ### Default behavior
 
@@ -271,7 +271,7 @@ As this range is a subrange of the exactly supported range \[`INT64_MIN`, `INT64
 
 > This specification allows implementations to set limits on the range and precision of numbers accepted. Since software that implements IEEE 754-2008 binary64 (double precision) numbers is generally available and widely used, good interoperability can be achieved by implementations that expect no more precision or range than these provide, in the sense that implementations will approximate JSON numbers within the expected precision.
 
-This implementation does exactly follow this approach, as it uses double precision floating-point numbers. Note values smaller than `-1.79769313486232e+308` and values greater than `1.79769313486232e+308` will be stored as NaN internally and be serialized to `null`.
+This implementation does exactly follow this approach, as it uses double precision floating-point numbers by default (see *NumberFloatType* above). Note that with the default `double`, numbers smaller than `-1.79769313486232e+308` or greater than `1.79769313486232e+308` are rejected during parsing with [`out_of_range.406`](https://json.nlohmann.me/home/exceptions/#jsonexceptionout_of_range406). Non-finite values (NaN and infinity) can only be stored by assigning them directly and are serialized to `null`.
 
 ### Storage
 

features/types/number_handling.md

@@ -82,12 +82,13 @@ flowchart TD
 
     - Numbers with a decimal digit or scientific notation are always stored as `#!c double`.
     - The number types can be changed, see [Template number types](#template-number-types). 
-    - Integers are converted by the library's own digit parser. Floating-point numbers are converted with
-      [`std::from_chars`](https://en.cppreference.com/w/cpp/utility/from_chars) if the library is compiled with C++17
-      and the standard library supports it, then with an exact fast path for `#!c double` values with few significant
-      digits, and otherwise with the locale-aware
-      [`std::strtod`](https://en.cppreference.com/w/cpp/string/byte/strtof) (`std::strtof`/`std::strtold` for the
-      other floating-point types). Before version 3.13.0, the conversion was realized by
+    - The library converts integers and floating-point numbers itself, independent of the locale. Floating-point
+      numbers are correctly rounded (to nearest, ties to even). Only a `#!c long double` that is not IEEE 754 binary64
+      (e.g., the 80-bit x87 format) is converted with `#!cpp std::from_chars` where available, or else with
+      [`std::strtold`](https://en.cppreference.com/w/cpp/string/byte/strtof). For that call, the library temporarily
+      replaces the `.` with the decimal point of the current locale (which may be longer than one byte, e.g., in
+      `fa_IR.UTF-8`), so the result does not depend on the locale either. Changing the locale in another thread during
+      parsing is undefined behavior of the C library, though. Before version 3.13.0, the conversion was realized by
       [`std::strtoull`](https://en.cppreference.com/w/cpp/string/byte/strtoul),
       [`std::strtoll`](https://en.cppreference.com/w/cpp/string/byte/strtol), and `std::strtod`, respectively.
 
@@ -100,10 +101,10 @@ flowchart TD
 ### Number limits
 
 - Any 64-bit signed or unsigned integer can be stored without loss of precision.
-- Numbers exceeding the limits of `#!c double` (i.e., numbers that after conversion via
-[`std::strtod`](https://en.cppreference.com/w/cpp/string/byte/strtof) are not satisfying
+- Numbers exceeding the limits of `#!c double` (i.e., numbers whose rounded value is not satisfying
 [`std::isfinite`](https://en.cppreference.com/w/cpp/numeric/math/isfinite) such as `#!c 1E400`) will throw exception
-[`json.exception.out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406) during parsing.
+[`json.exception.out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406) during parsing. Numbers too
+small for `#!c double` (such as `#!c 1E-400`) become zero, with the sign of the number.
 - Floating-point numbers are rounded to the next number representable as `double`. For instance
 `#!c 3.141592653589793238462643383279` is stored as [`0x400921fb54442d18`](https://float.exposed/0x400921fb54442d18).
 This is the same behavior as the code `#!c double x = 3.141592653589793238462643383279;`.
@@ -133,9 +134,10 @@ That is, `-0` is stored as a signed integer, but the serialization does not repr
 ### Number serialization
 
 - Integer numbers are serialized as is; that is, no scientific notation is used.
-- Floating-point numbers are serialized as specified by the `#!c %g` printf modifier with 
-  [`std::numeric_limits<double>::max_digits10`](https://en.cppreference.com/w/cpp/types/numeric_limits/max_digits10)
-  significant digits. The rationale is to use the shortest representation while still allowing round-tripping.
+- Floating-point numbers are serialized with the fewest digits that read back as the same value (the closest such
+  digits if there are several), in the layout of the `#!c %g` printf modifier: `#!c 1.5`, `#!c 100.0`, `#!c 1e+100`.
+  Doubles are converted with the algorithm of [Żmij](https://github.com/vitaut/zmij), floats with Grisu2, which
+  can write more digits than necessary.
 
 !!! hint "Notes regarding precision of floating-point numbers"
 

features/types/number_handling/index.md

@@ -55,7 +55,7 @@ Notes
 
 - Numbers with a decimal digit or scientific notation are always stored as `double`.
 - The number types can be changed, see [Template number types](#template-number-types).
-- Integers are converted by the library's own digit parser. Floating-point numbers are converted with [`std::from_chars`](https://en.cppreference.com/w/cpp/utility/from_chars) if the library is compiled with C++17 and the standard library supports it, then with an exact fast path for `double` values with few significant digits, and otherwise with the locale-aware [`std::strtod`](https://en.cppreference.com/w/cpp/string/byte/strtof) (`std::strtof`/`std::strtold` for the other floating-point types). Before version 3.13.0 unreleased, the conversion was realized by [`std::strtoull`](https://en.cppreference.com/w/cpp/string/byte/strtoul), [`std::strtoll`](https://en.cppreference.com/w/cpp/string/byte/strtol), and `std::strtod`, respectively.
+- The library converts integers and floating-point numbers itself, independent of the locale. Floating-point numbers are correctly rounded (to nearest, ties to even). Only a `long double` that is not IEEE 754 binary64 (e.g., the 80-bit x87 format) is converted with `std::from_chars` where available, or else with [`std::strtold`](https://en.cppreference.com/w/cpp/string/byte/strtof). For that call, the library temporarily replaces the `.` with the decimal point of the current locale (which may be longer than one byte, e.g., in `fa_IR.UTF-8`), so the result does not depend on the locale either. Changing the locale in another thread during parsing is undefined behavior of the C library, though. Before version 3.13.0 unreleased, the conversion was realized by [`std::strtoull`](https://en.cppreference.com/w/cpp/string/byte/strtoul), [`std::strtoll`](https://en.cppreference.com/w/cpp/string/byte/strtol), and `std::strtod`, respectively.
 
 Examples
 
@@ -65,7 +65,7 @@ Examples
 ### Number limits
 
 - Any 64-bit signed or unsigned integer can be stored without loss of precision.
-- Numbers exceeding the limits of `double` (i.e., numbers that after conversion via [`std::strtod`](https://en.cppreference.com/w/cpp/string/byte/strtof) are not satisfying [`std::isfinite`](https://en.cppreference.com/w/cpp/numeric/math/isfinite) such as `1E400`) will throw exception [`json.exception.out_of_range.406`](https://json.nlohmann.me/home/exceptions/#jsonexceptionout_of_range406) during parsing.
+- Numbers exceeding the limits of `double` (i.e., numbers whose rounded value is not satisfying [`std::isfinite`](https://en.cppreference.com/w/cpp/numeric/math/isfinite) such as `1E400`) will throw exception [`json.exception.out_of_range.406`](https://json.nlohmann.me/home/exceptions/#jsonexceptionout_of_range406) during parsing. Numbers too small for `double` (such as `1E-400`) become zero, with the sign of the number.
 - Floating-point numbers are rounded to the next number representable as `double`. For instance `3.141592653589793238462643383279` is stored as [`0x400921fb54442d18`](https://float.exposed/0x400921fb54442d18). This is the same behavior as the code `double x = 3.141592653589793238462643383279;`.
 
 Interoperability
@@ -91,7 +91,7 @@ That is, `-0` is stored as a signed integer, but the serialization does not repr
 ### Number serialization
 
 - Integer numbers are serialized as is; that is, no scientific notation is used.
-- Floating-point numbers are serialized as specified by the `%g` printf modifier with [`std::numeric_limits<double>::max_digits10`](https://en.cppreference.com/w/cpp/types/numeric_limits/max_digits10) significant digits. The rationale is to use the shortest representation while still allowing round-tripping.
+- Floating-point numbers are serialized with the fewest digits that read back as the same value (the closest such digits if there are several), in the layout of the `%g` printf modifier: `1.5`, `100.0`, `1e+100`. Doubles are converted with the algorithm of [Żmij](https://github.com/vitaut/zmij), floats with Grisu2, which can write more digits than necessary.
 
 Notes regarding precision of floating-point numbers
 

features/types/template_parameters.md

@@ -30,9 +30,9 @@ Requirements are split into two groups:
     diagnosed with dedicated error messages, and violating most of them results in a compiler error somewhere inside
     the library. Four violations are not caught at compile time at all:
 
-    - A [`StringType`](#stringtype) whose `data()` is not null-terminated compiles and can silently misparse
-      floating-point numbers, because the lexer may hand the buffer to `#!cpp std::strtod`, which reads up to the
-      terminating null character.
+    - A [`StringType`](#stringtype) whose `data()` is not null-terminated compiles and silently misparses numbers
+      stored as a `#!cpp long double` that is not IEEE 754 binary64 (e.g., the 80-bit x87 format), because the lexer
+      hands the buffer to `#!cpp std::strtold`.
     - A stateful [`AllocatorType`](#allocatortype) compiles and silently ignores its state: allocation, deallocation,
       and [`get_allocator()`](../../api/basic_json/get_allocator.md) each use a different default-constructed instance.
     - The two [cross-specialization conversions](#cross-specialization-conversions) below. These abort on an assertion
@@ -705,16 +705,21 @@ using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
 ### Always required
 
 - A member type `value_type` that is one byte wide and `char`-compatible. The library stores and processes UTF-8
-  encoded `char` data and passes `data()` to functions that take a `#!cpp const char*`, such as `#!cpp std::strtod`.
+  encoded `char` data and passes `data()` to functions that take a `#!cpp const char*`, such as `#!cpp std::strtold`
+  (only used to parse a `#!cpp long double` that is not IEEE 754 binary64, see
+  [`NumberFloatType`](#numberfloattype)).
   `#!cpp std::wstring`, `#!cpp std::u16string`, and `#!cpp std::u32string` are **not** valid choices; see the FAQ on
   [wide string handling](../../home/faq.md#wide-string-handling).
 - Constructors: default, copy, move, from `#!cpp const char*` (which must not be `#!cpp explicit`), from
   `#!cpp (const char*, size_type)`, and from `#!cpp (size_type, char)`; and copy or move assignment.
 - Member functions `size()`, `clear()`, `resize(n, c)`, `data()`, `push_back(char)`, and `operator[]`
   (const and non-const, returning references). `c_str()` and `back()` are **not** required.
-- `data()` must return a pointer to a contiguous, **null-terminated** buffer -- the parser may hand it to
-  `#!cpp std::strtod`, which reads up to the null character. A type whose `data()` is not null-terminated does not
-  fail to compile; it can silently misparse floating-point numbers.
+- `data()` must return a pointer to a contiguous, **null-terminated** buffer. `#!cpp float`, `#!cpp double`, and a
+  `#!cpp long double` that is IEEE 754 binary64 are converted by the library itself and do not depend on this. For any
+  other `NumberFloatType` (a `#!cpp long double` of another format), the parser falls back to `#!cpp std::strtold` when
+  `#!cpp std::from_chars` is not available or declines the token, and `std::strtold` reads up to the null character. A type whose `data()`
+  is not null-terminated does not fail to compile; with such a `NumberFloatType` it can silently misparse
+  floating-point numbers.
 - `append(const char*, size_type)`, used by [`dump`](../../api/basic_json/dump.md), and `append(const StringType&)`,
   used by the CBOR reader for indefinite-length strings. The library's internal string concatenation additionally has
   to append a `#!cpp char` and a `#!cpp const char*`; for each it selects between `append(arg)`, `#!cpp operator+=`,
@@ -1067,16 +1072,18 @@ therefore silently changes parse results rather than raising an error. See
 
 `NumberFloatType` must be one of `#!cpp float`, `#!cpp double`, or `#!cpp long double`:
 
-- The [parser](../parsing/index.md) converts number literals with `#!cpp std::from_chars` or, as a fallback, with
-  `#!cpp std::strtof`, `#!cpp std::strtod`, or `#!cpp std::strtold`; the library provides overloads for exactly these
-  three types.
+- The [parser](../parsing/index.md) converts number literals to `#!cpp float`, `#!cpp double`, and a
+  `#!cpp long double` that is IEEE 754 binary64 itself; other `#!cpp long double` formats are converted with
+  `#!cpp std::from_chars` where available, or with `#!cpp std::strtold`. The library provides overloads for exactly
+  these three types.
 - [`dump`](../../api/basic_json/dump.md) falls back to `#!cpp std::snprintf` with the `%g` and `%Lg` conversion
   specifiers, for which the library likewise provides only `#!cpp double` and `#!cpp long double` overloads
   (`#!cpp float` is promoted to `#!cpp double`).
 
-If `#!cpp std::numeric_limits<NumberFloatType>` describes an IEEE 754 binary32 or binary64 number, `dump` uses the
-Grisu2 algorithm, which produces the shortest representation that round-trips. Otherwise the `snprintf` fallback with
-`max_digits10` digits is used.
+If `#!cpp std::numeric_limits<NumberFloatType>` describes an IEEE 754 binary64 number, `dump` uses the algorithm of
+Żmij, which produces the shortest representation that round-trips. For IEEE 754 binary32 numbers, it uses Grisu2,
+which produces a short representation that round-trips. Otherwise the `snprintf` fallback with `max_digits10` digits is
+used.
 
 ### Required for the binary formats
 
@@ -1088,7 +1095,7 @@ binary32 or binary64 field and have no encoding for `#!cpp long double`.
 
 | Type                     | Support                                                                                                               |
 |--------------------------|-----------------------------------------------------------------------------------------------------------------------|
-| `#!cpp double` (default) | full; short round-trip output through Grisu2                                                                          |
+| `#!cpp double` (default) | full; shortest round-trip output through Żmij                                                                         |
 | `#!cpp float`            | full; short round-trip output through Grisu2                                                                          |
 | `#!cpp long double`      | `dump` and `parse` only; the binary format writers do not compile, as they only handle IEEE 754 binary32 and binary64 |
 | any other type           | not usable                                                                                                            |

features/types/template_parameters/index.md

@@ -15,7 +15,7 @@ Requirements are not checked
 
 Three requirements are checked with a `static_assert`: the array iterator category, the width of [`BinaryType`](#binarytype)'s `value_type`, and [`NumberUnsignedType`](#numberintegertype-and-numberunsignedtype) being at least as wide as [`NumberIntegerType`](#numberintegertype-and-numberunsignedtype). The rest are not diagnosed with dedicated error messages, and violating most of them results in a compiler error somewhere inside the library. Four violations are not caught at compile time at all:
 
-- A [`StringType`](#stringtype) whose `data()` is not null-terminated compiles and can silently misparse floating-point numbers, because the lexer may hand the buffer to `std::strtod`, which reads up to the terminating null character.
+- A [`StringType`](#stringtype) whose `data()` is not null-terminated compiles and silently misparses numbers stored as a `long double` that is not IEEE 754 binary64 (e.g., the 80-bit x87 format), because the lexer hands the buffer to `std::strtold`.
 - A stateful [`AllocatorType`](#allocatortype) compiles and silently ignores its state: allocation, deallocation, and [`get_allocator()`](https://json.nlohmann.me/api/basic_json/get_allocator/index.md) each use a different default-constructed instance.
 - The two [cross-specialization conversions](#cross-specialization-conversions) below. These abort on an assertion in a normal build, and only fail silently under `NDEBUG`.
 
@@ -608,10 +608,10 @@ true
 
 ### Always required
 
-- A member type `value_type` that is one byte wide and `char`-compatible. The library stores and processes UTF-8 encoded `char` data and passes `data()` to functions that take a `const char*`, such as `std::strtod`. `std::wstring`, `std::u16string`, and `std::u32string` are **not** valid choices; see the FAQ on [wide string handling](https://json.nlohmann.me/home/faq/#wide-string-handling).
+- A member type `value_type` that is one byte wide and `char`-compatible. The library stores and processes UTF-8 encoded `char` data and passes `data()` to functions that take a `const char*`, such as `std::strtold` (only used to parse a `long double` that is not IEEE 754 binary64, see [`NumberFloatType`](#numberfloattype)). `std::wstring`, `std::u16string`, and `std::u32string` are **not** valid choices; see the FAQ on [wide string handling](https://json.nlohmann.me/home/faq/#wide-string-handling).
 - Constructors: default, copy, move, from `const char*` (which must not be `explicit`), from `(const char*, size_type)`, and from `(size_type, char)`; and copy or move assignment.
 - Member functions `size()`, `clear()`, `resize(n, c)`, `data()`, `push_back(char)`, and `operator[]` (const and non-const, returning references). `c_str()` and `back()` are **not** required.
-- `data()` must return a pointer to a contiguous, **null-terminated** buffer -- the parser may hand it to `std::strtod`, which reads up to the null character. A type whose `data()` is not null-terminated does not fail to compile; it can silently misparse floating-point numbers.
+- `data()` must return a pointer to a contiguous, **null-terminated** buffer. `float`, `double`, and a `long double` that is IEEE 754 binary64 are converted by the library itself and do not depend on this. For any other `NumberFloatType` (a `long double` of another format), the parser falls back to `std::strtold` when `std::from_chars` is not available or declines the token, and `std::strtold` reads up to the null character. A type whose `data()` is not null-terminated does not fail to compile; with such a `NumberFloatType` it can silently misparse floating-point numbers.
 - `append(const char*, size_type)`, used by [`dump`](https://json.nlohmann.me/api/basic_json/dump/index.md), and `append(const StringType&)`, used by the CBOR reader for indefinite-length strings. The library's internal string concatenation additionally has to append a `char` and a `const char*`; for each it selects between `append(arg)`, `operator+=`, `append(first, last)`, and `append(data, size)`.
 - The comparison operator `==` against another `StringType`, and `<` for use as a key of the chosen [`ObjectType`](#objecttype) (with the default comparator, `std::less<>` must be able to compare two `StringType` values, and a `StringType` with the key types used for lookup). `!=` is never applied to a `StringType`, and `==` against `const char*` is resolved by the implicit `const char*` constructor.
 
@@ -920,10 +920,10 @@ The number types influence what the parser accepts: an integer literal that does
 
 `NumberFloatType` must be one of `float`, `double`, or `long double`:
 
-- The [parser](https://json.nlohmann.me/features/parsing/index.md) converts number literals with `std::from_chars` or, as a fallback, with `std::strtof`, `std::strtod`, or `std::strtold`; the library provides overloads for exactly these three types.
+- The [parser](https://json.nlohmann.me/features/parsing/index.md) converts number literals to `float`, `double`, and a `long double` that is IEEE 754 binary64 itself; other `long double` formats are converted with `std::from_chars` where available, or with `std::strtold`. The library provides overloads for exactly these three types.
 - [`dump`](https://json.nlohmann.me/api/basic_json/dump/index.md) falls back to `std::snprintf` with the `%g` and `%Lg` conversion specifiers, for which the library likewise provides only `double` and `long double` overloads (`float` is promoted to `double`).
 
-If `std::numeric_limits<NumberFloatType>` describes an IEEE 754 binary32 or binary64 number, `dump` uses the Grisu2 algorithm, which produces the shortest representation that round-trips. Otherwise the `snprintf` fallback with `max_digits10` digits is used.
+If `std::numeric_limits<NumberFloatType>` describes an IEEE 754 binary64 number, `dump` uses the algorithm of Żmij, which produces the shortest representation that round-trips. For IEEE 754 binary32 numbers, it uses Grisu2, which produces a short representation that round-trips. Otherwise the `snprintf` fallback with `max_digits10` digits is used.
 
 ### Required for the binary formats
 
@@ -933,7 +933,7 @@ If `std::numeric_limits<NumberFloatType>` describes an IEEE 754 binary32 or bina
 
 | Type               | Support                                                                                                               |
 | ------------------ | --------------------------------------------------------------------------------------------------------------------- |
-| `double` (default) | full; short round-trip output through Grisu2                                                                          |
+| `double` (default) | full; shortest round-trip output through Żmij                                                                         |
 | `float`            | full; short round-trip output through Grisu2                                                                          |
 | `long double`      | `dump` and `parse` only; the binary format writers do not compile, as they only handle IEEE 754 binary32 and binary64 |
 | any other type     | not usable                                                                                                            |

home/exceptions.md

@@ -1023,7 +1023,9 @@ contains other characters (e.g., `1a`), or `-` where it cannot be used.
 
 ### json.exception.out_of_range.405
 
-The JSON Patch operations 'remove' and 'add' cannot be applied to the root element of the JSON value.
+The JSON Patch operations 'remove' and 'move' cannot be applied to the root element of the JSON value. The exception is
+also thrown when the parent or a reference token of an empty JSON Pointer is requested, for instance by
+[`back`](../api/json_pointer/back.md) or [`pop_back`](../api/json_pointer/pop_back.md).
 
 !!! failure "Example message"
 
@@ -1048,15 +1050,23 @@ double-precision number when `number_float_t` is `#!cpp float`.
 
 ### json.exception.out_of_range.407
 
-This exception previously indicated that the UBJSON and BSON binary formats did not support integer numbers greater than
-9223372036854775807 due to limitations in the implemented mapping. However, these limitations have since been resolved,
-and this exception no longer occurs.
+An unsigned integer number greater than 9223372036854775807 cannot be represented in the binary format. This exception
+is only thrown by [`to_bon8`](../api/basic_json/to_bon8.md), as [BON8](../features/binary_formats/bon8.md) has no
+unsigned 64-bit integer type.
 
-!!! success "Exception cannot occur any more"
+!!! note "Former occurrences"
+
+    The UBJSON and BSON writers used to throw this exception as well:
 
     - Since version 3.9.0, integer numbers beyond int64 are serialized as high-precision UBJSON numbers.
     - Since version 3.12.0, integer numbers beyond int64 are serialized as uint64 BSON numbers.
 
+!!! failure "Example message"
+
+    ```
+    integer number 18446744073709551615 cannot be represented by BON8 as it does not fit int64
+    ```
+
 ### json.exception.out_of_range.408
 
 The size of an array or object in a [binary format](../features/binary_formats/index.md) exceeds the maximal capacity:

home/exceptions/index.md

@@ -1008,7 +1008,7 @@ unresolved reference token 'foo'
 
 ### json.exception.out_of_range.405
 
-The JSON Patch operations 'remove' and 'add' cannot be applied to the root element of the JSON value.
+The JSON Patch operations 'remove' and 'move' cannot be applied to the root element of the JSON value. The exception is also thrown when the parent or a reference token of an empty JSON Pointer is requested, for instance by [`back`](https://json.nlohmann.me/api/json_pointer/back/index.md) or [`pop_back`](https://json.nlohmann.me/api/json_pointer/pop_back/index.md).
 
 Example message
 
@@ -1032,13 +1032,21 @@ number overflow parsing '10E1000'
 
 ### json.exception.out_of_range.407
 
-This exception previously indicated that the UBJSON and BSON binary formats did not support integer numbers greater than 9223372036854775807 due to limitations in the implemented mapping. However, these limitations have since been resolved, and this exception no longer occurs.
+An unsigned integer number greater than 9223372036854775807 cannot be represented in the binary format. This exception is only thrown by [`to_bon8`](https://json.nlohmann.me/api/basic_json/to_bon8/index.md), as [BON8](https://json.nlohmann.me/features/binary_formats/bon8/index.md) has no unsigned 64-bit integer type.
 
-Exception cannot occur any more
+Former occurrences
+
+The UBJSON and BSON writers used to throw this exception as well:
 
 - Since version 3.9.0, integer numbers beyond int64 are serialized as high-precision UBJSON numbers.
 - Since version 3.12.0, integer numbers beyond int64 are serialized as uint64 BSON numbers.
 
+Example message
+
+```
+integer number 18446744073709551615 cannot be represented by BON8 as it does not fit int64
+```
+
 ### json.exception.out_of_range.408
 
 The size of an array or object in a [binary format](https://json.nlohmann.me/features/binary_formats/index.md) exceeds the maximal capacity: the size following `#` for [UBJSON](https://json.nlohmann.me/features/binary_formats/ubjson/index.md)/[BJData](https://json.nlohmann.me/features/binary_formats/bjdata/index.md), or the encoded length for [CBOR](https://json.nlohmann.me/features/binary_formats/cbor/index.md).

home/faq.md

@@ -66,7 +66,9 @@ Without the macro (default behavior), `json j{obj}` creates `[{"key":"value"}]`.
 
     Can you add an option to ignore trailing commas?
 
-This library does not support any feature that would jeopardize interoperability.
+Yes, trailing commas in arrays and objects can be allowed by setting parameter `ignore_trailing_commas` of
+[`parse`](../api/basic_json/parse.md) to `#!cpp true`; see [trailing commas](../features/trailing_commas.md). They are
+rejected by default, and the library never adds them when serializing.
 
 
 ### Parse errors reading non-ASCII characters
@@ -230,11 +232,11 @@ Yes, you can. Please define the symbol [`JSON_DIAGNOSTICS`](../api/macros/json_d
     - It seems that precision is lost when serializing a double.
     - Can I change the precision for floating-point serialization?
 
-The library uses `std::numeric_limits<number_float_t>::digits10` (15 for IEEE `double`s) digits for serialization. This value is sufficient to guarantee roundtripping. If one uses more than this number of digits of precision, then string -> value -> string is not guaranteed to round-trip.
+The library serializes floating-point numbers with the shortest representation that parses back to the same value, using at most `std::numeric_limits<number_float_t>::max_digits10` (17 for IEEE `double`s) significant digits. This guarantees that value -> string -> value round-trips. The reverse direction, string -> value -> string, is only guaranteed for numbers with at most `std::numeric_limits<number_float_t>::digits10` (15 for IEEE `double`s) significant digits; a number with more digits may not be representable exactly and is then serialized as the closest `double`.
 
-!!! quote "[cppreference.com](https://en.cppreference.com/w/cpp/types/numeric_limits/digits10)"
+!!! quote "[cppreference.com](https://en.cppreference.com/w/cpp/types/numeric_limits/max_digits10)"
 
-    The value of `std::numeric_limits<T>::digits10` is the number of base-10 digits that can be represented by the type T without change, that is, any number with this many significant decimal digits can be converted to a value of type T and back to decimal form, without change due to rounding or overflow. 
+    The value of `std::numeric_limits<T>::max_digits10` is the number of base-10 digits that are necessary to uniquely represent all distinct values of the type T, such as necessary for serialization/deserialization to text.
 
 !!! tip
 

home/faq/index.md

@@ -66,7 +66,7 @@ Question
 
 Can you add an option to ignore trailing commas?
 
-This library does not support any feature that would jeopardize interoperability.
+Yes, trailing commas in arrays and objects can be allowed by setting parameter `ignore_trailing_commas` of [`parse`](https://json.nlohmann.me/api/basic_json/parse/index.md) to `true`; see [trailing commas](https://json.nlohmann.me/features/trailing_commas/index.md). They are rejected by default, and the library never adds them when serializing.
 
 ### Parse errors reading non-ASCII characters
 
@@ -220,11 +220,11 @@ Question
 - It seems that precision is lost when serializing a double.
 - Can I change the precision for floating-point serialization?
 
-The library uses `std::numeric_limits<number_float_t>::digits10` (15 for IEEE `double`s) digits for serialization. This value is sufficient to guarantee roundtripping. If one uses more than this number of digits of precision, then string -> value -> string is not guaranteed to round-trip.
+The library serializes floating-point numbers with the shortest representation that parses back to the same value, using at most `std::numeric_limits<number_float_t>::max_digits10` (17 for IEEE `double`s) significant digits. This guarantees that value -> string -> value round-trips. The reverse direction, string -> value -> string, is only guaranteed for numbers with at most `std::numeric_limits<number_float_t>::digits10` (15 for IEEE `double`s) significant digits; a number with more digits may not be representable exactly and is then serialized as the closest `double`.
 
-[cppreference.com](https://en.cppreference.com/w/cpp/types/numeric_limits/digits10)
+[cppreference.com](https://en.cppreference.com/w/cpp/types/numeric_limits/max_digits10)
 
-The value of `std::numeric_limits<T>::digits10` is the number of base-10 digits that can be represented by the type T without change, that is, any number with this many significant decimal digits can be converted to a value of type T and back to decimal form, without change due to rounding or overflow.
+The value of `std::numeric_limits<T>::max_digits10` is the number of base-10 digits that are necessary to uniquely represent all distinct values of the type T, such as necessary for serialization/deserialization to text.
 
 Tip
 

home/license.md

@@ -18,6 +18,8 @@ The class contains the UTF-8 Decoder from Bjoern Hoehrmann which is licensed und
 
 The class contains a slightly modified version of the Grisu2 algorithm from Florian Loitsch which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright © 2009 [Florian Loitsch](https://florian.loitsch.com/)
 
+The class contains a port of the shortest double-to-decimal conversion of [Żmij](https://github.com/vitaut/zmij) by Victor Zverovich, including the conversion of the digits to text by Xiang JunBo and the SIMD instruction sequence of Dougall Johnson, which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright © 2025 [Victor Zverovich](https://github.com/vitaut)
+
 The class contains a copy of [Hedley](https://nemequ.github.io/hedley/) from Evan Nemerson which is licensed as [CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/).
 
-The class contains an adapted version of the Eisel-Lemire algorithm and its table of powers of five from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright © 2021 The fast_float authors
+The class contains an adapted version of the Eisel-Lemire algorithm, its table of powers of five, and its digit comparison for long numbers from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright © 2021 The fast_float authors

home/license/index.md

@@ -16,6 +16,8 @@ The class contains the UTF-8 Decoder from Bjoern Hoehrmann which is licensed und
 
 The class contains a slightly modified version of the Grisu2 algorithm from Florian Loitsch which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright © 2009 [Florian Loitsch](https://florian.loitsch.com/)
 
+The class contains a port of the shortest double-to-decimal conversion of [Żmij](https://github.com/vitaut/zmij) by Victor Zverovich, including the conversion of the digits to text by Xiang JunBo and the SIMD instruction sequence of Dougall Johnson, which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright © 2025 [Victor Zverovich](https://github.com/vitaut)
+
 The class contains a copy of [Hedley](https://nemequ.github.io/hedley/) from Evan Nemerson which is licensed as [CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/).
 
-The class contains an adapted version of the Eisel-Lemire algorithm and its table of powers of five from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright © 2021 The fast_float authors
+The class contains an adapted version of the Eisel-Lemire algorithm, its table of powers of five, and its digit comparison for long numbers from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright © 2021 The fast_float authors

integration/cmake.md

@@ -90,13 +90,13 @@ to the following.
 
 ### FetchContent
 
-Since CMake v3.11, [FetchContent](https://cmake.org/cmake/help/v3.11/module/FetchContent.html) can be used to
+Since CMake v3.14, [FetchContent](https://cmake.org/cmake/help/v3.14/module/FetchContent.html) can be used to
 automatically download a release as a dependency at configure time.
 
 !!! example
 
     ```cmake title="CMakeLists.txt"
-    cmake_minimum_required(VERSION 3.11)
+    cmake_minimum_required(VERSION 3.14)
     project(ExampleProject LANGUAGES CXX)
 
     include(FetchContent)

integration/cmake/index.md

@@ -86,14 +86,14 @@ endif()
 
 ### FetchContent
 
-Since CMake v3.11, [FetchContent](https://cmake.org/cmake/help/v3.11/module/FetchContent.html) can be used to automatically download a release as a dependency at configure time.
+Since CMake v3.14, [FetchContent](https://cmake.org/cmake/help/v3.14/module/FetchContent.html) can be used to automatically download a release as a dependency at configure time.
 
 Example
 
 CMakeLists.txt
 
 ```
-cmake_minimum_required(VERSION 3.11)
+cmake_minimum_required(VERSION 3.14)
 project(ExampleProject LANGUAGES CXX)
 
 include(FetchContent)

integration/compile_times.md

@@ -14,7 +14,8 @@ that cost, ordered by how much they typically save.
 
 Header files that only need to *name* the `json` type — for function declarations, members held by pointer or
 reference, or friend declarations — can include `<nlohmann/json_fwd.hpp>` instead of `<nlohmann/json.hpp>`. It only
-forward-declares `basic_json`, `json`, `ordered_json`, `json_pointer`, and `adl_serializer`. The translation units that
+forward-declares `basic_json`, `json_pointer`, `adl_serializer`, and `ordered_map`, and defines the aliases `json` and
+`ordered_json`. The translation units that
 actually use the values then include `<nlohmann/json.hpp>`.
 
 ```cpp title="person.hpp"