Fix -Wuseless-cast in array_prefix_set::reseed

uintptr_t is already uint64_t on LP64 Linux, so the explicit cast is useless there; rely on the implicit (widening) conversion instead. Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Make unflatten() linear in the length of the keys
2026-11-12 07:00:46 +00:00 · 2026-11-11 22:23:20 +01:00 · 2026-11-11 12:36:01 +01:00
30 changed files with 1077 additions and 2600 deletions
@@ -89,11 +89,8 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [out_of_range.406](../../home/exceptions.md#jsonexceptionout_of_range406) if a high-precision number, or a
  float64 when `number_float_t` is `float`, does not fit into `number_float_t`
 - Throws [out_of_range.408](../../home/exceptions.md#jsonexceptionout_of_range408) if the count of an optimized
-  container exceeds the capacity of the container (or of `std::size_t`; an array of type `N` is empty, so only the
+  container exceeds the capacity of the container (or of `std::size_t`), or if an optimized array of `Z`, `T`, or `F` has
-  latter applies to it), if an optimized array of `Z`, `T`, or `F` has more than 1,048,576 elements, or if the
+  more than 1,048,576 elements
  optimized arrays of `Z`, `T`, and `F` in the input together have more than 1,048,576 elements plus
  [`JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE`](../macros/json_ubjson_valueless_elements_per_byte.md) (4 by default) for
  every byte read so far
 ## Complexity
@@ -122,8 +119,6 @@ Linear in the size of the input.
 - [Parsing untrusted input](../../features/parsing/untrusted_input.md) - limits and safe handling of hostile data
 - [Binary values](../../features/binary_values.md) - how binary values and subtypes are handled
 - [`to_ubjson`](to_ubjson.md) - create a UBJSON serialization of a JSON value
 - [`JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE`](../macros/json_ubjson_valueless_elements_per_byte.md) -
  set how many elements of arrays of `null`, `true`, or `false` the input may announce per byte
 - [`from_cbor`](from_cbor.md) - create a JSON value from an input in CBOR format
 - [`from_msgpack`](from_msgpack.md) - create a JSON value from an input in MessagePack format
 - [`from_bson`](from_bson.md) - create a JSON value from an input in BSON format
@@ -137,12 +132,6 @@ Linear in the size of the input.
 - Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.
 - Extended overload (2) to accept heterogeneous iterator+sentinel pairs (C++20 ranges support) in version 3.13.0.
 - Added `error_handler` parameter in version 3.13.0.
 - Report `start_array(0)` to a SAX handler for an optimized array of type `N` (`[$N#n`), whatever its count, in version
  3.13.0.
 - Limited the total number of elements of optimized arrays of `Z`, `T`, and `F` in one input in version 3.13.0; the
  number of elements per byte can be set with
  [`JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE`](../macros/json_ubjson_valueless_elements_per_byte.md), for example to read
  files written by version 3.12.0 and earlier that exceed the default.
 !!! warning "Deprecation"
@@ -105,8 +105,6 @@ Linear in the size of the JSON value `j`.
 - [Binary formats](../../features/binary_formats/index.md) - overview and comparison of the supported binary formats
 - [Binary values](../../features/binary_values.md) - how binary values and subtypes are handled
 - [`from_ubjson`](from_ubjson.md) - create a JSON value from an input in UBJSON format
 - [`JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE`](../macros/json_ubjson_valueless_elements_per_byte.md) -
  set how many elements of arrays of `null`, `true`, or `false` a reader accepts per byte of input
 - [`to_cbor`](to_cbor.md) - create a CBOR serialization of a JSON value
 - [`to_msgpack`](to_msgpack.md) - create a MessagePack serialization of a JSON value
 - [`to_bson`](to_bson.md) - create a BSON serialization of a JSON value
@@ -119,10 +117,5 @@ Linear in the size of the JSON value `j`.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
  that is not valid UTF-8 unchanged, as before; `strict` (the default if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
 - Writes arrays of `Z`, `T`, or `F` without the `$` type annotation (`[#n Z Z ...`) once their elements in one call
  add up to more than 1,048,576, in version 3.13.0, so that `from_ubjson` can read the output back. Such output is
  larger: 270,000 rows of 100 `null` values take 26.8 MB instead of 1.35 MB. The limit does not depend on
  [`JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE`](../macros/json_ubjson_valueless_elements_per_byte.md): a reader accepts at
  least 1,048,576 elements whatever it is set to, so the writer follows that base only.
 - Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
  array or object was silently skipped, producing invalid UBJSON.
@@ -26,8 +26,6 @@ header. See also the [macro overview page](../../features/macros.md).
  UBJSON, BJData, and BSON writers
 - [**JSON_STRICT_NUL_HANDLING**](json_strict_nul_handling.md) - opt in to rejecting a NUL byte in the input instead of
  treating it as end of input
 - [**JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE**](json_ubjson_valueless_elements_per_byte.md) - set how many elements of
  UBJSON arrays of `null`, `true`, or `false` an input may announce per byte it has
 ## Language support
@@ -1,174 +0,0 @@
 # JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE
 ```cpp
 #define JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE /* value */
 ```
 [`from_ubjson`](../basic_json/from_ubjson.md) and [`sax_parse`](../basic_json/sax_parse.md) refuse an input in which the
 optimized arrays of type `Z` (null), `T` (true), and `F` (false) together have more than 1,048,576 elements plus
 `JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE` for every byte read so far, with
 [`out_of_range.408`](../../home/exceptions.md#jsonexceptionout_of_range408). The macro sets that number. It is the
 elements per byte that the input is allowed to announce without paying for them: an element of such an array is a
 single marker that is implied by the array's `$Z#n` header, so a few bytes can announce a million values (see
 [Parsing Untrusted Input](../../features/parsing/untrusted_input.md)).
 The macro only matters for input that was not written by this library 3.13.0 or later:
 [`to_ubjson`](../basic_json/to_ubjson.md) never writes more than the base of 1,048,576 elements in typed arrays of
 these types, and a reader accepts at least that many whatever the macro is. Its main use is reading files written by
 version 3.12.0 and earlier, which did not limit them (see
 [below](#reading-files-written-by-version-3120-and-earlier)).
 ## Default definition
 The default value is `4`.
 ```cpp
 #define JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE 4
 ```
 ## Notes
 !!! info "Allowed values"
    The value must be a **positive integer** (a value of `0` would not allow any element beyond the base, and a negative
    or fractional rate has no meaning). Any other value is a compile-time error with a message that names the macro:
    ```
    error: static assertion failed: JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE must be a positive integer
    error: static assertion failed: JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE must be an integer (not bool or a character type)
    error: static assertion failed: JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE must not be wider than std::uintmax_t
    ```
    The first is reported for `0` and negative values, the second for values such as `4.5`, `1e3`, `true`, or a
    character of any character type (`'a'`, `L'a'`, `u8'a'`, ...), and the third for an integer type that is wider than
    `#!cpp std::uintmax_t` (for example `unsigned __int128`). A value that is larger than the largest `#!cpp std::size_t` is treated as that largest value, so that a project can use one
    spelling, for example `0xFFFFFFFFFFFFFFFFu`, for 32-bit and 64-bit targets.
 !!! info "Large values: the limit is switched off"
    The limit is the base plus the rate times the bytes read. It saturates at the largest `#!cpp std::size_t` instead of
    overflowing, for any rate and any input size (also with a 32-bit `#!cpp std::size_t`), so a large value never makes
    the limit smaller. A rate of **at least 131,072** (`1048576 / 8`) effectively switches the limit for the whole
    input off: the shortest header of an array of more than 32,767 elements takes 8 bytes (`$Z#l` and four bytes of the
    count, inside an optimized array of arrays; 9 bytes, `[$Z#l`, at the top level), and a shorter header (`$Z#I` and
    two bytes) can announce at most 32,767. No array can then announce more than the rate times the bytes of its own
    header. With a rate of 131,071 that is not so: rows of 1,048,576 elements in 8 bytes each gain 8 elements per row,
    and a table of 278,527 such rows (2.2 MB) is the shortest input that is refused.
 !!! info "What the macro does not change"
    - The limit of **one array** stays at 1,048,576 elements
      ([`out_of_range.408`](../../home/exceptions.md#jsonexceptionout_of_range408), "excessive array size"), whatever
      the macro is. A value that switches the whole-input limit off does not allow a single array of 1,048,577
      elements.
    - The **base** of 1,048,576 elements is a fixed constant, the same as the limit of one array. An array that was
      accepted on its own before the whole-input limit existed is therefore still accepted at the start of an input.
    - The **writer** is not affected. [`to_ubjson`](../basic_json/to_ubjson.md) follows the base only: it writes a typed
      array of `Z`, `T`, or `F` only while the arrays written so far and this one stay within 1,048,576 elements, and
      writes the elements one by one otherwise. That is within the limit of every reader, because the limit is never
      below the base.
    - **Objects** and arrays of other types are not counted: every member of an object has a key, and every element of
      another type takes at least a byte of input.
    - [`from_bjdata`](../basic_json/from_bjdata.md) is not affected: BJData has no optimized arrays of these types.
 !!! info "Memory"
    A value takes 16 bytes in a DOM, so every element that the limit lets pass costs memory. Beyond the first 1,048,576
    elements (about 33 MB: 16 bytes per element, and a vector that grows by reallocation needs the old and the new
    storage at once), a malicious input of `n` bytes can take **about `20 * K * n` bytes** of memory in a DOM, where `K`
    is the value of the macro. The measurements below read inputs that are at the limit, with containers of `9 * K`
    elements (`[$Z#l` and a count, 9 bytes each), with `from_ubjson` on macOS, arm64, compiled with `-O2`. The numbers
    on other systems differ by the allocator; the 16 bytes per element are the lower bound.
    | `K`   | bytes of memory per byte of input | memory for 1 MB of input |
    |------:|----------------------------------:|-------------------------:|
    |     1 |                                25 |                    25 MB |
    |     4 |                                81 |                    81 MB |
    |    16 |                               312 |                   312 MB |
    |    64 |                             1,226 |                   1.2 GB |
    |   256 |                             5,493 |                   5.5 GB |
    A SAX handler receives the same number of events, and no memory beyond what it keeps. Choose the smallest value that
    accepts your files, not a large one, if the input comes from an untrusted source: a value of 131,072 or more
    switches the limit of the whole input off, so that every 8 bytes of input can announce another 1,048,576 values,
    the limit of one array.
 !!! warning "Define it before the include, in every translation unit"
    This macro must be defined **before** including `<nlohmann/json.hpp>`. Defining it after the include has no effect.
    The value is compiled into the member functions of the binary reader, which are inline, but it is **not**
    encoded in the [namespace](../../features/namespace.md) of the library (there is no ABI tag for it). It must
    have the same value in every translation unit of a program (for example by defining it on the command line or in
    a common header); translation units with different values violate the One Definition Rule, which is undefined
    behavior (no diagnostic is required). In practice, which value a read uses depends on which functions the compiler
    inlined and which out-of-line copy of each remaining function the linker kept, so a function compiled with one
    value can call a function compiled with the other, and a single parse can mix both values.
 ### Reading files written by version 3.12.0 and earlier
 Version 3.12.0 wrote an array of `Z`, `T`, or `F` of any length in the optimized form, and a table of equal rows as an
 optimized array of optimized arrays: a header of `[$[#` and the number of rows (`i` or `U` and 1 byte, `I` and 2 bytes, or
 `l` and 4 bytes: `h` = 6, 7, or 9 bytes in all for up to 255, 32,767, or more rows), then for every row `$Z#` and its count:
 5 bytes for up to 255 elements (`U`), 6 bytes for up to 32,767 (`I`), and 8 bytes above (`l`). Every row announces `N`
 elements for the `b` bytes of its header, so the limit grows by `K * b` and the number of elements by `N` per row.
 - A table is never refused if its rows have at most `K * b` elements each: at most 5 `K` for rows of up to 255
  elements (20 at the default of `K = 4`), at most 6 `K` for rows of 256 to 32,767 (rows of 1,000 need `K >= 167`),
  and at most 8 `K` above.
 - Otherwise the first `(1,048,576 + h * K) / (N - K * b)` rows are accepted, rounded down (`h` as above; 7 for the
  numbers here). For the default, a table of rows of 1,000 `null` values is read up to row 1,074 (the input of the first
  example below has 1,100); for `K = 1`, up to row 1,054; for `K = 16`, up to row 1,160.
 - In general, the smallest value that accepts an input is the largest of
  `(the elements of the arrays so far - 1,048,576) / (the bytes read when the header of the last of them has been
  read)` over all arrays, rounded up. For 1,100 rows of 1,000 elements that is
  `(1,100,000 - 1,048,576) / 6,607 = 7.8`, so `K = 8`.
 To read such a file, define the macro, before the include (or with `-DJSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE=8`), to
 the smallest value that accepts the file, and see the table above for what that value allows an untrusted input to
 cost. A file can be converted once: read it with the larger value and write it again with `to_ubjson`, which writes no
 typed array that a reader with the default value would refuse, so that the result does not need the macro.
 ## Examples
 ??? example "Example: default limit"
    The table of 1,100 rows of 1,000 `null` values (6,607 bytes) that version 3.12.0 wrote announces 1,100,000 values,
    which is more than 1,048,576 plus 4 for every byte read.
    ```cpp
    --8<-- "examples/ubjson_valueless_elements_per_byte.cpp"
    ```
    Output:
    ```
    --8<-- "examples/ubjson_valueless_elements_per_byte.output"
    ```
 ??? example "Example: raised limit"
    With 16 elements per byte the same table is read. The limit of one array still applies.
    ```cpp
    --8<-- "examples/ubjson_valueless_elements_per_byte_raised.cpp"
    ```
    Output:
    ```
    --8<-- "examples/ubjson_valueless_elements_per_byte_raised.output"
    ```
 ## See also
 - [`from_ubjson`](../basic_json/from_ubjson.md) - create a JSON value from a UBJSON serialization
 - [`to_ubjson`](../basic_json/to_ubjson.md) - create a UBJSON serialization of a JSON value
 - [`sax_parse`](../basic_json/sax_parse.md) - generate SAX events
 - [UBJSON](../../features/binary_formats/ubjson.md) - the format and its limits in the library
 - [Parsing Untrusted Input](../../features/parsing/untrusted_input.md) - limits and checks for input you do not control
 - [`out_of_range.408`](../../home/exceptions.md#jsonexceptionout_of_range408) - the exception that reports the limit
 ## Version history
 - Added in version 3.13.0.
@@ -50,8 +50,8 @@ flowchart LR
  enabled explicitly. Invalid UTF-8 is rejected.
 - **Errors are reported, not ignored.** Malformed input results in a [`parse_error`](../home/exceptions.md#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 all of them
+  only as bytes are actually read, arrays reserve at most a fixed number of elements up front, and sizes that no
-  together no more than the input read so far can back), and sizes that no container can hold are rejected.
+  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
@@ -1,34 +0,0 @@
 #include <cstdint>
 #include <iostream>
 #include <vector>
 #include <nlohmann/json.hpp>
 using json = nlohmann::json;
 // the bytes version 3.12.0 wrote for a table of 1100 rows of 1000 null values
 // with to_ubjson(table, true, true): `[$[#I` and the number of rows, then
 // `$Z#I` and the number of elements for every row
 std::vector<std::uint8_t> table_written_by_3_12_0()
 {
    std::vector<std::uint8_t> bytes = {'[', '$', '[', '#', 'I', 1100 >> 8, 1100 & 0xFF};
    for (int row = 0; row < 1100; ++row)
    {
        bytes.insert(bytes.end(), {'$', 'Z', '#', 'I', 1000 >> 8, 1000 & 0xFF});
    }
    return bytes;
 }
 int main()
 {
    try
    {
        // 6607 bytes announce 1,100,000 values, more than 1,048,576 plus 4 for
        // every byte read (the limit is exceeded in row 1075)
        json table = json::from_ubjson(table_written_by_3_12_0());
        std::cout << table.size() << " rows\n";
    }
    catch (const json::out_of_range& e)
    {
        std::cout << e.what() << '\n';
    }
 }
@@ -1 +0,0 @@
 [json.exception.out_of_range.408] syntax error while parsing UBJSON size: excessive number of elements without payload
@@ -1,42 +0,0 @@
 #include <cstdint>
 #include <iostream>
 #include <vector>
 // accept 16 values per byte of input instead of 4; define the macro before the
 // first inclusion of the header, and to the same value in every translation unit
 #define JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE 16
 #include <nlohmann/json.hpp>
 using json = nlohmann::json;
 // the bytes version 3.12.0 wrote for a table of 1100 rows of 1000 null values
 // with to_ubjson(table, true, true): `[$[#I` and the number of rows, then
 // `$Z#I` and the number of elements for every row
 std::vector<std::uint8_t> table_written_by_3_12_0()
 {
    std::vector<std::uint8_t> bytes = {'[', '$', '[', '#', 'I', 1100 >> 8, 1100 & 0xFF};
    for (int row = 0; row < 1100; ++row)
    {
        bytes.insert(bytes.end(), {'$', 'Z', '#', 'I', 1000 >> 8, 1000 & 0xFF});
    }
    return bytes;
 }
 int main()
 {
    // 6607 bytes announce 1,100,000 values, which is below 1,048,576 plus 16
    // for every byte read
    json table = json::from_ubjson(table_written_by_3_12_0());
    std::cout << table.size() << " rows of " << table[0].size() << " values\n";
    // a single container is still limited to 1,048,576 elements
    const std::vector<std::uint8_t> too_long = {'[', '$', 'Z', '#', 'l', 0x00, 0x10, 0x00, 0x01};
    try
    {
        json j = json::from_ubjson(too_long);
    }
    catch (const json::out_of_range& e)
    {
        std::cout << e.what() << '\n';
    }
 }
@@ -1,2 +0,0 @@
 1100 rows of 1000 values
 [json.exception.out_of_range.408] syntax error while parsing UBJSON size: excessive array size
@@ -119,31 +119,12 @@ The library uses the following mapping from JSON values types to UBJSON types ac
    receiving side is immediately informed on the number of elements of the container.
    An array whose type marker is `Z` (null), `T` (true) or `F` (false) stores no payload at all, because the marker
-    already is the value. Its declared count is therefore the only thing that decides how much memory the receiving
+    already is the value. Its declared count is therefore the only thing that decides how much memory the receiving side
-    side allocates, and a handful of bytes can describe billions of elements. `from_ubjson` rejects such an array with
+    allocates, and a handful of bytes can describe billions of elements. `from_ubjson` rejects such an array with
    [`out_of_range.408`](../../home/exceptions.md#jsonexceptionout_of_range408) when the count exceeds 1,048,576
-    (`1 << 20`), or when the counts of all such arrays in the input add up to more than 1,048,576 plus _K_ for every byte
+    (`1 << 20`), and `to_ubjson` writes longer arrays of these types in the counted but untyped form: the `$` type marker is
-    read so far, where _K_ is the value of the macro
+    dropped, the `#` count is kept, and every element is written with its own marker (`[#l 1048577 Z Z ...`), so any value
-    [`JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE`](../../api/macros/json_ubjson_valueless_elements_per_byte.md) (4 by
+    it produces can be read back. Objects and untyped counted arrays are not subject to this limit.
    default). `to_ubjson` therefore writes an array of these types in the counted but untyped form when it is longer
    than that, or when it would bring the total of the typed arrays written so far above 1,048,576: the `$` type
    marker is dropped, the `#` count is kept, and every element is written with its own marker 
    (`[#l 1048577 Z Z ...`), so everything it produces can be read back. Only input from another encoder, or written by version 3.12.0
    and earlier of this library, can exceed the limit: for example, 1,100 rows of 1,000 `null` values or 210,000 rows
    of 25, each with a `$Z` annotation. Version 3.12.0 writes a row in 5 bytes (6 above 255 elements, 8 above 32,767),
    which raises the limit by 5 _K_ (6 _K_, 8 _K_), so rows of up to 5 _K_ values (20 at the default) are never
    rejected. To read such a file, define the macro to a larger value (`8` is enough for the 1,100 rows of 1,000
    `null` values; memory for the arrays then rises to about 20 _K_ bytes per byte of input in a DOM); the macro's
    page explains how to choose a value and what it costs. The limit of one array of 1,048,576 elements does not
    depend on the macro. Objects and untyped counted arrays are not subject to this limit.
    An optimized array of type `N` (no-op) is empty whatever its count is, because a no-op is not a value. Its count is
    not passed on: `sax_parse` reports `start_array(0)` (versions before 3.13.0 reported the declared count), and the DOM
    parser reserves nothing for it.
    An optimized array of type `N` (no-op) is empty whatever its count is, because a no-op is not a value. Its count is
    not passed on: `sax_parse` reports `start_array(0)` (versions before 3.13.0 reported the declared count), and the DOM
    parser reserves nothing for it.
 !!! info "Binary values"
@@ -199,13 +180,10 @@ The library maps UBJSON types to JSON value types as follows:
    Every well-formed UBJSON value can be converted to a JSON value, with these exceptions: a high-precision number
    outside the range of `number_float_t` ([`out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406)),
-    optimized arrays of `Z`, `T`, or `F` with more elements than the limit allows (1,048,576 plus
+    an optimized array of `Z`, `T`, or `F` with more than 1,048,576 elements, and a count that exceeds the capacity of the
-    [`JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE`](../../api/macros/json_ubjson_valueless_elements_per_byte.md), 4 by default,
+    container ([`out_of_range.408`](../../home/exceptions.md#jsonexceptionout_of_range408)). High-precision numbers that
-    per byte read),
+    do not fit an integer type are stored as floating-point numbers and may lose precision. Ill-formed input is rejected
-    and a count that exceeds the capacity of the container
+    with a parse error.
    ([`out_of_range.408`](../../home/exceptions.md#jsonexceptionout_of_range408)). High-precision numbers that do not
    fit an integer type are stored as floating-point numbers and may lose precision. Ill-formed input is rejected with a
    parse error.
 !!! info "Duplicate object keys"
@@ -251,16 +251,6 @@ This macro overrides `#!cpp try` calls inside the library.
 See [full documentation of `JSON_TRY_USER`](../api/macros/json_throw_user.md).
 ## `JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE`
 Sets how many elements of optimized UBJSON arrays of `Z` (null), `T` (true), and `F` (false) a reader accepts for
 every byte of input it has read, on top of a base of 1,048,576 elements. These arrays have no payload, so a few bytes
 can announce a million values. The value must be a positive integer; the default is `4`, and a value of 131,072 or
 more switches the limit of the whole input off. The limit of 1,048,576 elements for a single array always applies. The
 macro is not part of the [ABI tag](namespace.md): use the same value in every translation unit.
 See [full documentation of `JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE`](../api/macros/json_ubjson_valueless_elements_per_byte.md).
 ## `JSON_USE_IMPLICIT_CONVERSIONS`
 When defined to `0`, implicit conversions are switched off. By default, implicit conversions are switched on.
@@ -71,39 +71,11 @@ For the binary formats, an announced size is never trusted outright:
  actually consumed, rather than allocating the announced length up front — a truncated input runs out of bytes
  (reported as a parse error) instead of triggering an oversized allocation.
 - When an array announces its number of elements and the array container supports `reserve()` (as `#!cpp std::vector`,
-  the default, does), the DOM parser reserves storage for them before the elements are read, but for at most 16384
+  the default, does), the library reserves storage for at most 16384 of them upfront, regardless of how large the
-  elements per array, regardless of how large the announced count is; further elements still grow the container
+  announced count is; further elements still grow the container normally as they are read.
  normally as they are read. The arrays that are open at the same time hold their storage at the same time, and an
  announcement is not backed by input when it is read, so the elements reserved for all arrays of one input together
  may not exceed 65,536 plus 2 for every byte of input read so far; an array that announces more gets what is left
  of that and grows as its elements arrive. An element takes at least one byte of input (except in the
  [UBJSON](../binary_formats/ubjson.md) arrays of type `Z`, `T` or `F` described below), so the elements of the
  arrays that were read use up what was reserved for them, and only arrays that are nested deeply, with an array as
  their first element, can announce more than is left. For a truncated or hostile input, the storage that
  announcements can hold is therefore at most (65,536 + 2 per byte of input) values, that is about 1 MiB plus 32 bytes
  per byte of input with 16-byte values (a value is larger with `JSON_DIAGNOSTICS` or `JSON_DIAGNOSTIC_POSITIONS`, 24 to
  40 bytes, and so is the bound). For example, 100,000 nested CBOR array headers `99 40 00` (300,000 bytes) that
  announce 16384 elements each peaked at 23 MiB, against 1.65 GiB if every array reserved what it announced and 12 MiB
  with version 3.12.0, which reserved nothing.
  A [SAX](../../api/json_sax/index.md) handler is not affected: it is told the announced number of elements.
 - An announced array or object size that exceeds what the target container could ever hold (its `max_size()`) is
  rejected immediately as [`out_of_range.408`](../../home/exceptions.md#jsonexceptionout_of_range408), without
  attempting to allocate anything.
 - A UBJSON array of the no-op type (`[$N#<n>`) is empty whatever count it declares: a SAX handler is told
  `start_array(0)` and the DOM parser reserves nothing.
 - A UBJSON array of type `Z`, `T` or `F` has no payload, so its announced count is not bounded by the input. One array
  may announce at most 1,048,576 elements, and all such arrays of one input together may contain at most 1,048,576
  elements plus _K_ for every byte read so far (checked when each array's header has been read), where _K_ is the
  value of the macro
  [`JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE`](../../api/macros/json_ubjson_valueless_elements_per_byte.md), 4 by
  default; beyond that the input is rejected as
  [`out_of_range.408`](../../home/exceptions.md#jsonexceptionout_of_range408). For a DOM that bounds the memory these
  arrays can need to about 20 _K_ bytes per byte of input (81 at the default, measured; 312 for _K_ = 16) plus about
  33 MB for the first 1,048,576 elements; a SAX handler receives at most that many events. Every other optimized array
  element, and every UBJSON object member (it has a key), takes at least one byte of input. Leave the macro at the
  default for input you do not control; raise it only to read trusted files that version 3.12.0 or earlier wrote with
  long arrays of these types, and see its page for how a value is chosen and what it costs. The limit of one array
  does not depend on the macro.
 ## Strings
@@ -1050,21 +1050,11 @@ The size of an array or object in a [binary format](../features/binary_formats/i
 the size following `#` for [UBJSON](../features/binary_formats/ubjson.md)/[BJData](../features/binary_formats/bjdata.md),
 or the encoded length for [CBOR](../features/binary_formats/cbor.md).
-The exception is also thrown for [UBJSON](../features/binary_formats/ubjson.md) arrays of a type that is encoded by
+The exception is also thrown for a [UBJSON](../features/binary_formats/ubjson.md) array of a type that is encoded by its
-its marker alone (`Z`, `T` or `F`). Such an array has no payload, so its count alone decides how much memory is
+marker alone (`Z`, `T` or `F`) whose declared count exceeds 1,048,576 (`1 << 20`). Such an array has no payload, so its
-allocated, and a handful of bytes would otherwise describe billions of values. It is thrown if the declared count of one
+count alone decides how much memory is allocated, and a handful of bytes would otherwise describe billions of values.
-array exceeds 1,048,576 (`1 << 20`), and if the counts of all such arrays read so far in one input add up to more than
+[`to_ubjson`](../api/basic_json/to_ubjson.md) writes longer arrays of these types without the `$` type annotation (the `#`
-1,048,576 plus 4 for every byte of the input read when the header of the last array has been read. The 4 is the
+count and one marker per element are kept), so any value it produces can still be read back.
 default of the macro
 [`JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE`](../api/macros/json_ubjson_valueless_elements_per_byte.md), which raises it
 (for the limit of the whole input; the limit of one array stays).
 [`to_ubjson`](../api/basic_json/to_ubjson.md) writes an array of these types without the `$` type annotation (the `#`
 count and one marker per element are kept) when it is longer, or when it would bring the total of the typed arrays
 written so far above 1,048,576, so everything it produces can be read back. Only input written by another encoder, or
 by version 3.12.0 and earlier of this library, can exceed the limit: for example, 1,100 rows of 1,000 `null` values or
 210,000 rows of 25, each with a `$Z` annotation. Version 3.12.0 writes such a row in 5 bytes (6 above 255 elements, 8
 above 32,767), so rows of 20 or fewer such values are never rejected at the default; define the macro to a larger value
 to read them.
 !!! failure "Example messages"
@@ -1080,9 +1070,6 @@ to read them.
    ```
    [json.exception.out_of_range.408] syntax error while parsing UBJSON size: excessive array size
    ```
    ```
    [json.exception.out_of_range.408] syntax error while parsing UBJSON size: excessive number of elements without payload
    ```
 ### json.exception.out_of_range.409
@@ -458,7 +458,6 @@ nav:
          - 'JSON_SKIP_UNSUPPORTED_COMPILER_CHECK': api/macros/json_skip_unsupported_compiler_check.md
          - 'JSON_STRICT_BINARY_UTF8': api/macros/json_strict_binary_utf8.md
          - 'JSON_STRICT_NUL_HANDLING': api/macros/json_strict_nul_handling.md
          - 'JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE': api/macros/json_ubjson_valueless_elements_per_byte.md
          - 'JSON_USE_GLOBAL_UDLS': api/macros/json_use_global_udls.md
          - 'JSON_USE_IMPLICIT_CONVERSIONS': api/macros/json_use_implicit_conversions.md
          - 'JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON': api/macros/json_use_legacy_discarded_value_comparison.md
@@ -16,7 +16,6 @@
 #include <iterator> // back_inserter
 #include <limits> // numeric_limits
 #include <string> // char_traits, string
 #include <type_traits> // false_type, integral_constant, is_convertible, is_integral, is_same, remove_cv, remove_reference, true_type
 #include <utility> // make_pair, move
 #include <vector> // vector
 #ifdef __cpp_lib_byteswap
@@ -74,132 +73,13 @@ the input.
 This is a sanity bound rather than a security boundary, and it is far above
 any container met in practice. @ref binary_writer falls back to the
-unoptimized encoding for longer containers, and for containers that together
+unoptimized encoding for longer containers, so that a value serialized by
-with the ones before them would exceed @ref valueless_elements_base, so that a
+this library can always be read back.
 value serialized by this library can always be read back.
@sa https://github.com/nlohmann/json/issues/2793
 */
 JSON_INLINE_VARIABLE constexpr std::size_t max_valueless_container_size = 1 << 20;
 /*!
@brief number of elements of valueless UBJSON containers accepted on top of
       @ref valueless_elements_per_byte
 The limit @ref max_valueless_container_size applies to each container on its
 own, so on its own it lets 9 bytes announce 1048576 values, and every further
 8 bytes (a row of an optimized array of arrays) another 1048576. The elements of all containers of a valueless type
 in one input are therefore added up, and the sum must stay below this base
 plus @ref valueless_elements_per_byte for every byte read so far. The base is
 the per-container limit, so a container that was accepted on its own before
 the sum was introduced is still accepted at the start of an input.
 */
 JSON_INLINE_VARIABLE constexpr std::size_t valueless_elements_base = max_valueless_container_size;
 /// the value of JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE as a std::size_t:
 /// saturated at the largest one, not truncated, for a value that is wider
 template<typename T>
 constexpr std::size_t valueless_elements_rate(const T value) noexcept
 {
    return static_cast<std::uintmax_t>(value) > (std::numeric_limits<std::size_t>::max)()
           ? (std::numeric_limits<std::size_t>::max)()
           : static_cast<std::size_t>(value);
 }
 /*!
@brief number of elements of valueless UBJSON containers accepted per byte of
       input, in addition to @ref valueless_elements_base
 This is the value of the macro JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE (4 by
 default), see docs/mkdocs/docs/api/macros/json_ubjson_valueless_elements_per_byte.md.
 An element of a value that has a payload costs at least one byte of input, but
 an element of a valueless type costs none, so these are the only elements whose
 number the input does not bound. They are accepted at this rate per byte read,
 which bounds the memory they take in a DOM: a value takes 16 bytes there, so
 the arrays at the limit take about 20 times this rate bytes of memory per byte
 of input (16 for the value, the rest is allocator rounding and the arrays
 themselves; measured on macOS, DOM, with containers of 9 times the rate
 elements: 25 bytes per byte at a rate of 1, 81 at 4, 312 at 16, 1226 at 64 and
 5493 at 256), plus about 33 MB for the first elements of the base (16 bytes for
 each of the 1048576 elements, and a vector that grows by reallocation, as only
 16384 elements are reserved upfront, needs the old and the new storage at once).
 The bound is meant for input written by other encoders and by versions before
 3.13.0, which wrote long arrays of this type optimized without a limit: input
 written by @ref binary_writer never needs more than the base, because the
 writer falls back to the unoptimized form once the arrays written so far and
 the next one add up to more than that, whatever the rate is.
 Range: a positive integer. A value that is not one is a compile-time error (a
 reader with a rate of 0 would accept nothing beyond the base, and a negative or
 fractional rate has no meaning). A value that does not fit into std::size_t is
 used as the largest std::size_t: the rate is so high then that the bound is
 out of reach anyway, and a project can use one spelling (for example
 `0xFFFFFFFFFFFFFFFFu`) for 32 and 64 bit targets. The type of the value must
 be an integer type that is not wider than std::uintmax_t and not bool or a
 character type. A rate of at least 2^20 / 8 = 131072 effectively switches the
 whole-input bound off: an array of more than 32767 elements needs a count of
 type `l`, so its shortest header is `$Z#l` and four bytes (8 bytes) inside an
 optimized array of arrays (9 bytes, `[$Z#l`, at the top level), and a shorter
 header (`$Z#I` and two bytes) announces at most 32767. Every container thus has
 at most (rate * header bytes) elements, which never exceeds the limit. With a
 rate of 131071 an input that is refused exists (rows of 1048576 elements gain
 8 elements each); the per-container limit still applies.
 The value must be the same in every translation unit of a program (it is
 compiled into member functions of binary_reader, which are inline), and it is
 not part of the ABI tag of the namespace.
 */
 JSON_INLINE_VARIABLE constexpr std::size_t valueless_elements_per_byte =
    // a value that does not fit into std::size_t is the largest one (see above);
    // the comparison is made in the widest unsigned type, so that nothing is
    // truncated before it is made. A function template, so that the casts are
    // not "useless" (-Wuseless-cast) where the macro already has the type
    valueless_elements_rate((JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE));
 /// the type of the macro's value is char8_t (C++20)
 template<typename T>
 #if defined(__cpp_char8_t)
 struct valueless_elements_rate_is_char8 : std::is_same<T, char8_t> {};
 #else
 struct valueless_elements_rate_is_char8 : std::false_type {};
 #endif
 /// the type of the macro's value is a character or boolean type
 template<typename T>
 struct valueless_elements_rate_is_char_or_bool
    : disjunction<std::is_same<T, bool>, std::is_same<T, char>, std::is_same<T, signed char>,
      std::is_same<T, unsigned char>, std::is_same<T, wchar_t>, std::is_same<T, char16_t>,
      std::is_same<T, char32_t>, valueless_elements_rate_is_char8<T>>
 {};
 // these messages are what a user sees for a wrong value of the macro. The
 // integer test comes first because a fractional value would also fail the
 // positivity test; a value wider than std::uintmax_t would be truncated by
 // the conversion above, so it is rejected
 static_assert(std::is_integral<typename std::remove_reference<decltype((JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE))>::type>::value
              && !valueless_elements_rate_is_char_or_bool<typename std::remove_cv<typename std::remove_reference<decltype((JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE))>::type>::type>::value,
              "JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE must be an integer (not bool or a character type)");
 static_assert(sizeof(decltype((JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE))) <= sizeof(std::uintmax_t),
              "JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE must not be wider than std::uintmax_t");
 static_assert((JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE) > 0,
              "JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE must be a positive integer");
 /*!
@brief the number of bytes read up to which
       @ref valueless_elements_base plus @ref valueless_elements_per_byte times
       that number can be computed in std::size_t
 For more bytes than this the limit of the valueless elements is the largest
 std::size_t, which is saturation: the sum is not computed, because it would wrap
 around, which happens for a rate that is large (the largest std::size_t as the
 rate wraps already at the first byte) or an input that is large (more than
 about a billion bytes for the default rate with a 32-bit std::size_t). It is a
 constant of the build, so no division is made while reading.
 */
 JSON_INLINE_VARIABLE constexpr std::size_t valueless_elements_saturation_chars =
    ((std::numeric_limits<std::size_t>::max)() - valueless_elements_base) / (valueless_elements_per_byte == 0 ? 1 : valueless_elements_per_byte);
 ///////////////////
 // binary reader //
 ///////////////////
@@ -267,8 +147,6 @@ class binary_reader
        sax = sax_;
        container_stack.clear();
        bon8_pushback_size = 0;
        // the position is only known to the DOM parser while this reader lives
        const position_binding binding(bound_parser(sax, std::is_convertible<SAX*, json_sax_dom_error_state*> {}), &chars_read);
        bool result = false;
        switch (input_format)
@@ -326,61 +204,6 @@ class binary_reader
    }
  private:
    /// the DOM parser of @a s whose reserved storage is bounded by the input
    /// read so far; nullptr for any other SAX parser, which does not reserve,
    /// and for one that derives from a DOM parser privately or protectedly
    /// (or ambiguously), which the reader cannot reach
    static json_sax_dom_error_state* bound_parser(SAX* s, std::true_type /*is a DOM parser*/) noexcept
    {
        return s;
    }
    static json_sax_dom_error_state* bound_parser(SAX* /*s*/, std::false_type /*is a DOM parser*/) noexcept
    {
        return nullptr;
    }
    /*!
    @brief tells a DOM parser where to find the number of characters read
           while sax_parse() runs, and puts back what it knew before when
           sax_parse() returns or throws
    The reader is a local of the caller and is gone then, so the parser must
    not keep its position. A parser that was bound by a reader that is still
    running (a parse inside a parse) gets that binding back; that reader is
    still alive, as it encloses this one.
    */
    class position_binding
    {
      public:
        position_binding(json_sax_dom_error_state* parser_, const std::size_t* position) noexcept
            : parser(parser_), saved()
        {
            if (parser != nullptr)
            {
                saved = parser->get_reserve_state();
                parser->set_input_position(position);
            }
        }
        position_binding(const position_binding&) = delete;
        position_binding(position_binding&&) = delete;
        position_binding& operator=(const position_binding&) = delete;
        position_binding& operator=(position_binding&&) = delete;
        ~position_binding()
        {
            if (parser != nullptr)
            {
                parser->set_reserve_state(saved);
            }
        }
      private:
        json_sax_dom_error_state* parser;
        json_sax_dom_error_state::reserve_state saved;
    };
    ////////////////////////
    // nested containers  //
    ////////////////////////
@@ -3877,38 +3700,6 @@ class binary_reader
        return emit_unsigned(number);
    }
    /*!
    @brief add the elements of a container of a valueless type to the total of
           the input and check the total against the input read so far
    A container of type 'Z', 'T' or 'F' has no payload, so its elements are the
    only ones for which the input does not bound the count. The check is made
    once per container, not per element.
    @param[in] count  number of elements the container declares; at most
                      @ref max_valueless_container_size
    @return false if the total is more than @ref valueless_elements_base plus
            @ref valueless_elements_per_byte for every byte read so far; the
            total is not changed then
    */
    bool charge_valueless_elements(const std::size_t count) noexcept
    {
        // limit = base + rate * chars_read, saturating at the largest size_t
        // instead of wrapping around, which would make a huge rate or input
        // reject everything. valueless_elements never exceeds the limit of an
        // earlier call, and the limit does not decrease, so the difference
        // below cannot underflow.
        const std::size_t limit = chars_read <= valueless_elements_saturation_chars
                                  ? valueless_elements_base + (valueless_elements_per_byte * chars_read)
                                  : (std::numeric_limits<std::size_t>::max)();
        if (JSON_HEDLEY_UNLIKELY(count > limit - valueless_elements))
        {
            return false;
        }
        valueless_elements += count;
        return true;
    }
    /*!
    @return whether array creation completed
    */
@@ -3994,27 +3785,24 @@ class binary_reader
            // declared count alone decides how much is allocated; the check is
            // made before the start event so that no container is opened that
            // is then abandoned. See @ref max_valueless_container_size.
-            if (JSON_HEDLEY_UNLIKELY(size_and_type.second == 'Z' || size_and_type.second == 'T' || size_and_type.second == 'F'))
+            if (JSON_HEDLEY_UNLIKELY((size_and_type.second == 'Z' || size_and_type.second == 'T' || size_and_type.second == 'F')
                                     && size_and_type.first > max_valueless_container_size))
            {
-                if (JSON_HEDLEY_UNLIKELY(size_and_type.first > max_valueless_container_size))
+                return out_of_range_error(exception_id::container_too_large, "excessive array size", "size");
                {
                    return out_of_range_error(exception_id::container_too_large, "excessive array size", "size");
                }
                if (JSON_HEDLEY_UNLIKELY(!charge_valueless_elements(size_and_type.first)))
                {
                    return out_of_range_error(exception_id::container_too_large, "excessive number of elements without payload", "size");
                }
            }
-            // a no-op is not a value, so an array of them is empty whatever
+            if (JSON_HEDLEY_UNLIKELY(!enter_array(size_and_type.first, size_and_type.second)))
            // count it declares: the SAX parser is told so, instead of being
            // made to reserve storage for a count that no input backs
            const std::size_t announced = size_and_type.second == 'N' ? 0 : size_and_type.first;
            if (JSON_HEDLEY_UNLIKELY(!enter_array(announced, size_and_type.second)))
            {
                return false;
            }
            if (size_and_type.second == 'N')
            {
                // a no-op is not a value, so a container of them holds none;
                // the declared size has already been passed to the SAX parser
                container_stack.back().remaining = 0;
            }
            return size_and_type.second == 0
                   || parse_ubjson_typed_run(container_stack.back().remaining, size_and_type.second, std::integral_constant<bool, bulk_scan> {});
        }
@@ -5326,10 +5114,6 @@ class binary_reader
    /// the number of characters read
    std::size_t chars_read = 0;
    /// UBJSON: the sum of the element counts of the containers of a valueless
    /// type read so far; see @ref charge_valueless_elements
    std::size_t valueless_elements = 0;
    /// whether we can assume little endianness
    const bool is_little_endian = little_endianness();
@@ -159,40 +159,6 @@ constexpr std::size_t unknown_size()
    return (std::numeric_limits<std::size_t>::max)();
 }
 /// the largest number of elements the DOM parsers reserve for one array upfront
 constexpr std::size_t reserve_cap()
 {
    return 16384;
 }
 /*!
@brief number of array elements a DOM parser may reserve upfront on top of
       @ref reserved_elements_per_byte
 An array that announces its size is given storage for that many elements when
 it opens (at most @ref reserve_cap of them), before any input backs the
 announcement, and the arrays that are open at the same time keep their storage
 until the input is complete: 100000 nested headers of three bytes each that
 announce 16384 elements would otherwise need 1.7 GB. The elements reserved for
 all arrays of an input are therefore added up, and the sum must stay below
 this base plus @ref reserved_elements_per_byte for every byte read so far; an
 array that would go beyond reserves what is left, and grows as its elements
 arrive. The base is four arrays of the maximum size, so the first nested
 arrays of an input are not affected.
 */
 JSON_INLINE_VARIABLE constexpr std::size_t reserved_elements_base = 4 * reserve_cap();
 /*!
@brief number of array elements a DOM parser may reserve upfront per byte of
       input, in addition to @ref reserved_elements_base
 An element of an array takes at least one byte of input, so an array that
 completes has used what was reserved for it. At a rate of 2 elements per
 byte, an array that announces more than the input provides keeps at most
 32 bytes of memory per byte of input, plus the base, until the parse fails.
 */
 JSON_INLINE_VARIABLE constexpr std::size_t reserved_elements_per_byte = 2;
 /*!
@brief reserve capacity for @a len elements in array @a arr
@@ -208,7 +174,8 @@ template<typename ArrayType>
 auto reserve_array(ArrayType& arr, std::size_t len, priority_tag<1> /*unused*/)
 -> decltype(arr.reserve(len), void())
 {
-    arr.reserve((std::min)(len, reserve_cap()));
+    constexpr std::size_t reserve_cap = 16384;
    arr.reserve((std::min)(len, reserve_cap));
 }
 template<typename ArrayType>
@@ -375,13 +342,6 @@ struct diagnostic_positions
 Holds whether a parse error occurred and whether errors are thrown, and
 implements the parse_error() and is_errored() members of the SAX interface for
 json_sax_dom_parser and json_sax_dom_callback_parser.
 It also bounds what the parsers reserve for arrays that announce their size
 (reserve_count()): the announced size is not backed by input yet when the
 array opens, and the arrays that are open at the same time each keep what was
 reserved for them, so the binary_reader tells the parser where to find the
 number of characters it has read (set_input_position()), which the bound
 is derived from.
 */
 class json_sax_dom_error_state
 {
@@ -415,103 +375,7 @@ class json_sax_dom_error_state
        return errored;
    }
    /// bind the number of characters the input has provided so far; see
    /// @ref reserve_count
    /// (nullptr: not known, which bounds only the size of each array)
    void set_input_position(const std::size_t* position) noexcept
    {
        input_position = position;
        credit_position = 0;
        reserve_credit = position != nullptr ? reserved_elements_base : (std::numeric_limits<std::size_t>::max)();
    }
    /// what set_input_position() changes, so that a binding can be undone
    struct reserve_state
    {
        const std::size_t* position;
        std::size_t position_at_refill;
        std::size_t credit;
    };
    reserve_state get_reserve_state() const noexcept
    {
        return {input_position, credit_position, reserve_credit};
    }
    void set_reserve_state(const reserve_state& state) noexcept
    {
        input_position = state.position;
        credit_position = state.position_at_refill;
        reserve_credit = state.credit;
    }
  protected:
    /*!
    @brief the number of elements to reserve for an array that announces @a len
    The announced number is not backed by input when the array opens, and the
    arrays that are open at the same time each keep what was reserved for
    them, so what is reserved for all arrays together is bounded by the
    input read so far: @ref reserved_elements_base plus
    @ref reserved_elements_per_byte for every character. An array that
    announces more than what is left of that is given what is left, and
    grows as its elements arrive. Without the position of the input (the
    parser is not driven by a binary_reader that is running) nothing is
    bounded but the cap of reserve_array().
    The common case, an array that announces no more than the credit left,
    costs a comparison and a subtraction. It is charged what it announces, which
    for an array of more than reserve_cap() elements is more than reserve_array()
    reserves for it, which its own elements refill as they are read.
    */
    std::size_t reserve_count(const std::size_t len) noexcept
    {
        if (JSON_HEDLEY_LIKELY(len <= reserve_credit))
        {
            reserve_credit -= len;
            return len;
        }
        return reserve_count_slowly(len);
    }
  private:
    JSON_HEDLEY_NEVER_INLINE
    std::size_t reserve_count_slowly(const std::size_t len) noexcept
    {
        constexpr std::size_t max_size = (std::numeric_limits<std::size_t>::max)();
        if (input_position == nullptr)
        {
            reserve_credit = max_size;
            return len;
        }
        // refill the credit with 'reserved_elements_per_byte' for every
        // character read since the last refill; it saturates instead of
        // overflowing when size_t is 32 bits wide and a very large input has
        // been read (the position goes back by up to two in BON8, which has
        // no sizes)
        const std::size_t position = *input_position;
        if (position > credit_position)
        {
            const std::size_t bytes = position - credit_position;
            reserve_credit = bytes <= (max_size - reserve_credit) / reserved_elements_per_byte
                             ? reserve_credit + (reserved_elements_per_byte * bytes)
                             : max_size;
            credit_position = position;
        }
        std::size_t count = (std::min)(len, reserve_cap());
        count = (std::min)(count, reserve_credit);
        reserve_credit -= count;
        return count;
    }
    /// the number of characters the input has provided so far, if known
    const std::size_t* input_position = nullptr;
    /// the number of characters the input had provided when the credit was refilled
    std::size_t credit_position = 0;
    /// the number of elements that may still be reserved
    std::size_t reserve_credit = reserved_elements_base;
    /// whether a syntax error occurred
    bool errored = false;
    /// whether to throw exceptions in case of errors
@@ -1346,7 +1210,7 @@ class json_sax_dom_parser : public json_sax_dom_error_state
        if (len != detail::unknown_size())
        {
-            reserve_array(*ref->m_data.m_value.array, reserve_count(len), priority_tag<1> {});
+            reserve_array(*ref->m_data.m_value.array, len, priority_tag<1> {});
        }
    }
@@ -1694,7 +1558,7 @@ class json_sax_dom_binary_parser : public json_sax_dom_error_state
        if (len != detail::unknown_size())
        {
-            reserve_array(*ref_stack.back()->m_data.m_value.array, reserve_count(len), priority_tag<1> {});
+            reserve_array(*ref_stack.back()->m_data.m_value.array, len, priority_tag<1> {});
        }
        return true;
@@ -1986,7 +1850,7 @@ class json_sax_dom_callback_parser : public json_sax_dom_error_state
            if (len != detail::unknown_size())
            {
-                reserve_array(*ref_stack.back()->m_data.m_value.array, reserve_count(len), priority_tag<1> {});
+                reserve_array(*ref_stack.back()->m_data.m_value.array, len, priority_tag<1> {});
            }
        }
@@ -852,139 +852,6 @@ class json_pointer
    }
  private:
    /*!
    @brief the pointer prefixes of a flattened object that denote arrays
    @ref unflatten creates arrays exactly below the prefixes that have a
    reference token 0 among their children, and objects everywhere else.
    Deciding this up front keeps the result independent of the order in which
    the flattened object is iterated, which is unspecified for some object
    types.
    A prefix is identified by the text of the key it is the beginning of:
    escaping is unambiguous, so equal prefixes of valid keys are equal texts.
    The set refers to the keys, which must outlive it.
    */
    class array_prefix_set
    {
      public:
        void insert(const char* data, std::size_t size)
        {
            // flattened objects are usually sorted, so most keys that have a
            // 0 yield the prefix of the previous one
            if (last_data != nullptr && last_size == size && std::memcmp(last_data, data, size) == 0)
            {
                return;
            }
            last_data = data;
            last_size = size;
            if (table.empty())
            {
                table.resize(16);
            }
            const std::size_t hash = hash_of(data, size);
            const std::size_t mask = table.size() - 1;
            std::size_t i = hash & mask;
            while (table[i].data != nullptr)
            {
                if (table[i].hash == hash && table[i].size == size && std::memcmp(table[i].data, data, size) == 0)
                {
                    return;
                }
                i = (i + 1) & mask;
            }
            table[i] = slot(hash, data, size);
            // keep the load factor below 1/2
            if (++used * 2 > table.size())
            {
                grow();
            }
        }
        bool empty() const noexcept
        {
            return used == 0;
        }
        bool contains(const char* data, std::size_t size) const noexcept
        {
            if (used == 0)
            {
                return false;
            }
            const std::size_t hash = hash_of(data, size);
            const std::size_t mask = table.size() - 1;
            for (std::size_t i = hash & mask; table[i].data != nullptr; i = (i + 1) & mask)
            {
                if (table[i].hash == hash && table[i].size == size && std::memcmp(table[i].data, data, size) == 0)
                {
                    return true;
                }
            }
            return false;
        }
      private:
        struct slot
        {
            slot() noexcept = default;
            slot(std::size_t h, const char* d, std::size_t s) noexcept
                : hash(h), data(d), size(s)
            {}
            std::size_t hash = 0;
            const char* data = nullptr; // nullptr: the slot is empty
            std::size_t size = 0;
        };
        static std::size_t hash_of(const char* data, std::size_t size) noexcept
        {
            std::uint64_t h = 0x9E3779B97F4A7C15ULL ^ size;
            std::size_t i = 0;
            for (; i + 8 <= size; i += 8)
            {
                std::uint64_t w = 0;
                std::memcpy(&w, data + i, 8);
                h = (h ^ w) * 0x100000001B3ULL;
                h ^= h >> 32u;
            }
            std::uint64_t w = 0;
            if (i < size)
            {
                std::memcpy(&w, data + i, size - i);
            }
            h = (h ^ w) * 0x9E3779B97F4A7C15ULL;
            return detail::conditional_static_cast<std::size_t>(h ^ (h >> 29u));
        }
        void grow()
        {
            std::vector<slot> old(table.size() * 2);
            old.swap(table);
            const std::size_t mask = table.size() - 1;
            for (const auto& s : old)
            {
                if (s.data != nullptr)
                {
                    std::size_t i = s.hash & mask;
                    while (table[i].data != nullptr)
                    {
                        i = (i + 1) & mask;
                    }
                    table[i] = s;
                }
            }
        }
        std::vector<slot> table{};
        std::size_t used = 0;
        const char* last_data = nullptr;
        std::size_t last_size = 0;
    };
    /// @brief the length of the longest common prefix of the first @a limit bytes of @a a and @a b
    static std::size_t common_prefix_length(const char* a, const char* b, const std::size_t limit) noexcept
    {
@@ -1007,6 +874,355 @@ class json_pointer
        return i;
    }
    /*!
    @brief the prefixes of a flattened object that are marked as arrays, for
           prefixes that are not short
    A prefix is identified by the tokens it consists of: a node of a tree
    stands for the prefix of its parent followed by a token, and is looked up
    by its parent and the text of the token. The node of a prefix is found by
    walking the tokens of the key from the root, so identifying all prefixes
    of a key together costs one pass over the key, however long the prefixes
    are, and no prefix is ever compared byte by byte as a whole. The nodes
    along the key that was walked last are kept, and the walk of the next key
    starts below the beginning it has in common with that key. The tree refers
    to the keys, which must outlive it.
    */
    class prefix_tree
    {
      public:
        /// @brief set the seed of the hash function, before anything is added
        void reseed(const std::uint64_t seed_value) noexcept
        {
            seed = seed_value;
        }
        /// @brief mark the first @a prefix_size bytes of the key of @a key_size bytes at @a data
        void mark(const char* data, std::size_t key_size, std::size_t prefix_size)
        {
            nodes[walk(data, key_size, prefix_size)].marked = true;
            any_marked = true;
        }
        bool is_marked(const char* data, std::size_t key_size, std::size_t prefix_size)
        {
            return any_marked && nodes[walk(data, key_size, prefix_size)].marked;
        }
        bool empty() const noexcept
        {
            return !any_marked;
        }
        /// @brief the hash of the first @a size bytes at @a data, for the seed @a seed_value
        static std::size_t hash_bytes(const char* data, std::size_t size, const std::uint64_t seed_value) noexcept
        {
            std::uint64_t h = seed_value ^ size;
            std::size_t i = 0;
            for (; i + 8 <= size; i += 8)
            {
                std::uint64_t w = 0;
                std::memcpy(&w, data + i, 8);
                h = (h ^ w) * 0x100000001B3ULL;
                h ^= h >> 32u;
            }
            std::uint64_t w = 0;
            if (i < size)
            {
                std::memcpy(&w, data + i, size - i);
            }
            h = (h ^ w) * 0x9E3779B97F4A7C15ULL;
            return detail::conditional_static_cast<std::size_t>(h ^ (h >> 29u));
        }
      private:
        struct node
        {
            std::size_t parent = 0;
            std::size_t hash = 0;
            const char* token = nullptr;
            std::size_t token_size = 0;
            bool marked = false;
        };
        /// @brief a slot of the hash table; the index of a node, 0 if the slot is empty
        struct bucket
        {
            std::size_t index = 0;
        };
        /// @brief the node after a token of the key that was walked last, and where the token ends
        struct step
        {
            std::size_t node = 0;
            std::size_t end = 0;
        };
        /// @brief the index of the node of the prefix that ends at the slash (or the end) at @a prefix_size
        std::size_t walk(const char* data, std::size_t key_size, std::size_t prefix_size)
        {
            if (nodes.empty())
            {
                nodes.emplace_back();
                table.resize(16);
                chain.emplace_back();
            }
            if (data != last_key)
            {
                // keep the nodes within the beginning that this key has in common
                // with the key they were found for; a prefix that ends inside a
                // token of this key is not one of its prefixes
                const std::size_t same = common_prefix_length(data, last_key, (std::min)(key_size, last_key_size));
                std::size_t keep = chain.size();
                while (keep > 1 && (chain[keep - 1].end > same || (chain[keep - 1].end == same && same < key_size && data[same] != '/')))
                {
                    --keep;
                }
                chain.resize(keep);
                last_key = data;
                last_key_size = key_size;
            }
            // walk the tokens that are not walked yet
            while (chain.back().end < prefix_size && chain.back().end < key_size)
            {
                const std::size_t start = chain.back().end + 1;
                const void* const slash = std::memchr(data + start, '/', key_size - start);
                const std::size_t end = slash == nullptr ? key_size : static_cast<std::size_t>(static_cast<const char*>(slash) - data);
                step next;
                next.node = child(chain.back().node, data + start, end - start);
                next.end = end;
                chain.push_back(next);
            }
            if (chain.back().end == prefix_size)
            {
                return chain.back().node;
            }
            // an earlier call walked further
            const auto it = std::lower_bound(chain.begin(), chain.end(), prefix_size, [](const step & s, std::size_t size)
            {
                return s.end < size;
            });
            return it->node;
        }
        std::size_t slot_of(std::size_t parent, std::size_t hash) const noexcept
        {
            std::uint64_t x = static_cast<std::uint64_t>(hash) ^ (static_cast<std::uint64_t>(parent) * 0x9E3779B97F4A7C15ULL);
            x ^= x >> 32u;
            x *= 0xD6E8FEB86659FD93ULL;
            x ^= x >> 32u;
            return static_cast<std::size_t>(x) & (table.size() - 1);
        }
        /// @brief the node of the prefix of the node @a parent followed by the token, which is added if it is not there
        std::size_t child(std::size_t parent, const char* token, std::size_t token_size)
        {
            const std::size_t hash = hash_bytes(token, token_size, seed);
            std::size_t i = slot_of(parent, hash);
            while (table[i].index != 0)
            {
                const node& n = nodes[table[i].index];
                if (n.parent == parent && n.hash == hash && n.token_size == token_size && std::memcmp(n.token, token, token_size) == 0)
                {
                    return table[i].index;
                }
                i = (i + 1) & (table.size() - 1);
            }
            node created;
            created.parent = parent;
            created.hash = hash;
            created.token = token;
            created.token_size = token_size;
            nodes.push_back(created);
            table[i].index = nodes.size() - 1;
            // keep the load factor below 1/2
            if (nodes.size() * 2 > table.size())
            {
                std::vector<bucket> old(table.size() * 2);
                old.swap(table);
                for (std::size_t k = 1; k < nodes.size(); ++k)
                {
                    std::size_t j = slot_of(nodes[k].parent, nodes[k].hash);
                    while (table[j].index != 0)
                    {
                        j = (j + 1) & (table.size() - 1);
                    }
                    table[j].index = k;
                }
            }
            return nodes.size() - 1;
        }
        std::uint64_t seed = 0;
        /// @brief the nodes; the first is the root, the empty prefix
        std::vector<node> nodes{};
        /// @brief the nodes (not the root) in a hash table
        std::vector<bucket> table{};
        /// @brief the root, and the node after each token of the key that was walked last
        std::vector<step> chain{};
        const char* last_key = nullptr;
        std::size_t last_key_size = 0;
        bool any_marked = false;
    };
    /*!
    @brief the pointer prefixes of a flattened object that denote arrays
    @ref unflatten creates arrays exactly below the prefixes that have a
    reference token 0 among their children, and objects everywhere else.
    Deciding this up front keeps the result independent of the order in which
    the flattened object is iterated, which is unspecified for some object
    types.
    A prefix is identified by the text of the key it is the beginning of:
    escaping is unambiguous, so equal prefixes of valid keys are equal texts.
    The set refers to the keys, which must outlive it. Short prefixes are
    kept in a hash table and compared as texts, which costs at most the length
    of the bound. Longer prefixes are kept in a @ref prefix_tree, because
    hashing and comparing every one of the prefixes of a key with many tokens
    from its beginning would take quadratic time.
    The hash function depends on a seed that is derived from the address of a
    local variable, which address space layout randomization changes between
    processes, so keys cannot be crafted to collide in advance; the result
    does not depend on the seed. Where the addresses are not randomized, or
    when the seed is known, keys can collide: k short prefixes then cost
    k^2 / 2 comparisons of fewer than 64 bytes each. The long prefixes are not
    hashed as a whole.
    */
    class array_prefix_set
    {
      public:
        /// @brief choose the seed of the hash function, before anything is added: it is derived from the address that is passed
        void reseed(const void* address) noexcept
        {
            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast): the address is only a source of entropy
            std::uint64_t x = reinterpret_cast<std::uintptr_t>(address);
            x ^= 0x9E3779B97F4A7C15ULL;
            x *= 0xBF58476D1CE4E5B9ULL;
            seed = x ^ (x >> 31u);
            tree.reseed(seed);
        }
        /// @brief add the first @a prefix_size bytes of the key of @a key_size bytes at @a data
        void insert(const char* data, std::size_t key_size, std::size_t prefix_size)
        {
            if (prefix_size >= short_limit)
            {
                tree.mark(data, key_size, prefix_size);
                return;
            }
            // flattened objects are usually sorted, so most keys that have a
            // 0 yield the prefix of the previous one
            if (last_data != nullptr && last_size == prefix_size && std::memcmp(last_data, data, prefix_size) == 0)
            {
                return;
            }
            last_data = data;
            last_size = prefix_size;
            const std::size_t hash = prefix_tree::hash_bytes(data, prefix_size, seed);
            if (table.empty())
            {
                table.resize(16);
            }
            const std::size_t mask = table.size() - 1;
            std::size_t i = hash & mask;
            while (table[i].data != nullptr)
            {
                if (table[i].hash == hash && table[i].size == prefix_size && std::memcmp(table[i].data, data, prefix_size) == 0)
                {
                    return;
                }
                i = (i + 1) & mask;
            }
            table[i] = slot(hash, data, prefix_size);
            // keep the load factor below 1/2
            if (++used * 2 > table.size())
            {
                grow();
            }
        }
        bool empty() const noexcept
        {
            return used == 0 && tree.empty();
        }
        /// @brief whether the first @a prefix_size bytes of the key of @a key_size bytes at @a data were added
        bool contains(const char* data, std::size_t key_size, std::size_t prefix_size)
        {
            if (prefix_size >= short_limit)
            {
                return tree.is_marked(data, key_size, prefix_size);
            }
            if (used == 0)
            {
                return false;
            }
            const std::size_t hash = prefix_tree::hash_bytes(data, prefix_size, seed);
            const std::size_t mask = table.size() - 1;
            for (std::size_t i = hash & mask; table[i].data != nullptr; i = (i + 1) & mask)
            {
                if (table[i].hash == hash && table[i].size == prefix_size && std::memcmp(table[i].data, data, prefix_size) == 0)
                {
                    return true;
                }
            }
            return false;
        }
      private:
        /// @brief prefixes of fewer bytes are kept in the hash table
        static constexpr std::size_t short_limit = 64;
        struct slot
        {
            slot() noexcept = default;
            slot(std::size_t h, const char* d, std::size_t s) noexcept
                : hash(h), data(d), size(s)
            {}
            std::size_t hash = 0;
            const char* data = nullptr; // nullptr: the slot is empty
            std::size_t size = 0;
        };
        void grow()
        {
            std::vector<slot> old(table.size() * 2);
            old.swap(table);
            const std::size_t mask = table.size() - 1;
            for (const auto& s : old)
            {
                if (s.data != nullptr)
                {
                    std::size_t i = s.hash & mask;
                    while (table[i].data != nullptr)
                    {
                        i = (i + 1) & mask;
                    }
                    table[i] = s;
                }
            }
        }
        std::uint64_t seed = 0;
        prefix_tree tree{};
        std::vector<slot> table{};
        std::size_t used = 0;
        const char* last_data = nullptr;
        std::size_t last_size = 0;
    };
    /*!
    @brief check that @a key is a valid JSON pointer, and add the prefixes of
           it that denote arrays to @a arrays
@@ -1052,7 +1268,7 @@ class json_pointer
                // a token 0 makes the pointer before it an array
                if (i - begin == 1 && data[begin] == '0')
                {
-                    arrays.insert(data, begin - 1);
+                    arrays.insert(data, size, begin - 1);
                }
                begin = i + 1;
            }
@@ -2062,6 +2278,7 @@ class json_pointer
        // token 0 among their children; the values below them are arrays,
        // all others are objects (see array_prefix_set)
        array_prefix_set arrays;
        arrays.reseed(&arrays);
        const string_t* previous_key = nullptr;
        for (const auto& element : *value.m_data.m_value.object)
        {
@@ -2153,7 +2370,7 @@ class json_pointer
                    case detail::value_t::null:
                    {
                        // a first child 0 makes the value an array without a look-up
-                        if ((token_size == 1 && data[pos + 1] == '0') || arrays.contains(data, pos))
+                        if ((token_size == 1 && data[pos + 1] == '0') || arrays.contains(data, key.size(), pos))
                        {
                            // some reference token below this position is 0, so the
                            // value is an array
@@ -917,14 +917,3 @@
 #ifndef JSON_DISABLE_TUPLE_REFERENCE_CONVERSION
    #define JSON_DISABLE_TUPLE_REFERENCE_CONVERSION 0
 #endif
 // JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE: how many elements of optimized
 // UBJSON containers of type Z, T or F (which have no payload) a reader accepts
 // per byte of input, on top of a fixed base. The value is checked and converted
 // in binary_reader.hpp; the macro is documented in
 // docs/mkdocs/docs/api/macros/json_ubjson_valueless_elements_per_byte.md.
 // It is not part of the ABI tag: it must have the same value in every
 // translation unit of a program.
 #ifndef JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE
    #define JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE 4
 #endif
@@ -60,7 +60,6 @@
    #undef JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
    #undef JSON_DISABLE_STREAM_BULK_SCAN
    #undef JSON_DISABLE_UNLOCKED_FILE_IO
    #undef JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE
 #endif
 #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
@@ -1204,29 +1204,20 @@ class binary_writer
            // an optimized array of a valueless type carries no payload, so a
            // reader has nothing but the declared count to bound the allocation
-            // by. It refuses one array of more than max_valueless_container_size
+            // by and refuses an excessive one. Write the unoptimized form for
-            // elements, and all such arrays of one input together when they add
+            // those, at one byte per element, so the result can be read back.
            // up to more than valueless_elements_base plus
            // JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE per byte read. Write the
            // unoptimized form, at one byte per element, for an array that
            // would exceed the base with the arrays written so far, so that the
            // result can be read back: the limit of a reader is never below the
            // base, whatever the macro is set to, so the writer does not use
            // it (and a reader with a larger rate reads this output as well).
            // Objects are not affected: every element is preceded by its key.
-            if (same_prefix && !(use_bjdata && is_bjdata_excluded_type_marker(first_prefix)))
+            const bool valueless_type = (first_prefix == 'Z' || first_prefix == 'T' || first_prefix == 'F');
            const bool excessive_valueless = IsArray
                                             && valueless_type
                                             && size > detail::max_valueless_container_size;
            if (same_prefix && !excessive_valueless
                    && !(use_bjdata && is_bjdata_excluded_type_marker(first_prefix)))
            {
-                const bool valueless_type = IsArray && (first_prefix == 'Z' || first_prefix == 'T' || first_prefix == 'F');
+                prefix_required = false;
-                if (!valueless_type || size <= detail::valueless_elements_base - valueless_elements_written)
+                oa.write_character(to_char_type('$'));
-                {
+                oa.write_character(first_prefix);
                    prefix_required = false;
                    oa.write_character(to_char_type('$'));
                    oa.write_character(first_prefix);
                    if (valueless_type)
                    {
                        valueless_elements_written += size;
                    }
                }
            }
        }
@@ -5450,10 +5441,6 @@ class binary_writer
    /// how to treat a string value or object key that is not valid UTF-8
    /// (CBOR, MessagePack, UBJSON, BJData, and BSON; not BON8)
    const error_handler_t error_handler = binary_writer_default_error_handler();
    /// UBJSON: the number of elements written so far in optimized arrays of a
    /// valueless type, which a reader adds up and bounds
    std::size_t valueless_elements_written = 0;
 };
 }  // namespace detail
@@ -410,34 +410,6 @@ json_test_add_test_for(src/unit-stream-bulk-scan.cpp
    MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force}
 )
 # test the budget for the elements of UBJSON containers of a valueless type again
 # with other values of JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE: 1 (the smallest),
 # 1000000 (so large that the budget cannot be reached), and the largest value of
 # a 64-bit integer (which saturates the limit already at the first byte, and is
 # clamped to the largest std::size_t where that has 32 bits). The file does not
 # mention JSON_HAS_CPP_<n>, so only C++11 is built unless the standards are forced
 json_test_set_test_options(test-ubjson_valueless_rate_1
    COMPILE_DEFINITIONS JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE=1
 )
 json_test_add_test_for(src/unit-ubjson_valueless.cpp
    NAME test-ubjson_valueless_rate_1
    MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force}
 )
 json_test_set_test_options(test-ubjson_valueless_rate_1000000
    COMPILE_DEFINITIONS JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE=1000000
 )
 json_test_add_test_for(src/unit-ubjson_valueless.cpp
    NAME test-ubjson_valueless_rate_1000000
    MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force}
 )
 json_test_set_test_options(test-ubjson_valueless_rate_max
    COMPILE_DEFINITIONS JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE=0xFFFFFFFFFFFFFFFFu
 )
 json_test_add_test_for(src/unit-ubjson_valueless.cpp
    NAME test-ubjson_valueless_rate_max
    MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force}
 )
 # test reading from a FILE* again with the locking stdio functions
 json_test_set_test_options(test-file_input_unlocked_io_disabled
    COMPILE_DEFINITIONS JSON_DISABLE_UNLOCKED_FILE_IO=1
@@ -1,86 +0,0 @@
 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
 // |  |  |__   |  |  | | | |  version 3.12.0
 // |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 //
 // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
 // SPDX-License-Identifier: MIT
 #pragma once
 #include <algorithm> // max
 #include <cstddef> // size_t
 #include <cstdint> // uint8_t
 #include <memory> // allocator
 #include <vector> // vector
 #include <nlohmann/json.hpp>
 namespace utils
 {
 /// the allocations of the values of a JSON type that uses counting_allocator
 struct allocation_counts
 {
    /// bytes allocated and not yet deallocated
    std::size_t current = 0;
    /// the largest value current had
    std::size_t peak = 0;
    /// number of allocations
    std::size_t allocations = 0;
 };
 /// the counts of all counting_allocators; the tests are single-threaded
 inline allocation_counts& counts()
 {
    static allocation_counts c; // NOLINT(misc-const-correctness)
    return c;
 }
 /// an allocator that counts the bytes and the number of allocations of a
 /// JSON type, so that a test can check how much memory a parse holds at any
 /// time without measuring the memory of the process
 template<class T>
 struct counting_allocator : std::allocator<T>
 {
    using std::allocator<T>::allocator;
    counting_allocator() = default;
    template<class U> counting_allocator(const counting_allocator<U>& /*unused*/) noexcept {} // NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
    template <class U>
    struct rebind
    {
        using other = counting_allocator<U>;
    };
    T* allocate(const std::size_t n)
    {
        T* const result = std::allocator<T>::allocate(n);
        allocation_counts& c = counts();
        c.current += n * sizeof(T);
        c.peak = (std::max)(c.peak, c.current);
        ++c.allocations;
        return result;
    }
    void deallocate(T* p, const std::size_t n)
    {
        counts().current -= n * sizeof(T);
        std::allocator<T>::deallocate(p, n);
    }
 };
 using counted_json = nlohmann::json::with_allocator_t<counting_allocator>;
 /// @a count times the bytes of @a unit
 inline std::vector<std::uint8_t> repeated(const std::vector<std::uint8_t>& unit, const std::size_t count)
 {
    std::vector<std::uint8_t> result;
    result.reserve(unit.size() * count);
    for (std::size_t i = 0; i < count; ++i)
    {
        result.insert(result.end(), unit.begin(), unit.end());
    }
    return result;
 }
 } // namespace utils
@@ -1,125 +0,0 @@
 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
 // |  |  |__   |  |  | | | |  version 3.12.0
 // |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 //
 // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
 // SPDX-License-Identifier: MIT
 #pragma once
 #include <cstddef> // size_t
 #include <cstdint> // uint8_t, uint32_t
 #include <limits> // numeric_limits
 #include <string> // string
 #include <vector> // vector
 #include <nlohmann/json.hpp>
 // helpers of the tests of the budget for the elements of UBJSON containers of
 // a valueless type (unit-ubjson.cpp and unit-ubjson_valueless.cpp)
 #if defined(__clang__)
    #pragma clang diagnostic push
    #pragma clang diagnostic ignored "-Wweak-vtables"
 #endif
 namespace utils
 {
 /// SAX consumer that counts the values and keeps the id of a parse error
 struct ValuelessEventCounter : public nlohmann::json_sax<nlohmann::json>
 {
    bool null() override
    {
        return ++values < stop_after;
    }
    bool boolean(bool /*val*/) override
    {
        return ++values < stop_after;
    }
    bool number_integer(nlohmann::json::number_integer_t /*val*/) override
    {
        ++values;
        return true;
    }
    bool number_unsigned(nlohmann::json::number_unsigned_t /*val*/) override
    {
        ++values;
        return true;
    }
    bool number_float(nlohmann::json::number_float_t /*val*/, const std::string& /*s*/) override
    {
        ++values;
        return true;
    }
    bool string(std::string& /*val*/) override
    {
        ++values;
        return true;
    }
    bool binary(nlohmann::json::binary_t& /*val*/) override
    {
        ++values;
        return true;
    }
    bool start_object(std::size_t /*elements*/) override
    {
        return true;
    }
    bool key(std::string& /*val*/) override
    {
        return true;
    }
    bool end_object() override
    {
        return true;
    }
    bool start_array(std::size_t /*elements*/) override
    {
        return true;
    }
    bool end_array() override
    {
        return true;
    }
    bool parse_error(std::size_t /*position*/, const std::string& /*last_token*/, const nlohmann::json::exception& ex) override
    {
        error_id = ex.id;
        return false;
    }
    /// the handler refuses the value that makes this many
    std::size_t stop_after = (std::numeric_limits<std::size_t>::max)();
    std::size_t values = 0;
    int error_id = 0;
 };
 /// appends `[$<marker>#l<count>` (nine bytes) to @a v
 inline void append_valueless_array(std::vector<std::uint8_t>& v, const char marker, const std::uint32_t count)
 {
    v.push_back('[');
    v.push_back('$');
    v.push_back(static_cast<std::uint8_t>(marker));
    v.push_back('#');
    v.push_back('l');
    v.push_back(static_cast<std::uint8_t>(count >> 24));
    v.push_back(static_cast<std::uint8_t>(count >> 16));
    v.push_back(static_cast<std::uint8_t>(count >> 8));
    v.push_back(static_cast<std::uint8_t>(count));
 }
 /// `[` followed by one `[$<marker>#l<count>` per entry of @a counts and `]`
 inline std::vector<std::uint8_t> valueless_arrays(const char marker, const std::vector<std::uint32_t>& counts)
 {
    std::vector<std::uint8_t> v = {'['};
    for (const auto count : counts)
    {
        append_valueless_array(v, marker, count);
    }
    v.push_back(']');
    return v;
 }
 } // namespace utils
 #if defined(__clang__)
    #pragma clang diagnostic pop
 #endif
@@ -31,7 +31,6 @@ using nlohmann::ordered_json;
 #include "make_test_data_available.hpp"
 #include "test_utils.hpp"
 #include "sax_countdown.hpp"
 #include "allocation_counter.hpp"
 #include "sax_event_loggers.hpp"
 using utils::SaxCountdown;
 using utils::SaxEventLogger;
@@ -4031,60 +4030,6 @@ TEST_CASE("issue #5405 - array reserve for definite-length BJData arrays")
    }
 }
 TEST_CASE("BJData - open arrays reserve only what the input has backed")
 {
    // an array that announces its size gets storage for (up to 16384 of) its
    // elements when it opens; the arrays that are open at the same time must
    // not hold more than the input read so far can back
    SECTION("nested headers that announce 16384 elements and are never completed")
    {
        // 200 levels would hold 200 * 16384 * sizeof(json),
        // if each of them reserved what it announces
        const auto input = utils::repeated({'[', '#', 'I', 0x00, 0x40}, 200);
        utils::counts() = utils::allocation_counts{};
        const auto j = utils::counted_json::from_bjdata(input, true, false);
        CHECK(j.is_discarded());
        CAPTURE(utils::counts().peak)
        // the credit is 65,536 values; the base peaks at more than 3 million
        CHECK(utils::counts().peak < sizeof(utils::counted_json) * 128 * 1024);
    }
    SECTION("a completed array is still reserved in one allocation")
    {
        json array = json::array();
        for (int i = 0; i < 10000; ++i)
        {
            array.push_back(i % 100);
        }
        // an array without a size is not reserved, so only these two
        {
            const auto packed = json::to_bjdata(array, true);
            utils::counts() = utils::allocation_counts{};
            const auto j = utils::counted_json::from_bjdata(packed);
            CHECK(j.size() == 10000);
            // the array and its storage; growing the storage as the elements
            // arrive would take more than a dozen allocations
            CAPTURE(utils::counts().allocations)
            CHECK(utils::counts().allocations <= 4);
        }
        {
            const auto packed = json::to_bjdata(array, true, true);
            utils::counts() = utils::allocation_counts{};
            const auto j = utils::counted_json::from_bjdata(packed);
            CHECK(j.size() == 10000);
            // the array and its storage; growing the storage as the elements
            // arrive would take more than a dozen allocations
            CAPTURE(utils::counts().allocations)
            CHECK(utils::counts().allocations <= 4);
        }
    }
 }
 TEST_CASE("Universal Binary JSON Specification Examples 1")
 {
    SECTION("Null Value")
@@ -29,7 +29,6 @@ using nlohmann::json;
 #include "round_trip_corpus.hpp"
 #include "test_utils.hpp"
 #include "sax_countdown.hpp"
 #include "allocation_counter.hpp"
 #include "sax_event_loggers.hpp"
 using utils::SaxCountdown;
 using utils::SaxEventLogger;
@@ -2710,289 +2709,6 @@ TEST_CASE("issue #5405 - array reserve for definite-length CBOR arrays")
    }
 }
 namespace
 {
 // NOLINTBEGIN(bugprone-derived-method-shadowing-base-method)
 using dom_parser = nlohmann::detail::json_sax_dom_parser<json, nlohmann::detail::input_stream_adapter>;
 // handlers that wrap a DOM parser, as users of the SAX interface do
 struct public_wrapper : dom_parser
 {
    explicit public_wrapper(json& result) : dom_parser(result, false)
    {}
 };
 /// parses another input with itself while the first parse is still running
 struct reentrant_wrapper : dom_parser
 {
    explicit reentrant_wrapper(json& result) : dom_parser(result, false)
    {}
    bool start_array(std::size_t len)
    {
        if (!inner_done)
        {
            inner_done = true;
            const std::vector<std::uint8_t> input = {0x80};
            json::sax_parse(input, this, json::input_format_t::cbor);
        }
        return dom_parser::start_array(len);
    }
    bool inner_done = false;
 };
 class private_wrapper : private dom_parser
 {
  public:
    explicit private_wrapper(json& result) : dom_parser(result, false)
    {}
    using dom_parser::null;
    using dom_parser::boolean;
    using dom_parser::number_integer;
    using dom_parser::number_unsigned;
    using dom_parser::number_float;
    using dom_parser::string;
    using dom_parser::binary;
    using dom_parser::start_array;
    using dom_parser::end_array;
    using dom_parser::parse_error;
    // the DOM parser has private overloads of these, which a using
    // declaration cannot expose; the input of the test has no objects
    static bool start_object(std::size_t /*len*/)
    {
        return false;
    }
    static bool key(std::string& /*val*/)
    {
        return false;
    }
    static bool end_object()
    {
        return false;
    }
 };
 class protected_wrapper : protected dom_parser
 {
  public:
    explicit protected_wrapper(json& result) : dom_parser(result, false)
    {}
    using dom_parser::null;
    using dom_parser::boolean;
    using dom_parser::number_integer;
    using dom_parser::number_unsigned;
    using dom_parser::number_float;
    using dom_parser::string;
    using dom_parser::binary;
    using dom_parser::start_array;
    using dom_parser::end_array;
    using dom_parser::parse_error;
    // the DOM parser has private overloads of these, which a using
    // declaration cannot expose; the input of the test has no objects
    static bool start_object(std::size_t /*len*/)
    {
        return false;
    }
    static bool key(std::string& /*val*/)
    {
        return false;
    }
    static bool end_object()
    {
        return false;
    }
 };
 // NOLINTEND(bugprone-derived-method-shadowing-base-method)
 /// the capacity of the fifth array of five that are open
 std::size_t innermost_capacity(const json& result)
 {
    const json* node = &result;
    for (int level = 0; level < 4; ++level)
    {
        node = &node->front();
    }
    return node->get_ref<const json::array_t&>().capacity();
 }
 } // namespace
 TEST_CASE("CBOR - open arrays reserve only what the input has backed")
 {
    // an array that announces its size gets storage for (up to 16384 of) its
    // elements when it opens; the arrays that are open at the same time must
    // not hold more than the input read so far can back
    SECTION("nested headers that announce 16384 elements and are never completed")
    {
        // 200 levels would hold 200 * 16384 * sizeof(json),
        // if each of them reserved what it announces
        const auto input = utils::repeated({0x99, 0x40, 0x00}, 200);
        utils::counts() = utils::allocation_counts{};
        const auto j = utils::counted_json::from_cbor(input, true, false);
        CHECK(j.is_discarded());
        CAPTURE(utils::counts().peak)
        // the credit is 65,536 values; the base peaks at more than 3 million
        CHECK(utils::counts().peak < sizeof(utils::counted_json) * 128 * 1024);
    }
    SECTION("a completed array is still reserved in one allocation")
    {
        json array = json::array();
        for (int i = 0; i < 10000; ++i)
        {
            array.push_back(i % 100);
        }
        {
            const auto packed = json::to_cbor(array);
            utils::counts() = utils::allocation_counts{};
            const auto j = utils::counted_json::from_cbor(packed);
            CHECK(j.size() == 10000);
            // the array and its storage; growing the storage as the elements
            // arrive would take more than a dozen allocations
            CAPTURE(utils::counts().allocations)
            CHECK(utils::counts().allocations <= 4);
        }
    }
    SECTION("an array that is given less than it announces is still decoded")
    {
        // five levels that announce 16384 elements each, the first of which
        // is the next level: they are more than the input could back when
        // they open
        constexpr std::size_t levels = 5;
        std::vector<std::uint8_t> input;
        for (std::size_t level = 0; level < levels; ++level)
        {
            input.insert(input.end(), {0x99, 0x40, 0x00});
        }
        input.insert(input.end(), 16384, 0x01);
        for (std::size_t level = 1; level < levels; ++level)
        {
            input.insert(input.end(), 16383, 0x02);
        }
        const auto j = json::from_cbor(input);
        const json* node = &j;
        for (std::size_t level = 0; level < levels; ++level)
        {
            REQUIRE(node->is_array());
            CHECK(node->size() == 16384);
            node = &node->front();
        }
        CHECK(*node == 1);
        CHECK(j.back() == 2);
    }
    SECTION("a DOM parser that a parse has finished with is not bounded by the input of that parse")
    {
        // the DOM parser learns where the reader counts its characters, and
        // must forget it when the parse is over: a handler may be driven by
        // other code afterwards, while the reader no longer exists
        // five levels announce more than the credit of one input, which a
        // parse of one byte has hardly refilled
        const auto check_unbounded = [](dom_parser & parser, json & result)
        {
            for (int level = 0; level < 5; ++level)
            {
                CHECK(parser.start_array(16384));
            }
            const json* node = &result;
            for (int level = 0; level < 4; ++level)
            {
                REQUIRE(node->is_array());
                REQUIRE(node->size() == 1);
                node = &node->front();
            }
            REQUIRE(node->is_array());
            CHECK(node->get_ref<const json::array_t&>().capacity() == 16384);
        };
        SECTION("after a parse that succeeded")
        {
            json result;
            dom_parser parser(result, false);
            const std::vector<std::uint8_t> input = {0x80};
            CHECK(json::sax_parse(input, &parser, json::input_format_t::cbor));
            check_unbounded(parser, result);
        }
 #if !defined(JSON_NOEXCEPTION)
        SECTION("after a parse that threw")
        {
            json result;
            dom_parser parser(result, true);
            const std::vector<std::uint8_t> input = {0x1C}; // not a CBOR value
            CHECK_THROWS_AS(json::sax_parse(input, &parser, json::input_format_t::cbor), json::parse_error&);
            check_unbounded(parser, result);
        }
 #endif
    }
    SECTION("a handler that wraps a DOM parser is bound if the reader can reach the parser")
    {
        // five arrays announce 16384 elements: the credit of one input covers
        // four of them, and a parse of 15 bytes has hardly refilled it
        const auto input = utils::repeated({0x99, 0x40, 0x00}, 5);
        SECTION("public base")
        {
            json result;
            public_wrapper handler(result);
            CHECK_FALSE(json::sax_parse(input, &handler, json::input_format_t::cbor));
            CHECK(innermost_capacity(result) < 16384);
        }
        SECTION("public base, a parse inside the parse")
        {
            json result;
            reentrant_wrapper handler(result);
            CHECK_FALSE(json::sax_parse(input, &handler, json::input_format_t::cbor));
            CHECK(handler.inner_done);
            CHECK(innermost_capacity(result) < 16384);
        }
        // the reader cannot convert these to the DOM parser: they are not bound
        SECTION("private base")
        {
            json result;
            private_wrapper handler(result);
            CHECK_FALSE(json::sax_parse(input, &handler, json::input_format_t::cbor));
            CHECK(innermost_capacity(result) == 16384);
        }
        SECTION("protected base")
        {
            json result;
            protected_wrapper handler(result);
            CHECK_FALSE(json::sax_parse(input, &handler, json::input_format_t::cbor));
            CHECK(innermost_capacity(result) == 16384);
        }
    }
    SECTION("SAX events report the announced size")
    {
        SaxEventLogger logger;
        const std::vector<std::uint8_t> input = {0x99, 0x40, 0x00};
        CHECK_FALSE(json::sax_parse(input, &logger, json::input_format_t::cbor));
        REQUIRE(logger.events.size() == 2);
        CHECK(logger.events[0] == "start_array(16384)");
        CHECK(logger.events[1] == "parse_error(4)");
    }
 }
 #if !defined(JSON_NOEXCEPTION) // corpus values that do not survive the round trip are skipped by catching the exception
 TEST_CASE("CBOR round-trip invariants")
 {
@@ -23,8 +23,10 @@ using nlohmann::json;
    using namespace nlohmann::literals; // NOLINT(google-build-using-namespace)
 #endif
 #include <algorithm>
 #include <cerrno>
 #include <cstdlib>
 #include <ctime>
 #include <limits>
 #include <map>
 #include <random>
@@ -1560,3 +1562,294 @@ TEST_CASE("JSON patch with moves and copies")
    CHECK_THROWS_AS(inplace.patch_inplace(json::parse(R"([{"op":"move","from":"","path":""}])")), json::out_of_range&);
    CHECK(inplace == doc);
 }
 namespace
 {
 // the keys of a shape of flattened objects with long keys; `zero` is the
 // token that is repeated `m` times
 // 0: one key, 1: one `zero` followed by tokens 1, 2: the token 1 followed by
 // tokens `zero`, 3 and 4: two keys with a long prefix, apart from other keys,
 // 5: the same for two long branches, 6: more of the keys of 3
 std::vector<std::string> shape_keys(const int shape, const std::size_t m, const std::string& zero)
 {
    std::string repeated;
    for (std::size_t i = 0; i < m; ++i)
    {
        repeated += "/" + zero;
    }
    std::vector<std::string> keys;
    switch (shape)
    {
        case 0:
            keys.push_back(repeated);
            break;
        case 1:
        {
            std::string key = "/" + zero;
            for (std::size_t i = 1; i < m; ++i)
            {
                key += "/1";
            }
            keys.push_back(key);
            break;
        }
        case 2:
        {
            std::string key = "/1";
            for (std::size_t i = 1; i < m; ++i)
            {
                key += "/" + zero;
            }
            keys.push_back(key);
            break;
        }
        case 3:
        case 4:
            keys = {repeated + "/a0", "/10", repeated + "/a1", "/11"};
            break;
        case 5:
            keys = {"/x" + repeated + "/a0", "/y" + repeated + "/a0", "/x" + repeated + "/a1", "/y" + repeated + "/a1"};
            break;
        case 6:
            for (int j = 0; j < 4; ++j)
            {
                keys.push_back(repeated + "/a" + std::to_string(j));
                keys.push_back("/1" + std::to_string(j));
            }
            break;
        default:
            break;
    }
    return keys;
 }
 // the best of `runs` times in seconds that std::clock() measures to unflatten the keys,
 // which an ordered_json holds in the order they are given (shape 4 uses a
 // json, which sorts them)
 double unflatten_cpu_time(const int shape, const std::size_t m, const int runs, const std::string& zero)
 {
    const std::vector<std::string> keys = shape_keys(shape, m, zero);
    nlohmann::ordered_json ordered = nlohmann::ordered_json::object();
    json sorted = json::object();
    for (const auto& key : keys)
    {
        ordered[key] = 1;
        sorted[key] = 1;
    }
    double best = 1e30;
    for (int i = 0; i < runs; ++i)
    {
        const std::clock_t start = std::clock();
        if (shape == 4)
        {
            const json nested = sorted.unflatten();
        }
        else
        {
            const nlohmann::ordered_json nested = ordered.unflatten();
        }
        best = (std::min)(best, static_cast<double>(std::clock() - start) / static_cast<double>(CLOCKS_PER_SEC));
    }
    return best;
 }
 } // namespace
 TEST_CASE("unflatten of keys with many reference tokens")
 {
    using nlohmann::ordered_json;
    SECTION("which prefixes become arrays")
    {
        // sorted keys that share a long beginning
        CHECK(json({{"/x/y/q/1", 5}, {"/x/y/w/0", 4}, {"/x/y/w/1", 3}, {"/x/y/z/0", 1}, {"/x/y/z/1", 2}}).unflatten() ==
        json::parse(R"({"x":{"y":{"q":{"1":5},"w":[4,3],"z":[1,2]}}})"));
        // prefixes that differ in the position of a slash only
        CHECK(json({{"/a/0/x", 1}, {"/a/1/y", 3}, {"/ab/1", 2}}).unflatten() ==
        json::parse(R"({"a":[{"x":1},{"y":3}],"ab":{"1":2}})"));
        CHECK(json({{"/a/b/1", 1}, {"/ab/0", 2}}).unflatten() ==
        json::parse(R"({"a":{"b":{"1":1}},"ab":[2]})"));
        // tokens longer than one word, escapes, and a token 0 below a token 1
        const std::string t = "token_with_more_than_eight_bytes";
        CHECK(json({{"/" + t + "/1/b/0", 1}, {"/" + t + "/0", 2}, {"/" + t + "/2/a~1b", 3}}).unflatten() ==
        json::parse(R"({"token_with_more_than_eight_bytes":[2,{"b":[1]},{"a/b":3}]})"));
        // prefixes of more than 64 bytes, that share a long beginning
        std::string deep;
        json expected = {{"a", {1, 2}}, {"b", {{"1", 3}}}, {"c", {{"1", {{"x", {4}}}}}}};
        for (int i = 0; i < 30; ++i)
        {
            deep += "/seg";
            expected = {{"seg", expected}};
        }
        CHECK(json({{deep + "/c/1/x/0", 4}, {deep + "/a/1", 2}, {deep + "/b/1", 3}, {deep + "/a/0", 1}}).unflatten() == expected);
        CHECK(json(ordered_json({{deep + "/c/1/x/0", 4}, {deep + "/a/1", 2}, {deep + "/b/1", 3}, {deep + "/a/0", 1}}).unflatten()) == expected);
        CHECK(json(ordered_json({{deep + "/a/1", 2}, {deep + "/a/0", 1}, {deep + "/b/1", 3}, {deep + "/c/1/x/0", 4}}).unflatten()) == expected);
        // prefixes of every length around the limit up to which they are hashed directly
        for (std::size_t length = 40; length < 90; ++length)
        {
            const std::string name(length, 'x');
            const json flat = {{"/" + name + "/a/0", 1}, {"/" + name + "/a/1", 2}, {"/" + name + "/b/1", 3}, {"/" + name + "/c/1/0", 4}};
            CHECK(flat.unflatten() == json({{name, {{"a", {1, 2}}, {"b", {{"1", 3}}}, {"c", {{"1", {4}}}}}}}));
        }
        // only the parent of a token 0 is an array, however deep the key is
        CHECK(json({{"/0/1/1/1", 1}}).unflatten() == json::parse(R"([{"1":{"1":{"1":1}}}])"));
        CHECK(json({{"/1/1/1/0", 1}}).unflatten() == json::parse(R"({"1":{"1":{"1":[1]}}})"));
        CHECK(json({{"/1/0/1/0", 1}}).unflatten() == json::parse(R"({"1":[{"1":[1]}]})"));
    }
    SECTION("the result does not depend on the order of the keys")
    {
        // random documents without empty containers and without the key "0" in
        // an object: flatten() and unflatten() are inverse to each other
        std::mt19937 gen(20261110); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed): reproducible
        const std::vector<std::string> names = {"a", "b", "ab", "1", "2", "10", "a/b", "a~b", "token_with_more_than_eight_bytes", "x"};
        struct builder
        {
            std::mt19937& gen;
            const std::vector<std::string>& names;
            json operator()(int depth) const
            {
                const int kind = std::uniform_int_distribution<int>(0, 9)(gen);
                if (depth == 0 || kind < 3)
                {
                    return kind;
                }
                json result = kind < 6 ? json::array() : json::object();
                const int size = std::uniform_int_distribution<int>(1, 4)(gen);
                for (int i = 0; i < size; ++i)
                {
                    if (kind < 6)
                    {
                        result.push_back((*this)(depth - 1));
                    }
                    else
                    {
                        result[names[std::uniform_int_distribution<std::size_t>(0, names.size() - 1)(gen)]] = (*this)(depth - 1);
                    }
                }
                return result;
            }
        };
        const builder build{gen, names};
        for (int round = 0; round < 200; ++round)
        {
            const json doc = build(6);
            const json flat = doc.flatten();
            CHECK(flat.unflatten() == doc);
            // the same entries in shuffled order, in an object that keeps it
            std::vector<std::pair<std::string, json>> entries;
            for (const auto& el : flat.items())
            {
                entries.emplace_back(el.key(), el.value());
            }
            std::shuffle(entries.begin(), entries.end(), gen);
            ordered_json shuffled = ordered_json::object();
            for (const auto& e : entries)
            {
                shuffled[e.first] = e.second;
            }
            CHECK(json(shuffled.unflatten()) == doc);
        }
    }
    SECTION("keys with long prefixes, in every order")
    {
        // prefixes of more than 64 bytes that share a long beginning, and
        // continue with tokens that start the same way
        std::string deep;
        for (int i = 0; i < 30; ++i)
        {
            deep += "/seg";
        }
        const std::string other = deep.substr(0, 70) + "/x" + deep.substr(70);
        std::vector<std::string> keys = {deep + "/a/0", deep + "/ab/1", deep + "/ab/x", deep + "/abc/0/y/0", other + "/b/1/0", deep + "/abc/1"};
        std::sort(keys.begin(), keys.end());
        // the result for the keys in sorted order, which json iterates in
        json sorted = json::object();
        for (const auto& key : keys)
        {
            sorted[key] = 1;
        }
        const json expected = sorted.unflatten();
        CHECK(expected.is_object());
        // ordered_json iterates in the order the keys were added
        std::vector<std::size_t> order(keys.size());
        for (std::size_t i = 0; i < order.size(); ++i)
        {
            order[i] = i;
        }
        std::size_t permutations = 0;
        bool all_equal = true;
        do
        {
            nlohmann::ordered_json flat = nlohmann::ordered_json::object();
            for (const auto i : order)
            {
                flat[keys[i]] = 1;
            }
            all_equal = all_equal && json(flat.unflatten()) == expected;
            ++permutations;
        }
        while (std::next_permutation(order.begin(), order.end()));
        CHECK(permutations == 720);
        CHECK(all_equal);
    }
    SECTION("time is linear in the number of tokens")
    {
        // A bound in seconds would depend on the machine. Instead, the time is
        // compared with the time for the same keys with the token 0 replaced by
        // a token that is not a number: there is no array, so no prefix is
        // looked up. The ratio is 1 to 3 for a linear algorithm, and between
        // 12 and 100 when looking up a prefix takes time proportional to its
        // length. The time that std::clock() measures is mostly the time of the
        // processor, which a busy machine does not inflate (on MSVC, it is the
        // time that has passed), and the best of two or three runs counts.
        for (int shape = 0; shape < 7; ++shape)
        {
            // the shapes with several keys, in an order that does not sort them,
            // need more tokens to be slow enough to tell
            const bool many = shape == 3 || shape == 5 || shape == 6;
            const std::size_t m = many ? 40000 : 10000;
            const int runs = many ? 2 : 3;
            // a busy machine may spoil one comparison, hardly two
            bool linear = false;
            double t_array = 0;
            double t_object = 0;
            for (int attempt = 0; attempt < 2 && !linear; ++attempt)
            {
                t_array = unflatten_cpu_time(shape, m, runs, "0");
                t_object = (std::max)(unflatten_cpu_time(shape, m, runs, "a"), 1e-3);
                linear = t_array < 6 * t_object;
            }
            CAPTURE(shape)
            CAPTURE(t_array)
            CAPTURE(t_object)
            CHECK(linear);
        }
        // the nesting is as expected: an array exactly below each token 0
        const json nested_deep = json::object({{shape_keys(0, 1000, "0")[0], 1}}).unflatten();
        std::size_t depth = 0;
        for (const json* p = &nested_deep; p->is_array(); p = &p->back())
        {
            ++depth;
        }
        CHECK(depth == 1000);
        const json nested_ones = json::object({{shape_keys(1, 1000, "0")[0], 1}}).unflatten();
        CHECK(nested_ones.is_array());
        CHECK(nested_ones.back().is_object());
    }
 }
@@ -33,7 +33,6 @@ using nlohmann::json;
 #include "round_trip_corpus.hpp"
 #include "test_utils.hpp"
 #include "sax_countdown.hpp"
 #include "allocation_counter.hpp"
 #include "sax_event_loggers.hpp"
 using utils::SaxCountdown;
 using utils::SaxEventLogger;
@@ -1760,47 +1759,6 @@ TEST_CASE("issue #5405 - array reserve for definite-length MessagePack arrays")
    }
 }
 TEST_CASE("MessagePack - open arrays reserve only what the input has backed")
 {
    // an array that announces its size gets storage for (up to 16384 of) its
    // elements when it opens; the arrays that are open at the same time must
    // not hold more than the input read so far can back
    SECTION("nested headers that announce 16384 elements and are never completed")
    {
        // 200 levels would hold 200 * 16384 * sizeof(json),
        // if each of them reserved what it announces
        const auto input = utils::repeated({0xDC, 0x40, 0x00}, 200);
        utils::counts() = utils::allocation_counts{};
        const auto j = utils::counted_json::from_msgpack(input, true, false);
        CHECK(j.is_discarded());
        CAPTURE(utils::counts().peak)
        // the credit is 65,536 values; the base peaks at more than 3 million
        CHECK(utils::counts().peak < sizeof(utils::counted_json) * 128 * 1024);
    }
    SECTION("a completed array is still reserved in one allocation")
    {
        json array = json::array();
        for (int i = 0; i < 10000; ++i)
        {
            array.push_back(i % 100);
        }
        {
            const auto packed = json::to_msgpack(array);
            utils::counts() = utils::allocation_counts{};
            const auto j = utils::counted_json::from_msgpack(packed);
            CHECK(j.size() == 10000);
            // the array and its storage; growing the storage as the elements
            // arrive would take more than a dozen allocations
            CAPTURE(utils::counts().allocations)
            CHECK(utils::counts().allocations <= 4);
        }
    }
 }
 TEST_CASE("regression test - MessagePack ext type rejects a subtype that doesn't fit a single byte")
 {
    // subtype 0-255 must still round-trip correctly (regression guard, pre-existing behavior)
@@ -27,9 +27,7 @@ using nlohmann::json;
 #include "round_trip_corpus.hpp"
 #include "test_utils.hpp"
 #include "sax_countdown.hpp"
 #include "allocation_counter.hpp"
 #include "sax_event_loggers.hpp"
 #include "ubjson_valueless.hpp"
 using utils::SaxCountdown;
 using utils::SaxEventLogger;
@@ -2438,155 +2436,6 @@ TEST_CASE("UBJSON optimized arrays of a valueless type are bounded")
    }
 }
 TEST_CASE("UBJSON the writer keeps the valueless elements of an input within the base")
 {
    // The budget of the reader is 1048576 plus a rate per byte read, see
    // unit-ubjson_valueless.cpp, which tests it for several values of the rate.
    // The writer does not use the rate and stays within the base
    json _;
    SECTION("to_ubjson writes the typed form up to the base only")
    {
        // 1048 rows of 1000 values fit under the base of 1048576, the 1049th
        // would not: its elements are written one by one. Written all typed,
        // 1100 rows of 6 bytes would be refused by a reader with the default
        // rate of the macro JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE (1074 rows
        // are the most it accepts); the writer does not follow the macro, since
        // the limit of a reader is never below the base. The rows hold null,
        // true or false, and the fallback does not depend on which
        std::vector<std::uint8_t> encoded;
        {
            json table = json::array();
            for (int row = 0; row < 1100; ++row)
            {
                const json cell = row % 3 == 0 ? json(nullptr) : json(row % 3 == 1);
                table.push_back(json(1000, cell));
            }
            encoded = json::to_ubjson(table, true, true);
        }
        // outer array: `[$[#I` and the count (7 bytes), then 1048 typed rows of 6
        // bytes (`$Z#I` and two bytes) and 52 rows of `#I`, two bytes, and 1000 `Z`
        CHECK(encoded.size() == 7 + (1048 * 6) + (52 * (4 + 1000)));
        // the output is read back
        utils::ValuelessEventCounter sax;
        CHECK(json::sax_parse(encoded, &sax, json::input_format_t::ubjson));
        CHECK(sax.error_id == 0);
        CHECK(sax.values == 1100u * 1000u);
    }
    SECTION("BJData is not affected")
    {
        // BJData has no optimized arrays of these types, and the writer does
        // not charge them
        json table = json::array();
        for (int row = 0; row < 3; ++row)
        {
            table.push_back(json(10, nullptr));
        }
        const auto encoded = json::to_bjdata(table, true, true);
        CHECK(json::from_bjdata(encoded) == table);
        const std::vector<std::uint8_t> input = {'[', '$', 'Z', '#', 'l', 0x00, 0x10, 0x00, 0x00};
        CHECK_THROWS_AS(_ = json::from_bjdata(input), json::parse_error&);
    }
    SECTION("an object of a valueless type needs a key for every value")
    {
        // an object member costs a key, so the count is bounded by the input
        // and is not charged to the budget
        const std::vector<std::uint8_t> input = {'{', '$', 'Z', '#', 'l', 0x00, 0x10, 0x00, 0x00};
        utils::ValuelessEventCounter sax;
        CHECK(!json::sax_parse(input, &sax, json::input_format_t::ubjson));
        CHECK(sax.error_id == 110);
        CHECK(sax.values == 0);
    }
 }
 TEST_CASE("UBJSON an optimized array of no-ops is empty whatever its count")
 {
    // A no-op ('N') is not a value, so `[$N#<n>` is an array without elements
    // for every n. The count used to be passed on to the SAX parser, which
    // told it to expect n elements, and the DOM parser reserved storage for
    // them: 16384 values (256 KB) for a count of 2^31 in 9 bytes of input.
    SECTION("the SAX parser is told that the array is empty")
    {
        for (const std::vector<std::uint8_t>& input :
                {
                    std::vector<std::uint8_t> {'[', '$', 'N', '#', 'i', 2},
                    std::vector<std::uint8_t> {'[', '$', 'N', '#', 'I', 0x7F, 0xFF},
                    std::vector<std::uint8_t> {'[', '$', 'N', '#', 'l', 0x7F, 0xFF, 0xFF, 0xFF},
                    std::vector<std::uint8_t> {'[', '$', 'N', '#', 'i', 0}
                })
        {
            SaxEventLogger logger;
            CHECK(json::sax_parse(input, &logger, json::input_format_t::ubjson));
            CHECK(logger.events == std::vector<std::string>({"start_array(0)", "end_array()"}));
        }
        // between other values, the next value is read as usual
        const std::vector<std::uint8_t> nested = {'[', '[', '$', 'N', '#', 'l', 0x7F, 0xFF, 0xFF, 0xFF, 'T', '[', '$', 'N', '#', 'i', 3, ']'};
        SaxEventLogger logger;
        CHECK(json::sax_parse(nested, &logger, json::input_format_t::ubjson));
        CHECK(logger.events == std::vector<std::string>({"start_array()", "start_array(0)", "end_array()", "boolean(true)", "start_array(0)", "end_array()", "end_array()"}));
    }
    SECTION("the DOM parser reserves nothing")
    {
        // 2000 arrays of 9 bytes that announce 2^31 elements each: with a
        // reservation of 16384 values per array this took about 500 MB
        std::vector<std::uint8_t> input = {'['};
        for (int i = 0; i < 2000; ++i)
        {
            input.insert(input.end(), {'[', '$', 'N', '#', 'l', 0x7F, 0xFF, 0xFF, 0xFF});
        }
        input.push_back(']');
        const json j = json::from_ubjson(input);
        REQUIRE(j.size() == 2000);
        std::size_t capacity = 0;
        for (const auto& element : j)
        {
            CHECK(element.is_array());
            CHECK(element.empty());
            capacity += element.get_ref<const json::array_t&>().capacity();
        }
        CHECK(capacity == 0);
        // the 7-byte form inside an optimized array of arrays
        std::vector<std::uint8_t> typed = {'[', '$', '[', '#', 'I', 0x07, 0xD0};
        for (int i = 0; i < 2000; ++i)
        {
            typed.insert(typed.end(), {'$', 'N', '#', 'I', 0x7F, 0xFF});
        }
        const json k = json::from_ubjson(typed);
        REQUIRE(k.size() == 2000);
        capacity = 0;
        for (const auto& element : k)
        {
            CHECK(element.empty());
            capacity += element.get_ref<const json::array_t&>().capacity();
        }
        CHECK(capacity == 0);
    }
    SECTION("a count that no container could hold is no longer an error")
    {
        // the array is empty, so nothing has to fit: 0x7FFFFFFF used to be
        // reported as out_of_range.408 where it exceeds the maximum size of
        // an array, and is accepted now
        const std::vector<std::uint8_t> input = {'[', '$', 'N', '#', 'l', 0x7F, 0xFF, 0xFF, 0xFF};
        CHECK(json::from_ubjson(input) == json::array());
        // a count that does not fit into std::size_t still is
 #if SIZE_MAX == 0xffffffff
        const std::vector<std::uint8_t> too_large = {'[', '$', 'N', '#', 'L', 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00};
        json _;
        CHECK_THROWS_AS(_ = json::from_ubjson(too_large), json::out_of_range&);
 #endif
    }
 }
 TEST_CASE("issue #5405 - array reserve for definite-length UBJSON arrays")
 {
 #if !defined(JSON_NOEXCEPTION)
@@ -2692,60 +2541,6 @@ TEST_CASE("issue #5405 - array reserve for definite-length UBJSON arrays")
    }
 }
 TEST_CASE("UBJSON - open arrays reserve only what the input has backed")
 {
    // an array that announces its size gets storage for (up to 16384 of) its
    // elements when it opens; the arrays that are open at the same time must
    // not hold more than the input read so far can back
    SECTION("nested headers that announce 16384 elements and are never completed")
    {
        // 200 levels would hold 200 * 16384 * sizeof(json),
        // if each of them reserved what it announces
        const auto input = utils::repeated({'[', '#', 'I', 0x40, 0x00}, 200);
        utils::counts() = utils::allocation_counts{};
        const auto j = utils::counted_json::from_ubjson(input, true, false);
        CHECK(j.is_discarded());
        CAPTURE(utils::counts().peak)
        // the credit is 65,536 values; the base peaks at more than 3 million
        CHECK(utils::counts().peak < sizeof(utils::counted_json) * 128 * 1024);
    }
    SECTION("a completed array is still reserved in one allocation")
    {
        json array = json::array();
        for (int i = 0; i < 10000; ++i)
        {
            array.push_back(i % 100);
        }
        // an array without a size is not reserved, so only these two
        {
            const auto packed = json::to_ubjson(array, true);
            utils::counts() = utils::allocation_counts{};
            const auto j = utils::counted_json::from_ubjson(packed);
            CHECK(j.size() == 10000);
            // the array and its storage; growing the storage as the elements
            // arrive would take more than a dozen allocations
            CAPTURE(utils::counts().allocations)
            CHECK(utils::counts().allocations <= 4);
        }
        {
            const auto packed = json::to_ubjson(array, true, true);
            utils::counts() = utils::allocation_counts{};
            const auto j = utils::counted_json::from_ubjson(packed);
            CHECK(j.size() == 10000);
            // the array and its storage; growing the storage as the elements
            // arrive would take more than a dozen allocations
            CAPTURE(utils::counts().allocations)
            CHECK(utils::counts().allocations <= 4);
        }
    }
 }
 TEST_CASE("Universal Binary JSON Specification Examples 1")
 {
@@ -1,324 +0,0 @@
 //     __ _____ _____ _____
 //  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
 // |  |  |__   |  |  | | | |  version 3.12.0
 // |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 //
 // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
 // SPDX-License-Identifier: MIT
 // The budget for the elements of the UBJSON containers of a valueless type
 // ('Z', 'T', 'F') of a whole input: 1048576 plus
 // JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE for every byte read (see
 // docs/mkdocs/docs/api/macros/json_ubjson_valueless_elements_per_byte.md).
 //
 // The file is built several times, with the macro defined to other values (see
 // tests/CMakeLists.txt), and every boundary below is computed from the macro.
 // What it can test depends on the value: with a rate of at most 10000 the
 // budget can be reached with the few bytes of a test, so the tests exceed it
 // at the exact byte; with a rate of 131072 or more the budget cannot be reached
 // by an input of any size (see the macro's page: 2^20 / 8 = 131072 elements per
 // byte is what the shortest header of a container of the largest size allows), and
 // the tests check that nothing is refused, in particular that the limit does
 // not wrap around for a rate near the largest integer. The input is read with
 // a SAX handler that counts the values, because a DOM of a million values is
 // what makes such a test slow under Valgrind.
 #include "doctest_compatibility.h"
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #include <cstddef> // size_t
 #include <cstdio> // FILE, tmpfile, fwrite, fseek, fclose
 #include <cstdint> // uint8_t, uint32_t
 #include <list>
 #include <sstream>
 #include <vector>
 #include "ubjson_valueless.hpp"
 using utils::ValuelessEventCounter;
 using utils::valueless_arrays;
 #ifndef JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE
    #error "this test needs the macro: compile it with JSON_TEST_KEEP_MACROS (see tests/CMakeLists.txt)"
 #endif
 namespace
 {
 /// the base of the budget and the limit of a single container: both 2^20
 constexpr std::uint32_t budget_base = 1048576;
 #if JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE <= 10000 || JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE >= 131072
 /// what version 3.12.0 wrote for a table of @a rows (at most 32767) rows of
 /// @a width nulls with to_ubjson(table, true, true): `[$[#I` and the count of
 /// the rows (7 bytes), then a row as `$Z#` and its count (`U` and 1 byte up to
 /// 255, `I` and 2 bytes up to 32767, `l` and 4 bytes above): 5, 6 or 8 bytes
 std::vector<std::uint8_t> rows_3_12_0(const std::uint32_t rows, const std::uint32_t width)
 {
    std::vector<std::uint8_t> v = {'[', '$', '[', '#', 'I', static_cast<std::uint8_t>(rows >> 8), static_cast<std::uint8_t>(rows)};
    for (std::uint32_t row = 0; row < rows; ++row)
    {
        v.push_back('$');
        v.push_back('Z');
        v.push_back('#');
        if (width <= 255)
        {
            v.push_back('U');
        }
        else if (width <= 32767)
        {
            v.push_back('I');
            v.push_back(static_cast<std::uint8_t>(width >> 8));
        }
        else
        {
            v.push_back('l');
            v.push_back(static_cast<std::uint8_t>(width >> 24));
            v.push_back(static_cast<std::uint8_t>(width >> 16));
            v.push_back(static_cast<std::uint8_t>(width >> 8));
        }
        v.push_back(static_cast<std::uint8_t>(width));
    }
    return v;
 }
 #endif
 } // namespace
 // the macro must not be a character or bool: every character type is refused
 static_assert(nlohmann::detail::valueless_elements_rate_is_char_or_bool<bool>::value, "bool is refused");
 static_assert(nlohmann::detail::valueless_elements_rate_is_char_or_bool<char>::value, "char is refused");
 static_assert(nlohmann::detail::valueless_elements_rate_is_char_or_bool<signed char>::value, "signed char is refused");
 static_assert(nlohmann::detail::valueless_elements_rate_is_char_or_bool<unsigned char>::value, "unsigned char is refused");
 static_assert(nlohmann::detail::valueless_elements_rate_is_char_or_bool<wchar_t>::value, "wchar_t is refused");
 static_assert(nlohmann::detail::valueless_elements_rate_is_char_or_bool<char16_t>::value, "char16_t is refused");
 static_assert(nlohmann::detail::valueless_elements_rate_is_char_or_bool<char32_t>::value, "char32_t is refused");
 #if defined(__cpp_char8_t)
    static_assert(nlohmann::detail::valueless_elements_rate_is_char_or_bool<char8_t>::value, "char8_t is refused");
 #endif
 static_assert(!nlohmann::detail::valueless_elements_rate_is_char_or_bool<int>::value, "int is accepted");
 static_assert(!nlohmann::detail::valueless_elements_rate_is_char_or_bool<unsigned long long>::value, "unsigned long long is accepted");
 TEST_CASE("UBJSON the limit of a single container does not depend on the macro")
 {
 #if !defined(JSON_NOEXCEPTION)
    json _;
    SECTION("a container of more than 1048576 elements is refused")
    {
        // the first check of every container; its message differs from that of
        // the budget, so that it is clear which limit was exceeded
        for (const char marker :
                {'Z', 'T', 'F'
                })
        {
            const auto input = valueless_arrays(marker, {budget_base + 1});
            CHECK_THROWS_WITH_AS(_ = json::from_ubjson(input), "[json.exception.out_of_range.408] syntax error while parsing UBJSON size: excessive array size", json::out_of_range&);
        }
    }
 #endif
    SECTION("a container of 1048576 elements is accepted at the start of an input")
    {
        // whatever the rate: the base is the per-container limit. The handler
        // ends the parse at the first value, so that the million values are
        // not read
        const std::vector<std::uint8_t> single = {'[', '$', 'Z', '#', 'l', 0x00, 0x10, 0x00, 0x00};
        ValuelessEventCounter sax;
        sax.stop_after = 1;
        CHECK(!json::sax_parse(single, &sax, json::input_format_t::ubjson));
        CHECK(sax.error_id == 0);
        CHECK(sax.values == 1);
    }
 }
 #if JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE <= 10000
 namespace
 {
 /// the rate of the build; at most 10000 here, which the boundaries rely on
 constexpr std::uint32_t rate = JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE;
 /// elements of the first of two containers; the second one is then refused at
 /// its header, which is read at byte 1 + 9 + 9 = 19
 constexpr std::uint32_t first_count = 524288;
 /// the largest count the second container may have at byte 19: base plus rate
 /// for each of the 19 bytes, less what the first one used. For a rate of at
 /// most 27594, the largest that keeps this within the limit of one container
 constexpr std::uint32_t second_allowed = budget_base - first_count + (19 * rate);
 } // namespace
 TEST_CASE("UBJSON the valueless elements of a whole input are bounded")
 {
    // The per-container limit alone let nine bytes (`[$Z#l` and a count of
    // 1048576) announce a million values, and every further nine bytes another
    // million. The elements of all containers of type 'Z', 'T' or 'F' in one
    // input are added up: they may not exceed 1048576 plus
    // JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE for every byte read when the
    // container's header has been read.
 #if !defined(JSON_NOEXCEPTION)
    json _;
    const char* const budget_message = "[json.exception.out_of_range.408] syntax error while parsing UBJSON size: excessive number of elements without payload";
 #endif
    SECTION("the input of the original report is rejected")
    {
        // the second array is the first one that is refused, by one element
 #if !defined(JSON_NOEXCEPTION)
        CHECK_THROWS_WITH_AS(_ = json::from_ubjson(valueless_arrays('Z', {first_count, second_allowed + 1})), budget_message, json::out_of_range&);
 #endif
        // and is accepted with one element less
        ValuelessEventCounter sax;
        CHECK(json::sax_parse(valueless_arrays('Z', {first_count, second_allowed}), &sax, json::input_format_t::ubjson));
        CHECK(sax.values == first_count + second_allowed);
    }
    SECTION("every input adapter applies the budget")
    {
        const auto input = valueless_arrays('Z', {first_count, second_allowed + 1});
        // stream; not strict, which does not matter
        std::stringstream stream;
        stream.write(reinterpret_cast<const char*>(input.data()), static_cast<std::streamsize>(input.size()));
        ValuelessEventCounter from_stream;
        CHECK(!json::sax_parse(stream, &from_stream, json::input_format_t::ubjson, false));
        CHECK(from_stream.error_id == 408);
        // a container that is not contiguous; the counts of arrays of
        // different types are added up
        std::vector<std::uint8_t> mixed = {'['};
        utils::append_valueless_array(mixed, 'T', first_count);
        utils::append_valueless_array(mixed, 'F', second_allowed + 1);
        mixed.push_back(']');
        const std::list<std::uint8_t> as_list(mixed.begin(), mixed.end());
        ValuelessEventCounter from_list;
        CHECK(!json::sax_parse(as_list.begin(), as_list.end(), &from_list, json::input_format_t::ubjson));
        CHECK(from_list.error_id == 408);
        CHECK(from_list.values == first_count);
        // FILE*
        FILE* const file = std::tmpfile(); // NOLINT(cppcoreguidelines-owning-memory)
        REQUIRE(file != nullptr);
        CHECK(std::fwrite(input.data(), 1, input.size(), file) == input.size());
        CHECK(std::fseek(file, 0, SEEK_SET) == 0);
        ValuelessEventCounter from_file;
        CHECK(!json::sax_parse(file, &from_file, json::input_format_t::ubjson));
        CHECK(from_file.error_id == 408);
        std::fclose(file); // NOLINT(cert-err33-c,cppcoreguidelines-owning-memory)
    }
    SECTION("the limit is exact and the bytes read raise it")
    {
        // [ [$Z#l first_count] [$U#l payload + payload bytes] [$Z#l count] ]:
        // chars_read is 1 + 9 + (9 + payload) + 9 = 28 + payload when the last
        // header has been read, so the last array may hold
        // rate * (28 + payload) values on top of the base less the
        // first_count of the first array. The payload is as large as the
        // limit of one container allows, but at most 4096
        constexpr std::uint32_t payload_limit = (524288 / rate) - 40;
        constexpr std::uint32_t payload = payload_limit < 4096 ? payload_limit : 4096;
        constexpr std::uint32_t last_allowed = budget_base - first_count + (rate * (28 + payload));
        static_assert(last_allowed < budget_base, "the count must be accepted by the limit of one container");
        for (const std::uint32_t count :
                {
                    last_allowed, last_allowed + 1
                })
        {
            CAPTURE(count)
            std::vector<std::uint8_t> input = {'['};
            utils::append_valueless_array(input, 'Z', first_count);
            input.insert(input.end(), {'[', '$', 'U', '#', 'l',
                                       static_cast<std::uint8_t>(payload >> 24), static_cast<std::uint8_t>(payload >> 16),
                                       static_cast<std::uint8_t>(payload >> 8), static_cast<std::uint8_t>(payload)
                                      });
            input.insert(input.end(), payload, 0x01);
            utils::append_valueless_array(input, 'Z', count);
            input.push_back(']');
            ValuelessEventCounter sax;
            const bool accepted = count == last_allowed;
            CHECK(json::sax_parse(input, &sax, json::input_format_t::ubjson) == accepted);
            CHECK(sax.error_id == (accepted ? 0 : 408));
            CHECK(sax.values == first_count + payload + (accepted ? count : 0u));
        }
    }
    SECTION("a table written by 3.12.0")
    {
        // Version 3.12.0 wrote a table of rows of nulls with one `$Z#` header
        // per row (see the macro's page). A row of `width` elements has a
        // header of 6 bytes up to 32767 elements (5 up to 255), so the budget
        // grows by 6 * rate per row, and the row brings `width`. The 7 bytes
        // of the outer header are read first. Row r is accepted while
        //     r * width <= 1048576 + rate * (7 + 6 * r),
        // which is r <= (1048576 + 7 * rate) / (width - 6 * rate) for a width
        // above 6 * rate, and always true otherwise.
        constexpr std::uint32_t width = 1000;
        constexpr std::uint32_t rows = 1200;
        constexpr std::uint32_t credit = 6 * rate;
        constexpr std::uint32_t accepted_rows = width > credit ? (budget_base + (7 * rate)) / (width - credit) : rows;
        constexpr std::uint32_t read_rows = accepted_rows < rows ? accepted_rows : rows;
        ValuelessEventCounter sax;
        CHECK(json::sax_parse(rows_3_12_0(rows, width), &sax, json::input_format_t::ubjson) == (accepted_rows >= rows));
        CHECK(sax.error_id == (accepted_rows >= rows ? 0 : 408));
        CHECK(sax.values == static_cast<std::size_t>(read_rows) * width);
    }
 }
 #elif JSON_UBJSON_VALUELESS_ELEMENTS_PER_BYTE >= 131072
 TEST_CASE("UBJSON a rate that cannot be reached switches the budget off")
 {
    // The rate is so large (2^20 / 8 = 131072 elements per byte or more)
    // that no input can exceed the budget: the shortest header of a container
    // of the largest size is 8 bytes (`$Z#l` and a count of 4 bytes, in an
    // array of arrays). The limit is base + rate * bytes read, which wraps
    // around for a rate near the largest integer in 64 and in 32
    // bits already at the first byte, unless it saturates: a wrapped limit
    // would refuse the second container below (at byte 19 or at byte 10, where
    // a limit of 2^20 + 10 * rate wraps for a 32-bit rate of 0x7FFFFFFF).
 #if !defined(JSON_NOEXCEPTION)
    json _;
 #endif
    SECTION("containers of the largest size are accepted one after the other")
    {
        // the first container is accepted by the base alone, the second one is
        // not: it needs the rate. The handler ends the parse at its first
        // value, so that the second million values are not read
        const auto input = valueless_arrays('Z', {budget_base, budget_base});
        ValuelessEventCounter sax;
        sax.stop_after = static_cast<std::size_t>(budget_base) + 1;
        CHECK(!json::sax_parse(input, &sax, json::input_format_t::ubjson));
        CHECK(sax.error_id == 0);
        CHECK(sax.values == static_cast<std::size_t>(budget_base) + 1);
    }
    SECTION("the limit of a single container still applies")
    {
        const auto input = valueless_arrays('T', {budget_base, budget_base + 1});
        ValuelessEventCounter sax;
        CHECK(!json::sax_parse(input, &sax, json::input_format_t::ubjson));
        CHECK(sax.error_id == 408);
        CHECK(sax.values == budget_base);
 #if !defined(JSON_NOEXCEPTION)
        CHECK_THROWS_WITH_AS(_ = json::from_ubjson(valueless_arrays('F', {budget_base + 1})), "[json.exception.out_of_range.408] syntax error while parsing UBJSON size: excessive array size", json::out_of_range&);
 #endif
    }
    SECTION("a table written by 3.12.0 is read completely")
    {
        // 1200 rows of 1000 values are refused after 1074 rows at the default
        // rate and are accepted with every rate of 167 and more
        ValuelessEventCounter sax;
        CHECK(json::sax_parse(rows_3_12_0(1200, 1000), &sax, json::input_format_t::ubjson));
        CHECK(sax.error_id == 0);
        CHECK(sax.values == 1200u * 1000u);
    }
 }
 // (rates from 10001 to 131071 can be reached, but not with the few bytes of a
 // test: there is nothing to test for them here)
 #endif
		`@@ -1 +0,0 @@`
			`[json.exception.out_of_range.408] syntax error while parsing UBJSON size: excessive number of elements without payload`
		`@@ -1,2 +0,0 @@`
			`1100 rows of 1000 values`
			`[json.exception.out_of_range.408] syntax error while parsing UBJSON size: excessive array size`