Test the C++11 stand-in for std::string_view of json_view

Six members of string_ref (length, begin, end, operator[], operator!=, and operator<<) were not reached before C++17, where string_ref is std::string_view. Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Remove the eight-digit case of the view's digit parser
2026-09-29 19:20:30 +00:00 · 2026-09-29 09:53:48 +02:00 · 2026-09-29 09:52:19 +02:00 · 2026-09-29 09:34:11 +02:00 · 2026-09-29 07:20:09 +02:00 · 2026-09-29 04:49:37 +02:00
147 changed files with 5079 additions and 72716 deletions
@@ -1,81 +0,0 @@
-name: "Check API documentation"
-
-on:
-  pull_request:
-
-permissions:
-  contents: read
-
-jobs:
-  check_api_docs:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Harden Runner
-        uses: step-security/harden-runner@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
-        with:
-          egress-policy: audit
-
-      - name: Checkout pull request
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
-
-      - name: Install clang
-        # Used only as a subprocess for `clang++ -E -v` system-include-path discovery in
-        # extract_api.py; it does not need to version-match the pinned libclang pip wheel
-        # below, which does the actual AST parsing. Do not "fix" this to be version-matched.
-        run: sudo apt-get update && sudo apt-get install -y clang
-
-      - name: Install Python dependencies
-        run: pip install -r tools/api_checker/requirements.txt
-
-      - name: Extract API and regenerate the committed surface file
-        run: |
-          python3 tools/api_checker/extract_api.py \
-            --header include/nlohmann/json.hpp \
-            --include include \
-            --output /tmp/api_snapshot.json \
-            --surface-output tools/api_checker/api_surface.json
-
-      - name: "Check API documentation (Phase 1: advisory)"
-        # Surfaces missing/broken @sa links without failing the job while the backlog from the
-        # initial AST-based rollout is burned down. See tools/api_checker/POLICY.md and the PR
-        # that introduced this workflow for the two-phase rollout plan.
-        continue-on-error: true
-        run: |
-          python3 tools/api_checker/check_docs.py \
-            --snapshot /tmp/api_snapshot.json
-
-      - name: Check macro documentation (advisory only)
-        # Cross-checks docs/mkdocs/docs/api/macros/ pages against #define sites. Only checks the
-        # documented-macro-still-exists direction; never blocks CI. See POLICY.md.
-        run: python3 tools/api_checker/check_macros.py
-
-      - name: Check for uncommitted API surface changes
-        id: diff
-        run: |
-          mkdir -p ${{ github.workspace }}/patch
-          git diff --patch --no-color -- tools/api_checker/api_surface.json > ${{ github.workspace }}/patch/api_surface.patch
-          if [ -s ${{ github.workspace }}/patch/api_surface.patch ]; then
-            echo "tools/api_checker/api_surface.json is out of date. Diff:"
-            cat ${{ github.workspace }}/patch/api_surface.patch
-            echo "has_diff=true" >> "$GITHUB_OUTPUT"
-          else
-            echo "has_diff=false" >> "$GITHUB_OUTPUT"
-          fi
-
-      # Uploaded so contributors can fix their PR with `git apply api_surface.patch`
-      # instead of installing libclang locally.
-      - name: Upload patch
-        if: steps.diff.outputs.has_diff == 'true'
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: api-surface-patch
-          path: patch/api_surface.patch
-
-      - name: Fail if API surface file is not up to date
-        # Unlike the doc-backlog check above, this is purely mechanical regeneration with no
-        # backlog to phase in -- blocking from the start, matching check_amalgamation.yml's
-        # precedent. Contributors who add/remove/rename public API must regenerate and commit
-        # tools/api_checker/api_surface.json as part of their PR.
-        if: steps.diff.outputs.has_diff == 'true'
-        run: exit 1
@@ -3,7 +3,6 @@
 *.gcno
 *.gcda
 .DS_Store
-__pycache__/

 /.idea
 /cmake-build-*
@@ -44,9 +43,5 @@ venv

 nlohmann_json.spdx

-# api_checker: ephemeral, location/doc-status-sensitive working file (not the committed
-# release-tracking artifact -- see tools/api_checker/api_surface.json for that)
-/tools/api_checker/api_snapshot.json
-
 # Bazel-related
 MODULE.bazel.lock
@@ -20,7 +20,9 @@ cc_library(
    hdrs = [
        "include/nlohmann/adl_serializer.hpp",
        "include/nlohmann/byte_container_with_subtype.hpp",
+        "include/nlohmann/detail/abi_config.hpp",
        "include/nlohmann/detail/abi_macros.hpp",
+        "include/nlohmann/detail/bit_ops.hpp",
        "include/nlohmann/detail/conversions/from_json.hpp",
        "include/nlohmann/detail/conversions/to_chars.hpp",
        "include/nlohmann/detail/conversions/to_json.hpp",
@@ -33,6 +35,7 @@ cc_library(
        "include/nlohmann/detail/input/number_parse.hpp",
        "include/nlohmann/detail/input/parser.hpp",
        "include/nlohmann/detail/input/position_t.hpp",
+        "include/nlohmann/detail/input/pow5_table.hpp",
        "include/nlohmann/detail/input/string_scan.hpp",
        "include/nlohmann/detail/iterators/internal_iterator.hpp",
        "include/nlohmann/detail/iterators/iter_impl.hpp",
@@ -63,6 +66,13 @@ cc_library(
        "include/nlohmann/detail/string_escape.hpp",
        "include/nlohmann/detail/string_utils.hpp",
        "include/nlohmann/detail/value_t.hpp",
+        "include/nlohmann/detail/view/builder.hpp",
+        "include/nlohmann/detail/view/document_data.hpp",
+        "include/nlohmann/detail/view/macro_scope.hpp",
+        "include/nlohmann/detail/view/macro_unscope.hpp",
+        "include/nlohmann/detail/view/node.hpp",
+        "include/nlohmann/detail/view/scan.hpp",
+        "include/nlohmann/detail/view/string_ref.hpp",
        "include/nlohmann/json.hpp",
        "include/nlohmann/json_fwd.hpp",
        "include/nlohmann/ordered_map.hpp",
@@ -106,7 +106,7 @@ Thanks everyone!

 :books: If you want to **learn more** about how to use the library, check out the rest of the [**README**](#examples), have a look at [**code examples**](https://github.com/nlohmann/json/tree/develop/docs/mkdocs/docs/examples), or browse through the [**help pages**](https://json.nlohmann.me).

-:construction: If you want to understand the **API** better, check out the [**API Reference**](https://json.nlohmann.me/api/basic_json/) or have a look at the [quick reference](#quick-reference) below. The public API surface is derived mechanically and checked for documentation coverage by the tooling in [`tools/api_checker/`](tools/api_checker/), whose [POLICY.md](tools/api_checker/POLICY.md) defines what counts as public API and what stability is guaranteed.
+:construction: If you want to understand the **API** better, check out the [**API Reference**](https://json.nlohmann.me/api/basic_json/) or have a look at the [quick reference](#quick-reference) below.

 :bug: If you found a **bug**, please check the [**FAQ**](https://json.nlohmann.me/home/faq/) if it is a known issue or the result of a design decision. Please also have a look at the [**issue list**](https://github.com/nlohmann/json/issues) before you [**create a new issue**](https://github.com/nlohmann/json/issues/new/choose). Please provide as much information as possible to help us understand and reproduce your issue.

@@ -1395,6 +1395,7 @@ THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR I
 - The class contains a slightly modified version of the Grisu2 algorithm from Florian Loitsch which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright &copy; 2009 [Florian Loitsch](https://florian.loitsch.com/)
 - The class contains a copy of [Hedley](https://nemequ.github.io/hedley/) from Evan Nemerson which is licensed as [CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/).
 - The class contains parts of [Google Abseil](https://github.com/abseil/abseil-cpp) which is licensed under the [Apache 2.0 License](https://opensource.org/licenses/Apache-2.0).
+- The class contains an adapted version of the Eisel-Lemire algorithm and its table of powers of five from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright &copy; 2021 The fast_float authors

 <img align="right" src="https://git.fsfe.org/reuse/reuse-ci/raw/branch/master/reuse-horizontal.png" alt="REUSE Software">

@@ -420,9 +420,7 @@ basic_json(basic_json&& other) noexcept;
 1. Since version 1.0.0.
 2. Since version 1.0.0.
 3. Since version 2.1.0.
-4. Since version 3.2.0. Also initializes the position reported by
-   [`start_pos()`](start_pos.md)/[`end_pos()`](end_pos.md) from `val` when
-   [`JSON_DIAGNOSTIC_POSITIONS`](../macros/json_diagnostic_positions.md) is enabled, since version 3.12.0.
+4. Since version 3.2.0.
 5. Since version 1.0.0.
 6. Since version 1.0.0.
 7. Since version 1.0.0.
@@ -1,38 +0,0 @@
-# <small>nlohmann::basic_json::</small>bjdata_version_t
-
-```cpp
-enum class bjdata_version_t
-{
-    draft2,
-    draft3,
-};
-```
-
-This enumeration is used in the [`to_bjdata`](to_bjdata.md) function to choose which draft version of
-the BJData specification to encode ND-array extensions for:
-
-draft2
-:   encode using the BJData Draft 2 ND-array format
-
-draft3
-:   encode using the BJData Draft 3 ND-array format
-
-## Examples
-
-??? example
-
-    The example shows how `bjdata_version_t` selects the BJData draft used by `to_bjdata`.
-
-    ```cpp
-    --8<-- "examples/bjdata_version_t.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/bjdata_version_t.output"
-    ```
-
-## Version history
-
- Added in version 3.12.0.
@@ -1,32 +0,0 @@
-# <small>nlohmann::basic_json::</small>initializer_list_t
-
-```cpp
-using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
-```
-
-The type used for the initializer-list [constructor](basic_json.md) (overload 5) and for functions
-such as [`operator=`](operator=.md) that accept a braced-init-list of JSON values. Each element wraps a
-`basic_json` value or something convertible to one, deferring the decision of whether the list should be
-parsed as a JSON array or a JSON object to the constructor itself.
-
-See the [constructor](basic_json.md) documentation for how `initializer_list_t` values are interpreted.
-
-## Examples
-
-??? example
-
-    The example shows how an `initializer_list_t` is used to construct a JSON value.
-
-    ```cpp
-    --8<-- "examples/initializer_list_t.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/initializer_list_t.output"
-    ```
-
-## Version history
-
- Since version 1.0.0.
@@ -1,31 +0,0 @@
-# <small>nlohmann::basic_json::</small>json_sax_t
-
-```cpp
-using json_sax_t = json_sax<basic_json>;
-```
-
-The [`json_sax`](../json_sax/index.md) interface bound to this `basic_json` specialization, i.e. with
-`BasicJsonType` fixed to `basic_json`. Used as the SAX interface type by [`sax_parse`](sax_parse.md) and
-other SAX-based parsing functions.
-
-See [`nlohmann::json_sax`](../json_sax/index.md) for more information.
-
-## Examples
-
-??? example
-
-    The example shows the type `json_sax_t`.
-
-    ```cpp
-    --8<-- "examples/json_sax_t.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/json_sax_t.output"
-    ```
-
-## Version history
-
- Added in version 3.2.0.
@@ -51,5 +51,3 @@ Linear.
 ## Version history

 - Added in version 1.0.0.
- The `noexcept` specification was extended to also depend on
-  [`json_base_class_t`](json_base_class_t.md)'s move-assignment in version 3.11.3.
@@ -85,8 +85,3 @@ Linear in the size of the JSON value.
 - Since version 1.0.0.
 - Macros `JSON_EXPLICIT`/[`JSON_USE_IMPLICIT_CONVERSIONS`](../macros/json_use_implicit_conversions.md) added
  in version 3.9.0.
- The exclusion of `std::any` from this conversion became conditional on
-  [`JSON_HAS_STATIC_RTTI`](../macros/json_has_static_rtti.md) in version 3.11.3.
- `std::optional<T>` excluded from this conversion in version 3.13.0; use
-  [`get<std::optional<T>>()`](get.md)/[`get_to()`](get_to.md) instead (see
-  [Converting values](../../features/conversions.md)).
@@ -1,32 +0,0 @@
-# <small>nlohmann::byte_container_with_subtype::</small>container_type
-
-```cpp
-using container_type = BinaryType;
-```
-
-The type of the underlying binary container, forwarded from the `BinaryType` template parameter that
-`byte_container_with_subtype` is instantiated with. `byte_container_with_subtype` publicly inherits from
-`container_type`.
-
-See [`basic_json::binary_t`](../basic_json/binary_t.md) for the type typically used to instantiate
-`BinaryType`.
-
-## Examples
-
-??? example
-
-    The example shows the type `container_type`.
-
-    ```cpp
-    --8<-- "examples/byte_container_with_subtype__container_type.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/byte_container_with_subtype__container_type.output"
-    ```
-
-## Version history
-
- Since version 3.8.0.
@@ -1,45 +0,0 @@
-# <small>nlohmann::byte_container_with_subtype::</small>operator==
-
-```cpp
-bool operator==(const byte_container_with_subtype& rhs) const;
-```
-
-Compares two `byte_container_with_subtype` values for equality by comparing the underlying binary
-container, the subtype, and whether a subtype is set.
-
-## Parameters
-
-`rhs` (in)
-:   value to compare `*this` against
-
-## Return value
-
-whether `*this` and `rhs` are equal
-
-## Exception safety
-
-No-throw guarantee: this function never throws exceptions.
-
-## Complexity
-
-Linear in the size of the underlying binary container.
-
-## Examples
-
-??? example
-
-    The example demonstrates comparing `byte_container_with_subtype` values.
-
-    ```cpp
-    --8<-- "examples/byte_container_with_subtype__operator_eq.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/byte_container_with_subtype__operator_eq.output"
-    ```
-
-## Version history
-
- Since version 3.8.0.
@@ -1,45 +0,0 @@
-# <small>nlohmann::byte_container_with_subtype::</small>operator!=
-
-```cpp
-bool operator!=(const byte_container_with_subtype& rhs) const;
-```
-
-Compares two `byte_container_with_subtype` values for inequality. Implemented as the negation of
-[`operator==`](operator_eq.md).
-
-## Parameters
-
-`rhs` (in)
-:   value to compare `*this` against
-
-## Return value
-
-whether `*this` and `rhs` are not equal
-
-## Exception safety
-
-No-throw guarantee: this function never throws exceptions.
-
-## Complexity
-
-Linear in the size of the underlying binary container.
-
-## Examples
-
-??? example
-
-    The example demonstrates comparing `byte_container_with_subtype` values.
-
-    ```cpp
-    --8<-- "examples/byte_container_with_subtype__operator_ne.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/byte_container_with_subtype__operator_ne.output"
-    ```
-
-## Version history
-
- Since version 3.8.0.
@@ -1,28 +0,0 @@
-# <small>nlohmann::byte_container_with_subtype::</small>subtype_type
-
-```cpp
-using subtype_type = std::uint64_t;
-```
-
-The type used to store the optional binary subtype tag. See [`subtype`](subtype.md) and
-[`set_subtype`](set_subtype.md).
-
-## Examples
-
-??? example
-
-    The example shows the type `subtype_type`.
-
-    ```cpp
-    --8<-- "examples/byte_container_with_subtype__subtype_type.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/byte_container_with_subtype__subtype_type.output"
-    ```
-
-## Version history
-
- Since version 3.8.0.
@@ -1,30 +0,0 @@
-# <small>nlohmann::json_sax::</small>binary_t
-
-```cpp
-using binary_t = typename BasicJsonType::binary_t;
-```
-
-The type used by the [`binary`](binary.md) callback for JSON binary values, forwarded from the
-`BasicJsonType` template parameter.
-
-See [`basic_json::binary_t`](../basic_json/binary_t.md) for more information.
-
-## Examples
-
-??? example
-
-    The example shows the type `binary_t` and its relation to `basic_json::binary_t`.
-
-    ```cpp
-    --8<-- "examples/json_sax__binary_t.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/json_sax__binary_t.output"
-    ```
-
-## Version history
-
- Added in version 3.8.0.
@@ -1,33 +0,0 @@
-# <small>nlohmann::json_sax::</small>json_sax
-
-```cpp
-// (1)
-json_sax() = default;
-
-// (2)
-json_sax(const json_sax&) = default;
-
-// (3)
-json_sax(json_sax&&) noexcept = default;
-```
-
-1. Default constructor.
-2. Copy constructor.
-3. Move constructor.
-
-`json_sax` is a pure abstract base class with no data members of its own, so all three constructors are
-defaulted and only exist to make derived SAX consumers explicitly copyable/movable.
-
-## Exception safety
-
-No-throw guarantee: none of these constructors throw exceptions.
-
-## Complexity
-
-Constant.
-
-<!-- NOLINT Examples -->
-
-## Version history
-
- Added in version 3.2.0.
@@ -1,30 +0,0 @@
-# <small>nlohmann::json_sax::</small>number_float_t
-
-```cpp
-using number_float_t = typename BasicJsonType::number_float_t;
-```
-
-The type used by the [`number_float`](number_float.md) callback for JSON floating-point numbers,
-forwarded from the `BasicJsonType` template parameter.
-
-See [`basic_json::number_float_t`](../basic_json/number_float_t.md) for more information.
-
-## Examples
-
-??? example
-
-    The example shows the type `number_float_t` and its relation to `basic_json::number_float_t`.
-
-    ```cpp
-    --8<-- "examples/json_sax__number_float_t.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/json_sax__number_float_t.output"
-    ```
-
-## Version history
-
- Added in version 3.2.0.
@@ -1,30 +0,0 @@
-# <small>nlohmann::json_sax::</small>number_integer_t
-
-```cpp
-using number_integer_t = typename BasicJsonType::number_integer_t;
-```
-
-The type used by the [`number_integer`](number_integer.md) callback for JSON integer numbers, forwarded
-from the `BasicJsonType` template parameter.
-
-See [`basic_json::number_integer_t`](../basic_json/number_integer_t.md) for more information.
-
-## Examples
-
-??? example
-
-    The example shows the type `number_integer_t` and its relation to `basic_json::number_integer_t`.
-
-    ```cpp
-    --8<-- "examples/json_sax__number_integer_t.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/json_sax__number_integer_t.output"
-    ```
-
-## Version history
-
- Added in version 3.2.0.
@@ -1,30 +0,0 @@
-# <small>nlohmann::json_sax::</small>number_unsigned_t
-
-```cpp
-using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-```
-
-The type used by the [`number_unsigned`](number_unsigned.md) callback for JSON unsigned integer numbers,
-forwarded from the `BasicJsonType` template parameter.
-
-See [`basic_json::number_unsigned_t`](../basic_json/number_unsigned_t.md) for more information.
-
-## Examples
-
-??? example
-
-    The example shows the type `number_unsigned_t` and its relation to `basic_json::number_unsigned_t`.
-
-    ```cpp
-    --8<-- "examples/json_sax__number_unsigned_t.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/json_sax__number_unsigned_t.output"
-    ```
-
-## Version history
-
- Added in version 3.2.0.
@@ -1,29 +0,0 @@
-# <small>nlohmann::json_sax::</small>operator=
-
-```cpp
-// (1)
-json_sax& operator=(const json_sax&) = default;
-
-// (2)
-json_sax& operator=(json_sax&&) noexcept = default;
-```
-
-1. Copy assignment operator.
-2. Move assignment operator.
-
-`json_sax` is a pure abstract base class with no data members of its own, so both assignment operators
-are defaulted and only exist to make derived SAX consumers explicitly copy-/move-assignable.
-
-## Exception safety
-
-No-throw guarantee: neither operator throws exceptions.
-
-## Complexity
-
-Constant.
-
-<!-- NOLINT Examples -->
-
-## Version history
-
- Added in version 3.2.0.
@@ -1,30 +0,0 @@
-# <small>nlohmann::json_sax::</small>string_t
-
-```cpp
-using string_t = typename BasicJsonType::string_t;
-```
-
-The type used by the [`string`](string.md) and [`key`](key.md) callbacks for JSON strings and object
-keys, forwarded from the `BasicJsonType` template parameter.
-
-See [`basic_json::string_t`](../basic_json/string_t.md) for more information.
-
-## Examples
-
-??? example
-
-    The example shows the type `string_t` and its relation to `basic_json::string_t`.
-
-    ```cpp
-    --8<-- "examples/json_sax__string_t.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/json_sax__string_t.output"
-    ```
-
-## Version history
-
- Added in version 3.2.0.
@@ -1,22 +0,0 @@
-# <small>nlohmann::json_sax::</small>~json_sax
-
-```cpp
-virtual ~json_sax() = default;
-```
-
-Destructor. Virtual to allow proper destruction of derived SAX consumer classes through a
-pointer/reference to `json_sax`.
-
-## Exception safety
-
-No-throw guarantee: this destructor never throws exceptions.
-
-## Complexity
-
-Constant.
-
-<!-- NOLINT Examples -->
-
-## Version history
-
- Added in version 3.2.0.
@@ -8,16 +8,16 @@ This type preserves the insertion order of object keys.

 ## Iterator invalidation

-The type is based on [`ordered_map`](ordered_map/index.md) which in turn uses a `std::vector` to store object elements.
+The type is based on [`ordered_map`](ordered_map.md) which in turn uses a `std::vector` to store object elements.
 Therefore, adding object elements can yield a reallocation in which case all iterators (including the
 [`end()`](basic_json/end.md) iterator) and all references to the elements are invalidated. Also, any iterator or
 reference after the insertion point will point to the same index, which is now a different value.

 ## Complexity

-[`ordered_map`](ordered_map/index.md) has no lookup index: every key-based object operation is a linear scan, so building or
+[`ordered_map`](ordered_map.md) has no lookup index: every key-based object operation is a linear scan, so building or
 parsing an object of `n` keys costs O(n²) rather than O(n log n). See
-[`ordered_map` complexity](ordered_map/index.md#complexity) for the per-operation table and for measured numbers.
+[`ordered_map` complexity](ordered_map.md#complexity) for the per-operation table and for measured numbers.

 ## Examples

@@ -37,7 +37,7 @@ parsing an object of `n` keys costs O(n²) rather than O(n log n). See

 ## See also

- [ordered_map](ordered_map/index.md)
+- [ordered_map](ordered_map.md)
 - [Object Order](../features/object_order.md)

 ## Version history
@@ -6,7 +6,7 @@ template<class Key, class T, class IgnoredLess = std::less<Key>,
 struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>;
 ```

-A minimal map-like container that preserves insertion order for use within [`nlohmann::ordered_json`](../ordered_json.md)
+A minimal map-like container that preserves insertion order for use within [`nlohmann::ordered_json`](ordered_json.md)
 (`nlohmann::basic_json<ordered_map>`).

 ## Template parameters
@@ -32,12 +32,12 @@ case all iterators (including the `end()` iterator) and all references to the el

 - **key_type** - key type (`Key`)
 - **mapped_type** - mapped type (`T`)
- [**Container**](Container.md) - base container type (`#!cpp std::vector<std::pair<const Key, T>, Allocator>`)
+- **Container** - base container type (`#!cpp std::vector<std::pair<const Key, T>, Allocator>`)
 - **iterator**
 - **const_iterator**
 - **size_type**
 - **value_type**
- [**key_compare**](key_compare.md) - key comparison function
+- **key_compare** - key comparison function
 ```cpp
 std::equal_to<Key>  // until C++14

@@ -46,16 +46,15 @@ std::equal_to<>     // since C++14

 ## Member functions

- [(constructor)](ordered_map.md)
- [(destructor)](~ordered_map.md)
- [**operator=**](operator=.md)
- [**emplace**](emplace.md)
- [**operator\[\]**](operator[].md)
- [**at**](at.md)
- [**erase**](erase.md)
- [**count**](count.md)
- [**find**](find.md)
- [**insert**](insert.md)
+- (constructor)
+- (destructor)
+- **emplace**
+- **operator\[\]**
+- **at**
+- **erase**
+- **count**
+- **find**
+- **insert**

 ## Complexity

@@ -117,9 +116,9 @@ This differs from `#!cpp std::map`, where the same operations are O(log n).

 ## See also

- [ordered_json](../ordered_json.md)
+- [ordered_json](ordered_json.md)

 ## Version history

- Added in version 3.9.0 to implement [`nlohmann::ordered_json`](../ordered_json.md).
+- Added in version 3.9.0 to implement [`nlohmann::ordered_json`](ordered_json.md).
 - Added **key_compare** member in version 3.11.0.
@@ -1,28 +0,0 @@
-# <small>nlohmann::ordered_map::</small>Container
-
-```cpp
-using Container = std::vector<std::pair<const Key, T>, Allocator>;
-```
-
-The base container type that `ordered_map` publicly inherits from. Elements are stored in insertion
-order as `#!cpp std::pair<const Key, T>` entries in a `std::vector`.
-
-## Examples
-
-??? example
-
-    The example shows the type `Container`.
-
-    ```cpp
-    --8<-- "examples/ordered_map__Container.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/ordered_map__Container.output"
-    ```
-
-## Version history
-
- Added in version 3.9.0 to implement [`nlohmann::ordered_json`](../ordered_json.md).
@@ -1,61 +0,0 @@
-# <small>nlohmann::ordered_map::</small>at
-
-```cpp
-// (1)
-T& at(const key_type& key);
-const T& at(const key_type& key) const;
-
-// (2)
-template<class KeyType>
-T& at(KeyType&& key);
-template<class KeyType>
-const T& at(KeyType&& key) const;
-```
-
-1. Returns a reference to the value mapped to `key`.
-2. Same as (1), but for any `KeyType` comparable to `key_type` via [`key_compare`](key_compare.md)
-   (heterogeneous lookup, e.g. looking up by a `#!cpp const char*` without constructing a temporary
-   `key_type`). Only participates in overload resolution if `KeyType` is usable as a key type.
-
-## Template parameters
-
-`KeyType`
-:   a type comparable to `key_type` via [`key_compare`](key_compare.md)
-
-## Parameters
-
-`key` (in)
-:   key of the element to find
-
-## Return value
-
-reference to the mapped value of the element with key equal to `key`
-
-## Exceptions
-
-Throws `std::out_of_range` if no element with key `key` exists.
-
-## Complexity
-
-Linear in the number of elements.
-
-## Examples
-
-??? example
-
-    The example shows how `at` is used.
-
-    ```cpp
-    --8<-- "examples/ordered_map__at.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/ordered_map__at.output"
-    ```
-
-## Version history
-
- Added in version 3.9.1 to implement [`nlohmann::ordered_json`](../ordered_json.md).
- Overload (2) added in version 3.11.0.
@@ -1,53 +0,0 @@
-# <small>nlohmann::ordered_map::</small>count
-
-```cpp
-// (1)
-size_type count(const key_type& key) const;
-
-// (2)
-template<class KeyType>
-size_type count(KeyType&& key) const;
-```
-
-1. Returns the number of elements with key equal to `key` (0 or 1, since keys are unique).
-2. Same as (1), but for any `KeyType` comparable to `key_type` via [`key_compare`](key_compare.md)
-   (heterogeneous lookup). Only participates in overload resolution if `KeyType` is usable as a key type.
-
-## Template parameters
-
-`KeyType`
-:   a type comparable to `key_type` via [`key_compare`](key_compare.md)
-
-## Parameters
-
-`key` (in)
-:   key of the elements to count
-
-## Return value
-
-number of elements with key equal to `key` (0 or 1)
-
-## Complexity
-
-Linear in the number of elements.
-
-## Examples
-
-??? example
-
-    The example shows how `count` is used.
-
-    ```cpp
-    --8<-- "examples/ordered_map__count.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/ordered_map__count.output"
-    ```
-
-## Version history
-
- Added in version 3.9.1 to implement [`nlohmann::ordered_json`](../ordered_json.md).
- Overload (2) added in version 3.11.0.
@@ -1,58 +0,0 @@
-# <small>nlohmann::ordered_map::</small>emplace
-
-```cpp
-// (1)
-std::pair<iterator, bool> emplace(const key_type& key, T&& t);
-
-// (2)
-template<class KeyType>
-std::pair<iterator, bool> emplace(KeyType&& key, T&& t);
-```
-
-1. Inserts `#!cpp {key, t}` if no element with an equal key already exists (per [`key_compare`](key_compare.md)),
-   appending it at the end to preserve insertion order. If an equal key already exists, does nothing.
-2. Same as (1), but for any `KeyType` comparable to `key_type` via [`key_compare`](key_compare.md)
-   (heterogeneous lookup). Only participates in overload resolution if `KeyType` is usable as a key type.
-
-## Template parameters
-
-`KeyType`
-:   a type comparable to `key_type` via [`key_compare`](key_compare.md)
-
-## Parameters
-
-`key` (in)
-:   key of the element to insert
-
-`t` (in)
-:   value of the element to insert
-
-## Return value
-
-pair of an iterator to the (possibly newly inserted) element, and a `bool` that is `true` if insertion
-took place and `false` if an element with an equal key already existed
-
-## Complexity
-
-Linear in the number of elements.
-
-## Examples
-
-??? example
-
-    The example shows how `emplace` is used.
-
-    ```cpp
-    --8<-- "examples/ordered_map__emplace.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/ordered_map__emplace.output"
-    ```
-
-## Version history
-
- Added in version 3.9.0 to implement [`nlohmann::ordered_json`](../ordered_json.md).
- Overload (2) added in version 3.11.0.
@@ -1,75 +0,0 @@
-# <small>nlohmann::ordered_map::</small>erase
-
-```cpp
-// (1)
-size_type erase(const key_type& key);
-
-// (2)
-template<class KeyType>
-size_type erase(KeyType&& key);
-
-// (3)
-iterator erase(iterator pos);
-
-// (4)
-iterator erase(iterator first, iterator last);
-```
-
-1. Removes the element with key equal to `key`, if any, preserving the relative order of the remaining
-   elements.
-2. Same as (1), but for any `KeyType` comparable to `key_type` via [`key_compare`](key_compare.md)
-   (heterogeneous lookup). Only participates in overload resolution if `KeyType` is usable as a key type.
-3. Removes the element at `pos`.
-4. Removes the elements in range `[first, last)`.
-
-## Template parameters
-
-`KeyType`
-:   a type comparable to `key_type` via [`key_compare`](key_compare.md)
-
-## Parameters
-
-`key` (in)
-:   key of the element to remove
-
-`pos` (in)
-:   iterator to the element to remove
-
-`first` (in)
-:   iterator to the first element to remove
-
-`last` (in)
-:   iterator one past the last element to remove
-
-## Return value
-
-1. number of elements removed (0 or 1)
-2. number of elements removed (0 or 1)
-3. iterator following the removed element
-4. iterator following the last removed element
-
-## Complexity
-
-Linear in the number of elements (elements after the removed one(s) are shifted to keep storage
-contiguous).
-
-## Examples
-
-??? example
-
-    The example shows how `erase` is used.
-
-    ```cpp
-    --8<-- "examples/ordered_map__erase.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/ordered_map__erase.output"
-    ```
-
-## Version history
-
- Added in version 3.9.0 to implement [`nlohmann::ordered_json`](../ordered_json.md).
- Overload (2) added in version 3.11.0.
@@ -1,56 +0,0 @@
-# <small>nlohmann::ordered_map::</small>find
-
-```cpp
-// (1)
-iterator find(const key_type& key);
-const_iterator find(const key_type& key) const;
-
-// (2)
-template<class KeyType>
-iterator find(KeyType&& key);
-template<class KeyType>
-const_iterator find(KeyType&& key) const;
-```
-
-1. Returns an iterator to the element with key equal to `key`, or `end()` if no such element exists.
-2. Same as (1), but for any `KeyType` comparable to `key_type` via [`key_compare`](key_compare.md)
-   (heterogeneous lookup). Only participates in overload resolution if `KeyType` is usable as a key type.
-
-## Template parameters
-
-`KeyType`
-:   a type comparable to `key_type` via [`key_compare`](key_compare.md)
-
-## Parameters
-
-`key` (in)
-:   key of the element to find
-
-## Return value
-
-iterator to the element with key equal to `key`, or `end()` if not found
-
-## Complexity
-
-Linear in the number of elements.
-
-## Examples
-
-??? example
-
-    The example shows how `find` is used.
-
-    ```cpp
-    --8<-- "examples/ordered_map__find.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/ordered_map__find.output"
-    ```
-
-## Version history
-
- Added in version 3.9.1 to implement [`nlohmann::ordered_json`](../ordered_json.md).
- Overload (2) added in version 3.11.0.
@@ -1,63 +0,0 @@
-# <small>nlohmann::ordered_map::</small>insert
-
-```cpp
-// (1)
-std::pair<iterator, bool> insert(value_type&& value);
-std::pair<iterator, bool> insert(const value_type& value);
-
-// (2)
-template<typename InputIt>
-void insert(InputIt first, InputIt last);
-```
-
-1. Inserts `value` if no element with an equal key already exists (per [`key_compare`](key_compare.md)),
-   appending it at the end to preserve insertion order. If an equal key already exists, does nothing.
-2. Inserts the elements from range `[first, last)`, in iteration order, applying the same equal-key rule
-   as (1) to each element.
-
-## Template parameters
-
-`InputIt`
-:   an input iterator type
-
-## Parameters
-
-`value` (in)
-:   value to insert
-
-`first` (in)
-:   iterator to the first element to insert
-
-`last` (in)
-:   iterator one past the last element to insert
-
-## Return value
-
-1. pair of an iterator to the (possibly newly inserted) element, and a `bool` that is `true` if insertion
-   took place and `false` if an element with an equal key already existed
-2. (none)
-
-## Complexity
-
-1. Linear in the number of elements.
-2. Linear in the distance between `first` and `last`, times linear in the number of elements.
-
-## Examples
-
-??? example
-
-    The example shows how `insert` is used.
-
-    ```cpp
-    --8<-- "examples/ordered_map__insert.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/ordered_map__insert.output"
-    ```
-
-## Version history
-
- Added in version 3.9.1 to implement [`nlohmann::ordered_json`](../ordered_json.md).
@@ -1,34 +0,0 @@
-# <small>nlohmann::ordered_map::</small>key_compare
-
-```cpp
-using key_compare = std::equal_to<Key>;  // until C++14
-
-using key_compare = std::equal_to<>;     // since C++14
-```
-
-The comparator used to determine key equality when looking up elements. Unlike `std::map`, `ordered_map`
-uses linear search with `key_compare` rather than an ordering relation, since element order reflects
-insertion order rather than key order.
-
-Since C++14, the transparent `#!cpp std::equal_to<>` is used, which enables heterogeneous lookup (e.g.
-looking up by a `#!cpp const char*` key without constructing a temporary `Key`).
-
-## Examples
-
-??? example
-
-    The example shows how `key_compare` is used.
-
-    ```cpp
-    --8<-- "examples/ordered_map__key_compare.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/ordered_map__key_compare.output"
-    ```
-
-## Version history
-
- Added in version 3.11.0.
@@ -1,32 +0,0 @@
-# <small>nlohmann::ordered_map::</small>operator=
-
-```cpp
-// (1)
-ordered_map& operator=(const ordered_map& other);
-
-// (2)
-ordered_map& operator=(ordered_map&& other) noexcept(std::is_nothrow_move_assignable<Container>::value);
-```
-
-1. Copy assignment operator.
-2. Move assignment operator.
-
-## Parameters
-
-`other` (in)
-:   value to assign from
-
-## Return value
-
-`*this`
-
-## Complexity
-
-1. Linear in the size of `other`.
-2. Constant.
-
-<!-- NOLINT Examples -->
-
-## Version history
-
- Added in version 3.9.0 to implement [`nlohmann::ordered_json`](../ordered_json.md).
@@ -1,62 +0,0 @@
-# <small>nlohmann::ordered_map::</small>operator[]
-
-```cpp
-// (1)
-T& operator[](const key_type& key);
-const T& operator[](const key_type& key) const;
-
-// (2)
-template<class KeyType>
-T& operator[](KeyType&& key);
-template<class KeyType>
-const T& operator[](KeyType&& key) const;
-```
-
-1. Returns a reference to the value mapped to `key`, inserting a default-constructed `T` (non-`const`
-   overload only) if no such element exists yet.
-2. Same as (1), but for any `KeyType` comparable to `key_type` via [`key_compare`](key_compare.md)
-   (heterogeneous lookup). Only participates in overload resolution if `KeyType` is usable as a key type.
-
-## Template parameters
-
-`KeyType`
-:   a type comparable to `key_type` via [`key_compare`](key_compare.md)
-
-## Parameters
-
-`key` (in)
-:   key of the element to find or insert
-
-## Return value
-
-reference to the mapped value of the element with key equal to `key`
-
-## Exceptions
-
-The `const` overloads throw `std::out_of_range` if no element with key `key` exists (they delegate to
-[`at`](at.md)).
-
-## Complexity
-
-Linear in the number of elements.
-
-## Examples
-
-??? example
-
-    The example shows how `operator[]` is used.
-
-    ```cpp
-    --8<-- "examples/ordered_map__operator_idx.cpp"
-    ```
-
-    Output:
-
-    ```
-    --8<-- "examples/ordered_map__operator_idx.output"
-    ```
-
-## Version history
-
- Added in version 3.9.0 to implement [`nlohmann::ordered_json`](../ordered_json.md).
- Overload (2) added in version 3.11.0.
@@ -1,66 +0,0 @@
-# <small>nlohmann::ordered_map::</small>ordered_map
-
-```cpp
-// (1)
-ordered_map() noexcept(noexcept(Container()));
-
-// (2)
-explicit ordered_map(const Allocator& alloc) noexcept(noexcept(Container(alloc)));
-
-// (3)
-template <class It>
-ordered_map(It first, It last, const Allocator& alloc = Allocator());
-
-// (4)
-ordered_map(std::initializer_list<value_type> init, const Allocator& alloc = Allocator());
-
-// (5)
-ordered_map(const ordered_map&) = default;
-
-// (6)
-ordered_map(ordered_map&&) noexcept(std::is_nothrow_move_constructible<Container>::value) = default;
-```
-
-1. Default constructor. Creates an empty `ordered_map`.
-2. Creates an empty `ordered_map` using the given allocator.
-3. Creates an `ordered_map` from the elements in range `[first, last)`, inserted in iteration order.
-4. Creates an `ordered_map` from an initializer list of key/value pairs, inserted in list order.
-5. Copy constructor.
-6. Move constructor.
-
-These constructors are declared explicitly (rather than inherited via `#!cpp using Container::Container`)
-because older compilers (GCC <= 5.5, Xcode <= 9.4) do not handle the inherited constructors correctly.
-
-## Template parameters
-
-`It`
-:   an input iterator type
-
-## Parameters
-
-`alloc` (in)
-:   allocator to use for the underlying container
-
-`first` (in)
-:   iterator to the first element to insert
-
-`last` (in)
-:   iterator one past the last element to insert
-
-`init` (in)
-:   initializer list of key/value pairs to insert
-
-## Complexity
-
-1. Constant.
-2. Constant.
-3. Linear in the distance between `first` and `last`.
-4. Linear in the size of `init`.
-5. Linear in the size of `other`.
-6. Constant.
-
-<!-- NOLINT Examples -->
-
-## Version history
-
- Added in version 3.9.0 to implement [`nlohmann::ordered_json`](../ordered_json.md).
@@ -1,17 +0,0 @@
-# <small>nlohmann::ordered_map::</small>~ordered_map
-
-```cpp
-~ordered_map() = default;
-```
-
-Destroys the `ordered_map` and frees all allocated memory.
-
-## Complexity
-
-Linear in the number of elements.
-
-<!-- NOLINT Examples -->
-
-## Version history
-
- Added in version 3.9.0 to implement [`nlohmann::ordered_json`](../ordered_json.md).
@@ -1,21 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-using json = nlohmann::json;
-
-int main()
-{
-    // an empty binary value is encoded differently by the two drafts:
-    // draft2 omits the optimized type marker for an empty byte array,
-    // while draft3 always writes it
-    json j = json::binary({});
-
-    // encode using BJData draft2 (the default)
-    auto v_draft2 = json::to_bjdata(j, true, true, json::bjdata_version_t::draft2);
-
-    // encode using BJData draft3
-    auto v_draft3 = json::to_bjdata(j, true, true, json::bjdata_version_t::draft3);
-
-    std::cout << "draft2 size: " << v_draft2.size() << '\n'
-              << "draft3 size: " << v_draft3.size() << std::endl;
-}
@@ -1,2 +0,0 @@
-draft2 size: 4
-draft3 size: 6
@@ -1,11 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-using byte_container_with_subtype = nlohmann::byte_container_with_subtype<std::vector<std::uint8_t>>;
-
-int main()
-{
-    std::cout << std::boolalpha
-              << std::is_same<byte_container_with_subtype::container_type, std::vector<std::uint8_t>>::value
-              << std::endl;
-}
@@ -1 +0,0 @@
-true
@@ -1,15 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-using byte_container_with_subtype = nlohmann::byte_container_with_subtype<std::vector<std::uint8_t>>;
-
-int main()
-{
-    byte_container_with_subtype c1({0xca, 0xfe});
-    byte_container_with_subtype c2({0xca, 0xfe});
-    byte_container_with_subtype c3({0xca, 0xfe}, 42);
-
-    std::cout << std::boolalpha
-              << "c1 == c2: " << (c1 == c2) << '\n'
-              << "c1 == c3: " << (c1 == c3) << std::endl;
-}
@@ -1,2 +0,0 @@
-c1 == c2: true
-c1 == c3: false
@@ -1,15 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-using byte_container_with_subtype = nlohmann::byte_container_with_subtype<std::vector<std::uint8_t>>;
-
-int main()
-{
-    byte_container_with_subtype c1({0xca, 0xfe});
-    byte_container_with_subtype c2({0xca, 0xfe});
-    byte_container_with_subtype c3({0xca, 0xfe}, 42);
-
-    std::cout << std::boolalpha
-              << "c1 != c2: " << (c1 != c2) << '\n'
-              << "c1 != c3: " << (c1 != c3) << std::endl;
-}
@@ -1,2 +0,0 @@
-c1 != c2: false
-c1 != c3: true
@@ -1,10 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-using byte_container_with_subtype = nlohmann::byte_container_with_subtype<std::vector<std::uint8_t>>;
-
-int main()
-{
-    std::cout << std::boolalpha
-              << std::is_same<byte_container_with_subtype::subtype_type, std::uint64_t>::value << std::endl;
-}
@@ -1 +0,0 @@
-true
@@ -1,13 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-using json = nlohmann::json;
-
-int main()
-{
-    // an initializer_list_t is what a braced-init-list of JSON values is deduced as
-    json::initializer_list_t init = {"a", 1, 2.0, false};
-
-    json j(init);
-    std::cout << j.dump() << std::endl;
-}
@@ -1 +0,0 @@
-["a",1,2.0,false]
@@ -1,10 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-using json = nlohmann::json;
-
-int main()
-{
-    std::cout << std::boolalpha
-              << std::is_same<json::json_sax_t::binary_t, json::binary_t>::value << std::endl;
-}
@@ -1 +0,0 @@
-true
@@ -1,10 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-using json = nlohmann::json;
-
-int main()
-{
-    std::cout << std::boolalpha
-              << std::is_same<json::json_sax_t::number_float_t, json::number_float_t>::value << std::endl;
-}
@@ -1 +0,0 @@
-true
@@ -1,10 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-using json = nlohmann::json;
-
-int main()
-{
-    std::cout << std::boolalpha
-              << std::is_same<json::json_sax_t::number_integer_t, json::number_integer_t>::value << std::endl;
-}
@@ -1 +0,0 @@
-true
@@ -1,10 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-using json = nlohmann::json;
-
-int main()
-{
-    std::cout << std::boolalpha
-              << std::is_same<json::json_sax_t::number_unsigned_t, json::number_unsigned_t>::value << std::endl;
-}
@@ -1 +0,0 @@
-true
@@ -1,10 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-using json = nlohmann::json;
-
-int main()
-{
-    std::cout << std::boolalpha
-              << std::is_same<json::json_sax_t::string_t, json::string_t>::value << std::endl;
-}
@@ -1 +0,0 @@
-true
@@ -1,10 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-using json = nlohmann::json;
-
-int main()
-{
-    std::cout << std::boolalpha
-              << std::is_same<json::json_sax_t, nlohmann::json_sax<json>>::value << std::endl;
-}
@@ -1 +0,0 @@
-true
@@ -1,12 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-int main()
-{
-    using Map = nlohmann::ordered_map<std::string, int>;
-
-    std::cout << std::boolalpha
-              << "Container is std::vector<std::pair<const Key, T>>: "
-              << std::is_same<Map::Container, std::vector<std::pair<const std::string, int>>>::value
-              << std::endl;
-}
@@ -1 +0,0 @@
-Container is std::vector<std::pair<const Key, T>>: true
@@ -1,26 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-int main()
-{
-    nlohmann::ordered_map<std::string, int> m;
-    m["one"] = 1;
-    m["two"] = 2;
-
-    // access an existing element
-    std::cout << "m.at(\"one\") = " << m.at("one") << std::endl;
-
-    // modify through the reference returned by at()
-    m.at("two") = 22;
-    std::cout << "m.at(\"two\") = " << m.at("two") << std::endl;
-
-    // accessing a missing key throws
-    try
-    {
-        m.at("three");
-    }
-    catch (const std::out_of_range& e)
-    {
-        std::cout << "exception: " << e.what() << std::endl;
-    }
-}
@@ -1,3 +0,0 @@
-m.at("one") = 1
-m.at("two") = 22
-exception: key not found
@@ -1,12 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-int main()
-{
-    nlohmann::ordered_map<std::string, int> m;
-    m["one"] = 1;
-
-    std::cout << std::boolalpha
-              << "m.count(\"one\") = " << m.count("one") << '\n'
-              << "m.count(\"two\") = " << m.count("two") << std::endl;
-}
@@ -1,2 +0,0 @@
-m.count("one") = 1
-m.count("two") = 0
@@ -1,15 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-int main()
-{
-    nlohmann::ordered_map<std::string, std::string> m;
-
-    // emplace a new element
-    auto res1 = m.emplace("one", "eins");
-    std::cout << std::boolalpha << "inserted: " << res1.second << ", value: " << res1.first->second << std::endl;
-
-    // emplace with an already-existing key: no-op, returns the existing element
-    auto res2 = m.emplace("one", "uno");
-    std::cout << std::boolalpha << "inserted: " << res2.second << ", value: " << res2.first->second << std::endl;
-}
@@ -1,2 +0,0 @@
-inserted: true, value: eins
-inserted: false, value: eins
@@ -1,24 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-int main()
-{
-    nlohmann::ordered_map<std::string, int> m;
-    m["one"] = 1;
-    m["two"] = 2;
-    m["three"] = 3;
-
-    // erase by key
-    std::size_t removed = m.erase("two");
-    std::cout << "removed by key: " << removed << std::endl;
-
-    // erase by iterator
-    m.erase(m.begin());
-
-    std::cout << "remaining: ";
-    for (const auto& element : m)
-    {
-        std::cout << element.first << ' ';
-    }
-    std::cout << std::endl;
-}
@@ -1,2 +0,0 @@
-removed by key: 1
-remaining: three 
@@ -1,19 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-int main()
-{
-    nlohmann::ordered_map<std::string, int> m;
-    m["one"] = 1;
-
-    auto it = m.find("one");
-    if (it != m.end())
-    {
-        std::cout << "found: " << it->first << " = " << it->second << std::endl;
-    }
-
-    if (m.find("two") == m.end())
-    {
-        std::cout << "\"two\" not found" << std::endl;
-    }
-}
@@ -1,2 +0,0 @@
-found: one = 1
-"two" not found
@@ -1,21 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-int main()
-{
-    nlohmann::ordered_map<std::string, int> m;
-
-    // insert a single value
-    auto res = m.insert({"one", 1});
-    std::cout << std::boolalpha << "inserted: " << res.second << std::endl;
-
-    // insert a range from another container
-    std::vector<std::pair<const std::string, int>> more = {{"two", 2}, {"three", 3}};
-    m.insert(more.begin(), more.end());
-
-    for (const auto& element : m)
-    {
-        std::cout << element.first << ':' << element.second << ' ';
-    }
-    std::cout << std::endl;
-}
@@ -1,2 +0,0 @@
-inserted: true
-one:1 two:2 three:3 
@@ -1,12 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-int main()
-{
-    using Map = nlohmann::ordered_map<std::string, int>;
-    Map::key_compare compare{};
-
-    std::cout << std::boolalpha
-              << "compare(\"a\", \"a\") = " << compare("a", "a") << '\n'
-              << "compare(\"a\", \"b\") = " << compare("a", "b") << std::endl;
-}
@@ -1,2 +0,0 @@
-compare("a", "a") = true
-compare("a", "b") = false
@@ -1,14 +0,0 @@
-#include <iostream>
-#include <nlohmann/json.hpp>
-
-int main()
-{
-    nlohmann::ordered_map<std::string, int> m;
-
-    // operator[] inserts a default-constructed value if the key doesn't exist yet
-    m["one"] = 1;
-    std::cout << "m[\"one\"] = " << m["one"] << std::endl;
-
-    // accessing again just returns the existing value
-    std::cout << "m[\"one\"] = " << m["one"] << std::endl;
-}
@@ -1,2 +0,0 @@
-m["one"] = 1
-m["one"] = 1
@@ -51,16 +51,16 @@ If you do want to preserve the **insertion order**, you can use the type [`nlohm
    --8<-- "examples/ordered_json.output"
    ```

-Alternatively, [`nlohmann::fifo_map`](https://github.com/nlohmann/fifo_map) also preserves the insertion order and, unlike [`ordered_map`](../api/ordered_map/index.md), keeps a lookup index, so it does not have the quadratic cost described below. It is used through a small adapter ([integration](https://github.com/nlohmann/json/issues/485#issuecomment-333652309)).
+Alternatively, [`nlohmann::fifo_map`](https://github.com/nlohmann/fifo_map) also preserves the insertion order and, unlike [`ordered_map`](../api/ordered_map.md), keeps a lookup index, so it does not have the quadratic cost described below. It is used through a small adapter ([integration](https://github.com/nlohmann/json/issues/485#issuecomment-333652309)).

 If the order does not matter and you only want faster lookup, `boost::unordered_flat_map`, `absl::flat_hash_map`, `absl::node_hash_map`, and several other hash maps work through an adapter that restores the template argument order `basic_json` expects; see [Template Parameter Requirements](types/template_parameters.md#objecttype). Note these are *unordered*, not insertion-ordered.

 [`tsl::ordered_map`](https://github.com/Tessil/ordered-map) cannot be used: its iterators expose the mapped value as `const`, while `basic_json` needs to modify it in place.

-The [`ordered_map`](../api/ordered_map/index.md) behind `nlohmann::ordered_json` is deliberately minimal and has no lookup
+The [`ordered_map`](../api/ordered_map.md) behind `nlohmann::ordered_json` is deliberately minimal and has no lookup
 index, so every key access is a linear scan and building an object of `n` keys costs O(n²). This is unnoticeable at
 typical object sizes but becomes significant for objects with many thousands of keys; see
-[`ordered_map` complexity](../api/ordered_map/index.md#complexity). The alternatives above keep a lookup index and do not
+[`ordered_map` complexity](../api/ordered_map.md#complexity). The alternatives above keep a lookup index and do not
 have this cost.

 ### Notes on parsing
@@ -37,7 +37,7 @@ Requirements are split into two groups:

 | Template parameter                                                | Default                           | Notable substitutes                                                   |
 |-------------------------------------------------------------------|-----------------------------------|-----------------------------------------------------------------------|
-| [`ObjectType`](#objecttype)                                       | `std::map`                        | [`nlohmann::ordered_map`](../../api/ordered_map/index.md), Abseil hash maps |
+| [`ObjectType`](#objecttype)                                       | `std::map`                        | [`nlohmann::ordered_map`](../../api/ordered_map.md), Abseil hash maps |
 | [`ArrayType`](#arraytype)                                         | `std::vector`                     | `#!cpp std::deque`                                                    |
 | [`StringType`](#stringtype)                                       | `std::string`                     | `std::string`-like types over `char`                                  |
 | [`BooleanType`](#booleantype)                                     | `bool`                            | none worth using                                                      |
@@ -230,7 +230,7 @@ The library does not sort or de-duplicate keys itself; the behavior described in
 | Container                                                                        | Notes                                                                         |
 |----------------------------------------------------------------------------------|-------------------------------------------------------------------------------|
 | `#!cpp std::map` (default)                                                       |                                                                               |
-| [`nlohmann::ordered_map`](../../api/ordered_map/index.md)                              | used by [`ordered_json`](../../api/ordered_json.md); keeps insertion order    |
+| [`nlohmann::ordered_map`](../../api/ordered_map.md)                              | used by [`ordered_json`](../../api/ordered_json.md); keeps insertion order    |
 | [`nlohmann::fifo_map`](https://github.com/nlohmann/fifo_map)                     | keeps insertion order; adapter puts `fifo_map_compare` in the comparator slot |
 | `boost::container::map`, `boost::container::flat_map`                            | no adapter needed                                                             |
 | `#!cpp std::unordered_map`                                                       | through the adapter above; not with libstdc++ 9, see the note                 |
@@ -50,7 +50,7 @@ The public headers are in [`include/nlohmann`](https://github.com/nlohmann/json/
 - [`adl_serializer.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/adl_serializer.hpp), [`byte_container_with_subtype.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/byte_container_with_subtype.hpp), and [`ordered_map.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/ordered_map.hpp) define
  [`adl_serializer`](../api/adl_serializer/index.md),
  [`byte_container_with_subtype`](../api/byte_container_with_subtype/index.md), and
-  [`ordered_map`](../api/ordered_map/index.md).
+  [`ordered_map`](../api/ordered_map.md).

 Everything else lives in [`detail/`](https://github.com/nlohmann/json/tree/develop/include/nlohmann/detail) and namespace `nlohmann::detail`, which is not part of the public API. Paths
 below are relative to `include/nlohmann`.
@@ -97,7 +97,7 @@ is generated from these files with `make amalgamate` and must not be edited by h
 The library provides two specializations:

 - [`json`](../api/json.md) uses all default template arguments.
- [`ordered_json`](../api/ordered_json.md) uses [`ordered_map`](../api/ordered_map/index.md) as `ObjectType` to keep the
+- [`ordered_json`](../api/ordered_json.md) uses [`ordered_map`](../api/ordered_map.md) as `ObjectType` to keep the
  insertion order of object keys.

 The requirements on the template arguments are listed in
@@ -19,3 +19,5 @@ The class contains the UTF-8 Decoder from Bjoern Hoehrmann which is licensed und
 The class contains a slightly modified version of the Grisu2 algorithm from Florian Loitsch which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright &copy; 2009 [Florian Loitsch](https://florian.loitsch.com/)

 The class contains a copy of [Hedley](https://nemequ.github.io/hedley/) from Evan Nemerson which is licensed as [CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/).
+
+The class contains an adapted version of the Eisel-Lemire algorithm and its table of powers of five from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright &copy; 2021 The fast_float authors
@@ -2,8 +2,7 @@

 This page summarizes the notable changes of every release and links to the relevant documentation.
 The **complete release notes** — including all changes, the download files, and their checksums — are
-published on the [GitHub releases page](https://github.com/nlohmann/json/releases). For a raw,
-signature-level diff of the public API between releases, see [API Changes](api_changes.md).
+published on the [GitHub releases page](https://github.com/nlohmann/json/releases).

 ## v3.12.0 (2025-04-11)

@@ -52,7 +52,6 @@ nav:
      - "FAQ": home/faq.md
      - home/exceptions.md
      - home/releases.md
-      - home/api_changes.md
      - home/design_goals.md
      - home/architecture.md
      - home/customers.md
@@ -120,7 +119,6 @@ nav:
          - 'begin': api/basic_json/begin.md
          - 'binary': api/basic_json/binary.md
          - 'binary_t': api/basic_json/binary_t.md
-          - 'bjdata_version_t': api/basic_json/bjdata_version_t.md
          - 'boolean_t': api/basic_json/boolean_t.md
          - 'cbegin': api/basic_json/cbegin.md
          - 'cbor_tag_handler_t': api/basic_json/cbor_tag_handler_t.md
@@ -159,7 +157,6 @@ nav:
          - 'get_to': api/basic_json/get_to.md
          - 'std::formatter&lt;basic_json&gt;': api/basic_json/std_formatter.md
          - 'std::hash&lt;basic_json&gt;': api/basic_json/std_hash.md
-          - 'initializer_list_t': api/basic_json/initializer_list_t.md
          - 'input_format_t': api/basic_json/input_format_t.md
          - 'insert': api/basic_json/insert.md
          - 'invalid_iterator': api/basic_json/invalid_iterator.md
@@ -178,7 +175,6 @@ nav:
          - 'is_structured': api/basic_json/is_structured.md
          - 'items': api/basic_json/items.md
          - 'json_base_class_t': api/basic_json/json_base_class_t.md
-          - 'json_sax_t': api/basic_json/json_sax_t.md
          - 'json_serializer': api/basic_json/json_serializer.md
          - 'max_size': api/basic_json/max_size.md
          - 'meta': api/basic_json/meta.md
@@ -236,13 +232,9 @@ nav:
          - 'Overview': api/byte_container_with_subtype/index.md
          - '(constructor)': api/byte_container_with_subtype/byte_container_with_subtype.md
          - 'clear_subtype': api/byte_container_with_subtype/clear_subtype.md
-          - 'container_type': api/byte_container_with_subtype/container_type.md
          - 'has_subtype': api/byte_container_with_subtype/has_subtype.md
-          - 'operator==': api/byte_container_with_subtype/operator_eq.md
-          - 'operator!=': api/byte_container_with_subtype/operator_ne.md
          - 'set_subtype': api/byte_container_with_subtype/set_subtype.md
          - 'subtype': api/byte_container_with_subtype/subtype.md
-          - 'subtype_type': api/byte_container_with_subtype/subtype_type.md
      - adl_serializer:
          - 'Overview': api/adl_serializer/index.md
          - 'from_json': api/adl_serializer/from_json.md
@@ -268,46 +260,25 @@ nav:
          - 'to_string': api/json_pointer/to_string.md
      - json_sax:
          - 'Overview': api/json_sax/index.md
-          - '(Constructor)': api/json_sax/json_sax.md
-          - '(Destructor)': api/json_sax/~json_sax.md
-          - 'operator=': api/json_sax/operator=.md
          - 'binary': api/json_sax/binary.md
-          - 'binary_t': api/json_sax/binary_t.md
          - 'boolean': api/json_sax/boolean.md
          - 'end_array': api/json_sax/end_array.md
          - 'end_object': api/json_sax/end_object.md
          - 'key': api/json_sax/key.md
          - 'null': api/json_sax/null.md
          - 'number_float': api/json_sax/number_float.md
-          - 'number_float_t': api/json_sax/number_float_t.md
          - 'number_integer': api/json_sax/number_integer.md
-          - 'number_integer_t': api/json_sax/number_integer_t.md
          - 'number_unsigned': api/json_sax/number_unsigned.md
-          - 'number_unsigned_t': api/json_sax/number_unsigned_t.md
          - 'parse_error': api/json_sax/parse_error.md
          - 'start_array': api/json_sax/start_array.md
          - 'start_object': api/json_sax/start_object.md
          - 'string': api/json_sax/string.md
-          - 'string_t': api/json_sax/string_t.md
      - 'operator<<(basic_json), operator<<(json_pointer)': api/operator_ltlt.md
      - 'operator>>(basic_json)': api/operator_gtgt.md
      - 'operator""_json': api/operator_literal_json.md
      - 'operator""_json_pointer': api/operator_literal_json_pointer.md
      - 'ordered_json': api/ordered_json.md
-      - ordered_map:
-          - 'Overview': api/ordered_map/index.md
-          - '(Constructor)': api/ordered_map/ordered_map.md
-          - '(Destructor)': api/ordered_map/~ordered_map.md
-          - 'operator=': api/ordered_map/operator=.md
-          - 'at': api/ordered_map/at.md
-          - 'Container': api/ordered_map/Container.md
-          - 'count': api/ordered_map/count.md
-          - 'emplace': api/ordered_map/emplace.md
-          - 'erase': api/ordered_map/erase.md
-          - 'find': api/ordered_map/find.md
-          - 'insert': api/ordered_map/insert.md
-          - 'key_compare': api/ordered_map/key_compare.md
-          - 'operator[]': api/ordered_map/operator[].md
+      - 'ordered_map': api/ordered_map.md
      - macros:
          - 'Overview': api/macros/index.md
          - 'JSON_ASSERT': api/macros/json_assert.md
@@ -22,9 +22,7 @@ template<typename BinaryType>
 class byte_container_with_subtype : public BinaryType
 {
  public:
-    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/container_type/
    using container_type = BinaryType;
-    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/subtype_type/
    using subtype_type = std::uint64_t;

    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
@@ -56,14 +54,12 @@ class byte_container_with_subtype : public BinaryType
        , m_has_subtype(true)
    {}

-    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/operator_eq/
    bool operator==(const byte_container_with_subtype& rhs) const
    {
        return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) ==
               std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype);
    }

-    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/operator_ne/
    bool operator!=(const byte_container_with_subtype& rhs) const
    {
        return !(rhs == *this);
@@ -0,0 +1,34 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <nlohmann/detail/abi_macros.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief the configuration macros that change the library's behavior
+
+json.hpp undefines these macros at its end (see macro_unscope.hpp), so code
+that builds on the library after it (json_view.hpp) reads them here. Like the
+macros, they are part of the ABI namespace, so they always match the
+basic_json they are used with.
+*/
+struct abi_config
+{
+    /// JSON_STRICT_NUL_HANDLING: a null byte is an error, not the end of input
+    static constexpr bool strict_nul_handling = JSON_STRICT_NUL_HANDLING != 0;
+    /// JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    static constexpr bool legacy_discarded_value_comparison = JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON != 0;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
@@ -0,0 +1,105 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <cstdint> // uint64_t
+
+#include <nlohmann/detail/abi_macros.hpp>
+
+// Portable bit-level helpers for the number and string scanners. They use
+// compiler builtins where available and plain C++ otherwise, so they need no
+// platform headers and work regardless of byte order.
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// number of leading zero bits of x (x != 0)
+inline int count_leading_zeros(std::uint64_t x) noexcept
+{
+#if defined(__GNUC__) || defined(__clang__)
+    return __builtin_clzll(x);
+#else
+    int n = 0;
+    for (int shift = 32; shift != 0; shift >>= 1)
+    {
+        if ((x >> (64 - shift)) == 0)
+        {
+            n += shift;
+            x <<= shift;
+        }
+    }
+    return n;
+#endif
+}
+
+/// number of trailing zero bits of x (x != 0)
+inline int count_trailing_zeros(std::uint64_t x) noexcept
+{
+#if defined(__GNUC__) || defined(__clang__)
+    return __builtin_ctzll(x);
+#else
+    int n = 0;
+    for (int shift = 32; shift != 0; shift >>= 1)
+    {
+        if ((x << (64 - shift)) == 0)
+        {
+            n += shift;
+            x >>= shift;
+        }
+    }
+    return n;
+#endif
+}
+
+/// the 128-bit product of two 64-bit numbers
+struct uint128_parts
+{
+    std::uint64_t low;
+    std::uint64_t high;
+};
+
+inline uint128_parts full_multiplication(std::uint64_t a, std::uint64_t b) noexcept
+{
+#if defined(__SIZEOF_INT128__)
+    __extension__ using uint128 = unsigned __int128;
+    const uint128 r = static_cast<uint128>(a) * b;
+    return {static_cast<std::uint64_t>(r), static_cast<std::uint64_t>(r >> 64u)};
+#else
+    const std::uint64_t a_lo = a & 0xFFFFFFFFu;
+    const std::uint64_t a_hi = a >> 32u;
+    const std::uint64_t b_lo = b & 0xFFFFFFFFu;
+    const std::uint64_t b_hi = b >> 32u;
+    const std::uint64_t lo_lo = a_lo * b_lo;
+    const std::uint64_t hi_lo = a_hi * b_lo;
+    const std::uint64_t lo_hi = a_lo * b_hi;
+    const std::uint64_t hi_hi = a_hi * b_hi;
+    const std::uint64_t cross = (lo_lo >> 32u) + (hi_lo & 0xFFFFFFFFu) + lo_hi;
+    return {(cross << 32u) | (lo_lo & 0xFFFFFFFFu), (hi_lo >> 32u) + (cross >> 32u) + hi_hi};
+#endif
+}
+
+/// eight bytes as a little-endian word (compilers fold this into one load on
+/// little-endian targets)
+inline std::uint64_t read_eight_bytes(const unsigned char* b) noexcept
+{
+    return static_cast<std::uint64_t>(b[0]) | (static_cast<std::uint64_t>(b[1]) << 8u)
+           | (static_cast<std::uint64_t>(b[2]) << 16u) | (static_cast<std::uint64_t>(b[3]) << 24u)
+           | (static_cast<std::uint64_t>(b[4]) << 32u) | (static_cast<std::uint64_t>(b[5]) << 40u)
+           | (static_cast<std::uint64_t>(b[6]) << 48u) | (static_cast<std::uint64_t>(b[7]) << 56u);
+}
+
+/// eight bytes as a little-endian word
+inline std::uint64_t read_eight_bytes(const char* p) noexcept
+{
+    return read_eight_bytes(reinterpret_cast<const unsigned char*>(p)); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
@@ -33,21 +33,15 @@ input.
 template<typename BasicJsonType>
 struct json_sax
 {
-    /// @sa https://json.nlohmann.me/api/json_sax/number_integer_t/
    using number_integer_t = typename BasicJsonType::number_integer_t;
-    /// @sa https://json.nlohmann.me/api/json_sax/number_unsigned_t/
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-    /// @sa https://json.nlohmann.me/api/json_sax/number_float_t/
    using number_float_t = typename BasicJsonType::number_float_t;
-    /// @sa https://json.nlohmann.me/api/json_sax/string_t/
    using string_t = typename BasicJsonType::string_t;
-    /// @sa https://json.nlohmann.me/api/json_sax/binary_t/
    using binary_t = typename BasicJsonType::binary_t;

    /*!
    @brief a null value was read
    @return whether parsing should proceed
-    @sa https://json.nlohmann.me/api/json_sax/null/
    */
    virtual bool null() = 0;

@@ -55,7 +49,6 @@ struct json_sax
    @brief a boolean value was read
    @param[in] val  boolean value
    @return whether parsing should proceed
-    @sa https://json.nlohmann.me/api/json_sax/boolean/
    */
    virtual bool boolean(bool val) = 0;

@@ -63,7 +56,6 @@ struct json_sax
    @brief an integer number was read
    @param[in] val  integer value
    @return whether parsing should proceed
-    @sa https://json.nlohmann.me/api/json_sax/number_integer/
    */
    virtual bool number_integer(number_integer_t val) = 0;

@@ -71,7 +63,6 @@ struct json_sax
    @brief an unsigned integer number was read
    @param[in] val  unsigned integer value
    @return whether parsing should proceed
-    @sa https://json.nlohmann.me/api/json_sax/number_unsigned/
    */
    virtual bool number_unsigned(number_unsigned_t val) = 0;

@@ -80,7 +71,6 @@ struct json_sax
    @param[in] val  floating-point value
    @param[in] s    raw token value
    @return whether parsing should proceed
-    @sa https://json.nlohmann.me/api/json_sax/number_float/
    */
    virtual bool number_float(number_float_t val, const string_t& s) = 0;

@@ -89,7 +79,6 @@ struct json_sax
    @param[in] val  string value
    @return whether parsing should proceed
    @note It is safe to move the passed string value.
-    @sa https://json.nlohmann.me/api/json_sax/string/
    */
    virtual bool string(string_t& val) = 0;

@@ -98,7 +87,6 @@ struct json_sax
    @param[in] val  binary value
    @return whether parsing should proceed
    @note It is safe to move the passed binary value.
-    @sa https://json.nlohmann.me/api/json_sax/binary/
    */
    virtual bool binary(binary_t& val) = 0;

@@ -107,7 +95,6 @@ struct json_sax
    @param[in] elements  number of object elements or -1 if unknown
    @return whether parsing should proceed
    @note binary formats may report the number of elements
-    @sa https://json.nlohmann.me/api/json_sax/start_object/
    */
    virtual bool start_object(std::size_t elements) = 0;

@@ -116,14 +103,12 @@ struct json_sax
    @param[in] val  object key
    @return whether parsing should proceed
    @note It is safe to move the passed string.
-    @sa https://json.nlohmann.me/api/json_sax/key/
    */
    virtual bool key(string_t& val) = 0;

    /*!
    @brief the end of an object was read
    @return whether parsing should proceed
-    @sa https://json.nlohmann.me/api/json_sax/end_object/
    */
    virtual bool end_object() = 0;

@@ -132,14 +117,12 @@ struct json_sax
    @param[in] elements  number of array elements or -1 if unknown
    @return whether parsing should proceed
    @note binary formats may report the number of elements
-    @sa https://json.nlohmann.me/api/json_sax/start_array/
    */
    virtual bool start_array(std::size_t elements) = 0;

    /*!
    @brief the end of an array was read
    @return whether parsing should proceed
-    @sa https://json.nlohmann.me/api/json_sax/end_array/
    */
    virtual bool end_array() = 0;

@@ -149,23 +132,16 @@ struct json_sax
    @param[in] last_token  the last read token
    @param[in] ex          an exception object describing the error
    @return whether parsing should proceed (must return false)
-    @sa https://json.nlohmann.me/api/json_sax/parse_error/
    */
    virtual bool parse_error(std::size_t position,
                             const std::string& last_token,
                             const detail::exception& ex) = 0;

-    /// @sa https://json.nlohmann.me/api/json_sax/json_sax/
    json_sax() = default;
-    /// @sa https://json.nlohmann.me/api/json_sax/json_sax/
    json_sax(const json_sax&) = default;
-    /// @sa https://json.nlohmann.me/api/json_sax/json_sax/
    json_sax(json_sax&&) noexcept = default;
-    /// @sa https://json.nlohmann.me/api/json_sax/operator=/
    json_sax& operator=(const json_sax&) = default;
-    /// @sa https://json.nlohmann.me/api/json_sax/operator=/
    json_sax& operator=(json_sax&&) noexcept = default;
-    /// @sa https://json.nlohmann.me/api/json_sax/~json_sax/
    virtual ~json_sax() = default;
 };

@@ -9,10 +9,8 @@
 #pragma once

 #include <array> // array
-#include <clocale> // localeconv
 #include <cstddef> // size_t
 #include <cstdio> // snprintf
-#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
 #include <initializer_list> // initializer_list
 #include <string> // char_traits, string
 #include <utility> // move
@@ -217,22 +215,48 @@ class lexer : public lexer_base<BasicJsonType>
    ~lexer() = default;

  private:
-    /////////////////////
-    // locales
-    /////////////////////
-
-    /// return the decimal point of the current locale
-    static char get_decimal_point() noexcept
-    {
-        const auto* loc = localeconv();
-        JSON_ASSERT(loc != nullptr);
-        return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
-    }
-
    /////////////////////
    // scan functions
    /////////////////////

+    /// contiguous input: try to decode the 4 hex digits following `\u`
+    /// directly from the input buffer via hex_codepoint(), instead of 4 calls
+    /// to get(). On success, advances the adapter and the position counters
+    /// exactly as those 4 get() calls would (a hex digit is never '\n', so
+    /// only the flat counters move) and leaves @a current holding the last of
+    /// the 4 digits, just as the last such get() would; the codepoint is
+    /// written to @a out. Makes no state change and returns false - for a
+    /// pending unget, fewer than 4 remaining bytes, or any of the 4 bytes not
+    /// being a hex digit - so the caller falls back unchanged to the
+    /// per-character loop, which then reports the same diagnostic (stopping
+    /// at the first invalid digit) as before this optimization.
+    bool get_codepoint_bulk(std::true_type /*bulk*/, int& out)
+    {
+        if (next_unget || ia.bulk_remaining() < 4)
+        {
+            return false;
+        }
+        const char_type* const raw = ia.bulk_data();
+        const int codepoint = hex_codepoint(reinterpret_cast<const unsigned char*>(raw));
+        if (codepoint < 0)
+        {
+            return false;
+        }
+        ia.bulk_skip(4);
+        // a hex digit is never a newline, so only the flat counters advance
+        position.chars_read_total += 4;
+        position.chars_read_current_line += 4;
+        current = char_traits<char_type>::to_int_type(raw[3]);
+        out = codepoint;
+        return true;
+    }
+
+    /// streaming input: no bulk fast path
+    bool get_codepoint_bulk(std::false_type /*bulk*/, int& /*out*/) const noexcept
+    {
+        return false;
+    }
+
    /*!
    @brief get codepoint from 4 hex characters following `\u`

@@ -252,6 +276,14 @@ class lexer : public lexer_base<BasicJsonType>
    {
        // this function only makes sense after reading `\u`
        JSON_ASSERT(current == 'u');
+
+        // contiguous input: decode all 4 hex digits directly from the buffer
+        int fast_codepoint = 0;
+        if (get_codepoint_bulk(std::integral_constant<bool, bulk_scan> {}, fast_codepoint))
+        {
+            return fast_codepoint;
+        }
+
        int codepoint = 0;

        const auto factors = { 12u, 8u, 4u, 0u };
@@ -1036,24 +1068,6 @@ class lexer : public lexer_base<BasicJsonType>
        }
    }

-    JSON_HEDLEY_NON_NULL(2)
-    static void strtof(float& f, const char* str, char** endptr) noexcept
-    {
-        f = std::strtof(str, endptr);
-    }
-
-    JSON_HEDLEY_NON_NULL(2)
-    static void strtof(double& f, const char* str, char** endptr) noexcept
-    {
-        f = std::strtod(str, endptr);
-    }
-
-    JSON_HEDLEY_NON_NULL(2)
-    static void strtof(long double& f, const char* str, char** endptr) noexcept
-    {
-        f = std::strtold(str, endptr);
-    }
-
    /*!
    @brief scan a number literal

@@ -1093,7 +1107,7 @@ class lexer : public lexer_base<BasicJsonType>
    @note The scanner is independent of the current locale: token_buffer
          always holds `.`. Only the std::strtod fallback of convert_number()
          depends on the locale, and it looks up the decimal point right
-          before converting (see convert_float_locale_aware()).
+          before converting (see detail::convert_float_locale_aware()).
    */
    token_type scan_number()  // lgtm [cpp/use-of-goto] `goto` is used in this function to implement the number-parsing state machine described above. By design, any finite input will eventually reach the "done" state or return token_type::parse_error. In each intermediate state, 1 byte of the input is appended to the token_buffer vector, and only the already initialized variables token_buffer, number_type, and error_message are manipulated.
    {
@@ -1424,59 +1438,6 @@ scan_number_done:
        return token_type::uninitialized;
    }

-    /*!
-    @brief check whether Clinger's fast path can still succeed for this token
-
-    parse_float_fast() needs a significand below 2^53. A mantissa with 17 or
-    more significant digits is at least 10^16 and therefore always exceeds it,
-    so calling the fast path would walk the token one extra time only to
-    decline before strtod has to run anyway.
-
-    Significant digits are the mantissa's digits from the first nonzero one on;
-    the sign, the decimal point, leading zeros, and the exponent do not count.
-    The answer is derived from indices - the digits are not scanned again - so
-    this stays off the hot path of the number scanners.
-
-    @param[in] mantissa_end  offset just past the last mantissa byte in
-                             token_buffer
-    @return false if parse_float_fast() is guaranteed to decline
-    */
-    bool mantissa_fits_clinger(std::size_t mantissa_end) const
-    {
-        // 10^16 already exceeds 2^53, so 17 digits can never fit
-        constexpr std::size_t limit = 17;
-
-        const std::size_t neg = (!token_buffer.empty() && token_buffer[0] == '-') ? 1u : 0u;
-        const std::size_t has_dot = (decimal_point_position != std::string::npos) ? 1u : 0u;
-        // the JSON grammar restricts the integer part to "0" or [1-9][0-9]*, so
-        // a leading zero can only be a lone "0", which is not significant
-        const std::size_t lead_zero = (token_buffer[neg] == '0') ? 1u : 0u;
-        JSON_ASSERT(mantissa_end >= neg + has_dot + lead_zero);
-        std::size_t digits = mantissa_end - neg - has_dot - lead_zero;
-
-        if (JSON_HEDLEY_LIKELY(digits < limit))
-        {
-            return true;
-        }
-
-        // Only a number below 1 can carry further insignificant zeros, and only
-        // while the count stays at the limit does removing them change the
-        // answer - so this loop is skipped for all but a few tokens. The
-        // fraction is located through decimal_point_position rather than by
-        // searching '.'.
-        if (lead_zero != 0)
-        {
-            JSON_ASSERT(has_dot != 0); // an integer "0" cannot reach the limit
-            for (std::size_t i = decimal_point_position + 1;
-                    digits >= limit && i < mantissa_end && token_buffer[i] == '0'; ++i)
-            {
-                --digits;
-            }
-        }
-
-        return digits < limit;
-    }
-
    /*!
    @brief convert the number text in token_buffer to its value and token type

@@ -1490,7 +1451,7 @@ scan_number_done:
                             token_buffer (the index of 'e'/'E', or
                             token_buffer.size() when there is no exponent);
                             used to skip Clinger's fast path when it cannot
-                             possibly succeed - see mantissa_fits_clinger()
+                             possibly succeed - see detail::mantissa_fits_clinger()
    */
    token_type convert_number(token_type number_type, std::size_t mantissa_end)
    {
@@ -1563,77 +1524,15 @@ scan_number_done:
        // (Eisel-Lemire, locale-independent, correctly rounded) when available;
        // otherwise the exact Clinger fast path (double only); otherwise the
        // locale-aware strtof/strtod/strtold.
-        if (parse_float_from_chars(num_begin, num_end, value_float))
-        {
-            return token_type::value_float;
-        }
-        // Skipping a fast path that cannot succeed is lossless and saves a full
-        // extra pass over the token's bytes, which otherwise shows up on
-        // high-precision inputs such as canada.json
-        if (mantissa_fits_clinger(mantissa_end)
-                && parse_float_fast(num_begin, num_end, value_float))
+        if (convert_float_fast(num_begin, num_end, decimal_point_position, mantissa_end, value_float))
        {
            return token_type::value_float;
        }

-        convert_float_locale_aware();
+        convert_float_locale_aware(token_buffer, decimal_point_position, value_float);
        return token_type::value_float;
    }

-    /*!
-    @brief convert the float in token_buffer with strtof/strtod/strtold
-
-    These functions expect the decimal point of the *current* locale, so it is
-    looked up right before the conversion instead of once when the lexer is
-    constructed: a locale change in between (by a parser callback, a SAX
-    handler, or another thread) must not truncate the value (#5198). The
-    token has been validated before, so if the conversion stops early and the
-    decimal point changed in the meantime, the locale changed between the
-    lookup and the call, and the conversion is repeated with the new decimal
-    point. If the decimal point did not change, a retry cannot succeed: the
-    locale's decimal point is not a single character (e.g., the two-byte
-    U+066B of ar_EG.UTF-8 or fa_IR.UTF-8) and cannot be substituted in place.
-    The value strtod parsed up to that point is kept, as before this change.
-
-    Note that changing the locale in another thread *while* strtod runs is
-    undefined behavior of the C library, which this function cannot prevent.
-    */
-    void convert_float_locale_aware()
-    {
-        const bool has_dot = decimal_point_position != std::string::npos;
-        char decimal_point = get_decimal_point();
-        for (;;)
-        {
-            const bool substitute = has_dot && decimal_point != '.';
-            if (substitute)
-            {
-                token_buffer[decimal_point_position] = static_cast<typename string_t::value_type>(decimal_point);
-            }
-
-            char* endptr = nullptr; // NOLINT(misc-const-correctness,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
-            strtof(value_float, token_buffer.data(), &endptr);
-
-            if (substitute)
-            {
-                // get_string() hands the token to the SAX interface with '.'
-                token_buffer[decimal_point_position] = '.';
-            }
-
-            if (JSON_HEDLEY_LIKELY(endptr == token_buffer.data() + token_buffer.size()))
-            {
-                return;
-            }
-
-            // retry only if the locale changed; otherwise, this would loop forever
-            const char current_decimal_point = get_decimal_point();
-            if (current_decimal_point == decimal_point)
-            {
-                return;
-            }
-            decimal_point = current_decimal_point;
-        }
-    }
-
    /*!
    @brief contiguous fast path for scanning a number

@@ -3,6 +3,7 @@
 // |  |  |__   |  |  | | | |  version 3.12.0
 // |_____|_____|_____|_|___|  https://github.com/nlohmann/json
 //
+// SPDX-FileCopyrightText: 2021 The fast_float authors <https://github.com/fastfloat/fast_float>
 // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
 // SPDX-License-Identifier: MIT

@@ -10,10 +11,16 @@

 #include <array> // array
 #include <cfloat> // FLT_EVAL_METHOD
+#include <clocale> // localeconv
 #include <cstddef> // size_t
 #include <cstdint> // int64_t, uint64_t
+#include <cstdlib> // strtof, strtod, strtold
+#include <cstring> // memcpy
 #include <limits> // numeric_limits
+#include <string> // string

+#include <nlohmann/detail/bit_ops.hpp>
+#include <nlohmann/detail/input/pow5_table.hpp>
 #include <nlohmann/detail/macro_scope.hpp>

 // std::from_chars lives in <charconv>, but being in C++17 mode does not
@@ -29,8 +36,9 @@

 // This file contains the value-conversion helpers used by the lexer to turn an
 // already-validated number token into a value, without the locale/errno
-// overhead of std::strtoull/std::strtod. They are free functions so the lexer
-// stays focused on scanning; see lexer::convert_number().
+// overhead of std::strtoull/std::strtod where possible. They are free functions
+// so the lexer stays focused on scanning (see lexer::convert_number()) and so
+// that other parsers of JSON text can convert tokens exactly like it does.

 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
@@ -293,5 +301,415 @@ bool parse_float_from_chars(const char* first, const char* last, FloatType& out)
 #endif
 }

+/// whether the eight bytes of @a v (see read_eight_bytes()) are ASCII digits
+/// (after fast_float's is_made_of_eight_digits_fast)
+inline bool is_eight_digits(std::uint64_t v) noexcept
+{
+    return ((v & 0xF0F0F0F0F0F0F0F0u) | (((v + 0x0606060606060606u) & 0xF0F0F0F0F0F0F0F0u) >> 4u)) == 0x3333333333333333u;
+}
+
+/// the value of the eight ASCII digits in @a v (see read_eight_bytes()), three
+/// multiplications instead of eight (after simdjson and fast_float)
+inline std::uint32_t parse_eight_digits(std::uint64_t v) noexcept
+{
+    v = ((v & 0x0F0F0F0F0F0F0F0Fu) * 2561u) >> 8u;
+    v = ((v & 0x00FF00FF00FF00FFu) * 6553601u) >> 16u;
+    return static_cast<std::uint32_t>(((v & 0x0000FFFF0000FFFFu) * 42949672960001u) >> 32u);
+}
+
+/*!
+@brief the double nearest to w * 10^q (Eisel-Lemire)
+
+The algorithm of Daniel Lemire, "Number Parsing at a Gigabyte per Second"
+(Software: Practice and Experience, 2021), after fast_float's compute_float
+(used under the MIT license). With a 128-bit approximation of 5^q, the product
+is always sufficient to round correctly for w with at most 19 digits (Noble
+Mushtak and Daniel Lemire, "Fast number parsing without fallback", Software:
+Practice and Experience, 2023). Only integer arithmetic is used, so the result
+does not depend on the floating-point environment.
+
+@param[in] q  decimal exponent
+@param[in] w  significand, w != 0
+@return the IEEE-754 bits of the positive result (0 for underflow, infinity
+        for overflow)
+*/
+inline std::uint64_t eisel_lemire(std::int64_t q, std::uint64_t w) noexcept
+{
+    constexpr int mantissa_bits = 52;
+    constexpr std::uint64_t infinity = std::uint64_t{0x7FF} << mantissa_bits;
+    if (q < pow5_128_smallest_power)
+    {
+        return 0;
+    }
+    if (q > pow5_128_largest_power)
+    {
+        return infinity;
+    }
+
+    const int lz = count_leading_zeros(w);
+    w <<= static_cast<unsigned>(lz);
+    const auto index = static_cast<std::size_t>(2 * (q - pow5_128_smallest_power));
+    uint128_parts product = full_multiplication(w, pow5_128()[index]);
+    constexpr std::uint64_t precision_mask = 0xFFFFFFFFFFFFFFFFu >> (mantissa_bits + 3);
+    if ((product.high & precision_mask) == precision_mask)
+    {
+        // the lower bits may carry into the result: use the next 64 bits of 5^q
+        const uint128_parts second = full_multiplication(w, pow5_128()[index + 1]);
+        product.low += second.high;
+        if (second.high > product.low)
+        {
+            ++product.high;
+        }
+    }
+
+    const auto upperbit = static_cast<int>(product.high >> 63u);
+    const int shift = upperbit + 64 - mantissa_bits - 3;
+    std::uint64_t mantissa = product.high >> static_cast<unsigned>(shift);
+    // floor(log2(10^q)) + 63 + 1023, with log2(10) ~ 217706 / 2^16
+    std::int64_t power2 = (((152170 + 65536) * q) >> 16) + 63 + upperbit - lz + 1023;
+
+    if (power2 <= 0) // subnormal
+    {
+        if (-power2 + 1 >= 64)
+        {
+            return 0;
+        }
+        mantissa >>= static_cast<unsigned>(-power2 + 1);
+        mantissa += (mantissa & 1u);
+        mantissa >>= 1u;
+        // rounding up may produce the smallest normal number
+        power2 = (mantissa < (std::uint64_t{1} << mantissa_bits)) ? 0 : 1;
+        return mantissa | (static_cast<std::uint64_t>(power2) << mantissa_bits);
+    }
+
+    // a value exactly between two doubles rounds to even; this can only
+    // happen for small |q|, where 5^q is exact
+    if (product.low <= 1 && q >= -4 && q <= 23 && (mantissa & 3u) == 1
+            && (mantissa << static_cast<unsigned>(shift)) == product.high)
+    {
+        mantissa &= ~std::uint64_t{1};
+    }
+    mantissa += (mantissa & 1u);
+    mantissa >>= 1u;
+    if (mantissa >= (std::uint64_t{2} << mantissa_bits))
+    {
+        mantissa = std::uint64_t{1} << mantissa_bits;
+        ++power2;
+    }
+    mantissa &= ~(std::uint64_t{1} << mantissa_bits);
+    if (power2 >= 0x7FF)
+    {
+        return infinity;
+    }
+    return mantissa | (static_cast<std::uint64_t>(power2) << mantissa_bits);
+}
+
+/*!
+@brief parse a validated float token with the Eisel-Lemire algorithm
+
+The significand is accumulated eight digits at a time where possible. A token
+with more than 19 significant digits is truncated to w; the value then lies
+in [w, w + 1) * 10^q, and it is only returned if both ends round to the same
+double, which covers all but a few such tokens.
+
+@param[in]  first  pointer to the first character of the token
+@param[in]  last   pointer past the last character
+@param[out] out    the correctly rounded value on success (±infinity if it
+                   overflows, like strtod)
+@return true on success; false if strtod must decide
+*/
+inline bool parse_float_eisel_lemire(const char* first, const char* last, double& out) noexcept
+{
+    const char* p = first;
+    const bool negative = (p != last && *p == '-');
+    if (negative)
+    {
+        ++p;
+    }
+
+    std::uint64_t w = 0;
+    int digits = 0; // significant digits in w
+    std::int64_t exponent = 0;
+    bool truncated = false;
+    bool in_fraction = false;
+    for (;;)
+    {
+        // eight digits at a time, as long as they fit into w
+        while (w != 0 && digits <= 19 - 8 && last - p >= 8)
+        {
+            const std::uint64_t v = read_eight_bytes(p);
+            if (!is_eight_digits(v))
+            {
+                break;
+            }
+            w = (w * 100000000u) + parse_eight_digits(v);
+            digits += 8;
+            exponent -= in_fraction ? 8 : 0;
+            p += 8;
+        }
+        if (p == last)
+        {
+            break;
+        }
+        const char c = *p;
+        if (c >= '0' && c <= '9')
+        {
+            if (w == 0 && c == '0')
+            {
+                // leading zeros are not significant, but scale a fraction
+                exponent -= in_fraction ? 1 : 0;
+            }
+            else if (digits < 19)
+            {
+                w = (w * 10u) + static_cast<std::uint64_t>(c - '0');
+                ++digits;
+                exponent -= in_fraction ? 1 : 0;
+            }
+            else
+            {
+                // dropped: the value lies between w and w + 1 (in units of
+                // the last kept digit) unless all dropped digits are zero
+                truncated = truncated || c != '0';
+                exponent += in_fraction ? 0 : 1;
+            }
+            ++p;
+        }
+        else if (c == '.')
+        {
+            in_fraction = true;
+            ++p;
+        }
+        else
+        {
+            break; // 'e' or 'E'
+        }
+    }
+
+    if (p != last)
+    {
+        ++p; // 'e' or 'E'
+        bool exp_negative = false;
+        if (p != last && (*p == '-' || *p == '+'))
+        {
+            exp_negative = (*p == '-');
+            ++p;
+        }
+        std::int64_t exp_value = 0;
+        for (; p != last; ++p)
+        {
+            // saturate: any exponent beyond this under- or overflows anyway
+            if (exp_value < 100000)
+            {
+                exp_value = (exp_value * 10) + (*p - '0');
+            }
+        }
+        exponent += exp_negative ? -exp_value : exp_value;
+    }
+
+    std::uint64_t bits = 0;
+    if (w != 0)
+    {
+        bits = eisel_lemire(exponent, w);
+        if (truncated && (w + 1 == 0 || eisel_lemire(exponent, w + 1) != bits))
+        {
+            return false;
+        }
+    }
+    bits |= negative ? (std::uint64_t{1} << 63u) : 0u;
+    static_assert(sizeof(double) == sizeof(std::uint64_t), "double must have 64 bits");
+    std::memcpy(&out, &bits, sizeof(out));
+    return true;
+}
+
+/// Eisel-Lemire is only implemented for `double`
+template<typename FloatType>
+bool parse_float_eisel_lemire(const char* /*first*/, const char* /*last*/, FloatType& /*out*/) noexcept
+{
+    return false;
+}
+
+/*!
+@brief check whether Clinger's fast path can still succeed for a float token
+
+parse_float_fast() needs a significand below 2^53. A mantissa with 17 or
+more significant digits is at least 10^16 and therefore always exceeds it,
+so calling the fast path would walk the token one extra time only to
+decline before strtod has to run anyway.
+
+Significant digits are the mantissa's digits from the first nonzero one on;
+the sign, the decimal point, leading zeros, and the exponent do not count.
+The answer is derived from indices - the digits are not scanned again - so
+this stays off the hot path of the number scanners.
+
+@param[in] token                   the validated number token ('.' as decimal point)
+@param[in] decimal_point_position  index of the '.' in @a token, or
+                                   std::string::npos if there is none
+@param[in] mantissa_end            offset just past the last mantissa byte
+@return false if parse_float_fast() is guaranteed to decline
+*/
+inline bool mantissa_fits_clinger(const char* token, std::size_t decimal_point_position, std::size_t mantissa_end) noexcept
+{
+    // 10^16 already exceeds 2^53, so 17 digits can never fit
+    constexpr std::size_t limit = 17;
+
+    const std::size_t neg = (token[0] == '-') ? 1u : 0u;
+    const std::size_t has_dot = (decimal_point_position != std::string::npos) ? 1u : 0u;
+    // the JSON grammar restricts the integer part to "0" or [1-9][0-9]*, so
+    // a leading zero can only be a lone "0", which is not significant
+    const std::size_t lead_zero = (token[neg] == '0') ? 1u : 0u;
+    JSON_ASSERT(mantissa_end >= neg + has_dot + lead_zero);
+    std::size_t digits = mantissa_end - neg - has_dot - lead_zero;
+
+    if (JSON_HEDLEY_LIKELY(digits < limit))
+    {
+        return true;
+    }
+
+    // Only a number below 1 can carry further insignificant zeros, and only
+    // while the count stays at the limit does removing them change the
+    // answer - so this loop is skipped for all but a few tokens. The
+    // fraction is located through decimal_point_position rather than by
+    // searching '.'.
+    if (lead_zero != 0)
+    {
+        JSON_ASSERT(has_dot != 0); // an integer "0" cannot reach the limit
+        for (std::size_t i = decimal_point_position + 1;
+                digits >= limit && i < mantissa_end && token[i] == '0'; ++i)
+        {
+            --digits;
+        }
+    }
+
+    return digits < limit;
+}
+
+/*!
+@brief convert a validated float token without the C library, if possible
+
+Tries std::from_chars (when available), Clinger's exact fast path (double
+only, skipped when it cannot succeed), and the Eisel-Lemire algorithm (double
+only).
+
+@param[in]  first                   pointer to the first character of the token
+@param[in]  last                    pointer past the last character
+@param[in]  decimal_point_position  index of the '.' in the token, or
+                                    std::string::npos if there is none
+@param[in]  mantissa_end            offset just past the last mantissa byte (the
+                                    index of 'e'/'E', or the token length)
+@param[out] value                   the converted value on success
+@return true if the value was converted; false if convert_float_locale_aware()
+        must convert it
+*/
+template<typename FloatType>
+bool convert_float_fast(const char* first, const char* last, std::size_t decimal_point_position,
+                        std::size_t mantissa_end, FloatType& value) noexcept
+{
+    if (parse_float_from_chars(first, last, value))
+    {
+        return true;
+    }
+    // Skipping a fast path that cannot succeed is lossless and saves a full
+    // extra pass over the token's bytes, which otherwise shows up on
+    // high-precision inputs such as canada.json
+    if (mantissa_fits_clinger(first, decimal_point_position, mantissa_end)
+            && parse_float_fast(first, last, value))
+    {
+        return true;
+    }
+    return parse_float_eisel_lemire(first, last, value);
+}
+
+/// std::strtof, std::strtod, or std::strtold, chosen by the type of @a f
+JSON_HEDLEY_NON_NULL(2)
+inline void strtof_by_type(float& f, const char* str, char** endptr) noexcept
+{
+    f = std::strtof(str, endptr);
+}
+
+/// std::strtof, std::strtod, or std::strtold, chosen by the type of @a f
+JSON_HEDLEY_NON_NULL(2)
+inline void strtof_by_type(double& f, const char* str, char** endptr) noexcept
+{
+    f = std::strtod(str, endptr);
+}
+
+/// std::strtof, std::strtod, or std::strtold, chosen by the type of @a f
+JSON_HEDLEY_NON_NULL(2)
+inline void strtof_by_type(long double& f, const char* str, char** endptr) noexcept
+{
+    f = std::strtold(str, endptr);
+}
+
+/// return the decimal point of the current locale
+inline char get_decimal_point() noexcept
+{
+    const auto* loc = localeconv();
+    JSON_ASSERT(loc != nullptr);
+    return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
+}
+
+/*!
+@brief convert a validated float token with strtof/strtod/strtold
+
+These functions expect the decimal point of the *current* locale, so it is
+looked up right before the conversion instead of once when the lexer is
+constructed: a locale change in between (by a parser callback, a SAX
+handler, or another thread) must not truncate the value (#5198). The
+token has been validated before, so if the conversion stops early and the
+decimal point changed in the meantime, the locale changed between the
+lookup and the call, and the conversion is repeated with the new decimal
+point. If the decimal point did not change, a retry cannot succeed: the
+locale's decimal point is not a single character (e.g., the two-byte
+U+066B of ar_EG.UTF-8 or fa_IR.UTF-8) and cannot be substituted in place.
+The value strtod parsed up to that point is kept, as before this change.
+
+Note that changing the locale in another thread *while* strtod runs is
+undefined behavior of the C library, which this function cannot prevent.
+
+@param[in,out] token                   the token with '.' as decimal point; its
+                                       decimal point is replaced during the
+                                       conversion and restored afterwards
+                                       (data() must be NUL-terminated)
+@param[in]     decimal_point_position  index of the '.' in @a token, or
+                                       std::string::npos if there is none
+@param[out]    value                   the converted value
+*/
+template<typename StringType, typename FloatType>
+void convert_float_locale_aware(StringType& token, std::size_t decimal_point_position, FloatType& value)
+{
+    const bool has_dot = decimal_point_position != std::string::npos;
+    char decimal_point = get_decimal_point();
+    for (;;)
+    {
+        const bool substitute = has_dot && decimal_point != '.';
+        if (substitute)
+        {
+            token[decimal_point_position] = static_cast<typename StringType::value_type>(decimal_point);
+        }
+
+        char* endptr = nullptr; // NOLINT(misc-const-correctness,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        strtof_by_type(value, token.data(), &endptr);
+
+        if (substitute)
+        {
+            // the caller hands the token on (e.g. to the SAX interface) with '.'
+            token[decimal_point_position] = '.';
+        }
+
+        if (JSON_HEDLEY_LIKELY(endptr == token.data() + token.size()))
+        {
+            return;
+        }
+
+        // retry only if the locale changed; otherwise, this would loop forever
+        const char current_decimal_point = get_decimal_point();
+        if (current_decimal_point == decimal_point)
+        {
+            return;
+        }
+        decimal_point = current_decimal_point;
+    }
+}
+
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
@@ -0,0 +1,371 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2021 The fast_float authors <https://github.com/fastfloat/fast_float>
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <array> // array
+#include <cstdint> // int64_t, uint64_t
+
+#include <nlohmann/detail/abi_macros.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// the range of decimal exponents covered by pow5_128()
+constexpr std::int64_t pow5_128_smallest_power = -342;
+constexpr std::int64_t pow5_128_largest_power = 308;
+
+/*!
+@brief 128-bit approximations of 5^q for q in [-342, 308]
+
+Entry q (at index 2 * (q + 342)) holds the most significant 128 bits of 5^q,
+normalized so that the highest bit is set: for q >= 0 the truncated value, for
+q < 0 the value rounded up. This is the table of fast_float (Daniel Lemire and
+contributors, used under the MIT license), generated like its
+script/table_generation.py; unit-class_lexer.cpp recomputes every entry.
+*/
+inline const std::array<std::uint64_t, 1302>& pow5_128() noexcept
+{
+    static const std::array<std::uint64_t, 1302> table =
+    {
+        {
+            0xeef453d6923bd65au, 0x113faa2906a13b3fu, 0x9558b4661b6565f8u, 0x4ac7ca59a424c507u,
+            0xbaaee17fa23ebf76u, 0x5d79bcf00d2df649u, 0xe95a99df8ace6f53u, 0xf4d82c2c107973dcu,
+            0x91d8a02bb6c10594u, 0x79071b9b8a4be869u, 0xb64ec836a47146f9u, 0x9748e2826cdee284u,
+            0xe3e27a444d8d98b7u, 0xfd1b1b2308169b25u, 0x8e6d8c6ab0787f72u, 0xfe30f0f5e50e20f7u,
+            0xb208ef855c969f4fu, 0xbdbd2d335e51a935u, 0xde8b2b66b3bc4723u, 0xad2c788035e61382u,
+            0x8b16fb203055ac76u, 0x4c3bcb5021afcc31u, 0xaddcb9e83c6b1793u, 0xdf4abe242a1bbf3du,
+            0xd953e8624b85dd78u, 0xd71d6dad34a2af0du, 0x87d4713d6f33aa6bu, 0x8672648c40e5ad68u,
+            0xa9c98d8ccb009506u, 0x680efdaf511f18c2u, 0xd43bf0effdc0ba48u, 0x0212bd1b2566def2u,
+            0x84a57695fe98746du, 0x014bb630f7604b57u, 0xa5ced43b7e3e9188u, 0x419ea3bd35385e2du,
+            0xcf42894a5dce35eau, 0x52064cac828675b9u, 0x818995ce7aa0e1b2u, 0x7343efebd1940993u,
+            0xa1ebfb4219491a1fu, 0x1014ebe6c5f90bf8u, 0xca66fa129f9b60a6u, 0xd41a26e077774ef6u,
+            0xfd00b897478238d0u, 0x8920b098955522b4u, 0x9e20735e8cb16382u, 0x55b46e5f5d5535b0u,
+            0xc5a890362fddbc62u, 0xeb2189f734aa831du, 0xf712b443bbd52b7bu, 0xa5e9ec7501d523e4u,
+            0x9a6bb0aa55653b2du, 0x47b233c92125366eu, 0xc1069cd4eabe89f8u, 0x999ec0bb696e840au,
+            0xf148440a256e2c76u, 0xc00670ea43ca250du, 0x96cd2a865764dbcau, 0x380406926a5e5728u,
+            0xbc807527ed3e12bcu, 0xc605083704f5ecf2u, 0xeba09271e88d976bu, 0xf7864a44c633682eu,
+            0x93445b8731587ea3u, 0x7ab3ee6afbe0211du, 0xb8157268fdae9e4cu, 0x5960ea05bad82964u,
+            0xe61acf033d1a45dfu, 0x6fb92487298e33bdu, 0x8fd0c16206306babu, 0xa5d3b6d479f8e056u,
+            0xb3c4f1ba87bc8696u, 0x8f48a4899877186cu, 0xe0b62e2929aba83cu, 0x331acdabfe94de87u,
+            0x8c71dcd9ba0b4925u, 0x9ff0c08b7f1d0b14u, 0xaf8e5410288e1b6fu, 0x07ecf0ae5ee44dd9u,
+            0xdb71e91432b1a24au, 0xc9e82cd9f69d6150u, 0x892731ac9faf056eu, 0xbe311c083a225cd2u,
+            0xab70fe17c79ac6cau, 0x6dbd630a48aaf406u, 0xd64d3d9db981787du, 0x092cbbccdad5b108u,
+            0x85f0468293f0eb4eu, 0x25bbf56008c58ea5u, 0xa76c582338ed2621u, 0xaf2af2b80af6f24eu,
+            0xd1476e2c07286faau, 0x1af5af660db4aee1u, 0x82cca4db847945cau, 0x50d98d9fc890ed4du,
+            0xa37fce126597973cu, 0xe50ff107bab528a0u, 0xcc5fc196fefd7d0cu, 0x1e53ed49a96272c8u,
+            0xff77b1fcbebcdc4fu, 0x25e8e89c13bb0f7au, 0x9faacf3df73609b1u, 0x77b191618c54e9acu,
+            0xc795830d75038c1du, 0xd59df5b9ef6a2417u, 0xf97ae3d0d2446f25u, 0x4b0573286b44ad1du,
+            0x9becce62836ac577u, 0x4ee367f9430aec32u, 0xc2e801fb244576d5u, 0x229c41f793cda73fu,
+            0xf3a20279ed56d48au, 0x6b43527578c1110fu, 0x9845418c345644d6u, 0x830a13896b78aaa9u,
+            0xbe5691ef416bd60cu, 0x23cc986bc656d553u, 0xedec366b11c6cb8fu, 0x2cbfbe86b7ec8aa8u,
+            0x94b3a202eb1c3f39u, 0x7bf7d71432f3d6a9u, 0xb9e08a83a5e34f07u, 0xdaf5ccd93fb0cc53u,
+            0xe858ad248f5c22c9u, 0xd1b3400f8f9cff68u, 0x91376c36d99995beu, 0x23100809b9c21fa1u,
+            0xb58547448ffffb2du, 0xabd40a0c2832a78au, 0xe2e69915b3fff9f9u, 0x16c90c8f323f516cu,
+            0x8dd01fad907ffc3bu, 0xae3da7d97f6792e3u, 0xb1442798f49ffb4au, 0x99cd11cfdf41779cu,
+            0xdd95317f31c7fa1du, 0x40405643d711d583u, 0x8a7d3eef7f1cfc52u, 0x482835ea666b2572u,
+            0xad1c8eab5ee43b66u, 0xda3243650005eecfu, 0xd863b256369d4a40u, 0x90bed43e40076a82u,
+            0x873e4f75e2224e68u, 0x5a7744a6e804a291u, 0xa90de3535aaae202u, 0x711515d0a205cb36u,
+            0xd3515c2831559a83u, 0x0d5a5b44ca873e03u, 0x8412d9991ed58091u, 0xe858790afe9486c2u,
+            0xa5178fff668ae0b6u, 0x626e974dbe39a872u, 0xce5d73ff402d98e3u, 0xfb0a3d212dc8128fu,
+            0x80fa687f881c7f8eu, 0x7ce66634bc9d0b99u, 0xa139029f6a239f72u, 0x1c1fffc1ebc44e80u,
+            0xc987434744ac874eu, 0xa327ffb266b56220u, 0xfbe9141915d7a922u, 0x4bf1ff9f0062baa8u,
+            0x9d71ac8fada6c9b5u, 0x6f773fc3603db4a9u, 0xc4ce17b399107c22u, 0xcb550fb4384d21d3u,
+            0xf6019da07f549b2bu, 0x7e2a53a146606a48u, 0x99c102844f94e0fbu, 0x2eda7444cbfc426du,
+            0xc0314325637a1939u, 0xfa911155fefb5308u, 0xf03d93eebc589f88u, 0x793555ab7eba27cau,
+            0x96267c7535b763b5u, 0x4bc1558b2f3458deu, 0xbbb01b9283253ca2u, 0x9eb1aaedfb016f16u,
+            0xea9c227723ee8bcbu, 0x465e15a979c1cadcu, 0x92a1958a7675175fu, 0x0bfacd89ec191ec9u,
+            0xb749faed14125d36u, 0xcef980ec671f667bu, 0xe51c79a85916f484u, 0x82b7e12780e7401au,
+            0x8f31cc0937ae58d2u, 0xd1b2ecb8b0908810u, 0xb2fe3f0b8599ef07u, 0x861fa7e6dcb4aa15u,
+            0xdfbdcece67006ac9u, 0x67a791e093e1d49au, 0x8bd6a141006042bdu, 0xe0c8bb2c5c6d24e0u,
+            0xaecc49914078536du, 0x58fae9f773886e18u, 0xda7f5bf590966848u, 0xaf39a475506a899eu,
+            0x888f99797a5e012du, 0x6d8406c952429603u, 0xaab37fd7d8f58178u, 0xc8e5087ba6d33b83u,
+            0xd5605fcdcf32e1d6u, 0xfb1e4a9a90880a64u, 0x855c3be0a17fcd26u, 0x5cf2eea09a55067fu,
+            0xa6b34ad8c9dfc06fu, 0xf42faa48c0ea481eu, 0xd0601d8efc57b08bu, 0xf13b94daf124da26u,
+            0x823c12795db6ce57u, 0x76c53d08d6b70858u, 0xa2cb1717b52481edu, 0x54768c4b0c64ca6eu,
+            0xcb7ddcdda26da268u, 0xa9942f5dcf7dfd09u, 0xfe5d54150b090b02u, 0xd3f93b35435d7c4cu,
+            0x9efa548d26e5a6e1u, 0xc47bc5014a1a6dafu, 0xc6b8e9b0709f109au, 0x359ab6419ca1091bu,
+            0xf867241c8cc6d4c0u, 0xc30163d203c94b62u, 0x9b407691d7fc44f8u, 0x79e0de63425dcf1du,
+            0xc21094364dfb5636u, 0x985915fc12f542e4u, 0xf294b943e17a2bc4u, 0x3e6f5b7b17b2939du,
+            0x979cf3ca6cec5b5au, 0xa705992ceecf9c42u, 0xbd8430bd08277231u, 0x50c6ff782a838353u,
+            0xece53cec4a314ebdu, 0xa4f8bf5635246428u, 0x940f4613ae5ed136u, 0x871b7795e136be99u,
+            0xb913179899f68584u, 0x28e2557b59846e3fu, 0xe757dd7ec07426e5u, 0x331aeada2fe589cfu,
+            0x9096ea6f3848984fu, 0x3ff0d2c85def7621u, 0xb4bca50b065abe63u, 0x0fed077a756b53a9u,
+            0xe1ebce4dc7f16dfbu, 0xd3e8495912c62894u, 0x8d3360f09cf6e4bdu, 0x64712dd7abbbd95cu,
+            0xb080392cc4349decu, 0xbd8d794d96aacfb3u, 0xdca04777f541c567u, 0xecf0d7a0fc5583a0u,
+            0x89e42caaf9491b60u, 0xf41686c49db57244u, 0xac5d37d5b79b6239u, 0x311c2875c522ced5u,
+            0xd77485cb25823ac7u, 0x7d633293366b828bu, 0x86a8d39ef77164bcu, 0xae5dff9c02033197u,
+            0xa8530886b54dbdebu, 0xd9f57f830283fdfcu, 0xd267caa862a12d66u, 0xd072df63c324fd7bu,
+            0x8380dea93da4bc60u, 0x4247cb9e59f71e6du, 0xa46116538d0deb78u, 0x52d9be85f074e608u,
+            0xcd795be870516656u, 0x67902e276c921f8bu, 0x806bd9714632dff6u, 0x00ba1cd8a3db53b6u,
+            0xa086cfcd97bf97f3u, 0x80e8a40eccd228a4u, 0xc8a883c0fdaf7df0u, 0x6122cd128006b2cdu,
+            0xfad2a4b13d1b5d6cu, 0x796b805720085f81u, 0x9cc3a6eec6311a63u, 0xcbe3303674053bb0u,
+            0xc3f490aa77bd60fcu, 0xbedbfc4411068a9cu, 0xf4f1b4d515acb93bu, 0xee92fb5515482d44u,
+            0x991711052d8bf3c5u, 0x751bdd152d4d1c4au, 0xbf5cd54678eef0b6u, 0xd262d45a78a0635du,
+            0xef340a98172aace4u, 0x86fb897116c87c34u, 0x9580869f0e7aac0eu, 0xd45d35e6ae3d4da0u,
+            0xbae0a846d2195712u, 0x8974836059cca109u, 0xe998d258869facd7u, 0x2bd1a438703fc94bu,
+            0x91ff83775423cc06u, 0x7b6306a34627ddcfu, 0xb67f6455292cbf08u, 0x1a3bc84c17b1d542u,
+            0xe41f3d6a7377eecau, 0x20caba5f1d9e4a93u, 0x8e938662882af53eu, 0x547eb47b7282ee9cu,
+            0xb23867fb2a35b28du, 0xe99e619a4f23aa43u, 0xdec681f9f4c31f31u, 0x6405fa00e2ec94d4u,
+            0x8b3c113c38f9f37eu, 0xde83bc408dd3dd04u, 0xae0b158b4738705eu, 0x9624ab50b148d445u,
+            0xd98ddaee19068c76u, 0x3badd624dd9b0957u, 0x87f8a8d4cfa417c9u, 0xe54ca5d70a80e5d6u,
+            0xa9f6d30a038d1dbcu, 0x5e9fcf4ccd211f4cu, 0xd47487cc8470652bu, 0x7647c3200069671fu,
+            0x84c8d4dfd2c63f3bu, 0x29ecd9f40041e073u, 0xa5fb0a17c777cf09u, 0xf468107100525890u,
+            0xcf79cc9db955c2ccu, 0x7182148d4066eeb4u, 0x81ac1fe293d599bfu, 0xc6f14cd848405530u,
+            0xa21727db38cb002fu, 0xb8ada00e5a506a7cu, 0xca9cf1d206fdc03bu, 0xa6d90811f0e4851cu,
+            0xfd442e4688bd304au, 0x908f4a166d1da663u, 0x9e4a9cec15763e2eu, 0x9a598e4e043287feu,
+            0xc5dd44271ad3cdbau, 0x40eff1e1853f29fdu, 0xf7549530e188c128u, 0xd12bee59e68ef47cu,
+            0x9a94dd3e8cf578b9u, 0x82bb74f8301958ceu, 0xc13a148e3032d6e7u, 0xe36a52363c1faf01u,
+            0xf18899b1bc3f8ca1u, 0xdc44e6c3cb279ac1u, 0x96f5600f15a7b7e5u, 0x29ab103a5ef8c0b9u,
+            0xbcb2b812db11a5deu, 0x7415d448f6b6f0e7u, 0xebdf661791d60f56u, 0x111b495b3464ad21u,
+            0x936b9fcebb25c995u, 0xcab10dd900beec34u, 0xb84687c269ef3bfbu, 0x3d5d514f40eea742u,
+            0xe65829b3046b0afau, 0x0cb4a5a3112a5112u, 0x8ff71a0fe2c2e6dcu, 0x47f0e785eaba72abu,
+            0xb3f4e093db73a093u, 0x59ed216765690f56u, 0xe0f218b8d25088b8u, 0x306869c13ec3532cu,
+            0x8c974f7383725573u, 0x1e414218c73a13fbu, 0xafbd2350644eeacfu, 0xe5d1929ef90898fau,
+            0xdbac6c247d62a583u, 0xdf45f746b74abf39u, 0x894bc396ce5da772u, 0x6b8bba8c328eb783u,
+            0xab9eb47c81f5114fu, 0x066ea92f3f326564u, 0xd686619ba27255a2u, 0xc80a537b0efefebdu,
+            0x8613fd0145877585u, 0xbd06742ce95f5f36u, 0xa798fc4196e952e7u, 0x2c48113823b73704u,
+            0xd17f3b51fca3a7a0u, 0xf75a15862ca504c5u, 0x82ef85133de648c4u, 0x9a984d73dbe722fbu,
+            0xa3ab66580d5fdaf5u, 0xc13e60d0d2e0ebbau, 0xcc963fee10b7d1b3u, 0x318df905079926a8u,
+            0xffbbcfe994e5c61fu, 0xfdf17746497f7052u, 0x9fd561f1fd0f9bd3u, 0xfeb6ea8bedefa633u,
+            0xc7caba6e7c5382c8u, 0xfe64a52ee96b8fc0u, 0xf9bd690a1b68637bu, 0x3dfdce7aa3c673b0u,
+            0x9c1661a651213e2du, 0x06bea10ca65c084eu, 0xc31bfa0fe5698db8u, 0x486e494fcff30a62u,
+            0xf3e2f893dec3f126u, 0x5a89dba3c3efccfau, 0x986ddb5c6b3a76b7u, 0xf89629465a75e01cu,
+            0xbe89523386091465u, 0xf6bbb397f1135823u, 0xee2ba6c0678b597fu, 0x746aa07ded582e2cu,
+            0x94db483840b717efu, 0xa8c2a44eb4571cdcu, 0xba121a4650e4ddebu, 0x92f34d62616ce413u,
+            0xe896a0d7e51e1566u, 0x77b020baf9c81d17u, 0x915e2486ef32cd60u, 0x0ace1474dc1d122eu,
+            0xb5b5ada8aaff80b8u, 0x0d819992132456bau, 0xe3231912d5bf60e6u, 0x10e1fff697ed6c69u,
+            0x8df5efabc5979c8fu, 0xca8d3ffa1ef463c1u, 0xb1736b96b6fd83b3u, 0xbd308ff8a6b17cb2u,
+            0xddd0467c64bce4a0u, 0xac7cb3f6d05ddbdeu, 0x8aa22c0dbef60ee4u, 0x6bcdf07a423aa96bu,
+            0xad4ab7112eb3929du, 0x86c16c98d2c953c6u, 0xd89d64d57a607744u, 0xe871c7bf077ba8b7u,
+            0x87625f056c7c4a8bu, 0x11471cd764ad4972u, 0xa93af6c6c79b5d2du, 0xd598e40d3dd89bcfu,
+            0xd389b47879823479u, 0x4aff1d108d4ec2c3u, 0x843610cb4bf160cbu, 0xcedf722a585139bau,
+            0xa54394fe1eedb8feu, 0xc2974eb4ee658828u, 0xce947a3da6a9273eu, 0x733d226229feea32u,
+            0x811ccc668829b887u, 0x0806357d5a3f525fu, 0xa163ff802a3426a8u, 0xca07c2dcb0cf26f7u,
+            0xc9bcff6034c13052u, 0xfc89b393dd02f0b5u, 0xfc2c3f3841f17c67u, 0xbbac2078d443ace2u,
+            0x9d9ba7832936edc0u, 0xd54b944b84aa4c0du, 0xc5029163f384a931u, 0x0a9e795e65d4df11u,
+            0xf64335bcf065d37du, 0x4d4617b5ff4a16d5u, 0x99ea0196163fa42eu, 0x504bced1bf8e4e45u,
+            0xc06481fb9bcf8d39u, 0xe45ec2862f71e1d6u, 0xf07da27a82c37088u, 0x5d767327bb4e5a4cu,
+            0x964e858c91ba2655u, 0x3a6a07f8d510f86fu, 0xbbe226efb628afeau, 0x890489f70a55368bu,
+            0xeadab0aba3b2dbe5u, 0x2b45ac74ccea842eu, 0x92c8ae6b464fc96fu, 0x3b0b8bc90012929du,
+            0xb77ada0617e3bbcbu, 0x09ce6ebb40173744u, 0xe55990879ddcaabdu, 0xcc420a6a101d0515u,
+            0x8f57fa54c2a9eab6u, 0x9fa946824a12232du, 0xb32df8e9f3546564u, 0x47939822dc96abf9u,
+            0xdff9772470297ebdu, 0x59787e2b93bc56f7u, 0x8bfbea76c619ef36u, 0x57eb4edb3c55b65au,
+            0xaefae51477a06b03u, 0xede622920b6b23f1u, 0xdab99e59958885c4u, 0xe95fab368e45ecedu,
+            0x88b402f7fd75539bu, 0x11dbcb0218ebb414u, 0xaae103b5fcd2a881u, 0xd652bdc29f26a119u,
+            0xd59944a37c0752a2u, 0x4be76d3346f0495fu, 0x857fcae62d8493a5u, 0x6f70a4400c562ddbu,
+            0xa6dfbd9fb8e5b88eu, 0xcb4ccd500f6bb952u, 0xd097ad07a71f26b2u, 0x7e2000a41346a7a7u,
+            0x825ecc24c873782fu, 0x8ed400668c0c28c8u, 0xa2f67f2dfa90563bu, 0x728900802f0f32fau,
+            0xcbb41ef979346bcau, 0x4f2b40a03ad2ffb9u, 0xfea126b7d78186bcu, 0xe2f610c84987bfa8u,
+            0x9f24b832e6b0f436u, 0x0dd9ca7d2df4d7c9u, 0xc6ede63fa05d3143u, 0x91503d1c79720dbbu,
+            0xf8a95fcf88747d94u, 0x75a44c6397ce912au, 0x9b69dbe1b548ce7cu, 0xc986afbe3ee11abau,
+            0xc24452da229b021bu, 0xfbe85badce996168u, 0xf2d56790ab41c2a2u, 0xfae27299423fb9c3u,
+            0x97c560ba6b0919a5u, 0xdccd879fc967d41au, 0xbdb6b8e905cb600fu, 0x5400e987bbc1c920u,
+            0xed246723473e3813u, 0x290123e9aab23b68u, 0x9436c0760c86e30bu, 0xf9a0b6720aaf6521u,
+            0xb94470938fa89bceu, 0xf808e40e8d5b3e69u, 0xe7958cb87392c2c2u, 0xb60b1d1230b20e04u,
+            0x90bd77f3483bb9b9u, 0xb1c6f22b5e6f48c2u, 0xb4ecd5f01a4aa828u, 0x1e38aeb6360b1af3u,
+            0xe2280b6c20dd5232u, 0x25c6da63c38de1b0u, 0x8d590723948a535fu, 0x579c487e5a38ad0eu,
+            0xb0af48ec79ace837u, 0x2d835a9df0c6d851u, 0xdcdb1b2798182244u, 0xf8e431456cf88e65u,
+            0x8a08f0f8bf0f156bu, 0x1b8e9ecb641b58ffu, 0xac8b2d36eed2dac5u, 0xe272467e3d222f3fu,
+            0xd7adf884aa879177u, 0x5b0ed81dcc6abb0fu, 0x86ccbb52ea94baeau, 0x98e947129fc2b4e9u,
+            0xa87fea27a539e9a5u, 0x3f2398d747b36224u, 0xd29fe4b18e88640eu, 0x8eec7f0d19a03aadu,
+            0x83a3eeeef9153e89u, 0x1953cf68300424acu, 0xa48ceaaab75a8e2bu, 0x5fa8c3423c052dd7u,
+            0xcdb02555653131b6u, 0x3792f412cb06794du, 0x808e17555f3ebf11u, 0xe2bbd88bbee40bd0u,
+            0xa0b19d2ab70e6ed6u, 0x5b6aceaeae9d0ec4u, 0xc8de047564d20a8bu, 0xf245825a5a445275u,
+            0xfb158592be068d2eu, 0xeed6e2f0f0d56712u, 0x9ced737bb6c4183du, 0x55464dd69685606bu,
+            0xc428d05aa4751e4cu, 0xaa97e14c3c26b886u, 0xf53304714d9265dfu, 0xd53dd99f4b3066a8u,
+            0x993fe2c6d07b7fabu, 0xe546a8038efe4029u, 0xbf8fdb78849a5f96u, 0xde98520472bdd033u,
+            0xef73d256a5c0f77cu, 0x963e66858f6d4440u, 0x95a8637627989aadu, 0xdde7001379a44aa8u,
+            0xbb127c53b17ec159u, 0x5560c018580d5d52u, 0xe9d71b689dde71afu, 0xaab8f01e6e10b4a6u,
+            0x9226712162ab070du, 0xcab3961304ca70e8u, 0xb6b00d69bb55c8d1u, 0x3d607b97c5fd0d22u,
+            0xe45c10c42a2b3b05u, 0x8cb89a7db77c506au, 0x8eb98a7a9a5b04e3u, 0x77f3608e92adb242u,
+            0xb267ed1940f1c61cu, 0x55f038b237591ed3u, 0xdf01e85f912e37a3u, 0x6b6c46dec52f6688u,
+            0x8b61313bbabce2c6u, 0x2323ac4b3b3da015u, 0xae397d8aa96c1b77u, 0xabec975e0a0d081au,
+            0xd9c7dced53c72255u, 0x96e7bd358c904a21u, 0x881cea14545c7575u, 0x7e50d64177da2e54u,
+            0xaa242499697392d2u, 0xdde50bd1d5d0b9e9u, 0xd4ad2dbfc3d07787u, 0x955e4ec64b44e864u,
+            0x84ec3c97da624ab4u, 0xbd5af13bef0b113eu, 0xa6274bbdd0fadd61u, 0xecb1ad8aeacdd58eu,
+            0xcfb11ead453994bau, 0x67de18eda5814af2u, 0x81ceb32c4b43fcf4u, 0x80eacf948770ced7u,
+            0xa2425ff75e14fc31u, 0xa1258379a94d028du, 0xcad2f7f5359a3b3eu, 0x096ee45813a04330u,
+            0xfd87b5f28300ca0du, 0x8bca9d6e188853fcu, 0x9e74d1b791e07e48u, 0x775ea264cf55347eu,
+            0xc612062576589ddau, 0x95364afe032a819eu, 0xf79687aed3eec551u, 0x3a83ddbd83f52205u,
+            0x9abe14cd44753b52u, 0xc4926a9672793543u, 0xc16d9a0095928a27u, 0x75b7053c0f178294u,
+            0xf1c90080baf72cb1u, 0x5324c68b12dd6339u, 0x971da05074da7beeu, 0xd3f6fc16ebca5e04u,
+            0xbce5086492111aeau, 0x88f4bb1ca6bcf585u, 0xec1e4a7db69561a5u, 0x2b31e9e3d06c32e6u,
+            0x9392ee8e921d5d07u, 0x3aff322e62439fd0u, 0xb877aa3236a4b449u, 0x09befeb9fad487c3u,
+            0xe69594bec44de15bu, 0x4c2ebe687989a9b4u, 0x901d7cf73ab0acd9u, 0x0f9d37014bf60a11u,
+            0xb424dc35095cd80fu, 0x538484c19ef38c95u, 0xe12e13424bb40e13u, 0x2865a5f206b06fbau,
+            0x8cbccc096f5088cbu, 0xf93f87b7442e45d4u, 0xafebff0bcb24aafeu, 0xf78f69a51539d749u,
+            0xdbe6fecebdedd5beu, 0xb573440e5a884d1cu, 0x89705f4136b4a597u, 0x31680a88f8953031u,
+            0xabcc77118461cefcu, 0xfdc20d2b36ba7c3eu, 0xd6bf94d5e57a42bcu, 0x3d32907604691b4du,
+            0x8637bd05af6c69b5u, 0xa63f9a49c2c1b110u, 0xa7c5ac471b478423u, 0x0fcf80dc33721d54u,
+            0xd1b71758e219652bu, 0xd3c36113404ea4a9u, 0x83126e978d4fdf3bu, 0x645a1cac083126eau,
+            0xa3d70a3d70a3d70au, 0x3d70a3d70a3d70a4u, 0xccccccccccccccccu, 0xcccccccccccccccdu,
+            0x8000000000000000u, 0x0000000000000000u, 0xa000000000000000u, 0x0000000000000000u,
+            0xc800000000000000u, 0x0000000000000000u, 0xfa00000000000000u, 0x0000000000000000u,
+            0x9c40000000000000u, 0x0000000000000000u, 0xc350000000000000u, 0x0000000000000000u,
+            0xf424000000000000u, 0x0000000000000000u, 0x9896800000000000u, 0x0000000000000000u,
+            0xbebc200000000000u, 0x0000000000000000u, 0xee6b280000000000u, 0x0000000000000000u,
+            0x9502f90000000000u, 0x0000000000000000u, 0xba43b74000000000u, 0x0000000000000000u,
+            0xe8d4a51000000000u, 0x0000000000000000u, 0x9184e72a00000000u, 0x0000000000000000u,
+            0xb5e620f480000000u, 0x0000000000000000u, 0xe35fa931a0000000u, 0x0000000000000000u,
+            0x8e1bc9bf04000000u, 0x0000000000000000u, 0xb1a2bc2ec5000000u, 0x0000000000000000u,
+            0xde0b6b3a76400000u, 0x0000000000000000u, 0x8ac7230489e80000u, 0x0000000000000000u,
+            0xad78ebc5ac620000u, 0x0000000000000000u, 0xd8d726b7177a8000u, 0x0000000000000000u,
+            0x878678326eac9000u, 0x0000000000000000u, 0xa968163f0a57b400u, 0x0000000000000000u,
+            0xd3c21bcecceda100u, 0x0000000000000000u, 0x84595161401484a0u, 0x0000000000000000u,
+            0xa56fa5b99019a5c8u, 0x0000000000000000u, 0xcecb8f27f4200f3au, 0x0000000000000000u,
+            0x813f3978f8940984u, 0x4000000000000000u, 0xa18f07d736b90be5u, 0x5000000000000000u,
+            0xc9f2c9cd04674edeu, 0xa400000000000000u, 0xfc6f7c4045812296u, 0x4d00000000000000u,
+            0x9dc5ada82b70b59du, 0xf020000000000000u, 0xc5371912364ce305u, 0x6c28000000000000u,
+            0xf684df56c3e01bc6u, 0xc732000000000000u, 0x9a130b963a6c115cu, 0x3c7f400000000000u,
+            0xc097ce7bc90715b3u, 0x4b9f100000000000u, 0xf0bdc21abb48db20u, 0x1e86d40000000000u,
+            0x96769950b50d88f4u, 0x1314448000000000u, 0xbc143fa4e250eb31u, 0x17d955a000000000u,
+            0xeb194f8e1ae525fdu, 0x5dcfab0800000000u, 0x92efd1b8d0cf37beu, 0x5aa1cae500000000u,
+            0xb7abc627050305adu, 0xf14a3d9e40000000u, 0xe596b7b0c643c719u, 0x6d9ccd05d0000000u,
+            0x8f7e32ce7bea5c6fu, 0xe4820023a2000000u, 0xb35dbf821ae4f38bu, 0xdda2802c8a800000u,
+            0xe0352f62a19e306eu, 0xd50b2037ad200000u, 0x8c213d9da502de45u, 0x4526f422cc340000u,
+            0xaf298d050e4395d6u, 0x9670b12b7f410000u, 0xdaf3f04651d47b4cu, 0x3c0cdd765f114000u,
+            0x88d8762bf324cd0fu, 0xa5880a69fb6ac800u, 0xab0e93b6efee0053u, 0x8eea0d047a457a00u,
+            0xd5d238a4abe98068u, 0x72a4904598d6d880u, 0x85a36366eb71f041u, 0x47a6da2b7f864750u,
+            0xa70c3c40a64e6c51u, 0x999090b65f67d924u, 0xd0cf4b50cfe20765u, 0xfff4b4e3f741cf6du,
+            0x82818f1281ed449fu, 0xbff8f10e7a8921a4u, 0xa321f2d7226895c7u, 0xaff72d52192b6a0du,
+            0xcbea6f8ceb02bb39u, 0x9bf4f8a69f764490u, 0xfee50b7025c36a08u, 0x02f236d04753d5b4u,
+            0x9f4f2726179a2245u, 0x01d762422c946590u, 0xc722f0ef9d80aad6u, 0x424d3ad2b7b97ef5u,
+            0xf8ebad2b84e0d58bu, 0xd2e0898765a7deb2u, 0x9b934c3b330c8577u, 0x63cc55f49f88eb2fu,
+            0xc2781f49ffcfa6d5u, 0x3cbf6b71c76b25fbu, 0xf316271c7fc3908au, 0x8bef464e3945ef7au,
+            0x97edd871cfda3a56u, 0x97758bf0e3cbb5acu, 0xbde94e8e43d0c8ecu, 0x3d52eeed1cbea317u,
+            0xed63a231d4c4fb27u, 0x4ca7aaa863ee4bddu, 0x945e455f24fb1cf8u, 0x8fe8caa93e74ef6au,
+            0xb975d6b6ee39e436u, 0xb3e2fd538e122b44u, 0xe7d34c64a9c85d44u, 0x60dbbca87196b616u,
+            0x90e40fbeea1d3a4au, 0xbc8955e946fe31cdu, 0xb51d13aea4a488ddu, 0x6babab6398bdbe41u,
+            0xe264589a4dcdab14u, 0xc696963c7eed2dd1u, 0x8d7eb76070a08aecu, 0xfc1e1de5cf543ca2u,
+            0xb0de65388cc8ada8u, 0x3b25a55f43294bcbu, 0xdd15fe86affad912u, 0x49ef0eb713f39ebeu,
+            0x8a2dbf142dfcc7abu, 0x6e3569326c784337u, 0xacb92ed9397bf996u, 0x49c2c37f07965404u,
+            0xd7e77a8f87daf7fbu, 0xdc33745ec97be906u, 0x86f0ac99b4e8dafdu, 0x69a028bb3ded71a3u,
+            0xa8acd7c0222311bcu, 0xc40832ea0d68ce0cu, 0xd2d80db02aabd62bu, 0xf50a3fa490c30190u,
+            0x83c7088e1aab65dbu, 0x792667c6da79e0fau, 0xa4b8cab1a1563f52u, 0x577001b891185938u,
+            0xcde6fd5e09abcf26u, 0xed4c0226b55e6f86u, 0x80b05e5ac60b6178u, 0x544f8158315b05b4u,
+            0xa0dc75f1778e39d6u, 0x696361ae3db1c721u, 0xc913936dd571c84cu, 0x03bc3a19cd1e38e9u,
+            0xfb5878494ace3a5fu, 0x04ab48a04065c723u, 0x9d174b2dcec0e47bu, 0x62eb0d64283f9c76u,
+            0xc45d1df942711d9au, 0x3ba5d0bd324f8394u, 0xf5746577930d6500u, 0xca8f44ec7ee36479u,
+            0x9968bf6abbe85f20u, 0x7e998b13cf4e1ecbu, 0xbfc2ef456ae276e8u, 0x9e3fedd8c321a67eu,
+            0xefb3ab16c59b14a2u, 0xc5cfe94ef3ea101eu, 0x95d04aee3b80ece5u, 0xbba1f1d158724a12u,
+            0xbb445da9ca61281fu, 0x2a8a6e45ae8edc97u, 0xea1575143cf97226u, 0xf52d09d71a3293bdu,
+            0x924d692ca61be758u, 0x593c2626705f9c56u, 0xb6e0c377cfa2e12eu, 0x6f8b2fb00c77836cu,
+            0xe498f455c38b997au, 0x0b6dfb9c0f956447u, 0x8edf98b59a373fecu, 0x4724bd4189bd5eacu,
+            0xb2977ee300c50fe7u, 0x58edec91ec2cb657u, 0xdf3d5e9bc0f653e1u, 0x2f2967b66737e3edu,
+            0x8b865b215899f46cu, 0xbd79e0d20082ee74u, 0xae67f1e9aec07187u, 0xecd8590680a3aa11u,
+            0xda01ee641a708de9u, 0xe80e6f4820cc9495u, 0x884134fe908658b2u, 0x3109058d147fdcddu,
+            0xaa51823e34a7eedeu, 0xbd4b46f0599fd415u, 0xd4e5e2cdc1d1ea96u, 0x6c9e18ac7007c91au,
+            0x850fadc09923329eu, 0x03e2cf6bc604ddb0u, 0xa6539930bf6bff45u, 0x84db8346b786151cu,
+            0xcfe87f7cef46ff16u, 0xe612641865679a63u, 0x81f14fae158c5f6eu, 0x4fcb7e8f3f60c07eu,
+            0xa26da3999aef7749u, 0xe3be5e330f38f09du, 0xcb090c8001ab551cu, 0x5cadf5bfd3072cc5u,
+            0xfdcb4fa002162a63u, 0x73d9732fc7c8f7f6u, 0x9e9f11c4014dda7eu, 0x2867e7fddcdd9afau,
+            0xc646d63501a1511du, 0xb281e1fd541501b8u, 0xf7d88bc24209a565u, 0x1f225a7ca91a4226u,
+            0x9ae757596946075fu, 0x3375788de9b06958u, 0xc1a12d2fc3978937u, 0x0052d6b1641c83aeu,
+            0xf209787bb47d6b84u, 0xc0678c5dbd23a49au, 0x9745eb4d50ce6332u, 0xf840b7ba963646e0u,
+            0xbd176620a501fbffu, 0xb650e5a93bc3d898u, 0xec5d3fa8ce427affu, 0xa3e51f138ab4cebeu,
+            0x93ba47c980e98cdfu, 0xc66f336c36b10137u, 0xb8a8d9bbe123f017u, 0xb80b0047445d4184u,
+            0xe6d3102ad96cec1du, 0xa60dc059157491e5u, 0x9043ea1ac7e41392u, 0x87c89837ad68db2fu,
+            0xb454e4a179dd1877u, 0x29babe4598c311fbu, 0xe16a1dc9d8545e94u, 0xf4296dd6fef3d67au,
+            0x8ce2529e2734bb1du, 0x1899e4a65f58660cu, 0xb01ae745b101e9e4u, 0x5ec05dcff72e7f8fu,
+            0xdc21a1171d42645du, 0x76707543f4fa1f73u, 0x899504ae72497ebau, 0x6a06494a791c53a8u,
+            0xabfa45da0edbde69u, 0x0487db9d17636892u, 0xd6f8d7509292d603u, 0x45a9d2845d3c42b6u,
+            0x865b86925b9bc5c2u, 0x0b8a2392ba45a9b2u, 0xa7f26836f282b732u, 0x8e6cac7768d7141eu,
+            0xd1ef0244af2364ffu, 0x3207d795430cd926u, 0x8335616aed761f1fu, 0x7f44e6bd49e807b8u,
+            0xa402b9c5a8d3a6e7u, 0x5f16206c9c6209a6u, 0xcd036837130890a1u, 0x36dba887c37a8c0fu,
+            0x802221226be55a64u, 0xc2494954da2c9789u, 0xa02aa96b06deb0fdu, 0xf2db9baa10b7bd6cu,
+            0xc83553c5c8965d3du, 0x6f92829494e5acc7u, 0xfa42a8b73abbf48cu, 0xcb772339ba1f17f9u,
+            0x9c69a97284b578d7u, 0xff2a760414536efbu, 0xc38413cf25e2d70du, 0xfef5138519684abau,
+            0xf46518c2ef5b8cd1u, 0x7eb258665fc25d69u, 0x98bf2f79d5993802u, 0xef2f773ffbd97a61u,
+            0xbeeefb584aff8603u, 0xaafb550ffacfd8fau, 0xeeaaba2e5dbf6784u, 0x95ba2a53f983cf38u,
+            0x952ab45cfa97a0b2u, 0xdd945a747bf26183u, 0xba756174393d88dfu, 0x94f971119aeef9e4u,
+            0xe912b9d1478ceb17u, 0x7a37cd5601aab85du, 0x91abb422ccb812eeu, 0xac62e055c10ab33au,
+            0xb616a12b7fe617aau, 0x577b986b314d6009u, 0xe39c49765fdf9d94u, 0xed5a7e85fda0b80bu,
+            0x8e41ade9fbebc27du, 0x14588f13be847307u, 0xb1d219647ae6b31cu, 0x596eb2d8ae258fc8u,
+            0xde469fbd99a05fe3u, 0x6fca5f8ed9aef3bbu, 0x8aec23d680043beeu, 0x25de7bb9480d5854u,
+            0xada72ccc20054ae9u, 0xaf561aa79a10ae6au, 0xd910f7ff28069da4u, 0x1b2ba1518094da04u,
+            0x87aa9aff79042286u, 0x90fb44d2f05d0842u, 0xa99541bf57452b28u, 0x353a1607ac744a53u,
+            0xd3fa922f2d1675f2u, 0x42889b8997915ce8u, 0x847c9b5d7c2e09b7u, 0x69956135febada11u,
+            0xa59bc234db398c25u, 0x43fab9837e699095u, 0xcf02b2c21207ef2eu, 0x94f967e45e03f4bbu,
+            0x8161afb94b44f57du, 0x1d1be0eebac278f5u, 0xa1ba1ba79e1632dcu, 0x6462d92a69731732u,
+            0xca28a291859bbf93u, 0x7d7b8f7503cfdcfeu, 0xfcb2cb35e702af78u, 0x5cda735244c3d43eu,
+            0x9defbf01b061adabu, 0x3a0888136afa64a7u, 0xc56baec21c7a1916u, 0x088aaa1845b8fdd0u,
+            0xf6c69a72a3989f5bu, 0x8aad549e57273d45u, 0x9a3c2087a63f6399u, 0x36ac54e2f678864bu,
+            0xc0cb28a98fcf3c7fu, 0x84576a1bb416a7ddu, 0xf0fdf2d3f3c30b9fu, 0x656d44a2a11c51d5u,
+            0x969eb7c47859e743u, 0x9f644ae5a4b1b325u, 0xbc4665b596706114u, 0x873d5d9f0dde1feeu,
+            0xeb57ff22fc0c7959u, 0xa90cb506d155a7eau, 0x9316ff75dd87cbd8u, 0x09a7f12442d588f2u,
+            0xb7dcbf5354e9beceu, 0x0c11ed6d538aeb2fu, 0xe5d3ef282a242e81u, 0x8f1668c8a86da5fau,
+            0x8fa475791a569d10u, 0xf96e017d694487bcu, 0xb38d92d760ec4455u, 0x37c981dcc395a9acu,
+            0xe070f78d3927556au, 0x85bbe253f47b1417u, 0x8c469ab843b89562u, 0x93956d7478ccec8eu,
+            0xaf58416654a6babbu, 0x387ac8d1970027b2u, 0xdb2e51bfe9d0696au, 0x06997b05fcc0319eu,
+            0x88fcf317f22241e2u, 0x441fece3bdf81f03u, 0xab3c2fddeeaad25au, 0xd527e81cad7626c3u,
+            0xd60b3bd56a5586f1u, 0x8a71e223d8d3b074u, 0x85c7056562757456u, 0xf6872d5667844e49u,
+            0xa738c6bebb12d16cu, 0xb428f8ac016561dbu, 0xd106f86e69d785c7u, 0xe13336d701beba52u,
+            0x82a45b450226b39cu, 0xecc0024661173473u, 0xa34d721642b06084u, 0x27f002d7f95d0190u,
+            0xcc20ce9bd35c78a5u, 0x31ec038df7b441f4u, 0xff290242c83396ceu, 0x7e67047175a15271u,
+            0x9f79a169bd203e41u, 0x0f0062c6e984d386u, 0xc75809c42c684dd1u, 0x52c07b78a3e60868u,
+            0xf92e0c3537826145u, 0xa7709a56ccdf8a82u, 0x9bbcc7a142b17ccbu, 0x88a66076400bb691u,
+            0xc2abf989935ddbfeu, 0x6acff893d00ea435u, 0xf356f7ebf83552feu, 0x0583f6b8c4124d43u,
+            0x98165af37b2153deu, 0xc3727a337a8b704au, 0xbe1bf1b059e9a8d6u, 0x744f18c0592e4c5cu,
+            0xeda2ee1c7064130cu, 0x1162def06f79df73u, 0x9485d4d1c63e8be7u, 0x8addcb5645ac2ba8u,
+            0xb9a74a0637ce2ee1u, 0x6d953e2bd7173692u, 0xe8111c87c5c1ba99u, 0xc8fa8db6ccdd0437u,
+            0x910ab1d4db9914a0u, 0x1d9c9892400a22a2u, 0xb54d5e4a127f59c8u, 0x2503beb6d00cab4bu,
+            0xe2a0b5dc971f303au, 0x2e44ae64840fd61du, 0x8da471a9de737e24u, 0x5ceaecfed289e5d2u,
+            0xb10d8e1456105dadu, 0x7425a83e872c5f47u, 0xdd50f1996b947518u, 0xd12f124e28f77719u,
+            0x8a5296ffe33cc92fu, 0x82bd6b70d99aaa6fu, 0xace73cbfdc0bfb7bu, 0x636cc64d1001550bu,
+            0xd8210befd30efa5au, 0x3c47f7e05401aa4eu, 0x8714a775e3e95c78u, 0x65acfaec34810a71u,
+            0xa8d9d1535ce3b396u, 0x7f1839a741a14d0du, 0xd31045a8341ca07cu, 0x1ede48111209a050u,
+            0x83ea2b892091e44du, 0x934aed0aab460432u, 0xa4e4b66b68b65d60u, 0xf81da84d5617853fu,
+            0xce1de40642e3f4b9u, 0x36251260ab9d668eu, 0x80d2ae83e9ce78f3u, 0xc1d72b7c6b426019u,
+            0xa1075a24e4421730u, 0xb24cf65b8612f81fu, 0xc94930ae1d529cfcu, 0xdee033f26797b627u,
+            0xfb9b7cd9a4a7443cu, 0x169840ef017da3b1u, 0x9d412e0806e88aa5u, 0x8e1f289560ee864eu,
+            0xc491798a08a2ad4eu, 0xf1a6f2bab92a27e2u, 0xf5b5d7ec8acb58a2u, 0xae10af696774b1dbu,
+            0x9991a6f3d6bf1765u, 0xacca6da1e0a8ef29u, 0xbff610b0cc6edd3fu, 0x17fd090a58d32af3u,
+            0xeff394dcff8a948eu, 0xddfc4b4cef07f5b0u, 0x95f83d0a1fb69cd9u, 0x4abdaf101564f98eu,
+            0xbb764c4ca7a4440fu, 0x9d6d1ad41abe37f1u, 0xea53df5fd18d5513u, 0x84c86189216dc5edu,
+            0x92746b9be2f8552cu, 0x32fd3cf5b4e49bb4u, 0xb7118682dbb66a77u, 0x3fbc8c33221dc2a1u,
+            0xe4d5e82392a40515u, 0x0fabaf3feaa5334au, 0x8f05b1163ba6832du, 0x29cb4d87f2a7400eu,
+            0xb2c71d5bca9023f8u, 0x743e20e9ef511012u, 0xdf78e4b2bd342cf6u, 0x914da9246b255416u,
+            0x8bab8eefb6409c1au, 0x1ad089b6c2f7548eu, 0xae9672aba3d0c320u, 0xa184ac2473b529b1u,
+            0xda3c0f568cc4f3e8u, 0xc9e5d72d90a2741eu, 0x8865899617fb1871u, 0x7e2fa67c7a658892u,
+            0xaa7eebfb9df9de8du, 0xddbb901b98feeab7u, 0xd51ea6fa85785631u, 0x552a74227f3ea565u,
+            0x8533285c936b35deu, 0xd53a88958f87275fu, 0xa67ff273b8460356u, 0x8a892abaf368f137u,
+            0xd01fef10a657842cu, 0x2d2b7569b0432d85u, 0x8213f56a67f6b29bu, 0x9c3b29620e29fc73u,
+            0xa298f2c501f45f42u, 0x8349f3ba91b47b8fu, 0xcb3f2f7642717713u, 0x241c70a936219a73u,
+            0xfe0efb53d30dd4d7u, 0xed238cd383aa0110u, 0x9ec95d1463e8a506u, 0xf4363804324a40aau,
+            0xc67bb4597ce2ce48u, 0xb143c6053edcd0d5u, 0xf81aa16fdc1b81dau, 0xdd94b7868e94050au,
+            0x9b10a4e5e9913128u, 0xca7cf2b4191c8326u, 0xc1d4ce1f63f57d72u, 0xfd1c2f611f63a3f0u,
+            0xf24a01a73cf2dccfu, 0xbc633b39673c8cecu, 0x976e41088617ca01u, 0xd5be0503e085d813u,
+            0xbd49d14aa79dbc82u, 0x4b2d8644d8a74e18u, 0xec9c459d51852ba2u, 0xddf8e7d60ed1219eu,
+            0x93e1ab8252f33b45u, 0xcabb90e5c942b503u, 0xb8da1662e7b00a17u, 0x3d6a751f3b936243u,
+            0xe7109bfba19c0c9du, 0x0cc512670a783ad4u, 0x906a617d450187e2u, 0x27fb2b80668b24c5u,
+            0xb484f9dc9641e9dau, 0xb1f9f660802dedf6u, 0xe1a63853bbd26451u, 0x5e7873f8a0396973u,
+            0x8d07e33455637eb2u, 0xdb0b487b6423e1e8u, 0xb049dc016abc5e5fu, 0x91ce1a9a3d2cda62u,
+            0xdc5c5301c56b75f7u, 0x7641a140cc7810fbu, 0x89b9b3e11b6329bau, 0xa9e904c87fcb0a9du,
+            0xac2820d9623bf429u, 0x546345fa9fbdcd44u, 0xd732290fbacaf133u, 0xa97c177947ad4095u,
+            0x867f59a9d4bed6c0u, 0x49ed8eabcccc485du, 0xa81f301449ee8c70u, 0x5c68f256bfff5a74u,
+            0xd226fc195c6a2f8cu, 0x73832eec6fff3111u, 0x83585d8fd9c25db7u, 0xc831fd53c5ff7eabu,
+            0xa42e74f3d032f525u, 0xba3e7ca8b77f5e55u, 0xcd3a1230c43fb26fu, 0x28ce1bd2e55f35ebu,
+            0x80444b5e7aa7cf85u, 0x7980d163cf5b81b3u, 0xa0555e361951c366u, 0xd7e105bcc332621fu,
+            0xc86ab5c39fa63440u, 0x8dd9472bf3fefaa7u, 0xfa856334878fc150u, 0xb14f98f6f0feb951u,
+            0x9c935e00d4b9d8d2u, 0x6ed1bf9a569f33d3u, 0xc3b8358109e84f07u, 0x0a862f80ec4700c8u,
+            0xf4a642e14c6262c8u, 0xcd27bb612758c0fau, 0x98e7e9cccfbd7dbdu, 0x8038d51cb897789cu,
+            0xbf21e44003acdd2cu, 0xe0470a63e6bd56c3u, 0xeeea5d5004981478u, 0x1858ccfce06cac74u,
+            0x95527a5202df0ccbu, 0x0f37801e0c43ebc8u, 0xbaa718e68396cffdu, 0xd30560258f54e6bau,
+            0xe950df20247c83fdu, 0x47c6b82ef32a2069u, 0x91d28b7416cdd27eu, 0x4cdc331d57fa5441u,
+            0xb6472e511c81471du, 0xe0133fe4adf8e952u, 0xe3d8f9e563a198e5u, 0x58180fddd97723a6u,
+            0x8e679c2f5e44ff8fu, 0x570f09eaa7ea7648u,
+        }
+    };
+    return table;
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
@@ -8,10 +8,12 @@

 #pragma once

+#include <array> // array
 #include <cstddef> // size_t
-#include <cstdint> // uint64_t
+#include <cstdint> // uint64_t, uint8_t
 #include <cstring> // memcpy

+#include <nlohmann/detail/bit_ops.hpp>
 #include <nlohmann/detail/macro_scope.hpp>

 // Optional SIMD backend for bulk UTF-8 validation. This is an opt-in external
@@ -69,18 +71,12 @@ inline std::size_t find_string_special(const unsigned char* data, std::size_t n)
    std::size_t i = 0;
    for (; i + 8 <= n; i += 8)
    {
-        std::uint64_t word = 0;
-        std::memcpy(&word, data + i, sizeof(word));
-        if (swar_string_special(word) != 0)
+        const std::uint64_t special = swar_string_special(read_eight_bytes(data + i));
+        if (special != 0)
        {
-            // a special byte is in this word; locate it (endian-agnostic)
-            for (std::size_t j = 0; j < 8; ++j)
-            {
-                if (is_string_special(data[i + j]))
-                {
-                    return i + j;
-                }
-            }
+            // the lowest flagged byte is the first special one: the borrows of
+            // the subtractions can only flag bytes above a true hit
+            return i + (static_cast<std::size_t>(count_trailing_zeros(special)) / 8);
        }
    }
    for (; i < n; ++i)
@@ -114,8 +110,7 @@ inline std::size_t find_ascii_copyable_run(const unsigned char* data, std::size_
    std::size_t i = 0;
    for (; i + 8 <= n; i += 8)
    {
-        std::uint64_t v = 0;
-        std::memcpy(&v, data + i, sizeof(v));
+        const std::uint64_t v = read_eight_bytes(data + i);
        const std::uint64_t q = v ^ 0x2222222222222222ull; // '"'  (0x22)
        const std::uint64_t b = v ^ 0x5C5C5C5C5C5C5C5Cull; // '\\' (0x5C)
        const std::uint64_t d = v ^ 0x7F7F7F7F7F7F7F7Full; // DEL  (0x7F)
@@ -126,7 +121,9 @@ inline std::size_t find_ascii_copyable_run(const unsigned char* data, std::size_
                                   | (v & high);               // >= 0x80
        if (stop != 0)
        {
-            break;
+            // the lowest flagged byte is the first one to stop at (see
+            // find_string_special())
+            return i + (static_cast<std::size_t>(count_trailing_zeros(stop)) / 8);
        }
    }
    for (; i < n; ++i)
@@ -253,12 +250,18 @@ inline std::size_t scalar_string_bulk_run(const unsigned char* data, std::size_t
        {
            break; // end of buffer, or a quote/escape/control byte
        }
-        const std::size_t seq = validate_one_utf8(data + pos, n - pos);
-        if (seq == 0)
+        // a run of multi-byte sequences (e.g. CJK text) is validated sequence
+        // by sequence without searching for the next special byte in between
+        do
        {
-            break; // ill-formed or truncated: let the byte path diagnose it
+            const std::size_t seq = validate_one_utf8(data + pos, n - pos);
+            if (seq == 0)
+            {
+                return pos; // ill-formed or truncated: let the byte path diagnose it
+            }
+            pos += seq;
        }
-        pos += seq;
+        while (pos < n && data[pos] >= 0x80u);
    }
    return pos;
 }
@@ -273,8 +276,7 @@ inline std::size_t find_string_delimiter(const unsigned char* data, std::size_t
    std::size_t i = 0;
    for (; i + 8 <= n; i += 8)
    {
-        std::uint64_t v = 0;
-        std::memcpy(&v, data + i, sizeof(v));
+        const std::uint64_t v = read_eight_bytes(data + i);
        const std::uint64_t q = v ^ 0x2222222222222222ull;
        const std::uint64_t b = v ^ 0x5C5C5C5C5C5C5C5Cull;
        const std::uint64_t hit = ((q - ones) & ~q & high)
@@ -282,14 +284,8 @@ inline std::size_t find_string_delimiter(const unsigned char* data, std::size_t
                                  | ((v - 0x2020202020202020ull) & ~v & high);
        if (hit != 0)
        {
-            for (std::size_t j = 0; j < 8; ++j)
-            {
-                const unsigned char c = data[i + j];
-                if (c == '\"' || c == '\\' || c < 0x20u)
-                {
-                    return i + j;
-                }
-            }
+            // the lowest flagged byte is the first delimiter (see find_string_special())
+            return i + (static_cast<std::size_t>(count_trailing_zeros(hit)) / 8);
        }
    }
    for (; i < n; ++i)
@@ -320,5 +316,50 @@ inline std::size_t string_bulk_run(const unsigned char* data, std::size_t n) noe
    return scalar_string_bulk_run(data, n);
 }

+// Decode the 4 hex digits at [data, data+4) - the digits following a `\u`
+// escape - into a codepoint 0x0000..0xFFFF via one table lookup per byte
+// (after yyjson's read_hex_u16), or return -1 if any of the 4 bytes is not a
+// hex digit ('0'..'9', 'A'..'F', 'a'..'f'). The caller must already have
+// checked that 4 bytes are available; used by lexer::get_codepoint()'s
+// contiguous fast path. On -1 it falls back to the byte-at-a-time loop, which
+// stops at the first invalid digit, so the reported error and position are
+// unaffected by this fast path.
+inline int hex_codepoint(const unsigned char* data) noexcept
+{
+    static const std::array<std::uint8_t, 256> hex_digit_table = // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+    {
+        {
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 00..0F
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 10..1F
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 20..2F
+            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 30..3F ('0'..'9')
+            0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 40..4F ('A'..'F')
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 50..5F
+            0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 60..6F ('a'..'f')
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 70..7F
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 80..8F
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 90..9F
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // A0..AF
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // B0..BF
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // C0..CF
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // D0..DF
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // E0..EF
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF  // F0..FF
+        }
+    };
+
+    const std::uint8_t d0 = hex_digit_table[data[0]];
+    const std::uint8_t d1 = hex_digit_table[data[1]];
+    const std::uint8_t d2 = hex_digit_table[data[2]];
+    const std::uint8_t d3 = hex_digit_table[data[3]];
+    // every valid digit is <= 0xF; the combined OR only exceeds it if at
+    // least one of the four bytes was not a hex digit (looked up as 0xFF)
+    if ((d0 | d1 | d2 | d3) > 0x0F)
+    {
+        return -1;
+    }
+    return (d0 << 12) | (d1 << 8) | (d2 << 4) | d3;
+}
+
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
@@ -56,7 +56,6 @@ class json_pointer

  public:
    // for backwards compatibility accept BasicJsonType
-    /// @sa https://json.nlohmann.me/api/json_pointer/string_t/
    using string_t = typename string_t_helper<RefStringType>::type;

    /// @brief create JSON pointer
@@ -0,0 +1,130 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <cstring> // memcpy
+#include <new> // operator new, placement new
+#include <string> // string
+
+#include <nlohmann/json.hpp>
+#include <nlohmann/detail/view/macro_scope.hpp>
+#include <nlohmann/detail/view/node.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace view
+{
+
+/// storage of a parsed document; heap-allocated (header and an initial node
+/// array in one block) so that views survive moves of the owning document
+struct document_data
+{
+    const char* src = nullptr;
+    std::size_t size = 0;
+    node* tape = nullptr;
+    std::size_t tape_size = 0;
+    std::size_t tape_cap = 0;
+    node* inline_tape = nullptr; ///< node array allocated together with this header
+    std::size_t inline_cap = 0;
+    std::string arena{}; ///< decoded strings that contained escapes // NOLINT(readability-redundant-member-init)
+    std::string owned{}; ///< owned copy of the input, if any // NOLINT(readability-redundant-member-init)
+    std::array<const char*, 4> base = {{nullptr, nullptr, nullptr, nullptr}}; ///< string bases: source, arena (indexed by flags & node_flags::storage)
+    bool discarded = true;
+
+    /// one allocation for the header and room for `nodes` nodes; large
+    /// documents get a separate node array instead (so it can be trimmed)
+    static document_data* create(std::size_t nodes)
+    {
+        nodes = nodes <= 256 ? nodes : 0;
+        void* mem = ::operator new (sizeof(document_data) + (nodes * sizeof(node)));
+        auto* d = new (mem) document_data(); // NOLINT(cppcoreguidelines-owning-memory): owned by the returned pointer, freed by deleter
+        // (aligned: sizeof is a multiple of the alignment; through void*, as GCC's -Wcast-align wants)
+        d->inline_tape = static_cast<node*>(static_cast<void*>(static_cast<char*>(mem) + sizeof(document_data))); // NOLINT(bugprone-casting-through-void)
+        d->inline_cap = nodes;
+        d->tape = d->inline_tape;
+        d->tape_cap = nodes;
+        return d;
+    }
+
+    struct deleter
+    {
+        void operator()(document_data* d) const noexcept
+        {
+            d->~document_data();
+            ::operator delete (d);
+        }
+    };
+
+    document_data() noexcept = default;
+    document_data(const document_data&) = delete;
+    document_data(document_data&&) = delete;
+    document_data& operator=(const document_data&) = delete;
+    document_data& operator=(document_data&&) = delete;
+    ~document_data()
+    {
+        release();
+    }
+
+    void release() noexcept
+    {
+        if (tape != inline_tape)
+        {
+            ::operator delete (tape);
+        }
+        tape = inline_tape;
+        tape_cap = inline_cap;
+    }
+
+    /// make room for n nodes; keeps the first tape_size nodes
+    void reserve(std::size_t n)
+    {
+        if (n <= tape_cap)
+        {
+            return;
+        }
+        node* fresh = static_cast<node*>(::operator new (n * sizeof(node)));
+        if (tape_size != 0)
+        {
+            std::memcpy(fresh, tape, tape_size * sizeof(node));
+        }
+        release();
+        tape = fresh;
+        tape_cap = n;
+    }
+
+    const char* str(const node& n) const noexcept
+    {
+        return base[n.flags & node_flags::storage] + n.off;
+    }
+
+    /// the node after n's subtree (containers span `next` nodes, scalars one)
+    static NLOHMANN_VIEW_ALWAYS_INLINE const node* after(const node* n) noexcept
+    {
+        return n + (is_container(*n) ? n->next : 1u);
+    }
+
+    /// first element (array) or first key (object) of a container
+    static NLOHMANN_VIEW_ALWAYS_INLINE const node* first_child(const node* n) noexcept
+    {
+        return n + 1;
+    }
+
+    /// end of the elements of a container
+    static NLOHMANN_VIEW_ALWAYS_INLINE const node* child_end(const node* n) noexcept
+    {
+        return n + n->next;
+    }
+};
+
+}  // namespace view
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
@@ -0,0 +1,63 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+// Macros of json_view.hpp and its detail headers. json.hpp undefines its own
+// macros at its end (macro_unscope.hpp), so the view defines the few it needs
+// under its own prefix; json_view.hpp undefines them all at its end
+// (detail/view/macro_unscope.hpp). Configuration that json.hpp undefines is
+// read from detail::abi_config instead.
+
+#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+    #define NLOHMANN_VIEW_HAS_CPP_17 1
+#else
+    #define NLOHMANN_VIEW_HAS_CPP_17 0
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+    #define NLOHMANN_VIEW_LIKELY(x) __builtin_expect(!!(x), 1)
+    #define NLOHMANN_VIEW_UNLIKELY(x) __builtin_expect(!!(x), 0)
+    #define NLOHMANN_VIEW_ALWAYS_INLINE inline __attribute__((always_inline))
+    #define NLOHMANN_VIEW_NOINLINE __attribute__((noinline))
+#elif defined(_MSC_VER)
+    #define NLOHMANN_VIEW_LIKELY(x) (x)
+    #define NLOHMANN_VIEW_UNLIKELY(x) (x)
+    #define NLOHMANN_VIEW_ALWAYS_INLINE __forceinline
+    #define NLOHMANN_VIEW_NOINLINE __declspec(noinline)
+#else
+    #define NLOHMANN_VIEW_LIKELY(x) (x)
+    #define NLOHMANN_VIEW_UNLIKELY(x) (x)
+    #define NLOHMANN_VIEW_ALWAYS_INLINE inline
+    #define NLOHMANN_VIEW_NOINLINE
+#endif
+
+// exceptions as in json.hpp (JSON_NOEXCEPTION, JSON_THROW_USER)
+#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
+    #define NLOHMANN_VIEW_THROW(exception) throw exception
+#else
+    #include <cstdlib>
+    // (the exception is built first, so that the arguments of the throwing
+    // helpers count as used; the program ends anyway)
+    #define NLOHMANN_VIEW_THROW(exception) (static_cast<void>(exception), std::abort())
+#endif
+#if defined(JSON_THROW_USER)
+    #undef NLOHMANN_VIEW_THROW
+    #define NLOHMANN_VIEW_THROW JSON_THROW_USER
+#endif
+
+// the parser stores a node's first word at once where the layout of `node` is
+// known to be little-endian (MSVC targets are); elsewhere field by field
+#if (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || defined(_MSC_VER)
+    #define NLOHMANN_VIEW_LITTLE_ENDIAN 1
+#else
+    #define NLOHMANN_VIEW_LITTLE_ENDIAN 0
+#endif
+
+/// sixteen checks at fixed offsets 0..15
+#define NLOHMANN_VIEW_REPEAT16(X) X(0) X(1) X(2) X(3) X(4) X(5) X(6) X(7) X(8) X(9) X(10) X(11) X(12) X(13) X(14) X(15)
@@ -0,0 +1,20 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+// undefine the macros of detail/view/macro_scope.hpp (at the end of json_view.hpp)
+
+#undef NLOHMANN_VIEW_HAS_CPP_17
+#undef NLOHMANN_VIEW_LIKELY
+#undef NLOHMANN_VIEW_UNLIKELY
+#undef NLOHMANN_VIEW_ALWAYS_INLINE
+#undef NLOHMANN_VIEW_NOINLINE
+#undef NLOHMANN_VIEW_THROW
+#undef NLOHMANN_VIEW_LITTLE_ENDIAN
+#undef NLOHMANN_VIEW_REPEAT16
@@ -0,0 +1,97 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstring> // memcpy
+
+#include <nlohmann/json.hpp>
+#include <nlohmann/detail/view/macro_scope.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace view
+{
+
+// the node kinds are value_t values; the tests of is_container() and of the
+// number kinds depend on this numbering
+static_assert(static_cast<std::uint8_t>(value_t::null) == 0 && static_cast<std::uint8_t>(value_t::object) == 1
+              && static_cast<std::uint8_t>(value_t::array) == 2 && static_cast<std::uint8_t>(value_t::string) == 3
+              && static_cast<std::uint8_t>(value_t::boolean) == 4 && static_cast<std::uint8_t>(value_t::number_integer) == 5
+              && static_cast<std::uint8_t>(value_t::number_unsigned) == 6 && static_cast<std::uint8_t>(value_t::number_float) == 7,
+              "the node format depends on the numbering of value_t");
+
+/// node flags
+struct node_flags
+{
+    static constexpr std::uint8_t escaped = 1; ///< string payload lives in the decode arena, not the source
+    static constexpr std::uint8_t storage = 3; ///< mask: where a string or number token lives (index into document_data::base)
+    static constexpr std::uint8_t is_true = 4; ///< boolean value
+};
+
+/// One entry of the flat index, in document order. An object's members are
+/// stored as key node followed by the value's subtree. Integers keep their
+/// converted 64-bit value in the len/next bytes (the node after a scalar is
+/// always the next one, and the token length follows from `extra`).
+struct node
+{
+    std::uint8_t kind;   ///< value_t
+    std::uint8_t flags;  ///< node_flags
+    std::uint16_t extra; ///< numbers: integer digits (low byte) and fraction digits (high byte), 255 = "many"; otherwise 0
+    std::uint32_t off;   ///< source offset (string content, number token, literal, bracket); arena offset if node_flags::escaped
+    std::uint32_t len;   ///< string: decoded bytes; float: token bytes; array/object: element count
+    std::uint32_t next;  ///< array/object: number of nodes of the subtree (its extent in the enclosing sequence)
+};
+static_assert(sizeof(node) == 16, "node must stay 16 bytes");
+
+NLOHMANN_VIEW_ALWAYS_INLINE bool is_container(const node& n) noexcept
+{
+    return static_cast<unsigned>(n.kind) - 1u <= 1u;
+}
+
+/// the converted value of an integer node (stored in len/next)
+NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t integer_bits(const node& n) noexcept
+{
+    std::uint64_t v = 0;
+    std::memcpy(&v, reinterpret_cast<const unsigned char*>(&n) + 8, 8); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+    return v;
+}
+
+NLOHMANN_VIEW_ALWAYS_INLINE void set_integer_bits(node& n, std::uint64_t v) noexcept
+{
+    std::memcpy(reinterpret_cast<unsigned char*>(&n) + 8, &v, 8); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+}
+
+/// token length of a number node
+NLOHMANN_VIEW_ALWAYS_INLINE std::uint32_t number_length(const node& n) noexcept
+{
+    return n.kind == static_cast<std::uint8_t>(value_t::number_float) ? n.len
+           : (n.extra & 0xFFu) + (n.kind == static_cast<std::uint8_t>(value_t::number_integer) ? 1u : 0u);
+}
+
+/// estimated number of nodes for an input of `size` bytes (one node per ~12
+/// bytes covers typical documents without regrowth)
+inline std::size_t estimate_nodes(std::size_t size) noexcept
+{
+    return (size / 12) + 16;
+}
+
+/// estimated number of nodes for the input [src, src + size): pretty-printed
+/// input (whitespace after the first byte) needs about a node per 12 bytes,
+/// minified input up to one per 4 (yyjson tells the two apart the same way)
+inline std::size_t estimate_nodes(const char* src, std::size_t size) noexcept
+{
+    return size >= 2 && (src[1] == ' ' || src[1] == '\n' || src[1] == '\r' || src[1] == '\t') ? estimate_nodes(size) : (size / 4) + 16;
+}
+
+}  // namespace view
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
@@ -0,0 +1,189 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-FileCopyrightText: 2020 YaoYuan <https://github.com/ibireme/yyjson>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t, uint16_t, uint64_t
+#include <cstring> // memcpy
+
+#include <nlohmann/json.hpp>
+#include <nlohmann/detail/view/macro_scope.hpp>
+
+// Scanning primitives of the view's parser. The unrolled checks at fixed
+// offsets follow yyjson (https://github.com/ibireme/yyjson, MIT license): the
+// loads do not depend on each other, so the CPU can run ahead. Words are read
+// with read_eight_bytes(), so nothing here depends on the byte order.
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace view
+{
+
+/// 1 for bytes that may appear verbatim in a string: 0x20..0x7F except '"' and '\\'
+inline const std::uint8_t* string_plain() noexcept
+{
+    static const std::array<std::uint8_t, 256> table =
+    {
+        {
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x00..0x1F
+            1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x20..0x3F ('"')
+            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, // 0x40..0x5F ('\\')
+            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x60..0x7F
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x80..0x9F
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xA0..0xBF
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xC0..0xDF
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xE0..0xFF
+        }
+    };
+    return table.data();
+}
+
+NLOHMANN_VIEW_ALWAYS_INLINE bool is_digit(unsigned char c) noexcept
+{
+    return static_cast<unsigned char>(c - '0') <= 9;
+}
+
+/// two bytes as they are in memory (only compared with byte-symmetric patterns)
+NLOHMANN_VIEW_ALWAYS_INLINE std::uint16_t load16(const unsigned char* p) noexcept
+{
+    std::uint16_t w = 0;
+    std::memcpy(&w, p, 2);
+    return w;
+}
+
+/// Advance over plain string bytes and well-formed UTF-8. Stops at a quote,
+/// a backslash, a control character, ill-formed UTF-8, or the end. The first
+/// 16 bytes are checked one by one, so that the position advances by
+/// constants in predicted branches (most strings are short); longer runs
+/// continue eight bytes at a time.
+NLOHMANN_VIEW_ALWAYS_INLINE const unsigned char* scan_string_run(const unsigned char* p, const unsigned char* e) noexcept
+{
+    const std::uint8_t* plain = string_plain();
+    for (;;)
+    {
+        if (e - p >= 16)
+        {
+#define NLOHMANN_VIEW_STEP(i) if (NLOHMANN_VIEW_LIKELY(plain[p[i]] != 0)) {} else { p += (i); goto stop; }
+            NLOHMANN_VIEW_REPEAT16(NLOHMANN_VIEW_STEP)
+#undef NLOHMANN_VIEW_STEP
+            p += 16;
+            while (e - p >= 8)
+            {
+                const std::uint64_t special = swar_string_special(read_eight_bytes(p));
+                if (special != 0)
+                {
+                    p += count_trailing_zeros(special) / 8;
+                    goto stop;
+                }
+                p += 8;
+            }
+            continue;
+        }
+        while (p != e && plain[*p] != 0)
+        {
+            ++p;
+        }
+        if (p == e)
+        {
+            return p;
+        }
+stop:
+        if (*p < 0x80)
+        {
+            return p; // quote, backslash, or control character
+        }
+        // non-ASCII: a run of well-formed sequences (the library's check, so
+        // that exactly what json::parse accepts is accepted)
+        do
+        {
+            const std::size_t n = validate_one_utf8(p, static_cast<std::size_t>(e - p));
+            if (n == 0)
+            {
+                return p;
+            }
+            p += n;
+        }
+        while (p != e && *p >= 0x80);
+    }
+}
+
+/// advance over ASCII digits
+NLOHMANN_VIEW_ALWAYS_INLINE const unsigned char* skip_digits(const unsigned char* p, const unsigned char* e) noexcept
+{
+    while (e - p >= 16)
+    {
+#define NLOHMANN_VIEW_STEP(i) if (NLOHMANN_VIEW_LIKELY(is_digit(p[i]))) {} else { return p + (i); }
+        NLOHMANN_VIEW_REPEAT16(NLOHMANN_VIEW_STEP)
+#undef NLOHMANN_VIEW_STEP
+        p += 16;
+    }
+    while (p != e && is_digit(*p))
+    {
+        ++p;
+    }
+    return p;
+}
+
+/// powers of ten up to 10^19 as integers
+inline std::uint64_t int_pow10(unsigned k) noexcept
+{
+    static const std::array<std::uint64_t, 20> table =
+    {
+        {
+            1u, 10u, 100u, 1000u, 10000u, 100000u, 1000000u, 10000000u, 100000000u, 1000000000u,
+            10000000000u, 100000000000u, 1000000000000u, 10000000000000u, 100000000000000u, 1000000000000000u,
+            10000000000000000u, 100000000000000000u, 1000000000000000000u, 10000000000000000000u
+        }
+    };
+    return table[k];
+}
+
+/// value of 0 < k < 8 digits at p in one step if [p, p + 8) lies below
+/// limit, else one digit at a time (whole blocks of eight digits are read by
+/// parse_upto19() directly)
+NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t parse_upto8(const unsigned char* p, unsigned k, const unsigned char* limit) noexcept
+{
+    if (NLOHMANN_VIEW_LIKELY(limit - p >= 8))
+    {
+        // move the k digits to the top and pad the vacated low bytes with '0'
+        const unsigned shift = 8 * (8 - k);
+        return parse_eight_digits((read_eight_bytes(p) << shift) | (0x3030303030303030u >> (8 * k)));
+    }
+    std::uint64_t v = 0;
+    for (unsigned i = 0; i < k; ++i)
+    {
+        v = (v * 10) + static_cast<std::uint64_t>(p[i] - '0');
+    }
+    return v;
+}
+
+/// value of k <= 19 digits at p
+NLOHMANN_VIEW_ALWAYS_INLINE std::uint64_t parse_upto19(const unsigned char* p, unsigned k, const unsigned char* limit) noexcept
+{
+    std::uint64_t w = 0;
+    while (k >= 8)
+    {
+        // (eight digits of the token: they lie below limit)
+        w = (w * 100000000u) + parse_eight_digits(read_eight_bytes(p));
+        p += 8;
+        k -= 8;
+    }
+    if (k != 0)
+    {
+        w = (w * int_pow10(k)) + parse_upto8(p, k, limit);
+    }
+    return w;
+}
+
+}  // namespace view
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Niels Lohmann	27468fa77e	Test the C++11 stand-in for std::string_view of json_view Six members of string_ref (length, begin, end, operator[], operator!=, and operator<<) were not reached before C++17, where string_ref is std::string_view. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-29 09:53:48 +02:00
Niels Lohmann	a49d6e2e3b	Remove the eight-digit case of the view's digit parser Since whole blocks of eight digits are read directly, parse_upto8() only gets fewer than eight digits; its eight-digit case was dead code. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-29 09:52:19 +02:00
Niels Lohmann	58ac756134	Address the cpplint findings of the view's parser The exponent of the overflow check is an std::int64_t instead of a long (runtime/int). Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-29 09:34:11 +02:00
Niels Lohmann	7917cfa0f4	Read whole blocks of eight digits of json_view directly A block of eight digits of a number token lies inside the input (the digits were counted while scanning, or are recorded in the digit layout), so parse_upto19() reads it without the bounds check of the last, partial block. Traversing canada.json: -11% instructions, -6% cycles. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-29 07:20:09 +02:00
Niels Lohmann	b5da87a5e3	Classify a NUL inside a string of json_view as a control character json::parse ends the input at a NUL only between values (where it does at all); inside a string, a NUL is a control character that must be escaped. The view reported it as a missing closing quote. (Only the error code differed: the exception comes from the library parser.) Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-29 04:49:37 +02:00
Niels Lohmann	6d479d13ce	Test the overflow check of json_view at the largest double Numbers of more than 19 digits at the boundary of the largest double are decided by the locale-aware fallback of the overflow check. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-29 03:49:32 +02:00
Niels Lohmann	ea5a1caf28	Address the clang-tidy findings of the view's parser - tables as std::array; the frames of the first 64 levels stay a C array (not initialized on purpose, NOLINT) - \u escapes are decoded with the library's hex_codepoint() instead of a second table - the parse failure is private, with an accessor; the special member functions of the builder are all declared - no nested conditional operators; explicit parentheses; a repeated branch body merged; auto for casts - the test's C arrays, fixed seed, and escaped literals are marked, as in the other tests Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-29 03:49:31 +02:00
Niels Lohmann	edfcff33c6	Keep the arguments of the view's throw helpers used without exceptions With JSON_NOEXCEPTION, NLOHMANN_VIEW_THROW(e) was std::abort() alone, so the parameters of the functions that build the exceptions were unused, a warning that the builds with -Werror turn into an error. The exception is now evaluated before std::abort(); the program ends anyway. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-29 03:49:30 +02:00
Niels Lohmann	a14ac39bdd	Add the one-pass parser of json_view (internal) The builder parses JSON text in one pass into the node index: strings and numbers stay in the source (escaped strings are decoded into an arena), integers are converted while their digits are in cache, and floats keep their digit layout for a later conversion. It accepts exactly what json::parse accepts, for every combination of comments and trailing commas, with and without a terminating NUL, and with JSON_STRICT_NUL_HANDLING. Parse state lives in a local cursor whose address never escapes, so that it stays in registers; out-of-line helpers (errors, regrowth, escapes, comments) are members of the builder and get the positions they need. The value dispatch is expanded once for array elements and once for member values. Literals are compared with memcmp and words read in a fixed byte order, so nothing depends on the platform's byte order. Error messages come with the public classes. Tests (unit-json_view_builder.cpp): accept/reject and values against json::parse for handwritten, generated, and damaged documents under all option combinations, from std::string and from exact-size buffers (no read past the input under AddressSanitizer), deep nesting up to 100,000 levels, NUL/BOM/whitespace cases, and the test-suite files. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-29 03:49:30 +02:00
Niels Lohmann	1ab017bbfe	Add the node index and scanning primitives of json_view (internal) Internal parts of the zero-copy view (#5295), under detail/view and not included by json.hpp, so that users of json.hpp compile nothing of it: - macro_scope.hpp/macro_unscope.hpp: the few macros the view needs, under its own prefix (json.hpp undefines its own at its end); the throw macro honors JSON_NOEXCEPTION and JSON_THROW_USER like JSON_THROW - string_ref.hpp: std::string_view from C++17 on, else a small stand-in - node.hpp: the 16-byte node of the index; its kinds are value_t values (checked by a static_assert) - document_data.hpp: the storage of a parsed document (node array, decode arena, owned input) - scan.hpp: string and digit scanning with unrolled checks at fixed offsets (after yyjson) and the library's SWAR and UTF-8 checks, independent of the byte order Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-29 03:49:29 +02:00
Niels Lohmann	6936b95a65	Keep the behavior-changing configuration readable after json.hpp json.hpp undefines JSON_STRICT_NUL_HANDLING and JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON at its end. Code that builds on the library after it, such as the planned json_view.hpp, reads them from detail::abi_config instead. The constants live in the ABI namespace, which already encodes both settings, so they always match the basic_json in use. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-29 03:49:28 +02:00
Niels Lohmann	a08f5501a7	Decode \u escapes with a table in the lexer get_codepoint() read the four hex digits of a \u escape with four calls to get(), each classified by a chain of range comparisons. For contiguous input, get_codepoint_bulk() now decodes them with one lookup per byte (hex_codepoint() in string_scan.hpp, after yyjson's read_hex_u16): a 256-entry table maps a byte to its value, or 0xFF for anything else, and an invalid digit shows in the OR of the four values. It then skips the four bytes and updates the position counters as four get() calls would. If a digit is invalid or fewer than four bytes are left, it changes nothing and the existing loop runs, so errors are reported with the same message and position as before. json::parse, best of 5 runs in separate processes (M1 Max): the escaped twitter.json (every non-ASCII character as \u) -13.6%, all other files within 0.3%. Tests compare the contiguous and the streaming path (value or exception message) for valid escapes, surrogate pairs, truncated and invalid digits at every position, and 3,000 seeded random escapes. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-29 03:49:27 +02:00
Niels Lohmann	31789f51cf	Find the stop byte of a string run without a byte loop find_string_special() and find_ascii_copyable_run() test eight bytes at a time, but located the stopping byte inside a word with a byte loop. The lowest flagged byte of the SWAR tests is always a true hit (the borrows of the subtractions can only flag bytes above one), so its index is now the trailing-zero count of the mask; words are read in little-endian order on every platform, so this does not depend on the byte order. scalar_string_bulk_run() validates a run of multi-byte UTF-8 sequences one after another instead of searching for the next special byte in between, which helps text in non-Latin scripts. The kernels serve the lexer's contiguous fast path, the serializer, and the binary formats. New tests compare all three with byte-by-byte reference scans on 100,000 generated buffers at three alignments; the portable fallback of count_trailing_zeros() was checked against the builtin. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-29 03:49:26 +02:00
Niels Lohmann	f295970fb6	Convert floats with Eisel-Lemire when std::from_chars is unavailable Float tokens that Clinger's fast path cannot convert (e.g. the 17-digit coordinates of canada.json) went to strtod unless std::from_chars was available. It is not used in C++11/14, and not with libc++, which does not define __cpp_lib_to_chars. The Eisel-Lemire algorithm (after fast_float's compute_float) now converts them with integer arithmetic, correctly rounded for any token with at most 19 significant digits. Longer tokens are truncated; the result is used if w and w + 1 round alike, else strtod decides as before. Overflow still yields infinity (out_of_range.406). The table of powers of five (fast_float's) lives in pow5_table.hpp; a unit test recomputes every entry with big-integer arithmetic. Further tests: known values generated with Python (whose float() is correctly rounded), 200,000 round trips through to_chars, and the 128-bit multiplication and leading-zero count against big-integer references (both with and without a 128-bit type). Checked against strtod on 6.5 million tokens, among them 60,000 exact halfway cases: no difference. json::parse on canada.json: -8.6% (C++11), -7.6% (C++17, Apple clang); other files unchanged. Compile time of a TU including json.hpp: +0.7%. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-29 03:49:25 +02:00
Niels Lohmann	f6c115a9a6	Move the float conversion chain out of the lexer lexer::convert_number() converted float tokens with std::from_chars (when available), Clinger's fast path, and the locale-aware strtod fallback, all as lexer members. They are now free functions in number_parse.hpp: - convert_float_fast(): std::from_chars, then Clinger's fast path, skipped when the mantissa has too many significant digits - convert_float_locale_aware(): strtof/strtod/strtold with the decimal point of the current locale, retried when the locale changed (#5198) so that other code converting JSON number tokens gets the same values. No change in behavior; the lexer no longer includes <clocale> and <cstdlib>. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-29 03:49:24 +02:00
Niels Lohmann	33ef25099d	Keep external headers as #include when amalgamating A header that builds on json.hpp (such as the planned json_view.hpp) must not inline json.hpp: its single-header version would contain a second copy of the library, and that copy would change with every library change. The optional config key "external" lists include paths that are kept as #include directives. Only the first directive per path is kept; repeated ones are commented out, as the tool already does for inlined headers. config_json_view.json uses it for json_view.hpp; the existing configs do not set it, and json.hpp and json_fwd.hpp regenerate byte-identically. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-29 03:49:24 +02:00
				`@@ -1 +0,0 @@`
				`Container is std::vector<std::pair<const Key, T>>: true`