Merge remote-tracking branch 'origin/json-view/14-view-compare' into HEAD

Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Merge remote-tracking branch 'origin/json-view/13-view-dump' into HEAD
2026-10-06 14:40:32 +00:00 · 2026-10-04 17:20:32 +02:00 · 2026-10-04 17:20:28 +02:00 · 2026-10-04 17:20:23 +02:00 · 2026-10-04 17:20:19 +02:00 · 2026-10-04 17:20:14 +02:00
90 changed files with 861 additions and 13417 deletions
@@ -16,9 +16,6 @@ only_commits:

 environment:
  matrix:
-    # The Visual Studio 2017 jobs compile everything with /std:c++17, so they
-    # only build the C++17 variant of each test, split into two jobs each to
-    # stay below AppVeyor's 60-minute limit per job.
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      configuration: Debug
      platform: x86
@@ -37,13 +34,7 @@ environment:
      configuration: Release
      platform: x86
      CXX_FLAGS: "/permissive- /std:c++17 /utf-8 /W4 /WX"
-      CMAKE_OPTIONS: "-DJSON_TestStandards=17 -DJSON_TestShard=0/2"
-      GENERATOR: Visual Studio 15 2017
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      configuration: Release
-      platform: x86
-      CXX_FLAGS: "/permissive- /std:c++17 /utf-8 /W4 /WX"
-      CMAKE_OPTIONS: "-DJSON_TestStandards=17 -DJSON_TestShard=1/2"
+      CMAKE_OPTIONS: ""
      GENERATOR: Visual Studio 15 2017

    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
@@ -64,13 +55,7 @@ environment:
      configuration: Release
      platform: x64
      CXX_FLAGS: "/permissive- /std:c++17 /Zc:__cplusplus /utf-8 /W4 /WX"
-      CMAKE_OPTIONS: "-DJSON_TestStandards=17 -DJSON_TestShard=0/2"
-      GENERATOR: Visual Studio 15 2017
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      configuration: Release
-      platform: x64
-      CXX_FLAGS: "/permissive- /std:c++17 /Zc:__cplusplus /utf-8 /W4 /WX"
-      CMAKE_OPTIONS: "-DJSON_TestStandards=17 -DJSON_TestShard=1/2"
+      CMAKE_OPTIONS: ""
      GENERATOR: Visual Studio 15 2017

 init:
@@ -81,7 +66,7 @@ install:
  - if "%platform%"=="x86"    set GENERATOR_PLATFORM=Win32

 before_build:
-  - cmake . -G "%GENERATOR%" -A "%GENERATOR_PLATFORM%" -DCMAKE_CXX_FLAGS="%CXX_FLAGS%" -DCMAKE_IGNORE_PATH="C:/Program Files/Git/usr/bin" -DJSON_BuildTests=On %CMAKE_OPTIONS%
+  - cmake . -G "%GENERATOR%" -A "%GENERATOR_PLATFORM%" -DCMAKE_CXX_FLAGS="%CXX_FLAGS%" -DCMAKE_IGNORE_PATH="C:/Program Files/Git/usr/bin" -DJSON_BuildTests=On "%CMAKE_OPTIONS%"

 build_script:
  - cmake --build . --config "%configuration%" --parallel 2
@@ -17,11 +17,11 @@ permissions:
  contents: read

 jobs:
-  macos-15:
-    runs-on: macos-15 # https://github.com/actions/runner-images/blob/main/images/macos/macos-15-Readme.md
+  macos-14:
+    runs-on: macos-14 # https://github.com/actions/runner-images/blob/main/images/macos/macos-14-Readme.md
    strategy:
      matrix:
-        xcode: ['16.0', '16.1', '16.2', '16.3', '16.4', '26.0.1', '26.1.1', '26.2', '26.3']
+        xcode: ['15.0.1', '15.1', '15.2', '15.3', '15.4']
    env:
      DEVELOPER_DIR: /Applications/Xcode_${{ matrix.xcode }}.app/Contents/Developer

@@ -36,11 +36,11 @@ jobs:
      - name: Test
        run: cd build ; ctest -j 10 --output-on-failure

-  macos-26:
-    runs-on: macos-26 # https://github.com/actions/runner-images/blob/main/images/macos/macos-26-arm64-Readme.md
+  macos-15:
+    runs-on: macos-15 # https://github.com/actions/runner-images/blob/main/images/macos/macos-15-Readme.md
    strategy:
      matrix:
-        xcode: ['26.4.1', '26.5', '26.6']
+        xcode: ['16.0', '16.1', '16.2', '16.3', '16.4', '26.0.1']
    env:
      DEVELOPER_DIR: /Applications/Xcode_${{ matrix.xcode }}.app/Contents/Developer

@@ -107,7 +107,7 @@ jobs:
    container: ubuntu:24.04
    strategy:
      matrix:
-        target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls, ci_test_disableenumserialization, ci_test_disabletuplereferenceconversion, ci_test_skiplibraryversioncheck, ci_test_simdutf, ci_test_strict_nul_handling, ci_test_delete_deprecated_functions, ci_test_no_thread_local]
+        target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls, ci_test_disableenumserialization, ci_test_disabletuplereferenceconversion, ci_test_skiplibraryversioncheck, ci_test_simdutf, ci_test_strict_nul_handling, ci_test_no_thread_local]
    steps:
      - name: Install build-essential
        run: apt-get update ; apt-get install -y build-essential unzip wget git
@@ -209,7 +209,7 @@ jobs:
    strategy:
      matrix:
        # older GCC docker images (4, 5, 6) fail to check out code
-        compiler: ['7', '8', '9', '10', '11', '12', '13', '14', '15', '16', 'latest']
+        compiler: ['7', '8', '9', '10', '11', '12', '13', '14', '15', 'latest']
    container: gcc:${{ matrix.compiler }}
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -26,7 +26,6 @@ cc_library(
        "include/nlohmann/detail/conversions/from_json.hpp",
        "include/nlohmann/detail/conversions/to_chars.hpp",
        "include/nlohmann/detail/conversions/to_json.hpp",
-        "include/nlohmann/detail/conversions/zmij.hpp",
        "include/nlohmann/detail/exceptions.hpp",
        "include/nlohmann/detail/hash.hpp",
        "include/nlohmann/detail/input/binary_reader.hpp",
@@ -62,7 +62,6 @@ option(JSON_MultipleHeaders                "Use non-amalgamated version of the l
 option(JSON_SystemInclude                  "Include as system headers (skip for clang-tidy)." OFF)
 option(JSON_StrictNulHandling              "Build with strict NUL-byte handling enabled." OFF)
 option(JSON_StrictBinaryUTF8               "Build with UTF-8 checks in the CBOR, UBJSON, BJData, and BSON writers enabled." OFF)
-option(JSON_DeleteDeprecatedFunctions      "Delete the deprecated functions instead of only deprecating them." OFF)

 if (JSON_CI)
    include(ci)
@@ -124,10 +123,6 @@ if (JSON_StrictBinaryUTF8)
    message(STATUS "Strict UTF-8 checks in binary writers enabled (JSON_STRICT_BINARY_UTF8=1)")
 endif()

-if (JSON_DeleteDeprecatedFunctions)
-    message(STATUS "Deprecated functions are deleted (JSON_DELETE_DEPRECATED_FUNCTIONS=1)")
-endif()
-
 if (JSON_Diagnostic_Positions)
    message(STATUS "Diagnostic positions enabled (JSON_DIAGNOSTIC_POSITIONS=1)")
 endif()
@@ -164,7 +159,6 @@ target_compile_definitions(
    $<$<BOOL:${JSON_LegacyDiscardedValueComparison}>:JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1>
    $<$<BOOL:${JSON_StrictNulHandling}>:JSON_STRICT_NUL_HANDLING=1>
    $<$<BOOL:${JSON_StrictBinaryUTF8}>:JSON_STRICT_BINARY_UTF8=1>
-    $<$<BOOL:${JSON_DeleteDeprecatedFunctions}>:JSON_DELETE_DEPRECATED_FUNCTIONS=1>
 )

 target_include_directories(
@@ -1399,7 +1399,6 @@ THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR I

 - The class contains the UTF-8 Decoder from Bjoern Hoehrmann which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright &copy; 2008-2009 [Björn Hoehrmann](https://bjoern.hoehrmann.de/) <bjoern@hoehrmann.de>
 - 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 port of the shortest double-to-decimal conversion of [Żmij](https://github.com/vitaut/zmij) by Victor Zverovich, which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright &copy; 2025 [Victor Zverovich](https://github.com/vitaut)
 - The class contains a copy of [Hedley](https://nemequ.github.io/hedley/) from Evan Nemerson which is licensed as [CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/).
 - The class contains 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, its table of powers of five, and its digit comparison for long numbers from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright &copy; 2021 The fast_float authors
@@ -249,20 +249,6 @@ add_custom_target(ci_test_strict_nul_handling
    COMMENT "Compile and test with strict NUL-byte handling enabled"
 )

-###############################################################################
-# Delete the deprecated functions.
-###############################################################################
-
-add_custom_target(ci_test_delete_deprecated_functions
-    COMMAND ${CMAKE_COMMAND}
-    -DCMAKE_BUILD_TYPE=Debug -GNinja
-    -DJSON_BuildTests=ON -DJSON_FastTests=ON -DJSON_DeleteDeprecatedFunctions=ON
-    -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_delete_deprecated_functions
-    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_delete_deprecated_functions
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_delete_deprecated_functions && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
-    COMMENT "Compile and test with the deprecated functions deleted"
-)
-
 ###############################################################################
 # Disable global UDLs.
 ###############################################################################
@@ -376,7 +362,7 @@ add_custom_target(ci_test_coverage
 # Sanitizers.
 ###############################################################################

-set(CLANG_CXX_FLAGS_SANITIZER "-g -O1 -fsanitize=address -fsanitize=undefined -fsanitize=integer -fsanitize=nullability -fno-omit-frame-pointer -fno-sanitize-recover=all -fno-sanitize=unsigned-integer-overflow -fno-sanitize=unsigned-shift-base -fsanitize-ignorelist=${PROJECT_SOURCE_DIR}/cmake/clang_sanitizer_ignorelist.txt")
+set(CLANG_CXX_FLAGS_SANITIZER "-g -O1 -fsanitize=address -fsanitize=undefined -fsanitize=integer -fsanitize=nullability -fno-omit-frame-pointer -fno-sanitize-recover=all -fno-sanitize=unsigned-integer-overflow -fno-sanitize=unsigned-shift-base")

 add_custom_target(ci_test_clang_sanitizer
    COMMAND CXX=${CLANG_TOOL} CXXFLAGS=${CLANG_CXX_FLAGS_SANITIZER} ${CMAKE_COMMAND}
@@ -722,7 +708,7 @@ ci_get_cmake(4.0.0  CMAKE_4_0_0_BINARY)
 # the tests require CMake 3.13 or later, so they are excluded for CMake 3.5.0
 set(JSON_CMAKE_FLAGS_3_5_0 JSON_Diagnostics JSON_Diagnostic_Positions JSON_GlobalUDLs JSON_ImplicitConversions JSON_DisableEnumSerialization
    JSON_LegacyDiscardedValueComparison JSON_Install JSON_MultipleHeaders JSON_SystemInclude JSON_Valgrind
-    JSON_StrictNulHandling JSON_StrictBinaryUTF8 JSON_DeleteDeprecatedFunctions)
+    JSON_StrictNulHandling JSON_StrictBinaryUTF8)
 set(JSON_CMAKE_FLAGS_3_31_6 JSON_BuildTests ${JSON_CMAKE_FLAGS_3_5_0})
 set(JSON_CMAKE_FLAGS_4_0_0 JSON_BuildTests ${JSON_CMAKE_FLAGS_3_5_0})

@@ -1,8 +0,0 @@
-# Sanitizer ignore list for ci_test_clang_sanitizer (-fsanitize-ignorelist).
-#
-# libstdc++ 14's <format> declares `_Scanner(basic_string_view<_CharT>, size_t __nargs = -1)`, so every std::format
-# call converts -1 to size_t, which -fsanitize=integer reports as implicit-integer-sign-change. This is
-# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=119429, not a bug in this library. Only that check and only <format> are
-# excluded, so implicit sign changes in the library and the tests are still reported.
-[implicit-integer-sign-change]
-src:*/include/c++/*/format
@@ -281,7 +281,6 @@ INSERT INTO searchIndex(name, type, path) VALUES ('Supported Macros', 'Guide', '
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_ASSERT', 'Macro', 'api/macros/json_assert/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_BRACE_INIT_COPY_SEMANTICS', 'Macro', 'api/macros/json_brace_init_copy_semantics/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_CATCH_USER', 'Macro', 'api/macros/json_throw_user/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DELETE_DEPRECATED_FUNCTIONS', 'Macro', 'api/macros/json_delete_deprecated_functions/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DIAGNOSTICS', 'Macro', 'api/macros/json_diagnostics/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DIAGNOSTIC_POSITIONS', 'Macro', 'api/macros/json_diagnostic_positions/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DISABLE_ENUM_SERIALIZATION', 'Macro', 'api/macros/json_disable_enum_serialization/index.html');
@@ -312,7 +311,6 @@ INSERT INTO searchIndex(name, type, path) VALUES ('JSON_TRY_USER', 'Macro', 'api
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_GLOBAL_UDLS', 'Macro', 'api/macros/json_use_global_udls/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_IMPLICIT_CONVERSIONS', 'Macro', 'api/macros/json_use_implicit_conversions/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON', 'Macro', 'api/macros/json_use_legacy_discarded_value_comparison/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS', 'Macro', 'api/macros/json_use_objects_for_enum_keyed_maps/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_SIMDUTF', 'Macro', 'api/macros/json_use_simdutf/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Macros', 'Macro', 'api/macros/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE', 'Macro', 'api/macros/nlohmann_define_derived_type/index.html');
@@ -8,7 +8,7 @@ static basic_json diff(const basic_json& source,
 Creates a [JSON Patch](http://jsonpatch.com) so that value `source` can be changed into the value `target` by calling
 [`patch`](patch.md) function.

-For two JSON values `source` and `target`, the following code always yields `#!cpp true`:
+For two JSON values `source` and `target`, the following code yields always `#!cpp true`:
 ```cpp
 source.patch(diff(source, target)) == target;
 ```
@@ -27,7 +27,7 @@ a JSON patch to convert the `source` to `target`

 ## Exception safety

-Strong guarantee: `source` and `target` are never modified.
+Strong guarantee: if an exception is thrown, there are no changes in the JSON value.

 ## Complexity

@@ -62,9 +62,6 @@ Linear.

 ## Notes

-Floating-point numbers are written with the fewest digits that read back as the same value (for `#!cpp double`; see
-[number handling](../../features/types/number_handling.md#number-serialization)).
-
 Binary values are serialized as an object containing two keys:

 - "bytes": an array of bytes as integers
@@ -102,5 +99,3 @@ Binary values are serialized as an object containing two keys:
 - Error handlers added in version 3.4.0.
 - Serialization of binary values added in version 3.8.0.
 - Error handler `keep` added in version 3.13.0.
- Doubles are written with the shortest digits (Żmij instead of Grisu2) since version 3.13.0; about 0.1% of doubles are
-  written differently, most of them with fewer digits.
@@ -120,12 +120,3 @@ Linear in the size of the input.
 - Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.
 - Extended overload (2) to accept heterogeneous iterator+sentinel pairs (C++20 ranges support) in version 3.13.0.
 - Added `error_handler` parameter in version 3.13.0.
-
-!!! warning "Deprecation"
-
-    - Overload (2) replaces calls to `from_bjdata` with a pointer and a length as first two parameters, which has been
-      deprecated in version 3.13.0. This overload will be removed in version 4.0.0. Please replace all calls like
-      `#!cpp from_bjdata(ptr, len, ...);` with `#!cpp from_bjdata(ptr, ptr+len, ...);`.
-
-    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
-    function.
@@ -106,12 +106,3 @@ Linear in the size of the input.
 ## Version history

 - Added in version 3.13.0.
-
-!!! warning "Deprecation"
-
-    - Overload (2) replaces calls to `from_bon8` with a pointer and a length as first two parameters, which has been
-      deprecated in version 3.13.0. This overload will be removed in version 4.0.0. Please replace all calls like
-      `#!cpp from_bon8(ptr, len, ...);` with `#!cpp from_bon8(ptr, ptr+len, ...);`.
-
-    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
-    function.
@@ -56,10 +56,6 @@ This implementation does exactly follow this approach, as it uses double precisi
 smaller than `-1.79769313486232e+308` and values greater than `1.79769313486232e+308` will be stored as NaN internally
 and be serialized to `null`.

-During deserialization (from JSON text or any of the binary formats), a finite number that does not fit into
-`number_float_t` is rejected with [`out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406), for
-example a double-precision number in a binary format when `number_float_t` is `#!cpp float`.
-
 ### Storage

 Floating-point number values are stored directly inside a `basic_json` type.
@@ -47,9 +47,8 @@ With the default values for `NumberIntegerType` (`std::int64_t`), the default va

 When the default type is used, the maximal integer number that can be stored is `9223372036854775807` (INT64_MAX) and
 the minimal integer number that can be stored is `-9223372036854775808` (INT64_MIN). Integer numbers that are out of
-range will yield over/underflow when used in a constructor. During deserialization (from JSON text or any of the binary
-formats), too large or small integer numbers will automatically be stored as [`number_unsigned_t`](number_unsigned_t.md)
-or [`number_float_t`](number_float_t.md).
+range will yield over/underflow when used in a constructor. During deserialization, too large or small integer numbers
+will automatically be stored as [`number_unsigned_t`](number_unsigned_t.md) or [`number_float_t`](number_float_t.md).

 [RFC 8259](https://tools.ietf.org/html/rfc8259) further states:
 > Note that when such software is used, numbers that are integers and are in the range [-2<sup>53</sup>+1, 2<sup>53</sup>-1] are
@@ -48,9 +48,8 @@ With the default values for `NumberUnsignedType` (`std::uint64_t`), the default

 When the default type is used, the maximal integer number that can be stored is `18446744073709551615` (UINT64_MAX) and
 the minimal integer number that can be stored is `0`. Integer numbers that are out of range will yield over/underflow
-when used in a constructor. During deserialization (from JSON text or any of the binary formats), too large or small
-integer numbers will automatically be stored as [`number_integer_t`](number_integer_t.md) or
-[`number_float_t`](number_float_t.md).
+when used in a constructor. During deserialization, too large or small integer numbers will automatically be stored
+as [`number_integer_t`](number_integer_t.md) or [`number_float_t`](number_float_t.md).

 [RFC 8259](https://tools.ietf.org/html/rfc8259) further states:
 > Note that when such software is used, numbers that are integers and are in the range [-2<sup>53</sup>+1, 2<sup>53</sup>-1] are
@@ -68,8 +68,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
  not valid UTF-8 and `error_handler` is `strict` (the default only if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if `j` or a value nested in it is
-  discarded; example: `"cannot serialize discarded value to BJData"`

 ## Complexity

@@ -122,5 +120,3 @@ Linear in the size of the JSON value `j`.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
  that is not valid UTF-8 unchanged, as before; `strict` (the default if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
- Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
-  array or object was silently skipped, producing invalid BJData.
@@ -58,9 +58,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key is
  not valid UTF-8 and `error_handler` is `strict` (the default only if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if a value nested in `j` is discarded
-  (the top-level value itself is covered by `type_error.317` above, since it must be an object); example:
-  `"cannot serialize discarded value to BSON"`

 ## Complexity

@@ -113,8 +110,6 @@ pass before anything is written.
 - Throws `out_of_range.412` and `out_of_range.415` since version 3.13.0.
 - Linear in the size of `j`, and no longer limited by the call stack for deeply nested values, since version 3.13.0.
 - `out_of_range.415` is now detected before anything is written, like the other exceptions above, since version 3.13.0.
- Throws `type_error.321` for a discarded value nested in `j` since version 3.13.0; previously, it was silently
-  skipped, producing a document whose declared size did not match what was actually written.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
  that is not valid UTF-8 unchanged, as before; `strict` (the default if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316` before anything
@@ -49,8 +49,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
  not valid UTF-8 and `error_handler` is `strict` (the default only if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if `j` or a value nested in it is
-  discarded; example: `"cannot serialize discarded value to CBOR"`

 ## Complexity

@@ -88,5 +86,3 @@ Linear in the size of the JSON value `j`.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
  that is not valid UTF-8 unchanged, as before; `strict` (the default if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
- Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
-  array or object was silently skipped, producing invalid CBOR.
@@ -54,8 +54,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
  `"subtype 70000 is too large for the MessagePack ext type (max 255)"`
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
  not valid UTF-8 and `error_handler` is `strict`
- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if `j` or a value nested in it is
-  discarded; example: `"cannot serialize discarded value to MessagePack"`

 ## Complexity

@@ -110,5 +108,3 @@ Linear in the size of the JSON value `j`.
 - Fixed in version 3.13.0 to serialize `number_integer_t`/`number_unsigned_t` pairs of different width correctly;
  before, integers could be serialized with the wrong value if `number_integer_t` was narrower than
  `number_unsigned_t`.
- Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
-  array or object was silently skipped, producing invalid MessagePack.
@@ -61,8 +61,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
  not valid UTF-8 and `error_handler` is `strict` (the default only if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if `j` or a value nested in it is
-  discarded; example: `"cannot serialize discarded value to UBJSON"`

 ## Complexity

@@ -114,5 +112,3 @@ Linear in the size of the JSON value `j`.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
  that is not valid UTF-8 unchanged, as before; `strict` (the default if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
- Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
-  array or object was silently skipped, producing invalid UBJSON.
@@ -58,13 +58,6 @@ header. See also the [macro overview page](../../features/macros.md).
 - [**JSON_DISABLE_ENUM_SERIALIZATION**](json_disable_enum_serialization.md) - switch off default serialization/deserialization functions for enums
 - [**JSON_DISABLE_TUPLE_REFERENCE_CONVERSION**](json_disable_tuple_reference_conversion.md) - switch off conversion from a one-element tuple of a JSON reference
 - [**JSON_USE_IMPLICIT_CONVERSIONS**](json_use_implicit_conversions.md) - control implicit conversions
- [**JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS**](json_use_objects_for_enum_keyed_maps.md) - opt in to storing maps with enum
-  keys as objects
-
-## Deprecated functions
-
- [**JSON_DELETE_DEPRECATED_FUNCTIONS**](json_delete_deprecated_functions.md) - opt in to deleting the deprecated
-  functions ahead of their removal in version 4.0.0

 ## Comparison behavior

@@ -1,96 +0,0 @@
-# JSON_DELETE_DEPRECATED_FUNCTIONS
-
-```cpp
-#define JSON_DELETE_DEPRECATED_FUNCTIONS /* value */
-```
-
-When defined to `1`, all [deprecated functions](../../community/roadmap.md#removal-of-deprecated-functions) of the
-library are declared as deleted (`= delete`) instead of only being marked as deprecated. Code that still calls one of
-them no longer compiles. This way, you can find all calls that need to be replaced before version 4.0.0 removes these
-functions; the [migration guide](../../integration/migration_guide.md#replace-deprecated-functions) describes how.
-
-A deleted function, unlike a removed one, still takes part in overload resolution. A call that would select it
-therefore fails to compile instead of silently selecting another overload. This matters for the deprecated
-`from_*(ptr, len)` overloads of [`from_cbor`](../basic_json/from_cbor.md), [`from_msgpack`](../basic_json/from_msgpack.md),
-[`from_ubjson`](../basic_json/from_ubjson.md), [`from_bjdata`](../basic_json/from_bjdata.md),
-[`from_bon8`](../basic_json/from_bon8.md), and [`from_bson`](../basic_json/from_bson.md): without them, a call like
-`from_cbor(ptr, len)` would compile, read `ptr` as a NUL-terminated string, and convert `len` to the `strict` parameter.
-
-The macro does not affect the deprecated legacy comparison of discarded values, which is controlled by
-[`JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](json_use_legacy_discarded_value_comparison.md).
-
-## Default definition
-
-The default value is `0` (disabled, the deprecated functions can still be called, and the compiler warns about it).
-
-```cpp
-#define JSON_DELETE_DEPRECATED_FUNCTIONS 0
-```
-
-## Notes
-
-!!! info "CMake option"
-
-    The macro can also be set with the CMake option
-    [`JSON_DeleteDeprecatedFunctions`](../../integration/cmake.md#json_deletedeprecatedfunctions) (`OFF` by default).
-
-!!! warning "Opt-in only"
-
-    This macro must be defined **before** including `<nlohmann/json.hpp>`. Defining it after the include has no
-    effect. Define it for the whole project to avoid different declarations of the same class in different
-    translation units.
-
-!!! note "ABI compatibility"
-
-    The macro only turns calls that compile into calls that do not; it does not change the layout or the behavior of
-    any type. Its value is therefore not encoded in the [namespace](../../features/namespace.md).
-
-## Examples
-
-??? example "Example: default behavior (macro not defined)"
-
-    Without the macro, the deprecated overload is called, and the compiler warns about it:
-
-    ```cpp
-    #include <nlohmann/json.hpp>
-
-    using json = nlohmann::json;
-
-    int main()
-    {
-        const std::vector<std::uint8_t> v = {0x82, 0x01, 0x02};
-        auto j = json::from_cbor(v.data(), v.size());
-        // warning: 'from_cbor' is deprecated: Since 3.8.0; use from_cbor(ptr, ptr + len)
-    }
-    ```
-
-??? example "Example: deleted deprecated functions (macro defined to 1)"
-
-    With the macro, the call does not compile:
-
-    ```cpp
-    #define JSON_DELETE_DEPRECATED_FUNCTIONS 1
-    #include <nlohmann/json.hpp>
-
-    using json = nlohmann::json;
-
-    int main()
-    {
-        const std::vector<std::uint8_t> v = {0x82, 0x01, 0x02};
-        auto j = json::from_cbor(v.data(), v.size());
-        // error: call to deleted function 'from_cbor'
-    }
-    ```
-
-## See also
-
- [Roadmap: removal of deprecated functions](../../community/roadmap.md#removal-of-deprecated-functions) - the
-  deprecated functions and the version they were deprecated in
- [Migration guide: replace deprecated functions](../../integration/migration_guide.md#replace-deprecated-functions) -
-  how to replace each deprecated function
-
-## Version history
-
- Added in version 3.13.0.
- Planned to be removed in version 4.0.0, which removes the deprecated functions. The deprecated `from_*(ptr, len)`
-  overloads stay deleted in version 4.0.0.
@@ -112,4 +112,3 @@ The default value is `0` (disabled — existing behavior is preserved).
 ## Version history

 - Added in version 3.13.0.
- Planned to become the default (with the macro removed) in version 4.0.0.
@@ -44,7 +44,7 @@ By default, implicit conversions are enabled.

 ## Examples

-??? example "Example: implicit and explicit conversions"
+??? example "Example: implicit conversion"

    This is an example for an implicit conversion:

@@ -1,139 +0,0 @@
-# JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-
-```cpp
-#define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS /* value */
-```
-
-When defined to `1`, maps whose keys are enums (such as `std::map<E, T>` or `std::unordered_map<E, T>`) are stored as
-JSON objects, using the enum's own conversion for the keys. By default, they are stored as arrays of `[key, value]`
-pairs.
-
-## Default definition
-
-The default value is `0` (disabled — existing behavior is preserved).
-
-```cpp
-#define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS 0
-```
-
-## Notes
-
-!!! note "Background"
-
-    JSON object keys are strings, so a map is only stored as an object if its keys can be converted to a string type.
-    Enums are not, even if [`NLOHMANN_JSON_SERIALIZE_ENUM`](nlohmann_json_serialize_enum.md) maps them to strings, so a
-    map with enum keys becomes an array of `[key, value]` pairs:
-
-    ```json
-    [["stopped", "aa"], ["completed", "bb"]]
-    ```
-
-    With this macro, the same map becomes an object
-    (see [#4378](https://github.com/nlohmann/json/issues/4378)):
-
-    ```json
-    {"completed": "bb", "stopped": "aa"}
-    ```
-
-!!! note "Maps with non-unique keys"
-
-    Maps that allow duplicate keys, such as `std::multimap<E, T>` or `std::unordered_multimap<E, T>`, are not affected
-    by the macro and are still stored as arrays of `[key, value]` pairs, as an object cannot hold duplicate keys.
-
-!!! note "Reading"
-
-    Reading is not affected by the macro: a map with enum keys can always be read from both an array of pairs and an
-    object. For the latter, each key is converted to the enum with its `from_json` function, e.g., the one defined by
-    [`NLOHMANN_JSON_SERIALIZE_ENUM`](nlohmann_json_serialize_enum.md). Data written without the macro can therefore
-    still be read after enabling it.
-
-!!! warning "Keys must serialize to distinct strings"
-
-    Each key is converted with the enum's `to_json` function. If a key is not converted to a string (for instance, an
-    enum without [`NLOHMANN_JSON_SERIALIZE_ENUM`](nlohmann_json_serialize_enum.md), which is stored as an integer, or an
-    enumerator mapped to `nullptr`), [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) is thrown.
-    If two keys are converted to the same string (for instance, because
-    [`NLOHMANN_JSON_SERIALIZE_ENUM`](nlohmann_json_serialize_enum.md) maps an unlisted enumerator to the first entry),
-    [`type_error.318`](../../home/exceptions.md#jsonexceptiontype_error318) is thrown. In both cases, the target value
-    is not changed.
-
-!!! warning "Opt-in only"
-
-    This macro must be defined **before** including `<nlohmann/json.hpp>`. Defining it after the include has no effect.
-
-!!! note "ABI compatibility"
-
-    The value of this macro is encoded in the [namespace](../../features/namespace.md) (tag `_ekmo`), resulting in
-    distinct symbol names. Translation units compiled with and without it can therefore be linked into the same program
-    without One Definition Rule (ODR) violations, but they cannot exchange instances of library types.
-
-## Examples
-
-??? example "Example: default behavior (macro not defined)"
-
-    Without the macro, a map with enum keys is stored as an array of pairs:
-
-    ```cpp
-    #include <map>
-    #include <nlohmann/json.hpp>
-
-    using json = nlohmann::json;
-
-    enum TaskState { TS_STOPPED, TS_RUNNING, TS_COMPLETED };
-
-    NLOHMANN_JSON_SERIALIZE_ENUM(TaskState, {
-        {TS_STOPPED, "stopped"},
-        {TS_RUNNING, "running"},
-        {TS_COMPLETED, "completed"},
-    })
-
-    int main()
-    {
-        std::map<TaskState, std::string> m = {{TS_STOPPED, "aa"}, {TS_COMPLETED, "bb"}};
-
-        json j = m;
-        // j is [["stopped","aa"],["completed","bb"]]
-    }
-    ```
-
-??? example "Example: objects for enum-keyed maps (macro defined to 1)"
-
-    With the macro, the same map is stored as an object:
-
-    ```cpp
-    #define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS 1
-    #include <map>
-    #include <nlohmann/json.hpp>
-
-    using json = nlohmann::json;
-
-    enum TaskState { TS_STOPPED, TS_RUNNING, TS_COMPLETED };
-
-    NLOHMANN_JSON_SERIALIZE_ENUM(TaskState, {
-        {TS_STOPPED, "stopped"},
-        {TS_RUNNING, "running"},
-        {TS_COMPLETED, "completed"},
-    })
-
-    int main()
-    {
-        std::map<TaskState, std::string> m = {{TS_STOPPED, "aa"}, {TS_COMPLETED, "bb"}};
-
-        json j = m;
-        // j is {"completed":"bb","stopped":"aa"}
-
-        auto m2 = j.get<std::map<TaskState, std::string>>();
-        // m2 == m
-    }
-    ```
-
-## See also
-
- [Specializing enum conversion](../../features/enum_conversion.md)
- [**NLOHMANN_JSON_SERIALIZE_ENUM**](nlohmann_json_serialize_enum.md) - serialize/deserialize an enum
- [**NLOHMANN_JSON_SERIALIZE_ENUM_STRICT**](nlohmann_json_serialize_enum_strict.md) - serialize/deserialize an enum with
-  exceptions
-
-## Version history
-
- Added in version 3.13.0.
@@ -41,9 +41,6 @@ inline void from_json(const BasicJsonType& j, type& e);
      conversion. Select this default pair carefully. See example 1 below.
    - If an enum or JSON value is specified in multiple conversions, the first matching conversion from the top of the
      list will be returned when converting to or from JSON. See example 2 below.
-    - Maps with enum keys (e.g., `std::map<ENUM_TYPE, T>`) are stored as arrays of `[key, value]` pairs by default.
-      Define [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](json_use_objects_for_enum_keyed_maps.md) to store them as objects
-      with the converted keys. Such maps can be read from both forms.

 ## Examples

@@ -83,7 +80,6 @@ inline void from_json(const BasicJsonType& j, type& e);
 - [Specializing enum conversion](../../features/enum_conversion.md)
 - [`NLOHMANN_JSON_SERIALIZE_ENUM_STRICT`](./nlohmann_json_serialize_enum_strict.md)
 - [`JSON_DISABLE_ENUM_SERIALIZATION`](json_disable_enum_serialization.md)
- [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](json_use_objects_for_enum_keyed_maps.md)

 ## Version history

@@ -44,9 +44,6 @@ inline void from_json(const BasicJsonType& j, type& e);
      `"enum value out of range for <type>"`.
    - If an enum or JSON value is specified in multiple conversions, the first matching conversion from the top of the
      list will be returned when converting to or from JSON. See example 2 below.
-    - Maps with enum keys (e.g., `std::map<ENUM_TYPE, T>`) are stored as arrays of `[key, value]` pairs by default.
-      Define [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](json_use_objects_for_enum_keyed_maps.md) to store them as objects
-      with the converted keys. Such maps can be read from both forms.

 ## Examples

@@ -102,7 +99,6 @@ inline void from_json(const BasicJsonType& j, type& e);
 - [Specializing enum conversion](../../features/enum_conversion.md)
 - [`NLOHMANN_JSON_SERIALIZE_ENUM`](./nlohmann_json_serialize_enum.md)
 - [`JSON_DISABLE_ENUM_SERIALIZATION`](json_disable_enum_serialization.md)
- [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](json_use_objects_for_enum_keyed_maps.md)

 ## Version history

@@ -21,18 +21,17 @@ Note: Some modern features (like C++20 ranges or filesystem support) may be disa
      
        | Compiler                                     | Architecture | Operating System                  | CI        |
        |----------------------------------------------|--------------|-----------------------------------|-----------|
+        | AppleClang 15.0.0.15000040; Xcode 15.0.1     | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
+        | AppleClang 15.0.0.15000100; Xcode 15.1       | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
+        | AppleClang 15.0.0.15000100; Xcode 15.2       | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
+        | AppleClang 15.0.0.15000309; Xcode 15.3       | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
+        | AppleClang 15.0.0.15000309; Xcode 15.4       | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
        | AppleClang 16.0.0.16000026; Xcode 16         | arm64        | macOS 15.2 (Sequoia)              | GitHub    |
        | AppleClang 16.0.0.16000026; Xcode 16.1       | arm64        | macOS 15.2 (Sequoia)              | GitHub    |
        | AppleClang 16.0.0.16000026; Xcode 16.2       | arm64        | macOS 15.2 (Sequoia)              | GitHub    |
        | AppleClang 17.0.0.17000013; Xcode 16.3       | arm64        | macOS 15.5 (Sequoia)              | GitHub    |
        | AppleClang 17.0.0.17000013; Xcode 16.4       | arm64        | macOS 15.5 (Sequoia)              | GitHub    |
        | AppleClang 17.0.0.17000319; Xcode 26.0.1     | arm64        | macOS 15.5 (Sequoia)              | GitHub    |
-        | AppleClang 17.0.0.17000404; Xcode 26.1.1     | arm64        | macOS 15.7.9 (Sequoia)            | GitHub    |
-        | AppleClang 17.0.0.17000603; Xcode 26.2       | arm64        | macOS 15.7.9 (Sequoia)            | GitHub    |
-        | AppleClang 17.0.0.17000604; Xcode 26.3       | arm64        | macOS 15.7.9 (Sequoia)            | GitHub    |
-        | AppleClang 21.0.0.21000099; Xcode 26.4.1     | arm64        | macOS 26.6.2 (Tahoe)              | GitHub    |
-        | AppleClang 21.0.0.21000101; Xcode 26.5       | arm64        | macOS 26.6.2 (Tahoe)              | GitHub    |
-        | AppleClang 21.0.0.21000101; Xcode 26.6       | arm64        | macOS 26.6.2 (Tahoe)              | GitHub    |
        | Clang 3.4.2                                  | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | Clang 3.5.2                                  | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | Clang 3.6.2                                  | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
@@ -90,7 +89,7 @@ Note: Some modern features (like C++20 ranges or filesystem support) may be disa
        | GNU 13.3.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | GNU 14.2.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | GNU 15.1.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
-        | GNU 16.2.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
+        | GNU 16.1.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | GNU 16.1.0                                   | arm64        | Ubuntu 24.04                      | GitHub    |
        | icpc (ICC) 2021.10.0 20230609                | x86_64       | Ubuntu 22.04 LTS                  | GitHub    |
        | icpx (Intel oneAPI DPC++/C++) 2025.3.2       | x86_64       | Ubuntu 24.04 LTS                  | GitHub    |
@@ -64,8 +64,6 @@ The following macros guard changes that are planned to become the default in ver
 | [`JSON_PRECISE_STREAM_POSITION`](../api/macros/json_precise_stream_position.md)                                  | `0`         | `1`: reading from a stream does not consume the character after a number                                                      | –                                                                                                                  | 3.13.0 |
 | [`JSON_STRICT_NUL_HANDLING`](../api/macros/json_strict_nul_handling.md)                                          | `0`         | `1`: a NUL byte in the input is a parse error instead of the end of input                                                     | [`JSON_StrictNulHandling`](../integration/cmake.md#json_strictnulhandling)                                         | 3.13.0 |
 | [`JSON_STRICT_BINARY_UTF8`](../api/macros/json_strict_binary_utf8.md)                                            | `0`         | `1`: `to_cbor`, `to_ubjson`, `to_bjdata`, and `to_bson` throw for strings that are not valid UTF-8 by default                 | [`JSON_StrictBinaryUTF8`](../integration/cmake.md#json_strictbinaryutf8)                                           | 3.13.0 |
-| [`JSON_DISABLE_TUPLE_REFERENCE_CONVERSION`](../api/macros/json_disable_tuple_reference_conversion.md)            | `0`         | `1`: a `basic_json` value can no longer be created from a one-element tuple of a reference to it, such as `std::forward_as_tuple(j)`| [`JSON_DisableTupleReferenceConversion`](../integration/cmake.md#json_disabletuplereferenceconversion)             | 3.13.0 |
-| [`JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md)                          | `0`         | removed: the deprecated functions are removed (see below); the `from_*(ptr, len)` overloads stay deleted                      | [`JSON_DeleteDeprecatedFunctions`](../integration/cmake.md#json_deletedeprecatedfunctions)                         | 3.13.0 |

 For example, the following makes a 3.x release behave like version 4.0 with respect to these changes:

@@ -77,8 +75,6 @@ For example, the following makes a 3.x release behave like version 4.0 with resp
 #define JSON_PRECISE_STREAM_POSITION 1
 #define JSON_STRICT_NUL_HANDLING 1
 #define JSON_STRICT_BINARY_UTF8 1
-#define JSON_DISABLE_TUPLE_REFERENCE_CONVERSION 1
-#define JSON_DELETE_DEPRECATED_FUNCTIONS 1
 #include <nlohmann/json.hpp>
 ```

@@ -88,13 +84,8 @@ way to achieve this.
 ### Removal of deprecated functions

 Version 4.0 will remove all deprecated functions. Compiling with deprecation warnings enabled shows which of them your
-code still uses. Defining [`JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md) to
-`1` turns these warnings into errors, as the deprecated functions are then deleted. The
-[migration guide](../integration/migration_guide.md#replace-deprecated-functions) shows how to replace each of them.
-
-The `from_*` overloads taking a pointer and a length are not removed in version 4.0, but stay deleted. Without them, a
-call like `from_cbor(ptr, len)` would still compile: it would read `ptr` as a NUL-terminated string and convert `len`
-to the `strict` parameter.
+code still uses. The [migration guide](../integration/migration_guide.md#replace-deprecated-functions) shows how to
+replace each of them.

 | Deprecated                                                                                                                                                                                                                                         | Since  | Migration                                                                        |
 |----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------|----------------------------------------------------------------------------------|
@@ -106,7 +97,6 @@ to the `strict` parameter.
 | [`json_pointer::operator string_t`](../api/json_pointer/operator_string_t.md)                                                                                                                                                                      | 3.11.0 | [JSON Pointers](../integration/migration_guide.md#json-pointers)                 |
 | [`json_pointer`](../api/json_pointer/index.md) with a `basic_json` type as template argument, and the overloads of `value`, `contains`, `operator[]`, and `at` accepting such a pointer                                                           | 3.11.0 | [JSON Pointers](../integration/migration_guide.md#json-pointers)                 |
 | Comparing a [`json_pointer`](../api/json_pointer/index.md) with a string via [`operator==`](../api/json_pointer/operator_eq.md) or [`operator!=`](../api/json_pointer/operator_ne.md)                                                              | 3.11.2 | [JSON Pointers](../integration/migration_guide.md#json-pointers)                 |
-| [`from_bjdata`](../api/basic_json/from_bjdata.md) and [`from_bon8`](../api/basic_json/from_bon8.md) with `(ptr, len)`                                                                                                                              | 3.13.0 | [Parsing](../integration/migration_guide.md#parsing)                             |

 The deprecated legacy comparison of discarded values is controlled by a macro and therefore listed in the table above.

@@ -168,9 +168,9 @@ The library maps CBOR types to JSON value types as follows:
 !!! warning "Negative integer overflow"

    CBOR negative integers (major type 1) are decoded as `-1 - n`. If the encoded magnitude `n` is too large for the
-    result to fit into `number_integer_t` (`std::int64_t` by default), the result is stored as `number_float_t`, like
-    a too small integer in JSON text. For example, `-18446744073709551616` (`0x3B` followed by eight `0xFF` bytes) is
-    stored as `-1.8446744073709552e+19`.
+    result to fit into `number_integer_t` (`std::int64_t` by default), parsing fails with a
+    [`parse_error.112`](../../home/exceptions.md#jsonexceptionparse_error112) exception rather than overflowing
+    silently.

 !!! warning "Object keys"

@@ -58,23 +58,6 @@ assert(jPi.get<TaskState>() == TS_INVALID );
    --8<-- "examples/nlohmann_json_serialize_enum.output"
    ```

-## Maps with enum keys
-
-By default, maps with enum keys, such as `std::map<TaskState, std::string>`, are stored as arrays of `[key, value]`
-pairs, because JSON object keys must be strings. Define
-[`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md) before including the
-library to store them as objects, with the keys converted by the enum's `to_json()` function:
-
-```cpp
-std::map<TaskState, std::string> m = {{TS_STOPPED, "aa"}, {TS_COMPLETED, "bb"}};
-
-json j = m;
-// default:                                   [["stopped","aa"],["completed","bb"]]
-// with JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS: {"completed":"bb","stopped":"aa"}
-```
-
-Either form can be read back, with or without the macro.
-
 ## Notes

 Just as in [Arbitrary Type Conversions](arbitrary_types.md) above,
@@ -23,17 +23,6 @@ This macro overrides [`#!cpp catch`](https://en.cppreference.com/w/cpp/language/

 See [full documentation of `JSON_CATCH_USER(exception)`](../api/macros/json_throw_user.md).

-## `JSON_DELETE_DEPRECATED_FUNCTIONS`
-
-When defined to `1`, all deprecated functions are declared as deleted instead of only being marked as deprecated, so
-code that still calls them no longer compiles. This way, you can find all calls that need to be replaced before version
-4.0.0 removes these functions.
-
-The macro can also be set with the CMake option
-[`JSON_DeleteDeprecatedFunctions`](../integration/cmake.md#json_deletedeprecatedfunctions) (`OFF` by default).
-
-See [full documentation of `JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md).
-
 ## `JSON_DIAGNOSTICS`

 This macro enables extended diagnostics for exception messages. Possible values are `1` to enable or `0` to disable
@@ -97,8 +86,7 @@ See [full documentation of `JSON_DISABLE_ENUM_SERIALIZATION`](../api/macros/json
 ## `JSON_DISABLE_TUPLE_REFERENCE_CONVERSION`

 When defined to `1`, a JSON value can no longer be created from a one-element `std::tuple` holding a reference to a JSON
-value, such as the result of `std::forward_as_tuple(j)`. This lets `std::tuple` convert such tuples element-wise. This
-is planned to become the default in version 4.0.0.
+value, such as the result of `std::forward_as_tuple(j)`. This lets `std::tuple` convert such tuples element-wise.

 See [full documentation of `JSON_DISABLE_TUPLE_REFERENCE_CONVERSION`](../api/macros/json_disable_tuple_reference_conversion.md).

@@ -210,13 +198,6 @@ default.

 See [full documentation of `JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](../api/macros/json_use_legacy_discarded_value_comparison.md).

-## `JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`
-
-When defined to `1`, maps with enum keys (e.g., `std::map<E, T>`) are stored as objects, using the enum's conversion for
-the keys, instead of arrays of `[key, value]` pairs. It is switched off (`0`) by default.
-
-See [full documentation of `JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md).
-
 ## `JSON_USE_SIMDUTF`

 When defined, UTF-8 validation of JSON strings read from contiguous byte input is delegated to the
@@ -21,8 +21,6 @@ The complete default namespace name is derived as follows:
    - [`JSON_PRECISE_STREAM_POSITION`](../api/macros/json_precise_stream_position.md) defined non-zero appends `_psp`.
    - [`JSON_STRICT_NUL_HANDLING`](../api/macros/json_strict_nul_handling.md) defined non-zero appends `_snul`.
    - [`JSON_STRICT_BINARY_UTF8`](../api/macros/json_strict_binary_utf8.md) defined non-zero appends `_sbu8`.
-    - [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md) defined non-zero
-      appends `_ekmo`.
 - The inline namespace ends with the suffix `_v` followed by the 3 components of the version number separated by
  underscores. To omit the version component, see [Disabling the version component](#disabling-the-version-component)
  below.
@@ -55,7 +55,7 @@ always use the scalar path regardless of this macro.

 Parsing always produces SAX events internally; [`parse`](../api/basic_json/parse.md) simply feeds them to a consumer
 that builds a complete `basic_json` value tree (a DOM) in memory. For documents too large to comfortably hold as
-a DOM, three alternatives avoid building it:
+a DOM, two alternatives avoid building it:

 - Implement the [SAX interface](parsing/sax_interface.md) directly and pass it to
  [`sax_parse`](../api/basic_json/sax_parse.md); only the parts of the input you choose to keep ever become
@@ -64,12 +64,6 @@ a DOM, three alternatives avoid building it:
  discard finished elements as soon as they are handled, so memory usage stays bounded by one element (plus the
  unparsed remainder of the input) instead of the whole document -- see the [recipe for streaming a large homogeneous
  array](parsing/parser_callbacks.md#recipe-streaming-a-large-homogeneous-array).
- Parse into a [`json_document`](json_view.md) (`#!cpp <nlohmann/json_view.hpp>`) instead of a `basic_json`. It keeps
-  the input text and builds a flat index of 16 bytes per value; strings and numbers are not copied, but read from the
-  text when needed. Read-only [views](../api/basic_json_view/index.md) give the familiar element access, and only the
-  parts you [`materialize()`](../api/basic_json_view/materialize.md) become `basic_json` values. A document that
-  borrows the text instead of owning a copy needs the text to outlive it; see
-  [choosing between `json`, the SAX interface, and `json_view`](json_view.md#choosing-between-json-ordered_json-the-sax-interface-and-json_view).

 If the data is naturally record-oriented, consider [JSON Lines](parsing/json_lines.md) instead of one large JSON
 document: reading and parsing it line by line with `#!cpp std::getline` means only one line's value is ever in memory
@@ -215,7 +209,6 @@ those headers are then never processed by the compiler at all.
 - [Architecture](../home/architecture.md) - how input adapters, the lexer, and the serializer fit together
 - [Parsing](parsing/index.md) - the available parsing functions and inputs
 - [SAX interface](parsing/sax_interface.md) - parse without building a DOM
- [Zero-copy JSON views](json_view.md) - parse into a flat index of the text and read it without building a DOM
 - [Binary formats](binary_formats/index.md) - compact alternatives to JSON text
 - [Object Order](object_order.md) - `json` vs. `ordered_json` and other `ObjectType` choices
 - [Template Parameter Requirements](types/template_parameters.md) - custom container and allocator types
@@ -134,10 +134,9 @@ That is, `-0` is stored as a signed integer, but the serialization does not repr
 ### Number serialization

 - Integer numbers are serialized as is; that is, no scientific notation is used.
- Floating-point numbers are serialized with the fewest digits that read back as the same value (the closest such
-  digits if there are several), in the layout of the `#!c %g` printf modifier: `#!c 1.5`, `#!c 100.0`, `#!c 1e+100`.
-  Doubles are converted with the algorithm of [Żmij](https://github.com/vitaut/zmij), floats with Grisu2, which
-  can write more digits than necessary.
+- Floating-point numbers are serialized as specified by the `#!c %g` printf modifier with 
+  [`std::numeric_limits<double>::max_digits10`](https://en.cppreference.com/w/cpp/types/numeric_limits/max_digits10)
+  significant digits. The rationale is to use the shortest representation while still allowing round-tripping.

 !!! hint "Notes regarding precision of floating-point numbers"

@@ -545,10 +545,9 @@ therefore silently changes parse results rather than raising an error. See
  specifiers, for which the library likewise provides only `#!cpp double` and `#!cpp long double` overloads
  (`#!cpp float` is promoted to `#!cpp double`).

-If `#!cpp std::numeric_limits<NumberFloatType>` describes an IEEE 754 binary64 number, `dump` uses the algorithm of
-Żmij, which produces the shortest representation that round-trips. For IEEE 754 binary32 numbers, it uses Grisu2,
-which produces a short representation that round-trips. Otherwise the `snprintf` fallback with `max_digits10` digits is
-used.
+If `#!cpp std::numeric_limits<NumberFloatType>` describes an IEEE 754 binary32 or binary64 number, `dump` uses the
+Grisu2 algorithm, which produces the shortest representation that round-trips. Otherwise the `snprintf` fallback with
+`max_digits10` digits is used.

 ### Required for the binary formats

@@ -560,7 +559,7 @@ binary32 or binary64 field and have no encoding for `#!cpp long double`.

 | Type                     | Support                                                                                                               |
 |--------------------------|-----------------------------------------------------------------------------------------------------------------------|
-| `#!cpp double` (default) | full; shortest round-trip output through Żmij                                                                         |
+| `#!cpp double` (default) | full; short round-trip output through Grisu2                                                                          |
 | `#!cpp float`            | full; short round-trip output through Grisu2                                                                          |
 | `#!cpp long double`      | `dump` and `parse` only; the binary format writers do not compile, as they only handle IEEE 754 binary32 and binary64 |
 | any other type           | not usable                                                                                                            |
@@ -331,6 +331,9 @@ An unexpected byte was read in a [binary format](../features/binary_formats/inde
    [json.exception.parse_error.112] parse error at byte 15: syntax error while parsing BSON binary: byte array length cannot be negative, is -1
    ```
    ```
+    [json.exception.parse_error.112] parse error at byte 9: syntax error while parsing CBOR value: negative integer overflow
+    ```
+    ```
    [json.exception.parse_error.112] parse error at byte 5: syntax error while parsing BSON document: document size 6 does not match the number of bytes read (5)
    ```

@@ -596,9 +599,6 @@ During implicit or explicit value conversion, the JSON type must be compatible w
    [json.exception.type_error.302] type must be string, but is object
    ```

-This exception is also thrown with [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md)
-if a key of a map with enum keys is not converted to a string, for instance, because the enum is stored as an integer.
-
 ### json.exception.type_error.303

 To retrieve a reference to a value stored in a `basic_json` object with `get_ref`, the type of the reference must match the value type. For instance, for a JSON array, the `ReferenceType` must be `array_t &`.
@@ -791,33 +791,6 @@ The dynamic type of the object cannot be represented in the requested serializat

    Encapsulate the JSON value in an object. That is, instead of serializing `#!json true`, serialize `#!json {"value": true}`

-### json.exception.type_error.318
-
-With [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md), a map with enum
-keys is stored as an object. This exception is thrown if two of its keys are converted to the same string, so one of the
-entries would be lost. This happens, for instance, if [`NLOHMANN_JSON_SERIALIZE_ENUM`](../api/macros/nlohmann_json_serialize_enum.md)
-does not list an enumerator and it is therefore converted like the first listed one.
-
-!!! failure "Example message"
-
-    ```
-    [json.exception.type_error.318] duplicate object key 'red'
-    ```
-
-### json.exception.type_error.321
-
-A discarded value (one created by [`parse()`](../api/basic_json/parse.md) with a callback that returns `false` for the
-value, or by default-constructing a [`basic_json`](../api/basic_json/index.md) with
-[`value_t::discarded`](../api/basic_json/value_t.md)) was passed to a binary serialization function, either directly or
-nested in an array or object. There is no way to represent a discarded value in CBOR, MessagePack, UBJSON, BJData, or BSON.
-
-!!! failure "Example message"
-
-    Serializing `#!json [1, 2]` to CBOR, where the second element was discarded by a parser callback:
-    ```
-    [json.exception.type_error.321] cannot serialize discarded value to CBOR
-    ```
-
 ## Out of range

 This exception is thrown in case a library function is called on an input parameter that exceeds the expected range, for instance, in the case of array indices or nonexisting object keys.
@@ -890,18 +863,13 @@ The JSON Patch operations 'remove' and 'add' cannot be applied to the root eleme

 ### json.exception.out_of_range.406

-A parsed number could not be stored without changing it to NaN or INF. For the binary formats, this happens when a
-finite floating-point number does not fit into [`number_float_t`](../api/basic_json/number_float_t.md), for example a
-double-precision number when `number_float_t` is `#!cpp float`.
+A parsed number could not be stored as without changing it to NaN or INF.

-!!! failure "Example messages"
+!!! failure "Example message"

    ```
    number overflow parsing '10E1000'
    ```
-    ```
-    [json.exception.out_of_range.406] syntax error while parsing CBOR value: number overflow
-    ```

 ### json.exception.out_of_range.407

@@ -18,8 +18,6 @@ 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 port of the shortest double-to-decimal conversion of [Żmij](https://github.com/vitaut/zmij) by Victor Zverovich, which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright &copy; 2025 [Victor Zverovich](https://github.com/vitaut)
-
 The class contains a copy of [Hedley](https://nemequ.github.io/hedley/) from Evan Nemerson which is licensed as [CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/).

 The class contains an adapted version of the Eisel-Lemire algorithm, its table of powers of five, and its digit comparison for long numbers from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright &copy; 2021 The fast_float authors
@@ -132,12 +132,6 @@ Build the unit tests when [`BUILD_TESTING`](https://cmake.org/cmake/help/latest/

 Enable CI build targets. The exact targets are used during the several CI steps and are subject to change without notice. This option is `OFF` by default.

-### `JSON_DeleteDeprecatedFunctions`
-
-Delete the deprecated functions instead of only deprecating them by defining the macro
-[`JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md). This option is `OFF` by
-default.
-
 ### `JSON_Diagnostics`

 Enable [extended diagnostic messages](../home/exceptions.md#extended-diagnostic-messages) by defining macro [`JSON_DIAGNOSTICS`](../api/macros/json_diagnostics.md). This option is `OFF` by default.
@@ -14,13 +14,6 @@ deprecations are annotated with
 [`HEDLEY_DEPRECATED_FOR`](https://nemequ.github.io/hedley/api-reference.html#HEDLEY_DEPRECATED_FOR) to report which
 function to use instead.

-!!! tip "Find all calls of deprecated functions"
-
-    Define [`JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md) to `1` (or set the
-    CMake option [`JSON_DeleteDeprecatedFunctions`](cmake.md#json_deletedeprecatedfunctions)) to delete all deprecated
-    functions. Every remaining call then fails to compile, even if deprecation warnings are disabled, so your code is
-    ready for version 4.0.0 once it compiles with the macro.
-
 ### Parsing

 - Function `friend std::istream& operator<<(basic_json&, std::istream&)` is deprecated since 3.0.0. Please use
@@ -48,10 +41,8 @@ function to use instead.
  [`from_ubjson`](../api/basic_json/from_ubjson.md), and [`from_bson`](../api/basic_json/from_bson.md)) via initializer
  lists is deprecated since 3.8.0. Instead, pass two iterators; for instance, call `from_cbor(ptr, ptr+len)` instead of
  `from_cbor({ptr, len})`. Likewise, passing a pointer and a length as two separate arguments to `from_cbor`,
-  `from_msgpack`, `from_ubjson`, and `from_bson` is deprecated since 3.8.0, and to
-  [`from_bjdata`](../api/basic_json/from_bjdata.md) and [`from_bon8`](../api/basic_json/from_bon8.md) since 3.13.0; call
-  `from_cbor(ptr, ptr+len)` instead of `from_cbor(ptr, len)`. These overloads will not be removed in version 4.0.0, but
-  deleted, so a call like `from_cbor(ptr, len)` cannot compile and convert `len` to the `strict` parameter.
+  `from_msgpack`, `from_ubjson`, and `from_bson` is deprecated since 3.8.0; call `from_cbor(ptr, ptr+len)` instead of
+  `from_cbor(ptr, len)`.

    === "Deprecated"
  
@@ -356,7 +356,6 @@ nav:
          - 'JSON_BRACE_INIT_COPY_SEMANTICS': api/macros/json_brace_init_copy_semantics.md
          - 'JSON_CATCH_USER, JSON_THROW_USER, JSON_TRY_USER': api/macros/json_throw_user.md
          - 'JSON_DIAGNOSTICS': api/macros/json_diagnostics.md
-          - 'JSON_DELETE_DEPRECATED_FUNCTIONS': api/macros/json_delete_deprecated_functions.md
          - 'JSON_DIAGNOSTIC_POSITIONS': api/macros/json_diagnostic_positions.md
          - 'JSON_DISABLE_ENUM_SERIALIZATION': api/macros/json_disable_enum_serialization.md
          - 'JSON_DISABLE_TUPLE_REFERENCE_CONVERSION': api/macros/json_disable_tuple_reference_conversion.md
@@ -378,7 +377,6 @@ nav:
          - 'JSON_USE_GLOBAL_UDLS': api/macros/json_use_global_udls.md
          - 'JSON_USE_IMPLICIT_CONVERSIONS': api/macros/json_use_implicit_conversions.md
          - 'JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON': api/macros/json_use_legacy_discarded_value_comparison.md
-          - 'JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS': api/macros/json_use_objects_for_enum_keyed_maps.md
          - 'JSON_USE_SIMDUTF': api/macros/json_use_simdutf.md
          - 'NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE, NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE': api/macros/nlohmann_define_derived_type.md
          - 'NLOHMANN_DEFINE_TYPE_INTRUSIVE, NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT, NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE': api/macros/nlohmann_define_type_intrusive.md
@@ -50,10 +50,6 @@
    #define JSON_STRICT_BINARY_UTF8 0
 #endif

-#ifndef JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-    #define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS 0
-#endif
-
 #if JSON_DIAGNOSTICS
    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
 #else
@@ -96,20 +92,14 @@
    #define NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8
 #endif

-#if JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-    #define NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS _ekmo
-#else
-    #define NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS
-#endif
-
 #ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
    #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
 #endif

 // Construct the namespace ABI tags component
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h) json_abi ## a ## b ## c ## d ## e ## f ## g ## h
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g, h) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g) json_abi ## a ## b ## c ## d ## e ## f ## g
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g)

 #define NLOHMANN_JSON_ABI_TAGS                                       \
    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
@@ -119,8 +109,7 @@
            NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS,         \
            NLOHMANN_JSON_ABI_TAG_PRECISE_STREAM_POSITION,           \
            NLOHMANN_JSON_ABI_TAG_STRICT_NUL_HANDLING,               \
-            NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8,                \
-            NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS)
+            NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8)

 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
@@ -86,9 +86,8 @@ inline uint128_parts full_multiplication(std::uint64_t a, std::uint64_t b) noexc
 }

 /// eight bytes as a little-endian word (compilers fold this into one load on
-/// little-endian targets; always inlined, as GCC otherwise calls it in the
-/// number loops)
-JSON_HEDLEY_ALWAYS_INLINE std::uint64_t read_eight_bytes(const unsigned char* b) noexcept
+/// 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)
@@ -97,7 +96,7 @@ JSON_HEDLEY_ALWAYS_INLINE std::uint64_t read_eight_bytes(const unsigned char* b)
 }

 /// eight bytes as a little-endian word
-JSON_HEDLEY_ALWAYS_INLINE std::uint64_t read_eight_bytes(const char* p) noexcept
+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)
 }
@@ -172,7 +172,7 @@ inline void from_json(const BasicJsonType& j, EnumType& e)
          typename BasicJsonType::number_unsigned_t, underlying_type>::type;
    value_type val;
    get_arithmetic_value(j, val);
-    e = static_cast<EnumType>(bool_aware_static_cast<underlying_type>(val));
+    e = static_cast<EnumType>(static_cast<underlying_type>(val));
 }
 #endif  // JSON_DISABLE_ENUM_SERIALIZATION

@@ -530,40 +530,11 @@ void from_json_pair_array_to_map(const BasicJsonType& j, MapType& m)
    }
 }

-// read a map with enum keys from an object, using the enum's own from_json for
-// the keys (e.g., from NLOHMANN_JSON_SERIALIZE_ENUM); this is the form written
-// with JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-template<typename BasicJsonType, typename Map>
-inline bool from_json_enum_keyed_object(const BasicJsonType& j, Map& m, std::true_type /*key is enum*/)
-{
-    if (!j.is_object())
-    {
-        return false;
-    }
-    m.clear();
-    for (const auto& p : *j.template get_ptr<const typename BasicJsonType::object_t*>())
-    {
-        m.emplace(BasicJsonType(p.first).template get<typename Map::key_type>(), p.second.template get<typename Map::mapped_type>());
-    }
-    return true;
-}
-
-template<typename BasicJsonType, typename Map>
-inline bool from_json_enum_keyed_object(const BasicJsonType& /*j*/, Map& /*m*/, std::false_type /*key is enum*/)
-{
-    return false;
-}
-
 template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
           typename = enable_if_t < !std::is_constructible <
                                        typename BasicJsonType::string_t, Key >::value >>
 void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
 {
-    // NOLINTNEXTLINE(modernize-type-traits) we use C++11
-    if (from_json_enum_keyed_object(j, m, std::is_enum<Key> {}))
-    {
-        return;
-    }
    from_json_pair_array_to_map(j, m);
 }

@@ -572,11 +543,6 @@ template < typename BasicJsonType, typename Key, typename Value, typename Hash,
                                        typename BasicJsonType::string_t, Key >::value >>
 void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
 {
-    // NOLINTNEXTLINE(modernize-type-traits) we use C++11
-    if (from_json_enum_keyed_object(j, m, std::is_enum<Key> {}))
-    {
-        return;
-    }
    from_json_pair_array_to_map(j, m);
 }

@@ -11,32 +11,11 @@

 #include <array> // array
 #include <cmath>   // signbit, isfinite
-#include <cstddef> // size_t
 #include <cstdint> // intN_t, uintN_t
 #include <cstring> // memcpy, memmove
 #include <limits> // numeric_limits
 #include <type_traits> // conditional

-#ifdef _MSC_VER
-    #include <cstdlib> // _byteswap_uint64
-#endif
-
-// SSE2 (every x86-64 CPU) and NEON (every 64-bit Arm CPU) convert the 16
-// digits of a double at once
-#if defined(__x86_64__) || (defined(_M_X64) && !defined(_M_ARM64EC))
-    #include <emmintrin.h>
-    #define JSON_DTOA_SSE2 1
-    #define JSON_DTOA_NEON 0
-#elif (defined(__aarch64__) || defined(_M_ARM64)) && !defined(_M_ARM64EC) && !defined(__ARM_BIG_ENDIAN)
-    #include <arm_neon.h>
-    #define JSON_DTOA_SSE2 0
-    #define JSON_DTOA_NEON 1
-#else
-    #define JSON_DTOA_SSE2 0
-    #define JSON_DTOA_NEON 0
-#endif
-
-#include <nlohmann/detail/conversions/zmij.hpp>
 #include <nlohmann/detail/macro_scope.hpp>

 NLOHMANN_JSON_NAMESPACE_BEGIN
@@ -939,88 +918,6 @@ void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
    grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
 }

-/*!
-@brief the shortest digits of a positive finite float (other than double): Grisu2
-*/
-template<typename FloatType>
-JSON_HEDLEY_NON_NULL(1)
-void shortest_digits(char* buf, int& len, int& decimal_exponent, FloatType value)
-{
-    grisu2(buf, len, decimal_exponent, value);
-}
-
-/*!
-@brief the shortest digits of a positive finite double: the conversion of
-Zmij (see zmij.hpp), which always finds the shortest digits that read back as
-the same value (Grisu2 does not for about one double in a thousand), and the
-closest of them if there are several
-
-v = buf * 10^decimal_exponent, as for grisu2()
-*/
-JSON_HEDLEY_NON_NULL(1)
-inline void shortest_digits(char* buf, int& len, int& decimal_exponent, double value)
-{
-    static_assert(std::numeric_limits<double>::is_iec559 && std::numeric_limits<double>::digits == 53,
-                  "internal error: the conversion of Zmij needs IEEE 754 binary64 doubles");
-    JSON_ASSERT(std::isfinite(value));
-    JSON_ASSERT(value > 0);
-
-    std::uint64_t bits = 0;
-    std::memcpy(&bits, &value, sizeof(bits));
-    zmij::decimal d = zmij::to_decimal(bits);
-    // without trailing zeros (up to 16): 8, 4, 2, 1 at a time
-    while (d.significand % 100000000 == 0)
-    {
-        d.significand /= 100000000;
-        d.exponent += 8;
-    }
-    if (d.significand % 10000 == 0)
-    {
-        d.significand /= 10000;
-        d.exponent += 4;
-    }
-    if (d.significand % 100 == 0)
-    {
-        d.significand /= 100;
-        d.exponent += 2;
-    }
-    if (d.significand % 10 == 0)
-    {
-        d.significand /= 10;
-        d.exponent += 1;
-    }
-    // at most 17 digits, written from the back two at a time
-    static constexpr const char* pairs =
-        "00010203040506070809101112131415161718192021222324252627282930313233343536373839"
-        "40414243444546474849505152535455565758596061626364656667686970717273747576777879"
-        "8081828384858687888990919293949596979899";
-    std::array<char, 20> digits{};
-    std::size_t n = digits.size();
-    while (d.significand >= 100)
-    {
-        const std::uint64_t two_digits = d.significand % 100; // a variable: GCC calls a cast of the remainder useless where std::uint64_t is std::size_t
-        const auto i = static_cast<std::size_t>(two_digits) * 2;
-        d.significand /= 100;
-        n -= 2;
-        digits[n] = pairs[i];
-        digits[n + 1] = pairs[i + 1];
-    }
-    if (d.significand >= 10)
-    {
-        const auto i = static_cast<std::size_t>(d.significand) * 2;
-        n -= 2;
-        digits[n] = pairs[i];
-        digits[n + 1] = pairs[i + 1];
-    }
-    else
-    {
-        digits[--n] = static_cast<char>('0' + d.significand);
-    }
-    len = static_cast<int>(digits.size() - n);
-    std::memcpy(buf, digits.data() + n, static_cast<std::size_t>(len));
-    decimal_exponent = d.exponent;
-}
-
 /*!
@brief appends a decimal representation of e to buf
@return a pointer to the element following the exponent.
@@ -1150,374 +1047,6 @@ inline char* format_buffer(char* buf, int len, int decimal_exponent,
    return append_exponent(buf, n - 1);
 }

-/// eight decimal digits (a value below 10^8) as bytes 0..9, the first digit
-/// in the most significant byte: three steps that divide all lanes at once
-/// by a multiplication (the conversion of Xiang JunBo, as in Zmij)
-inline std::uint64_t eight_digit_bytes(std::uint64_t abcdefgh) noexcept
-{
-    const std::uint64_t abcd_efgh = abcdefgh + (((std::uint64_t{1} << 32u) - 10000u) * ((abcdefgh * (((std::uint64_t{1} << 40u) / 10000u) + 1u)) >> 40u));
-    const std::uint64_t ab_cd_ef_gh = abcd_efgh + (((std::uint64_t{1} << 16u) - 100u) * (((abcd_efgh * (((std::uint64_t{1} << 19u) / 100u) + 1u)) >> 19u) & 0x7F0000007Fu));
-    return ab_cd_ef_gh + (((std::uint64_t{1} << 8u) - 10u) * (((ab_cd_ef_gh * (((std::uint64_t{1} << 10u) / 10u) + 1u)) >> 10u) & 0x000F000F000F000Fu));
-}
-
-/// store the bytes of v, the most significant one first (one byte swap and
-/// one store where the byte order is known: compilers do not reliably merge
-/// the byte stores once this is inlined)
-inline void store_msb_first(char* p, std::uint64_t v) noexcept
-{
-#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-    v = __builtin_bswap64(v);
-    std::memcpy(p, &v, sizeof(v));
-#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-    std::memcpy(p, &v, sizeof(v));
-#elif defined(_MSC_VER) // (little-endian on all its targets)
-    v = _byteswap_uint64(v);
-    std::memcpy(p, &v, sizeof(v));
-#else
-    for (unsigned i = 0; i < 8; ++i)
-    {
-        p[i] = static_cast<char>(v >> (56u - (8u * i)));
-    }
-#endif
-}
-
-/*!
-@brief digits * 10^exp for a double, in the layout of format_buffer()
-
-The layout is that of format_buffer() with min_exp -4 and max_exp 15 (the
-digits10 of double). The digits are converted eight at a time and placed
-with fixed-size moves instead of per-digit loops and moves of the buffer.
-
-@param[in] digits  the digits (not 0, at most 17 digits; trailing zeros allowed)
-@param[in] exp     the decimal exponent of the last digit
-@return a pointer past the text; up to 41 bytes at @a first are written
-        (some beyond the returned end)
-*/
-JSON_HEDLEY_NON_NULL(1)
-JSON_HEDLEY_RETURNS_NON_NULL
-inline char* write_decimal(char* first, std::uint64_t digits, int exp) noexcept
-{
-    JSON_ASSERT(digits != 0 && digits < 100000000000000000u);
-    const std::uint64_t upper = digits / 100000000u;
-    const std::uint64_t b0 = upper / 100000000u; // (one digit: it is its own byte)
-    const std::uint64_t b1 = eight_digit_bytes(upper % 100000000u);
-    const std::uint64_t b2 = eight_digit_bytes(digits % 100000000u);
-    // leading and trailing zero digits: zero bytes, counted without division
-    int leading = 16;
-    int zeros = 16;
-    if (b0 != 0)
-    {
-        leading = count_leading_zeros(b0) / 8;
-    }
-    else if (b1 != 0)
-    {
-        leading = 8 + (count_leading_zeros(b1) / 8);
-    }
-    else
-    {
-        leading += count_leading_zeros(b2) / 8;
-    }
-    if (b2 != 0)
-    {
-        zeros = count_trailing_zeros(b2) / 8;
-    }
-    else if (b1 != 0)
-    {
-        zeros = 8 + (count_trailing_zeros(b1) / 8);
-    }
-    // (else: 16, b0 is the one digit that is not 0)
-    // the digits as text at text + leading, then '0's, so that fixed-size
-    // moves need not check how many digits there are
-    std::array<char, 64> text; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-    store_msb_first(text.data(), b0 + 0x3030303030303030u);
-    store_msb_first(text.data() + 8, b1 + 0x3030303030303030u);
-    store_msb_first(text.data() + 16, b2 + 0x3030303030303030u);
-    std::memset(text.data() + 24, '0', 40);
-    const int k = 24 - leading - zeros; // significant digits
-    const int n = k + exp + zeros;      // position of the decimal point after the first digit
-    const char* const s0 = text.data() + leading;
-
-    if (-4 < n && n <= 15)
-    {
-        // "0.[000]digits" (n <= 0) is the digits after 1 - n leading '0's
-        // with the point after the first; "digits[000].0" (n >= k) and
-        // "dig.its" put the point after n characters
-        const int pad = n <= 0 ? 1 - n : 0;
-        const char* const s = s0 - pad;
-        const int len = k + pad;
-        const int point = n + pad;
-        std::memcpy(first, s, 16);
-        std::memcpy(first + point + 1, s + point, 24);
-        first[point] = '.';
-        return first + (point >= len ? point + 2 : len + 1);
-    }
-
-    // d.igitse+XX, with at least two exponent digits (as append_exponent())
-    std::memcpy(first, s0, 16);
-    std::memcpy(first + 2, s0 + 1, 16);
-    first[1] = '.';
-    char* const end = first + (k == 1 ? 1 : k + 1);
-    const int e = n - 1;
-    const auto ea = static_cast<unsigned>(e < 0 ? -e : e);
-    const bool three = ea >= 100;
-    end[0] = 'e';
-    end[1] = e < 0 ? '-' : '+';
-    end[2] = static_cast<char>('0' + (three ? ea / 100 : (ea / 10) % 10));
-    end[3] = static_cast<char>('0' + (three ? (ea / 10) % 10 : ea % 10));
-    end[4] = static_cast<char>('0' + (ea % 10));
-    return end + (three ? 5 : 4);
-}
-
-/*!
-@brief the shortest decimal of a positive double (Zmij), as write_decimal()
-writes it
-
-For a normal double, the shorter candidate has 15 or 16 digits: they are
-converted at once (two halves of eight digits) and followed by the digit
-after them, if there is one, without the multiplication and division by 10
-that counting the digits of one number would take. The fixed layouts move
-the digits after the point by one byte.
-
-@return a pointer past the text; up to 41 bytes at @a first are written
-        (some beyond the returned end)
-*/
-JSON_HEDLEY_NON_NULL(1)
-JSON_HEDLEY_RETURNS_NON_NULL
-inline char* write_shortest(char* first, const zmij::shortest_decimal d) noexcept
-{
-    const std::uint64_t sig = d.integral;
-    if (JSON_HEDLEY_UNLIKELY(sig < 100000000000000u || sig >= 10000000000000000u))
-    {
-        // (subnormals)
-        return d.has_digit ? write_decimal(first, (sig * 10) + d.digit, d.exponent) : write_decimal(first, sig, d.exponent + 1);
-    }
-    const bool sixteen = sig >= 1000000000000000u; // (else 15 digits)
-    const int last = d.has_digit ? d.digit : 0;
-    const std::uint64_t upper = sig / 100000000u;
-#if JSON_DTOA_SSE2
-    // NOLINTBEGIN(portability-simd-intrinsics)
-    // the two halves in the 64-bit lanes, each as abcd * 2^32 + efgh, then as
-    // bytes (as eight_digit_bytes(), one lane each)
-    const __m128i x = _mm_set_epi64x(static_cast<long long>(sig - (upper * 100000000u)), static_cast<long long>(upper));
-    const __m128i abcd = _mm_srli_epi64(_mm_mul_epu32(x, _mm_set1_epi64x(109951163)), 40); // 2^40 / 10000 + 1
-    const __m128i abcd_efgh = _mm_add_epi64(x, _mm_mul_epu32(abcd, _mm_set1_epi64x(4294957296))); // 2^32 - 10000
-    // 32-bit lanes in the order of the text: abcd, efgh of both halves
-    const __m128i fours = _mm_shuffle_epi32(abcd_efgh, _MM_SHUFFLE(2, 3, 0, 1));
-    const __m128i ab = _mm_srli_epi16(_mm_mulhi_epu16(fours, _mm_set1_epi32(5243)), 3);
-    const __m128i ab_cd = _mm_or_si128(_mm_slli_epi32(_mm_sub_epi16(fours, _mm_mullo_epi16(ab, _mm_set1_epi32(100))), 16), ab);
-    // 16-bit lanes ab (< 100) -> bytes a, b: 256 * ab - 2559 * (ab / 10)
-    const __m128i bytes = _mm_sub_epi16(_mm_slli_epi16(ab_cd, 8), _mm_mullo_epi16(_mm_set1_epi16(2559), _mm_mulhi_epu16(ab_cd, _mm_set1_epi16(6554))));
-    // the last digit that is not 0 (sig is not 0)
-    const auto nonzero = static_cast<std::uint64_t>(_mm_movemask_epi8(_mm_cmpgt_epi8(bytes, _mm_setzero_si128())));
-    const int digits = 63 - count_leading_zeros(nonzero) + (sixteen ? 1 : 0); // without trailing zeros
-    const __m128i chars = _mm_add_epi8(bytes, _mm_set1_epi8('0'));
-    // the 16 characters from the first digit
-    const __m128i s = sixteen ? chars : _mm_or_si128(_mm_srli_si128(chars, 1), _mm_slli_si128(_mm_cvtsi32_si128('0' + last), 15));
-    const char s16 = static_cast<char>(sixteen ? '0' + last : '0'); // the 17th
-    const auto store_16 = [&s](char* p) noexcept
-    {
-        std::memcpy(p, &s, 16);
-    };
-    const char first_digit = static_cast<char>(_mm_cvtsi128_si32(s));
-    // NOLINTEND(portability-simd-intrinsics)
-#elif JSON_DTOA_NEON
-    // as with SSE2: the halves in 32-bit lanes, then abcd, efgh of both
-    const uint32x2_t halves = vcreate_u32(upper | ((sig - (upper * 100000000u)) << 32u));
-    const uint32x2_t abcd = vmovn_u64(vshrq_n_u64(vmull_n_u32(halves, static_cast<std::uint32_t>(((std::uint64_t{1} << 40u) / 10000u) + 1u)), 40));
-    const uint32x2_t efgh = vmls_n_u32(halves, abcd, 10000u);
-    const uint32x4_t fours = vcombine_u32(vzip1_u32(abcd, efgh), vzip2_u32(abcd, efgh));
-    const uint32x4_t ab = vshrq_n_u32(vmulq_n_u32(fours, 5243u), 19);
-    const uint16x8_t ab_cd = vreinterpretq_u16_u32(vorrq_u32(ab, vshlq_n_u32(vmlsq_n_u32(fours, ab, 100u), 16)));
-    const uint16x8_t tens = vshrq_n_u16(vmulq_n_u16(ab_cd, 103u), 10);
-    const uint8x16_t bytes = vreinterpretq_u8_u16(vorrq_u16(tens, vshlq_n_u16(vmlsq_n_u16(ab_cd, tens, 10u), 8)));
-    // the last digit that is not 0 (sig is not 0): a nibble per byte
-    const std::uint64_t nonzero = vget_lane_u64(vreinterpret_u64_u8(vshrn_n_u16(vreinterpretq_u16_u8(vtstq_u8(bytes, bytes)), 4)), 0);
-    const int digits = ((63 - count_leading_zeros(nonzero)) / 4) + (sixteen ? 1 : 0); // without trailing zeros
-    const uint8x16_t chars = vaddq_u8(bytes, vdupq_n_u8('0'));
-    // the 16 characters from the first digit
-    const uint8x16_t s = sixteen ? chars : vextq_u8(chars, vdupq_n_u8(static_cast<std::uint8_t>('0' + last)), 1);
-    const char s16 = static_cast<char>(sixteen ? '0' + last : '0'); // the 17th
-    const auto store_16 = [&s](char* p) noexcept
-    {
-        vst1q_u8(reinterpret_cast<std::uint8_t*>(p), s); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
-    };
-    const auto first_digit = static_cast<char>(vgetq_lane_u8(s, 0));
-#else
-    const std::uint64_t hi = eight_digit_bytes(upper);
-    const std::uint64_t lo = eight_digit_bytes(sig - (upper * 100000000u));
-    // trailing zero digits: zero bytes (sig is not 0)
-    const int zeros = lo != 0 ? count_trailing_zeros(lo) / 8 : 8 + (count_trailing_zeros(hi) / 8);
-    const int digits = 15 - zeros + (sixteen ? 1 : 0); // without trailing zeros
-    // the 16 characters from the first digit
-    const std::uint64_t s_hi = (sixteen ? hi : (hi << 8u) | (lo >> 56u)) + 0x3030303030303030u;
-    const std::uint64_t s_lo = (sixteen ? lo : (lo << 8u) | static_cast<std::uint64_t>(last)) + 0x3030303030303030u;
-    const char s16 = static_cast<char>(sixteen ? '0' + last : '0'); // the 17th
-    const auto store_16 = [s_hi, s_lo](char* p) noexcept
-    {
-        store_msb_first(p, s_hi);
-        store_msb_first(p + 8, s_lo);
-    };
-    const auto first_digit = static_cast<char>(s_hi >> 56u);
-#endif
-    const int len = d.has_digit ? 16 + (sixteen ? 1 : 0) : digits; // significant digits
-    const int n = 16 + (sixteen ? 1 : 0) + d.exponent;           // digits before the point
-
-    if (JSON_HEDLEY_LIKELY(n >= 1 && n <= 15))
-    {
-        // "dig.its" and "digits[000].0": the digits after the point move by
-        // one byte ('0's follow the digits)
-#if JSON_DTOA_SSE2
-        // NOLINTBEGIN(portability-simd-intrinsics)
-        // (in the register: reading the digits back from memory right after
-        // storing them waits until the stores are done)
-        const __m128i at = _mm_set1_epi8(static_cast<char>(n));
-        const __m128i index = _mm_setr_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
-        const __m128i before = _mm_cmpgt_epi8(at, index);
-        const __m128i after = _mm_cmpgt_epi8(index, at);
-        const __m128i text = _mm_or_si128(_mm_or_si128(_mm_and_si128(s, before), _mm_and_si128(_mm_slli_si128(s, 1), after)),
-                                          _mm_andnot_si128(_mm_or_si128(before, after), _mm_set1_epi8('.')));
-        std::memcpy(first, &text, 16);
-        first[16] = static_cast<char>(_mm_extract_epi16(s, 7) >> 8);
-        first[17] = s16;
-        // NOLINTEND(portability-simd-intrinsics)
-#elif JSON_DTOA_NEON
-        const uint8x16_t index = vcombine_u8(vcreate_u8(0x0706050403020100u), vcreate_u8(0x0F0E0D0C0B0A0908u));
-        const uint8x16_t at = vdupq_n_u8(static_cast<std::uint8_t>(n));
-        const uint8x16_t after_point = vbslq_u8(vcgtq_u8(index, at), vextq_u8(vdupq_n_u8(0), s, 15), vdupq_n_u8('.'));
-        vst1q_u8(reinterpret_cast<std::uint8_t*>(first), vbslq_u8(vcltq_u8(index, at), s, after_point)); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
-        first[16] = static_cast<char>(vgetq_lane_u8(s, 15));
-        first[17] = s16;
-#else
-        store_16(first);
-        first[16] = s16;
-        std::uint64_t after_point[2]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-        std::memcpy(after_point, first + n, 16);
-        std::memcpy(first + n + 1, after_point, 16);
-        first[n] = '.';
-#endif
-        return first + (n >= len ? n + 2 : len + 1);
-    }
-    if (n <= 0 && n > -4)
-    {
-        // "0.[000]digits"
-        std::memset(first, '0', 8);
-        first[1] = '.';
-        store_16(first + 2 - n);
-        first[18 - n] = s16;
-        return first + 2 - n + len;
-    }
-    // d.igitse+XX, with at least two exponent digits (as append_exponent())
-    store_16(first + 1);
-    first[17] = s16;
-    first[0] = first_digit;
-    first[1] = '.';
-    char* const end = first + (len == 1 ? 1 : len + 1);
-    const int e = n - 1;
-    const auto ea = static_cast<unsigned>(e < 0 ? -e : e);
-    const bool three = ea >= 100;
-    end[0] = 'e';
-    end[1] = e < 0 ? '-' : '+';
-    end[2] = static_cast<char>('0' + (three ? ea / 100 : (ea / 10) % 10));
-    end[3] = static_cast<char>('0' + (three ? (ea / 10) % 10 : ea % 10));
-    end[4] = static_cast<char>('0' + (ea % 10));
-    return end + (three ? 5 : 4);
-}
-
-/// the powers of ten up to 10^16
-inline const std::array<std::uint64_t, 17>& powers_of_ten_16() noexcept
-{
-    static const std::array<std::uint64_t, 17> powers =
-    {
-        {
-            1u, 10u, 100u, 1000u, 10000u, 100000u, 1000000u, 10000000u, 100000000u, 1000000000u, 10000000000u,
-            100000000000u, 1000000000000u, 10000000000000u, 100000000000000u, 1000000000000000u, 10000000000000000u
-        }
-    };
-    return powers;
-}
-
-/*!
-@brief digits * 10^exp, as write_decimal() writes it, for the digits of a
-double that need no conversion (count digits, at most 15, the first not 0;
-trailing zeros allowed): extended to 16 digits and written by write_shortest()
-
-@return a pointer past the text; up to 41 bytes at @a first are written
-        (some beyond the returned end)
-*/
-JSON_HEDLEY_NON_NULL(1)
-JSON_HEDLEY_RETURNS_NON_NULL
-inline char* write_short_decimal(char* first, std::uint64_t digits, int count, int exp) noexcept
-{
-    JSON_ASSERT(digits >= powers_of_ten_16()[static_cast<std::size_t>(count - 1)] && count <= 15);
-    const int scale = 16 - count;
-    return write_shortest(first, zmij::shortest_decimal{digits * powers_of_ten_16()[static_cast<std::size_t>(scale)], exp - scale - 1, 0, false});
-}
-
-/// as write_short_decimal(), counting the digits (not 0, less than 10^15)
-JSON_HEDLEY_NON_NULL(1)
-JSON_HEDLEY_RETURNS_NON_NULL
-inline char* write_short_decimal(char* first, std::uint64_t digits, int exp) noexcept
-{
-    JSON_ASSERT(digits != 0 && digits < 1000000000000000u);
-    // floor(log10(2^bits)) + 1 digits, or one less
-    const int log2_bound = ((64 - count_leading_zeros(digits)) * 1233) >> 12;
-    const int count = log2_bound + (digits >= powers_of_ten_16()[static_cast<std::size_t>(log2_bound)] ? 1 : 0);
-    return write_short_decimal(first, digits, count, exp);
-}
-
-/// a positive finite float (other than double): Grisu2 and format_buffer()
-template<typename FloatType>
-JSON_HEDLEY_NON_NULL(1, 2)
-JSON_HEDLEY_RETURNS_NON_NULL
-char* write_positive(char* first, const char* last, FloatType value)
-{
-    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
-
-    // Compute v = buffer * 10^decimal_exponent.
-    // The decimal digits are stored in the buffer, which needs to be interpreted
-    // as an unsigned decimal integer.
-    // len is the length of the buffer, i.e., the number of decimal digits.
-    int len = 0;
-    int decimal_exponent = 0;
-    shortest_digits(first, len, decimal_exponent, value);
-
-    JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
-
-    // Format the buffer like printf("%.*g", prec, value)
-    constexpr int kMinExp = -4;
-    // Use digits10 here to increase compatibility with version 2.
-    constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
-
-    JSON_ASSERT(last - first >= kMaxExp + 2);
-    JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
-    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
-
-    return format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
-}
-
-/// a positive finite double: the shortest digits (Zmij), laid out by
-/// write_shortest() (through a local buffer if [first, last) is shorter than
-/// the 41 bytes it may write)
-JSON_HEDLEY_NON_NULL(1, 2)
-JSON_HEDLEY_RETURNS_NON_NULL
-inline char* write_positive(char* first, const char* last, double value)
-{
-    static_assert(std::numeric_limits<double>::is_iec559 && std::numeric_limits<double>::digits == 53,
-                  "internal error: the conversion of Zmij needs IEEE 754 binary64 doubles");
-    std::uint64_t bits = 0;
-    std::memcpy(&bits, &value, sizeof(bits));
-    const zmij::shortest_decimal d = zmij::to_shortest(bits);
-    if (JSON_HEDLEY_LIKELY(last - first >= 41))
-    {
-        return write_shortest(first, d);
-    }
-    std::array<char, 64> buf; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
-    const auto len = static_cast<std::size_t>(write_shortest(buf.data(), d) - buf.data());
-    JSON_ASSERT(static_cast<std::size_t>(last - first) >= len);
-    std::memcpy(first, buf.data(), len);
-    return first + len;
-}
-
 }  // namespace dtoa_impl

 /*!
@@ -1535,6 +1064,7 @@ JSON_HEDLEY_NON_NULL(1, 2)
 JSON_HEDLEY_RETURNS_NON_NULL
 char* to_chars(char* first, const char* last, FloatType value)
 {
+    static_cast<void>(last); // maybe unused - fix warning
    JSON_ASSERT(std::isfinite(value));

    // Use signbit(value) instead of (value < 0) since signbit works for -0.
@@ -1560,7 +1090,28 @@ char* to_chars(char* first, const char* last, FloatType value)
    JSON_HEDLEY_DIAGNOSTIC_POP
 #endif

-    return dtoa_impl::write_positive(first, last, value);
+    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
+
+    // Compute v = buffer * 10^decimal_exponent.
+    // The decimal digits are stored in the buffer, which needs to be interpreted
+    // as an unsigned decimal integer.
+    // len is the length of the buffer, i.e., the number of decimal digits.
+    int len = 0;
+    int decimal_exponent = 0;
+    dtoa_impl::grisu2(first, len, decimal_exponent, value);
+
+    JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
+
+    // Format the buffer like printf("%.*g", prec, value)
+    constexpr int kMinExp = -4;
+    // Use digits10 here to increase compatibility with version 2.
+    constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
+
+    JSON_ASSERT(last - first >= kMaxExp + 2);
+    JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
+    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
+
+    return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
 }

 }  // namespace detail
@@ -23,7 +23,6 @@
 #include <valarray> // valarray
 #include <vector> // vector

-#include <nlohmann/detail/exceptions.hpp>
 #include <nlohmann/detail/iterators/iteration_proxy.hpp>
 #include <nlohmann/detail/meta/cpp_future.hpp>
 #include <nlohmann/detail/meta/std_fs.hpp>
@@ -287,20 +286,9 @@ struct external_constructor<value_t::object>
 /////////////

 #ifdef JSON_HAS_CPP_17
-// whether storing the value of a std::optional<T> cannot throw; MSVC 2017
-// evaluates std::is_nothrow_assignable as true even if T's to_json throws, so
-// the exception would call std::terminate (#5642)
-#if defined(_MSC_VER) && !defined(__clang__) && _MSC_VER < 1920
-    template<typename BasicJsonType, typename T>
-    using is_nothrow_optional_to_json = std::false_type;
-#else
-    template<typename BasicJsonType, typename T>
-    using is_nothrow_optional_to_json = std::is_nothrow_assignable<BasicJsonType&, const T&>;
-#endif
-
 template<typename BasicJsonType, typename T,
         enable_if_t<std::is_constructible<BasicJsonType, T>::value, int> = 0>
-void to_json(BasicJsonType& j, const std::optional<T>& opt) noexcept(is_nothrow_optional_to_json<BasicJsonType, T>::value)
+void to_json(BasicJsonType& j, const std::optional<T>& opt) noexcept(std::is_nothrow_assignable<BasicJsonType&, const T&>::value)
 {
    if (opt.has_value())
    {
@@ -376,7 +364,7 @@ inline void to_json(BasicJsonType& j, EnumType e) noexcept
 {
    using underlying_type = typename std::underlying_type<EnumType>::type;
    static constexpr value_t integral_value_t = std::is_unsigned<underlying_type>::value ? value_t::number_unsigned : value_t::number_integer;
-    external_constructor<integral_value_t>::construct(j, bool_aware_static_cast<underlying_type>(e));
+    external_constructor<integral_value_t>::construct(j, static_cast<underlying_type>(e));
 }
 #endif  // JSON_DISABLE_ENUM_SERIALIZATION

@@ -396,9 +384,6 @@ template < typename BasicJsonType, typename CompatibleArrayType,
                         !is_basic_json<CompatibleArrayType>::value
 #if JSON_HAS_RANGE_VIEW_CONVERSION
    && !is_compatible_range_view<CompatibleArrayType>::value
-#endif
-#if JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-    && !is_enum_keyed_map<CompatibleArrayType>::value
 #endif
                         ,
                         int > = 0 >
@@ -453,33 +438,6 @@ inline void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
    external_constructor<value_t::object>::construct(j, obj);
 }

-#if JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-// store a map with enum keys as an object, using the enum's own to_json for the
-// keys (e.g., from NLOHMANN_JSON_SERIALIZE_ENUM); without the macro, such maps
-// are stored as arrays of [key, value] pairs
-template < typename BasicJsonType, typename EnumKeyedMap,
-           enable_if_t < is_enum_keyed_map<EnumKeyedMap>::value&& !is_basic_json<EnumKeyedMap>::value, int > = 0 >
-inline void to_json(BasicJsonType& j, const EnumKeyedMap& map)
-{
-    typename BasicJsonType::object_t obj;
-    for (const auto& p : map)
-    {
-        BasicJsonType key = p.first;
-        if (JSON_HEDLEY_UNLIKELY(!key.is_string()))
-        {
-            JSON_THROW(type_error::create(302, concat("type must be string, but is ", key.type_name()), &key));
-        }
-
-        auto& key_string = *key.template get_ptr<typename BasicJsonType::string_t*>();
-        if (JSON_HEDLEY_UNLIKELY(!obj.emplace(key_string, BasicJsonType(p.second)).second))
-        {
-            JSON_THROW(type_error::create(318, concat("duplicate object key '", key_string, "'"), &key));
-        }
-    }
-    external_constructor<value_t::object>::construct(j, std::move(obj));
-}
-#endif
-
 template<typename BasicJsonType>
 inline void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
 {
@@ -1,238 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2025 Victor Zverovich <https://github.com/vitaut/zmij>
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <array> // array
-#include <cstddef> // size_t
-#include <cstdint> // uint32_t, uint64_t
-
-#include <nlohmann/detail/abi_macros.hpp>
-#include <nlohmann/detail/bit_ops.hpp>
-#include <nlohmann/detail/input/pow5_table.hpp>
-#include <nlohmann/detail/macro_scope.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail
-{
-
-/*!
-@brief the shortest decimal representation of a double
-
-A C++11 port of the conversion of Zmij by Victor Zverovich
-(https://github.com/vitaut/zmij, MIT license): the shortest decimal in the
-rounding interval of a double, the closest one if there are several. Zmij
-credits Xiang JunBo (producing the shorter candidate without a division) and
-Dougall Johnson (the compressed powers of ten). The powers of ten are taken
-from the table for number parsing (pow5_table.hpp) where it holds them, and
-computed from the compressed tables of Zmij beyond it.
-*/
-namespace zmij
-{
-
-/// significand * 10^exponent
-struct decimal
-{
-    std::uint64_t significand;
-    int exponent;
-};
-
-/// the compressed powers of ten of Zmij
-inline const std::array<std::uint64_t, 28>& pow10_minor() noexcept
-{
-    static const std::array<std::uint64_t, 28> table =
-    {
-        {
-            0x8000000000000000u, 0xa000000000000000u, 0xc800000000000000u, 0xfa00000000000000u, 0x9c40000000000000u,
-            0xc350000000000000u, 0xf424000000000000u, 0x9896800000000000u, 0xbebc200000000000u, 0xee6b280000000000u,
-            0x9502f90000000000u, 0xba43b74000000000u, 0xe8d4a51000000000u, 0x9184e72a00000000u, 0xb5e620f480000000u,
-            0xe35fa931a0000000u, 0x8e1bc9bf04000000u, 0xb1a2bc2ec5000000u, 0xde0b6b3a76400000u, 0x8ac7230489e80000u,
-            0xad78ebc5ac620000u, 0xd8d726b7177a8000u, 0x878678326eac9000u, 0xa968163f0a57b400u, 0xd3c21bcecceda100u,
-            0x84595161401484a0u, 0xa56fa5b99019a5c8u, 0xcecb8f27f4200f3au
-        }
-    };
-    return table;
-}
-
-/// (high, low) pairs
-inline const std::array<std::uint64_t, 50>& pow10_major() noexcept
-{
-    static const std::array<std::uint64_t, 50> table =
-    {
-        {
-            0xaddcb9e83c6b1793u, 0xdf4abe242a1bbf3eu, 0xaf8e5410288e1b6fu, 0x07ecf0ae5ee44ddau, 0xb1442798f49ffb4au, 0x99cd11cfdf41779du,
-            0xb2fe3f0b8599ef07u, 0x861fa7e6dcb4aa15u, 0xb4bca50b065abe63u, 0x0fed077a756b53aau, 0xb67f6455292cbf08u, 0x1a3bc84c17b1d543u,
-            0xb84687c269ef3bfbu, 0x3d5d514f40eea742u, 0xba121a4650e4ddebu, 0x92f34d62616ce413u, 0xbbe226efb628afeau, 0x890489f70a55368cu,
-            0xbdb6b8e905cb600fu, 0x5400e987bbc1c921u, 0xbf8fdb78849a5f96u, 0xde98520472bdd034u, 0xc16d9a0095928a27u, 0x75b7053c0f178294u,
-            0xc350000000000000u, 0x0000000000000000u, 0xc5371912364ce305u, 0x6c28000000000000u, 0xc722f0ef9d80aad6u, 0x424d3ad2b7b97ef6u,
-            0xc913936dd571c84cu, 0x03bc3a19cd1e38eau, 0xcb090c8001ab551cu, 0x5cadf5bfd3072cc6u, 0xcd036837130890a1u, 0x36dba887c37a8c10u,
-            0xcf02b2c21207ef2eu, 0x94f967e45e03f4bcu, 0xd106f86e69d785c7u, 0xe13336d701beba52u, 0xd31045a8341ca07cu, 0x1ede48111209a051u,
-            0xd51ea6fa85785631u, 0x552a74227f3ea566u, 0xd732290fbacaf133u, 0xa97c177947ad4096u, 0xd94ad8b1c7380874u, 0x18375281ae7822bdu,
-            0xdb68c2ca82ed2a05u, 0xa67398db9f6820e1u
-        }
-    };
-    return table;
-}
-
-/// one bit per power: whether the computed value is one unit too large
-inline const std::array<std::uint32_t, 21>& pow10_fixups() noexcept
-{
-    static const std::array<std::uint32_t, 21> table =
-    {
-        {
-            0x8d8fc810u, 0x06100293u, 0x19000000u, 0x00100000u, 0x00000908u, 0x00000000u, 0x04e00300u, 0x3807e0b2u, 0x3d83d793u, 0x0006f5ccu,
-            0x00000000u, 0xffff0000u, 0x8076337du, 0x4ff45ba0u, 0x09405033u, 0x034376d9u, 0x09000000u, 0x4e100501u, 0x076d14dcu, 0xf964f45eu,
-            0x0000003du
-        }
-    };
-    return table;
-}
-
-/// the 128-bit significand of 10^k, rounded down, for k in [-307, 341]
-/// (compute_pow10 of Zmij)
-inline uint128_parts compute_pow10(int k) noexcept
-{
-    const auto i = static_cast<unsigned>(k + 307);
-    const std::uint64_t m = pow10_minor()[(i + 24) % 28];
-    const std::size_t j = 2 * static_cast<std::size_t>((i + 24) / 28);
-    const std::uint64_t h_hi = pow10_major()[j];
-    const std::uint64_t h_lo = pow10_major()[j + 1];
-    const std::uint64_t h1 = full_multiplication(h_lo, m).high;
-    const std::uint64_t c0 = h_lo * m;
-    const std::uint64_t c1 = h1 + (h_hi * m);
-    const std::uint64_t c2 = (c1 < h1 ? 1u : 0u) + full_multiplication(h_hi, m).high;
-    uint128_parts r{};
-    if ((c2 >> 63u) != 0)
-    {
-        r.high = c2;
-        r.low = c1;
-    }
-    else
-    {
-        r.high = (c2 << 1u) | (c1 >> 63u);
-        r.low = (c1 << 1u) | (c0 >> 63u);
-    }
-    r.low -= (pow10_fixups()[i >> 5u] >> (i & 31u)) & 1u;
-    return r;
-}
-
-/// The 128-bit significand of 10^k, rounded down, for k in [-342, 341].
-/// Up to 10^308, the table for number parsing holds the same significands
-/// (those of 5^k), except for k in [-27, -1], where it holds them one unit
-/// larger (as the Eisel-Lemire algorithm needs them).
-inline uint128_parts pow10(int k) noexcept
-{
-    if (k > pow5_128_largest_power)
-    {
-        return compute_pow10(k); // (only for the smallest doubles)
-    }
-    const auto i = 2 * static_cast<std::size_t>(k - pow5_128_smallest_power);
-    uint128_parts r{pow5_128()[i + 1], pow5_128()[i]};
-    const std::uint64_t adjust = static_cast<unsigned>(k + 27) < 27u ? 1u : 0u;
-    r.high -= r.low < adjust ? 1u : 0u;
-    r.low -= adjust;
-    return r;
-}
-
-/// (x_hi * 2^64 + x_lo) * y >> 64, as 128 bits
-inline uint128_parts umul192_hi128(std::uint64_t x_hi, std::uint64_t x_lo, std::uint64_t y) noexcept
-{
-    const uint128_parts p = full_multiplication(x_hi, y);
-    uint128_parts r{};
-    r.low = p.low + full_multiplication(x_lo, y).high;
-    r.high = p.high + (r.low < p.low ? 1u : 0u);
-    return r;
-}
-
-/// (x * y + c) >> 64
-inline std::uint64_t umul128_add_hi64(std::uint64_t x, std::uint64_t y, std::uint64_t c) noexcept
-{
-    const uint128_parts p = full_multiplication(x, y);
-    return p.high + (p.low + c < p.low ? 1u : 0u);
-}
-
-/// the result of Zmij: the shorter candidate and, if that is outside the
-/// rounding interval, the digit after it (16 bytes: returned in registers)
-struct shortest_decimal
-{
-    std::uint64_t integral;  ///< the shorter candidate (15 or 16 digits for normal doubles)
-    int exponent;            ///< the decimal exponent of the digit after it
-    unsigned char digit;     ///< the digit after it (if has_digit)
-    bool has_digit;          ///< whether the shortest decimal is integral * 10 + digit
-};
-
-/// The shortest decimal in the rounding interval of a positive finite double
-/// given by its bits, the closest one if there are several (to_decimal of
-/// Zmij, which keeps the last digit apart: the 15 or 16 digits before it can be
-/// converted without a multiplication by 10 first). Always inlined: GCC
-/// otherwise calls it, and its result goes through memory.
-JSON_HEDLEY_ALWAYS_INLINE shortest_decimal to_shortest(std::uint64_t bits) noexcept
-{
-    constexpr int extra_shift = 9;
-    const auto raw_exp = static_cast<int>((bits >> 52u) & 0x7FFu);
-    std::uint64_t bin_sig = bits & ((std::uint64_t{1} << 52u) - 1);
-    // a power of two has a narrower interval below (except the smallest normal)
-    const bool regular = bin_sig != 0 || raw_exp <= 1;
-    const int bin_exp = (raw_exp == 0 ? 1 : raw_exp) - 1075;
-    if (raw_exp != 0)
-    {
-        bin_sig |= std::uint64_t{1} << 52u;
-    }
-    // floor(log10(2^bin_exp)), or floor(log10(3/4 * 2^bin_exp)) for the irregular case
-    const int dec_exp = ((bin_exp * 315653) - (regular ? 0 : 131072)) >> 20;
-    // scaled by 10^(-dec_exp - 1): the integral part is the shorter candidate
-    const int shift = bin_exp + ((-(dec_exp + 1) * 217707) >> 16) + 1 + extra_shift;
-    const uint128_parts p10 = pow10(-dec_exp - 1);
-    const uint128_parts p = umul192_hi128(p10.high, p10.low, bin_sig << static_cast<unsigned>(shift));
-    std::uint64_t integral = p.high >> static_cast<unsigned>(extra_shift);
-    const std::uint64_t fractional = (p.high << static_cast<unsigned>(64 - extra_shift)) | (p.low >> static_cast<unsigned>(extra_shift));
-    std::uint64_t digit = 0;
-    bool round_up = false;
-    bool round_down = false;
-    if (JSON_HEDLEY_LIKELY(regular))
-    {
-        const std::uint64_t half_ulp = (p10.high >> static_cast<unsigned>(extra_shift + 1 - shift)) + (1 - (bin_sig & 1u));
-        round_up = fractional + half_ulp < fractional;
-        round_down = half_ulp > fractional;
-        // the last digit of the longer candidate, rounded to nearest
-        digit = umul128_add_hi64(fractional, 10, (std::uint64_t{1} << 63u) + 6);
-        if (fractional == (std::uint64_t{1} << 62u))
-        {
-            digit = 2; // 2.5 rounds to 2
-        }
-    }
-    else
-    {
-        const std::uint64_t half_ulp = p10.high >> static_cast<unsigned>(extra_shift + 1 - shift);
-        round_up = half_ulp > ~std::uint64_t{0} - fractional;
-        round_down = (half_ulp >> 1u) > fractional;
-        digit = umul128_add_hi64(fractional, 10, (std::uint64_t{1} << 63u) - 1);
-        const std::uint64_t lowest = umul128_add_hi64(fractional - (half_ulp >> 1u), 10, ~std::uint64_t{0});
-        digit = digit < lowest ? lowest : digit;
-    }
-    integral += round_up ? 1u : 0u;
-    // if the shorter candidate is outside the rounding interval: one digit more
-    return shortest_decimal{integral, dec_exp, static_cast<unsigned char>(digit), !round_up && !round_down};
-}
-
-/// The shortest decimal in the rounding interval of a positive finite double
-/// given by its bits, as one number. The significand can end in zeros.
-inline decimal to_decimal(std::uint64_t bits) noexcept
-{
-    const shortest_decimal d = to_shortest(bits);
-    if (d.has_digit)
-    {
-        return decimal{(d.integral * 10) + d.digit, d.exponent};
-    }
-    return decimal{d.integral, d.exponent + 1};
-}
-
-}  // namespace zmij
-}  // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
@@ -221,7 +221,7 @@ class lexer : public lexer_base<BasicJsonType>
    // scan functions
    /////////////////////

-    /// contiguous input: try to decode the 4 hex digits following `\\u`
+    /// 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
@@ -2070,39 +2070,6 @@ scan_number_done:
        // read the next character and ignore whitespace
        skip_whitespace();

-        return scan_after_whitespace();
-    }
-
-    /*!
-    @brief scan the next token when the caller expects a separator (':' or
-           ',') most of the time
-
-    After an object key the next token is almost always ':', after a value
-    inside an object or array almost always ','. Testing for that character
-    first is a compare and a well-predicted branch, where the switch in
-    scan_after_whitespace() is an indirect jump through a table. Anything else
-    goes through the switch, so the result is the same as scan()'s.
-
-    May only be called after scan() has run once (the BOM check is skipped).
-    */
-    token_type scan_expecting(token_type expected_type)
-    {
-        JSON_ASSERT(expected_type == token_type::name_separator || expected_type == token_type::value_separator);
-        JSON_ASSERT(position.chars_read_total > 0);
-        const char_int_type expected_char = static_cast<unsigned char>((expected_type == token_type::name_separator) ? ':' : ',');
-        skip_whitespace();
-        if (JSON_HEDLEY_LIKELY(current == expected_char))
-        {
-            return expected_type;
-        }
-        return scan_after_whitespace();
-    }
-
-  private:
-    /// the part of scan() after the leading whitespace: skip comments and
-    /// scan the token that starts with current
-    token_type scan_after_whitespace()
-    {
        // ignore comments
        while (ignore_comments && current == '/')
        {
@@ -2182,6 +2149,7 @@ scan_number_done:
        }
    }

+  private:
    /// input adapter
    InputAdapterType ia;

@@ -249,9 +249,8 @@ template<typename FloatType>
 using native_float_t = typename std::conditional<std::numeric_limits<FloatType>::digits == 24, float, double>::type;

 /// the value of the eight ASCII digits in @a v (see read_eight_bytes()), three
-/// multiplications instead of eight (after simdjson and fast_float); always
-/// inlined, as GCC otherwise calls it in the number loops
-JSON_HEDLEY_ALWAYS_INLINE std::uint32_t parse_eight_digits(std::uint64_t v) noexcept
+/// 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;
@@ -260,7 +260,7 @@ class parser
                        }

                        // parse separator (:)
-                        if (JSON_HEDLEY_UNLIKELY(!get_token_expecting(token_type::name_separator)))
+                        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
                        {
                            return sax->parse_error(m_lexer.get_position(),
                                                    m_lexer.get_token_string(),
@@ -423,7 +423,7 @@ class parser
            {
                // comma -> next value
                // or end of array (ignore_trailing_commas = true)
-                if (get_token_expecting(token_type::value_separator))
+                if (get_token() == token_type::value_separator)
                {
                    // parse a new value
                    get_token();
@@ -463,7 +463,7 @@ class parser

            // comma -> next value
            // or end of object (ignore_trailing_commas = true)
-            if (get_token_expecting(token_type::value_separator))
+            if (get_token() == token_type::value_separator)
            {
                get_token();

@@ -484,7 +484,7 @@ class parser
                    }

                    // parse separator (:)
-                    if (JSON_HEDLEY_UNLIKELY(!get_token_expecting(token_type::name_separator)))
+                    if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
                    {
                        return sax->parse_error(m_lexer.get_position(),
                                                m_lexer.get_token_string(),
@@ -528,13 +528,6 @@ class parser
        return last_token = m_lexer.scan();
    }

-    /// get next token from lexer; true if it is the separator @a expected_type
-    /// (name_separator or value_separator), which it usually is
-    bool get_token_expecting(token_type expected_type)
-    {
-        return (last_token = m_lexer.scan_expecting(expected_type)) == expected_type;
-    }
-
    std::string exception_message(const token_type expected, const std::string& context)
    {
        std::string error_msg = "syntax error ";
@@ -88,13 +88,9 @@ class json_pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_string_t/
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string())
    operator string_t() const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return to_string();
    }
-#endif

 #ifndef JSON_NO_IO
    /// @brief write string representation of the JSON pointer to stream
@@ -1033,13 +1029,9 @@ class json_pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
    JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer))
    bool operator==(const string_t& rhs) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return *this == json_pointer(rhs);
    }
-#endif

    /// @brief 3-way compares two JSON pointers
    template<typename RefStringTypeRhs>
@@ -1117,26 +1109,18 @@ template<typename RefStringTypeLhs,
 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
 inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
                       const StringType& rhs)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
 {
    return lhs == json_pointer<RefStringTypeLhs>(rhs);
 }
-#endif

 template<typename RefStringTypeRhs,
         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
 inline bool operator==(const StringType& lhs,
                       const json_pointer<RefStringTypeRhs>& rhs)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
 {
    return json_pointer<RefStringTypeRhs>(lhs) == rhs;
 }
-#endif

 template<typename RefStringTypeLhs, typename RefStringTypeRhs>
 inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
@@ -1150,26 +1134,18 @@ template<typename RefStringTypeLhs,
 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
 inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
                       const StringType& rhs)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
 {
    return !(lhs == rhs);
 }
-#endif

 template<typename RefStringTypeRhs,
         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
 inline bool operator!=(const StringType& lhs,
                       const json_pointer<RefStringTypeRhs>& rhs)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
 {
    return !(lhs == rhs);
 }
-#endif

 template<typename RefStringTypeLhs, typename RefStringTypeRhs>
 inline bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
@@ -888,10 +888,6 @@
    #define JSON_DISABLE_ENUM_SERIALIZATION 0
 #endif

-#ifndef JSON_DELETE_DEPRECATED_FUNCTIONS
-    #define JSON_DELETE_DEPRECATED_FUNCTIONS 0
-#endif
-
 #ifndef JSON_DISABLE_TUPLE_REFERENCE_CONVERSION
    #define JSON_DISABLE_TUPLE_REFERENCE_CONVERSION 0
 #endif
@@ -21,8 +21,6 @@
 #undef JSON_NO_UNIQUE_ADDRESS
 #undef JSON_DISABLE_ENUM_SERIALIZATION
 #undef JSON_DISABLE_TUPLE_REFERENCE_CONVERSION
-#undef JSON_DTOA_SSE2
-#undef JSON_DTOA_NEON

 #ifndef JSON_TEST_KEEP_MACROS
    #undef JSON_CATCH
@@ -45,8 +43,6 @@
    #undef JSON_PRECISE_STREAM_POSITION
    #undef JSON_STRICT_NUL_HANDLING
    #undef JSON_STRICT_BINARY_UTF8
-    #undef JSON_DELETE_DEPRECATED_FUNCTIONS
-    #undef JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
 #endif

 #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
@@ -438,30 +438,6 @@ template<typename BasicJsonType, typename CompatibleObjectType>
 struct is_compatible_object_type
    : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};

-template<typename T>
-using insert_result_t = decltype(std::declval<T&>().insert(std::declval<const value_type_t<T>&>()));
-
-template<typename T>
-using insert_result_second_t = decltype(std::declval<T&>().insert(std::declval<const value_type_t<T>&>()).second);
-
-// a map-like type (std::map, std::unordered_map, ...) whose keys are enums; see
-// JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-template<typename T, typename = void>
-struct is_enum_keyed_map : std::false_type {};
-
-template<typename T>
-struct is_enum_keyed_map <
-    T, enable_if_t < is_detected<mapped_type_t, T>::value&&
-    is_detected<key_type_t, T>::value >>
-{
-    // maps with non-unique keys (std::multimap, std::unordered_multimap, ...)
-    // are excluded, because an object cannot hold duplicate keys; they are
-    // detected by insert() returning an iterator instead of a pair<iterator, bool>
-    // NOLINTNEXTLINE(modernize-type-traits) we use C++11
-    static constexpr bool value = std::is_enum<typename T::key_type>::value &&
-                                  !(is_detected<insert_result_t, T>::value && !is_detected<insert_result_second_t, T>::value);
-};
-
 template<typename BasicJsonType, typename ConstructibleObjectType,
         typename = void>
 struct is_constructible_object_type_impl : std::false_type {};
@@ -906,21 +882,6 @@ T conditional_static_cast(U value)
    return value;
 }

-// like conditional_static_cast, but converts to bool by comparing with zero,
-// because MSVC 2015 warns about any conversion to bool (C4800), even with an
-// explicit cast; used for enums whose underlying type is bool
-template < typename T, typename U, enable_if_t < !std::is_same<T, bool>::value, int > = 0 >
-T bool_aware_static_cast(U value)
-{
-    return conditional_static_cast<T>(value);
-}
-
-template<typename T, typename U, enable_if_t<std::is_same<T, bool>::value, int> = 0>
-bool bool_aware_static_cast(U value)
-{
-    return value != U();
-}
-
 template<typename... Types>
 using all_integral = conjunction<std::is_integral<Types>...>;

@@ -127,7 +127,6 @@ class binary_writer
    @throw type_error.316 if a string value or an object key is not valid
           UTF-8
    @throw type_error.317 if @a j is not an object
-    @throw type_error.321 if a value nested in @a j is discarded
    */
    void write_bson(const BasicJsonType& j)
    {
@@ -159,7 +158,6 @@ class binary_writer
    @param[in] j  JSON value to serialize
    @throw type_error.316 if a string value or an object key is not valid
           UTF-8
-    @throw type_error.321 if @a j or a value nested in it is discarded
    */
    void write_cbor(const BasicJsonType& j)
    {
@@ -324,7 +322,7 @@ class binary_writer

            case value_t::discarded:
            default:
-                throw_on_discarded(j, "CBOR");
+                break;
        }
    }

@@ -384,7 +382,6 @@ class binary_writer

    /*!
    @param[in] j  JSON value to serialize
-    @throw type_error.321 if @a j or a value nested in it is discarded
    */
    void write_msgpack(const BasicJsonType& j)
    {
@@ -658,7 +655,7 @@ class binary_writer

            case value_t::discarded:
            default:
-                throw_on_discarded(j, "MessagePack");
+                break;
        }
    }

@@ -671,7 +668,6 @@ class binary_writer
    @param[in] bjdata_version  which BJData version to use, default is draft2
    @throw type_error.316 if a string value or an object key is not valid
           UTF-8
-    @throw type_error.321 if @a j or a value nested in it is discarded
    */
    void write_ubjson(const BasicJsonType& j, const bool use_count,
                      const bool use_type, const bool add_prefix = true,
@@ -905,7 +901,7 @@ class binary_writer

            case value_t::discarded:
            default:
-                throw_on_discarded(j, use_bjdata ? "BJData" : "UBJSON");
+                break;
        }
    }

@@ -925,15 +921,6 @@ class binary_writer
    }

  private:
-    /*!
-    @brief throws because @a j is discarded and cannot be serialized
-    @throw type_error.321 always
-    */
-    JSON_HEDLEY_NO_RETURN static void throw_on_discarded(const BasicJsonType& j, const char* format_name)
-    {
-        JSON_THROW(type_error::create(321, concat("cannot serialize discarded value to ", format_name), &j));
-    }
-
    //////////
    // BSON //
    //////////
@@ -1185,7 +1172,6 @@ class binary_writer
           into a byte, before anything is written
    @throw type_error.316 if @a j is a string that is not valid UTF-8, before
           anything is written
-    @throw type_error.321 if @a j is discarded
    */
    std::size_t calc_bson_value_size(const BasicJsonType& j)
    {
@@ -1212,12 +1198,10 @@ class binary_writer
            case value_t::null:
                return 0ul;

-            case value_t::discarded:
-                throw_on_discarded(j, "BSON");
-
            // LCOV_EXCL_START
            case value_t::object:
            case value_t::array:
+            case value_t::discarded:
            default:
                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
                return 0ul;
@@ -1254,12 +1238,10 @@ class binary_writer
            case value_t::null:
                return write_bson_null(name);

-            case value_t::discarded:
-                throw_on_discarded(j, "BSON");
-
            // LCOV_EXCL_START
            case value_t::object:
            case value_t::array:
+            case value_t::discarded:
            default:
                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
                return;
@@ -1326,8 +1308,6 @@ class binary_writer
           byte, before anything is written
    @throw type_error.316 if a string value or a key is not valid UTF-8,
           before anything is written
-    @throw type_error.321 if a value nested in @a document is discarded,
-           before anything is written
    */
    std::size_t calc_bson_sizes(const BasicJsonType& document, std::vector<std::size_t>& nested_sizes)
    {
@@ -1366,9 +1366,8 @@ class serializer
    /*!
    @brief dump an integer

-    Dump a given integer, appending it to @ref write_buffer (directly: copying
-    the digits from another buffer right after writing them waits until the
-    stores are done).
+    Dump a given integer, appending it to @ref write_buffer. Works internally with
+    @a number_buffer.

    @param[in] x  integer number (signed or unsigned) to dump
    @tparam NumberType either @a number_integer_t or @a number_unsigned_t
@@ -1403,57 +1402,33 @@ class serializer
            return;
        }

-        // use a pointer to fill the buffer (room for as much as number_buffer holds)
-        if (JSON_HEDLEY_UNLIKELY(write_buffer_pos + number_buffer.size() > write_buffer.size()))
-        {
-            flush();
-        }
-        auto* buffer_ptr = write_buffer.data() + write_buffer_pos;
+        // use a pointer to fill the buffer
+        auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto)

        number_unsigned_t abs_value;

-        // one byte for the minus sign
-        unsigned int n_chars = 0;
+        unsigned int n_chars{};

        if (is_negative_number(x))
        {
            *buffer_ptr = '-';
            abs_value = remove_sign(static_cast<number_integer_t>(x));
-            n_chars = 1;
+
+            // account one more byte for the minus sign
+            n_chars = 1 + count_digits(abs_value);
        }
        else
        {
            abs_value = static_cast<number_unsigned_t>(x);
+            n_chars = count_digits(abs_value);
        }

-        // up to 16 digits: eight at a time (as the digits of floats), written
-        // without leading zeros
-        if (abs_value < 10000000000000000u)
-        {
-            const std::uint64_t value = abs_value;
-            const std::uint64_t upper = value / 100000000u;
-            const std::uint64_t first = dtoa_impl::eight_digit_bytes(upper != 0 ? upper : value);
-            const auto leading = static_cast<unsigned>(count_leading_zeros(first) / 8); // (first is not 0)
-            char* const p = buffer_ptr + n_chars;
-            dtoa_impl::store_msb_first(p, (first << (8 * leading)) + 0x3030303030303030u);
-            n_chars += 8 - leading;
-            if (upper != 0)
-            {
-                dtoa_impl::store_msb_first(p + 8 - leading, dtoa_impl::eight_digit_bytes(value - (upper * 100000000u)) + 0x3030303030303030u);
-                n_chars += 8;
-            }
-            write_buffer_pos += n_chars;
-            return;
-        }
-
-        n_chars += count_digits(abs_value);
-
        // spare 1 byte for '\0'
        JSON_ASSERT(n_chars < number_buffer.size() - 1);

        // jump to the end to generate the string from backward,
        // so we later avoid reversing the result
-        buffer_ptr += n_chars;
+        buffer_ptr += static_cast<typename decltype(number_buffer)::difference_type>(n_chars);

        // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
        // See: https://www.youtube.com/watch?v=o4-CwDo2zpg
@@ -1476,13 +1451,14 @@ class serializer
            *(--buffer_ptr) = static_cast<char>('0' + abs_value);
        }

-        write_buffer_pos += n_chars;
+        put_buffer(number_buffer, n_chars);
    }

    /*!
    @brief dump a floating-point number

-    Dump a given floating-point number, appending it to @ref write_buffer.
+    Dump a given floating-point number, appending it to @ref write_buffer. Works internally
+    with @a number_buffer.

    @param[in] x  floating-point number to dump
    */
@@ -1509,15 +1485,10 @@ class serializer

    void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
    {
-        // directly into the write buffer: copying the text from number_buffer
-        // right after to_chars() wrote it waits until its stores are done
-        if (JSON_HEDLEY_UNLIKELY(write_buffer_pos + number_buffer.size() > write_buffer.size()))
-        {
-            flush();
-        }
-        auto* begin = write_buffer.data() + write_buffer_pos;
+        auto* begin = number_buffer.data();
        auto* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
-        write_buffer_pos += static_cast<std::size_t>(end - begin);
+
+        put_buffer(number_buffer, static_cast<std::size_t>(end - begin));
    }

    JSON_HEDLEY_NON_NULL(1)
@@ -157,12 +157,14 @@ class builder
        if (p[1] == '/')
        {
            p += 2;
-            // (as in parse(), a null byte is the end of the input, so it is
-            // left for the caller to see)
            while (p != e && *p != '\n' && *p != '\r' && !(NulIsEnd && *p == 0))
            {
                ++p;
            }
+            if (NulIsEnd && p != e && *p == 0)
+            {
+                ++p; // as in parse(), a null byte ends the comment like a line break
+            }
            return p;
        }
        if (p[1] == '*')
@@ -613,210 +613,100 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        /// constructor for rvalue binary arrays (internal type)
        json_value(binary_t&& value) : binary(create<binary_t>(std::move(value))) {}

-private:
-        // raw, allocation-free transfer of m_data from src to dst: no
-        // set_parents()/assert_invariant() (the former is O(#children) per
-        // call under JSON_DIAGNOSTICS, which would make the walk below
-        // quadratic); dst takes ownership, src is left as value_t::null.
-        static void take(basic_json& dst, basic_json& src) noexcept
-        {
-            dst.m_data.m_type = src.m_data.m_type;
-            dst.m_data.m_value = src.m_data.m_value;
-            src.m_data.m_type = value_t::null;
-        }
-
-        // true if v is not an array/object, or is an already-empty one
-        static bool has_no_children(const basic_json& v) noexcept
-        {
-            switch (v.m_data.m_type)
-            {
-                case value_t::array:
-                    return v.m_data.m_value.array->empty();
-                case value_t::object:
-                    return v.m_data.m_value.object->empty();
-                default:
-                    return true;
-            }
-        }
-
-        static basic_json& last_child(basic_json& v)
-        {
-            if (v.m_data.m_type == value_t::array)
-            {
-                return v.m_data.m_value.array->back();
-            }
-            JSON_ASSERT(v.m_data.m_type == value_t::object);
-            return v.m_data.m_value.object->rbegin()->second;
-        }
-
-        // removes the last child of a non-empty array/object v; this never
-        // allocates, and since it is only ever called when that child is a
-        // scalar or an already-empty array/object, destroying it never
-        // recurses more than one level deep (see destroy() below)
-        static void pop_last_child(basic_json& v)
-        {
-            if (v.m_data.m_type == value_t::array)
-            {
-                v.m_data.m_value.array->pop_back();
-            }
-            else
-            {
-                JSON_ASSERT(v.m_data.m_type == value_t::object);
-                // erase() needs a forward iterator, so std::prev(end()) is
-                // used here rather than rbegin() (see last_child() above)
-                v.m_data.m_value.object->erase(std::prev(v.m_data.m_value.object->end()));
-            }
-        }
-
-        // deallocates the (already empty) array/object held by v; this is
-        // the same allocator-based free the old recursive implementation
-        // used, just factored out so every level of the walk in destroy()
-        // can share it
-        static void free_container(basic_json& v) noexcept
-        {
-            if (v.m_data.m_type == value_t::array)
-            {
-                JSON_ASSERT(v.m_data.m_value.array->empty());
-                AllocatorType<array_t> alloc;
-                std::allocator_traits<decltype(alloc)>::destroy(alloc, v.m_data.m_value.array);
-                std::allocator_traits<decltype(alloc)>::deallocate(alloc, v.m_data.m_value.array, 1);
-            }
-            else
-            {
-                JSON_ASSERT(v.m_data.m_type == value_t::object);
-                JSON_ASSERT(v.m_data.m_value.object->empty());
-                AllocatorType<object_t> alloc;
-                std::allocator_traits<decltype(alloc)>::destroy(alloc, v.m_data.m_value.object);
-                std::allocator_traits<decltype(alloc)>::deallocate(alloc, v.m_data.m_value.object, 1);
-            }
-            v.m_data.m_type = value_t::null; // avoid a double free if v is later destructed
-        }
-
-public:
-        void destroy_string() noexcept
-        {
-            if (string == nullptr)
-            {
-                // not initialized (e.g., due to exception in the ctor)
-                return;
-            }
-            AllocatorType<string_t> alloc;
-            std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
-            std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
-        }
-
-        void destroy_binary() noexcept
-        {
-            if (binary == nullptr)
-            {
-                // not initialized (e.g., due to exception in the ctor)
-                return;
-            }
-            AllocatorType<binary_t> alloc;
-            std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
-            std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
-        }
-
-        // t must be value_t::array or value_t::object
-        void destroy_container(value_t t) noexcept
+        void destroy(value_t t)
        {
            if (
                (t == value_t::object && object == nullptr) ||
-                (t == value_t::array && array == nullptr)
+                (t == value_t::array && array == nullptr) ||
+                (t == value_t::string && string == nullptr) ||
+                (t == value_t::binary && binary == nullptr)
            )
            {
                // not initialized (e.g., due to exception in the ctor)
                return;
            }
-
-            // Destroy the tree without recursing per nesting level and
-            // without any heap allocation: a heap-allocated flattening
-            // stack (the previous implementation) can itself throw
-            // bad_alloc, which would escape this noexcept destructor and
-            // terminate the program (#5135).
-            //
-            // Instead, walk down the "last child" chain, reversing links
-            // as we go: cur is the container currently being emptied,
-            // and prev is its parent (value_t::null when there is none).
-            // Each parent's last child slot doubles as storage for that
-            // parent's own parent link while we are below it, so no
-            // extra memory is needed. We only ever remove a child once
-            // it is a scalar or an empty array/object, which neither
-            // allocates nor recurses more than one level deep.
-            //
-            // This json_value is not itself a basic_json, so the
-            // top-level container is first moved into a local stand-in
-            // ("cur"); a default-constructed basic_json has a null
-            // pointer in its m_value (see data::m_value's initializer),
-            // so swapping it with *this leaves this union's own pointer
-            // null, and it is never looked at or freed a second time.
-            basic_json cur;
-            cur.m_data.m_type = t;
-            using std::swap;
-            swap(cur.m_data.m_value, *this);
-
-            basic_json prev; // value_t::null: no parent
-
-            while (true)
+            if (t == value_t::array || t == value_t::object)
            {
-                if (has_no_children(cur))
+                // flatten the current json_value to a heap-allocated stack
+                std::vector<basic_json> stack;
+
+                // move the top-level items to stack
+                if (t == value_t::array)
                {
-                    if (prev.m_data.m_type == value_t::null)
-                    {
-                        free_container(cur);
-                        return; // back at the top with nothing left to do
+                    stack.reserve(array->size());
+                    std::move(array->begin(), array->end(), std::back_inserter(stack));
                }
-
-                    // ascend: detach the grandparent link from prev's
-                    // last slot, drop that (now null) slot, free cur
-                    // (it is empty), then move up one level
-                    basic_json gp;
-                    take(gp, last_child(prev));
-                    pop_last_child(prev);
-
-                    free_container(cur);
-
-                    take(cur, prev);
-                    take(prev, gp);
-                    continue;
-                }
-
-                basic_json& cur_last_ref = last_child(cur);
-
-                if (has_no_children(cur_last_ref))
+                else
                {
-                    // scalar, or already-empty array/object
-                    pop_last_child(cur);
-                    continue;
-                }
-
-                // descend into the non-empty last child, reversing the
-                // link: its slot takes over prev, and the child becomes
-                // the new cur
-                basic_json tmp;
-                take(tmp, cur_last_ref);
-                take(cur_last_ref, prev);
-                take(prev, cur);
-                take(cur, tmp);
+                    stack.reserve(object->size());
+                    for (auto&& it : *object)
+                    {
+                        stack.push_back(std::move(it.second));
                    }
                }

-        void destroy(value_t t)
+                while (!stack.empty())
                {
+                    // move the last item to a local variable to be processed
+                    basic_json current_item(std::move(stack.back()));
+                    stack.pop_back();
+
+                    // if current_item is array/object, move
+                    // its children to the stack to be processed later
+                    if (current_item.is_array())
+                    {
+                        std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
+
+                        current_item.m_data.m_value.array->clear();
+                    }
+                    else if (current_item.is_object())
+                    {
+                        for (auto&& it : *current_item.m_data.m_value.object)
+                        {
+                            stack.push_back(std::move(it.second));
+                        }
+
+                        current_item.m_data.m_value.object->clear();
+                    }
+
+                    // it's now safe that current_item gets destructed
+                    // since it doesn't have any children
+                }
+            }
+
            switch (t)
            {
-                case value_t::string:
-                    destroy_string();
+                case value_t::object:
+                {
+                    AllocatorType<object_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
                    break;
+                }
+
+                case value_t::array:
+                {
+                    AllocatorType<array_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
+                    break;
+                }

                case value_t::binary:
-                    destroy_binary();
-                    break;
-
-                case value_t::object:
-                case value_t::array:
-                    destroy_container(t);
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
                    break;
+                }

                case value_t::null:
                case value_t::boolean:
@@ -825,9 +715,11 @@ public:
                case value_t::number_float:
                case value_t::discarded:
                default:
+                {
                    break;
                }
            }
+        }
    };

  private:
@@ -3601,13 +3493,9 @@ public:
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    ValueType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, const ValueType& default_value) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return value(ptr.convert(), default_value);
    }
-#endif

    template < class ValueType, class BasicJsonType, class ReturnType = typename value_return_type<ValueType>::type,
               detail::enable_if_t <
@@ -3616,13 +3504,9 @@ public:
                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    ReturnType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, ValueType && default_value) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return value(ptr.convert(), std::forward<ValueType>(default_value));
    }
-#endif

    /// @brief access the first element
    /// @sa https://json.nlohmann.me/api/basic_json/front/
@@ -3980,13 +3864,9 @@ public:
    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return ptr.contains(this);
    }
-#endif

    /// @}

@@ -4097,13 +3977,9 @@ public:
    ///             that is, replace `json::iterator_wrapper(j)` with `j.items()`.
    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
    static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return ref.items();
    }
-#endif

    /// @brief wrapper to access iterator member functions in range-based for
    /// @sa https://json.nlohmann.me/api/basic_json/items/
@@ -4112,13 +3988,9 @@ public:
    ///         that is, replace `json::iterator_wrapper(j)` with `j.items()`.
    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
    static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return ref.items();
    }
-#endif

    /// @brief helper to access iterator member functions in range-based for
    /// @sa https://json.nlohmann.me/api/basic_json/items/
@@ -5207,7 +5079,7 @@ public:
    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
    template<typename ScalarType>
    requires std::is_scalar_v<ScalarType>
-    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) <= rhs;
    }
@@ -5216,7 +5088,7 @@ public:
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
    template<typename ScalarType>
    requires std::is_scalar_v<ScalarType>
-    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) >= rhs;
    }
@@ -5237,16 +5109,11 @@ public:
 #endif
    }

-    // The friend comparisons with a scalar name the JSON type via decltype of
-    // their parameter in noexcept, because older MSVC versions do not see the
-    // class scope there: MSVC 2015 and 2017 take basic_json as the template,
-    // and MSVC 2019 16.0 rejects member types and template parameters.
-
    /// @brief comparison: equal
    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator==(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator==(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return lhs == basic_json(rhs);
    }
@@ -5255,7 +5122,7 @@ public:
    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator==(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator==(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) == rhs;
    }
@@ -5271,7 +5138,7 @@ public:
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return lhs != basic_json(rhs);
    }
@@ -5280,7 +5147,7 @@ public:
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) != rhs;
    }
@@ -5300,7 +5167,7 @@ public:
    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator<(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator<(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return lhs < basic_json(rhs);
    }
@@ -5309,7 +5176,7 @@ public:
    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator<(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator<(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) < rhs;
    }
@@ -5329,7 +5196,7 @@ public:
    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return lhs <= basic_json(rhs);
    }
@@ -5338,7 +5205,7 @@ public:
    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) <= rhs;
    }
@@ -5359,7 +5226,7 @@ public:
    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator>(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator>(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return lhs > basic_json(rhs);
    }
@@ -5368,7 +5235,7 @@ public:
    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator>(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator>(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) > rhs;
    }
@@ -5388,7 +5255,7 @@ public:
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(lhs)>, ScalarType>::value)
+    friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return lhs >= basic_json(rhs);
    }
@@ -5397,7 +5264,7 @@ public:
    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
    template<typename ScalarType, typename std::enable_if<
                 std::is_scalar<ScalarType>::value, int>::type = 0>
-    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<detail::uncvref_t<decltype(rhs)>, ScalarType>::value)
+    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept(std::is_nothrow_constructible<basic_json, ScalarType>::value)
    {
        return basic_json(lhs) >= rhs;
    }
@@ -5433,9 +5300,6 @@ public:
        return o;
    }

-#if !JSON_DELETE_DEPRECATED_FUNCTIONS
-    // the deleted version is a function template after the class, because
-    // GCC < 5 and Clang < 10 reject deleted friend functions in class templates
    /// @brief serialize to stream
    /// @sa https://json.nlohmann.me/api/operator_ltlt/
    /// @deprecated This function is deprecated since 3.0.0 and will be removed in
@@ -5447,7 +5311,6 @@ public:
    {
        return o << j;
    }
-#endif
 #endif  // JSON_NO_IO
    /// @}

@@ -5499,16 +5362,12 @@ public:
                            const bool allow_exceptions = true,
                            const bool ignore_comments = false,
                            const bool ignore_trailing_commas = false)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        basic_json result;
        auto p = parser(i.get(), std::move(cb), allow_exceptions, ignore_comments, ignore_trailing_commas);
        p.parse(true, result);
        return result;
    }
-#endif

    /// @brief check if the input is valid JSON
    /// @sa https://json.nlohmann.me/api/basic_json/accept/
@@ -5538,13 +5397,9 @@ public:
    static bool accept(detail::span_input_adapter&& i,
                       const bool ignore_comments = false,
                       const bool ignore_trailing_commas = false)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return parser(i.get(), nullptr, false, ignore_comments, ignore_trailing_commas, true).accept(true);
    }
-#endif

    /// @brief generate SAX events
    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
@@ -5605,9 +5460,6 @@ public:
                          const bool strict = true,
                          const bool ignore_comments = false,
                          const bool ignore_trailing_commas = false)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        auto ia = i.get();
        return format == input_format_t::json
@@ -5616,14 +5468,10 @@ public:
               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(sax, strict);
    }
-#endif
 #if defined(__clang__)
 #pragma clang diagnostic pop
 #endif
 #ifndef JSON_NO_IO
-#if !JSON_DELETE_DEPRECATED_FUNCTIONS
-    // the deleted version is a function template after the class, because
-    // GCC < 5 and Clang < 10 reject deleted friend functions in class templates
    /// @brief deserialize from stream
    /// @sa https://json.nlohmann.me/api/operator_gtgt/
    /// @deprecated This stream operator is deprecated since 3.0.0 and will be removed in
@@ -5635,7 +5483,6 @@ public:
    {
        return operator>>(i, j);
    }
-#endif

    /// @brief deserialize from stream
    /// @sa https://json.nlohmann.me/api/operator_gtgt/
@@ -5961,13 +5808,9 @@ public:
                                const bool strict = true,
                                const bool allow_exceptions = true,
                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
    }
-#endif

    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
@@ -5975,13 +5818,9 @@ public:
                                const bool strict = true,
                                const bool allow_exceptions = true,
                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return from_binary_impl(i.get(), input_format_t::cbor, strict, allow_exceptions, error_handler_t::keep, tag_handler);
    }
-#endif

    /// @brief create a JSON value from an input in MessagePack format
    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
@@ -6014,26 +5853,18 @@ public:
    static basic_json from_msgpack(const T* ptr, std::size_t len,
                                   const bool strict = true,
                                   const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
    }
-#endif

    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
    static basic_json from_msgpack(detail::span_input_adapter&& i,
                                   const bool strict = true,
                                   const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return from_binary_impl(i.get(), input_format_t::msgpack, strict, allow_exceptions);
    }
-#endif

    /// @brief create a JSON value from an input in UBJSON format
    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
@@ -6066,26 +5897,18 @@ public:
    static basic_json from_ubjson(const T* ptr, std::size_t len,
                                  const bool strict = true,
                                  const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
    }
-#endif

    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
    static basic_json from_ubjson(detail::span_input_adapter&& i,
                                  const bool strict = true,
                                  const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return from_binary_impl(i.get(), input_format_t::ubjson, strict, allow_exceptions);
    }
-#endif

    /// @brief create a JSON value from an input in BJData format
    /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
@@ -6112,20 +5935,6 @@ public:
        return from_binary_impl(detail::input_adapter(std::move(first), std::move(last)), input_format_t::bjdata, strict, allow_exceptions, error_handler);
    }

-    template<typename T>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    JSON_HEDLEY_DEPRECATED_FOR(3.13.0, from_bjdata(ptr, ptr + len))
-    static basic_json from_bjdata(const T* ptr, std::size_t len,
-                                  const bool strict = true,
-                                  const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
-    {
-        return from_bjdata(ptr, ptr + len, strict, allow_exceptions);
-    }
-#endif
-
    /// @brief create a JSON value from an input in BON8 format
    /// @sa https://json.nlohmann.me/api/basic_json/from_bon8/
    template<typename InputType>
@@ -6149,20 +5958,6 @@ public:
        return from_binary_impl(detail::input_adapter(std::move(first), std::move(last)), input_format_t::bon8, strict, allow_exceptions);
    }

-    template<typename T>
-    JSON_HEDLEY_WARN_UNUSED_RESULT
-    JSON_HEDLEY_DEPRECATED_FOR(3.13.0, from_bon8(ptr, ptr + len))
-    static basic_json from_bon8(const T* ptr, std::size_t len,
-                                const bool strict = true,
-                                const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
-    {
-        return from_bon8(ptr, ptr + len, strict, allow_exceptions);
-    }
-#endif
-
    /// @brief create a JSON value from an input in BSON format
    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
    template<typename InputType>
@@ -6194,26 +5989,18 @@ public:
    static basic_json from_bson(const T* ptr, std::size_t len,
                                const bool strict = true,
                                const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return from_bson(ptr, ptr + len, strict, allow_exceptions);
    }
-#endif

    JSON_HEDLEY_WARN_UNUSED_RESULT
    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
    static basic_json from_bson(detail::span_input_adapter&& i,
                                const bool strict = true,
                                const bool allow_exceptions = true)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return from_binary_impl(i.get(), input_format_t::bson, strict, allow_exceptions);
    }
-#endif
    /// @}

    //////////////////////////
@@ -6233,13 +6020,9 @@ public:
    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return ptr.get_unchecked(this);
    }
-#endif

    /// @brief access specified element via JSON Pointer
    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
@@ -6251,13 +6034,9 @@ public:
    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    const_reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return ptr.get_unchecked(this);
    }
-#endif

    /// @brief access specified element via JSON Pointer
    /// @sa https://json.nlohmann.me/api/basic_json/at/
@@ -6269,13 +6048,9 @@ public:
    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return ptr.get_checked(this);
    }
-#endif

    /// @brief access specified element via JSON Pointer
    /// @sa https://json.nlohmann.me/api/basic_json/at/
@@ -6287,13 +6062,9 @@ public:
    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
    const_reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
    {
        return ptr.get_checked(this);
    }
-#endif

    /// @brief return flattened JSON value
    /// @sa https://json.nlohmann.me/api/basic_json/flatten/
@@ -7270,18 +7041,6 @@ std::string format_as(const NLOHMANN_BASIC_JSON_TPL& j)
    return j.dump();
 }

-#if JSON_DELETE_DEPRECATED_FUNCTIONS && !defined(JSON_NO_IO)
-    /// @brief serialize to stream (deleted; use operator<<(std::ostream&, const basic_json&))
-    /// @sa https://json.nlohmann.me/api/operator_ltlt/
-    NLOHMANN_BASIC_JSON_TPL_DECLARATION
-    std::ostream& operator>>(const NLOHMANN_BASIC_JSON_TPL& j, std::ostream& o) = delete;
-
-    /// @brief deserialize from stream (deleted; use operator>>(std::istream&, basic_json&))
-    /// @sa https://json.nlohmann.me/api/operator_gtgt/
-    NLOHMANN_BASIC_JSON_TPL_DECLARATION
-    std::istream& operator<<(NLOHMANN_BASIC_JSON_TPL& j, std::istream& i) = delete;
-#endif
-
 NLOHMANN_JSON_NAMESPACE_END

 ///////////////////////
@@ -67,10 +67,6 @@
    #define JSON_STRICT_BINARY_UTF8 0
 #endif

-#ifndef JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-    #define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS 0
-#endif
-
 #if JSON_DIAGNOSTICS
    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
 #else
@@ -113,20 +109,14 @@
    #define NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8
 #endif

-#if JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-    #define NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS _ekmo
-#else
-    #define NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS
-#endif
-
 #ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
    #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
 #endif

 // Construct the namespace ABI tags component
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h) json_abi ## a ## b ## c ## d ## e ## f ## g ## h
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g, h) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g) json_abi ## a ## b ## c ## d ## e ## f ## g
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g)

 #define NLOHMANN_JSON_ABI_TAGS                                       \
    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
@@ -136,8 +126,7 @@
            NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS,         \
            NLOHMANN_JSON_ABI_TAG_PRECISE_STREAM_POSITION,           \
            NLOHMANN_JSON_ABI_TAG_STRICT_NUL_HANDLING,               \
-            NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8,                \
-            NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS)
+            NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8)

 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
@@ -701,12 +701,14 @@ class builder
        if (p[1] == '/')
        {
            p += 2;
-            // (as in parse(), a null byte is the end of the input, so it is
-            // left for the caller to see)
            while (p != e && *p != '\n' && *p != '\r' && !(NulIsEnd && *p == 0))
            {
                ++p;
            }
+            if (NulIsEnd && p != e && *p == 0)
+            {
+                ++p; // as in parse(), a null byte ends the comment like a line break
+            }
            return p;
        }
        if (p[1] == '*')
@@ -8,7 +8,6 @@ set(JSON_SIMDUTF_VERSION 9.1.0 CACHE STRING "The simdutf version used by JSON_Te

 set(JSON_32bitTest     AUTO CACHE STRING "Enable the 32bit unit test (ON/OFF/AUTO/ONLY).")
 set(JSON_TestStandards "" CACHE STRING "The list of standards to test explicitly.")
-set(JSON_TestShard     "" CACHE STRING "Build only a part of the unit tests, given as <index>/<count> (e.g. 0/2), to split them across CI jobs with a time limit.")

 # using an env var, since this will also affect targets executing cmake (such as "ci_test_compiler_default")
 if (NOT "" STREQUAL "$ENV{JSON_FORCED_GLOBAL_COMPILE_OPTIONS}")
@@ -289,33 +288,6 @@ elseif(NOT json_32bit_test)
    list(FILTER files EXCLUDE REGEX src/unit-32bit.cpp)
 endif()

-# with JSON_TestShard=<index>/<count>, keep every <count>-th unit test file,
-# starting at <index> (the glob is sorted, so the split is stable)
-set(test_shard_index 0)
-if(NOT "${JSON_TestShard}" STREQUAL "")
-    if(NOT JSON_TestShard MATCHES "^([0-9]+)/([1-9][0-9]*)$")
-        message(FATAL_ERROR "JSON_TestShard must be <index>/<count>, e.g. 0/2, not '${JSON_TestShard}'.")
-    endif()
-    set(test_shard_index ${CMAKE_MATCH_1})
-    set(test_shard_count ${CMAKE_MATCH_2})
-    if(NOT test_shard_index LESS test_shard_count)
-        message(FATAL_ERROR "JSON_TestShard: the index must be less than the count, not '${JSON_TestShard}'.")
-    endif()
-    list(LENGTH files test_file_count)
-    set(shard_files "")
-    set(file_position 0)
-    foreach(file ${files})
-        math(EXPR file_shard "${file_position} % ${test_shard_count}")
-        if(file_shard EQUAL test_shard_index)
-            list(APPEND shard_files ${file})
-        endif()
-        math(EXPR file_position "${file_position} + 1")
-    endforeach()
-    set(files ${shard_files})
-    list(LENGTH files shard_file_count)
-    message(STATUS "Test shard ${JSON_TestShard}: ${shard_file_count} of ${test_file_count} unit test files")
-endif()
-
 foreach(file ${files})
    json_test_add_test_for(${file} MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force})
 endforeach()
@@ -333,9 +305,6 @@ if(json_32bit_test_only)
    return()
 endif()

-# the following variants of single test files are only built in the first shard
-if(test_shard_index EQUAL 0)
-
 # test legacy comparison of discarded values
 json_test_set_test_options(test-comparison_legacy
    COMPILE_DEFINITIONS JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1
@@ -363,8 +332,6 @@ json_test_add_test_for(src/unit-diagnostic-positions.cpp
    MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force}
 )

-endif()
-
 # *DO NOT* use json_test_set_test_options() below this line

 #############################################################################
@@ -48,10 +48,6 @@ TEST_CASE("default namespace")
        expected += "_sbu8";
 #endif

-#if JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-        expected += "_ekmo";
-#endif
-
        expected += "_v" STRINGIZE(NLOHMANN_JSON_VERSION_MAJOR);
        expected += "_" STRINGIZE(NLOHMANN_JSON_VERSION_MINOR);
        expected += "_" STRINGIZE(NLOHMANN_JSON_VERSION_PATCH) "::basic_json";
@@ -49,10 +49,6 @@ TEST_CASE("default namespace without version component")
        expected += "_sbu8";
 #endif

-#if JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-        expected += "_ekmo";
-#endif
-
        expected += "::basic_json";

        // fallback for Clang
@@ -521,10 +521,6 @@ struct countdown_allocator : std::allocator<T>

 TEST_CASE("converting a deeply nested value from another specialization fails cleanly (#5650)")
 {
-    // MSVC 2015's debug STL constructs the containers' debug proxies through
-    // the allocator in noexcept constructors, so a failing construction crashes
-    // the program there instead of throwing std::bad_alloc. Nothing to check.
-#if !(defined(_MSC_VER) && _MSC_VER < 1910 && defined(_ITERATOR_DEBUG_LEVEL) && _ITERATOR_DEBUG_LEVEL > 0)
    using countdown_json = nlohmann::basic_json<std::map,
          std::vector,
          std::string,
@@ -562,7 +558,6 @@ TEST_CASE("converting a deeply nested value from another specialization fails cl
        }
    }
    CHECK(failures > 0);
-#endif
 }

 namespace
@@ -607,88 +602,3 @@ TEST_CASE("bad my_allocator::construct")
        j["test"].push_back("should not leak");
    }
 }
-
-namespace
-{
-std::size_t counting_allocator_allocations = 0;
-std::size_t counting_allocator_deallocations = 0;
-
-template<class T>
-struct counting_allocator : std::allocator<T>
-{
-    using std::allocator<T>::allocator;
-
-    T* allocate(std::size_t n)
-    {
-        ++counting_allocator_allocations;
-        return std::allocator<T>::allocate(n);
-    }
-
-    void deallocate(T* p, std::size_t n)
-    {
-        ++counting_allocator_deallocations;
-        std::allocator<T>::deallocate(p, n);
-    }
-
-    template <class U>
-    struct rebind
-    {
-        using other = counting_allocator<U>;
-    };
-};
-} // namespace
-
-TEST_CASE("destructor performs no allocation, only deallocation")
-{
-    // see https://github.com/nlohmann/json/issues/4842 and
-    // https://github.com/nlohmann/json/issues/5135: destroying nested
-    // arrays/objects used to allocate a temporary stack (first with
-    // std::allocator, later - after #4842 - with the provided allocator).
-    // Since that stack could itself throw bad_alloc from inside the
-    // noexcept destructor (#5135), destroy() no longer allocates anything:
-    // it only ever frees what is already there.
-    using counting_json = nlohmann::basic_json<std::map,
-          std::vector,
-          std::string,
-          bool,
-          std::int64_t,
-          std::uint64_t,
-          double,
-          counting_allocator>;
-
-    SECTION("array")
-    {
-        auto* j = new counting_json({1, {2, {3, 4}}, 5}); // NOLINT(cppcoreguidelines-owning-memory)
-        const auto allocations_before = counting_allocator_allocations;
-        const auto deallocations_before = counting_allocator_deallocations;
-        delete j; // NOLINT(cppcoreguidelines-owning-memory)
-        CHECK(counting_allocator_allocations == allocations_before);
-        CHECK(counting_allocator_deallocations > deallocations_before);
-    }
-
-    SECTION("object")
-    {
-        auto* j = new counting_json({{"a", {{"b", {1, 2}}}}, {"c", 3}}); // NOLINT(cppcoreguidelines-owning-memory)
-        const auto allocations_before = counting_allocator_allocations;
-        const auto deallocations_before = counting_allocator_deallocations;
-        delete j; // NOLINT(cppcoreguidelines-owning-memory)
-        CHECK(counting_allocator_allocations == allocations_before);
-        CHECK(counting_allocator_deallocations > deallocations_before);
-    }
-
-    SECTION("mixed tree of empty/non-empty arrays and objects")
-    {
-        auto* j = new counting_json( // NOLINT(cppcoreguidelines-owning-memory)
-        {
-            {"empty_obj", counting_json::object()},
-            {"empty_arr", counting_json::array()},
-            {"nested", {{"a", counting_json::array({1, 2, counting_json::object()})}, {"b", 3}}},
-            {"tail", counting_json::array({counting_json::array({1}), 2, counting_json::array({3})})}
-        });
-        const auto allocations_before = counting_allocator_allocations;
-        const auto deallocations_before = counting_allocator_deallocations;
-        delete j; // NOLINT(cppcoreguidelines-owning-memory)
-        CHECK(counting_allocator_allocations == allocations_before);
-        CHECK(counting_allocator_deallocations > deallocations_before);
-    }
-}
@@ -11,12 +11,7 @@
 #include <nlohmann/json.hpp>
 using nlohmann::json;

-#include <cmath>
 #include <fstream>
-#include <limits>
-#include <map>
-#include <string>
-#include <vector>
 #include "make_test_data_available.hpp"

 TEST_CASE("Binary Formats" * doctest::skip())
@@ -38,7 +33,7 @@ TEST_CASE("Binary Formats" * doctest::skip())
        const auto ubjson_2_size = json::to_ubjson(j, true).size();
        const auto ubjson_3_size = json::to_ubjson(j, true, true).size();

-        CHECK(json_size == 2090234);
+        CHECK(json_size == 2090303);
        CHECK(bjdata_1_size == 1112030);
        CHECK(bjdata_2_size == 1224148);
        CHECK(bjdata_3_size == 1224148);
@@ -51,16 +46,16 @@ TEST_CASE("Binary Formats" * doctest::skip())
        CHECK(ubjson_3_size == 1169069);

        CHECK((100.0 * double(json_size) / double(json_size)) == Approx(100.0));
-        CHECK((100.0 * double(bjdata_1_size) / double(json_size)) == Approx(53.201));
-        CHECK((100.0 * double(bjdata_2_size) / double(json_size)) == Approx(58.565));
-        CHECK((100.0 * double(bjdata_3_size) / double(json_size)) == Approx(58.565));
-        CHECK((100.0 * double(bon8_size) / double(json_size)) == Approx(50.511));
-        CHECK((100.0 * double(bson_size) / double(json_size)) == Approx(85.853));
-        CHECK((100.0 * double(cbor_size) / double(json_size)) == Approx(50.499));
-        CHECK((100.0 * double(msgpack_size) / double(json_size)) == Approx(50.528));
-        CHECK((100.0 * double(ubjson_1_size) / double(json_size)) == Approx(53.201));
-        CHECK((100.0 * double(ubjson_2_size) / double(json_size)) == Approx(58.565));
-        CHECK((100.0 * double(ubjson_3_size) / double(json_size)) == Approx(55.930));
+        CHECK((100.0 * double(bjdata_1_size) / double(json_size)) == Approx(53.199));
+        CHECK((100.0 * double(bjdata_2_size) / double(json_size)) == Approx(58.563));
+        CHECK((100.0 * double(bjdata_3_size) / double(json_size)) == Approx(58.563));
+        CHECK((100.0 * double(bon8_size) / double(json_size)) == Approx(50.509));
+        CHECK((100.0 * double(bson_size) / double(json_size)) == Approx(85.849));
+        CHECK((100.0 * double(cbor_size) / double(json_size)) == Approx(50.497));
+        CHECK((100.0 * double(msgpack_size) / double(json_size)) == Approx(50.526));
+        CHECK((100.0 * double(ubjson_1_size) / double(json_size)) == Approx(53.199));
+        CHECK((100.0 * double(ubjson_2_size) / double(json_size)) == Approx(58.563));
+        CHECK((100.0 * double(ubjson_3_size) / double(json_size)) == Approx(55.928));
    }

    SECTION("twitter.json")
@@ -229,139 +224,3 @@ TEST_CASE("Binary Formats" * doctest::skip())
        CHECK((100.0 * double(ubjson_3_size) / double(json_size)) == Approx(89.450));
    }
 }
-
-namespace
-{
-// the binary formats as function pointers for "Binary formats with narrow number types";
-// named functions rather than lambdas, because clang 3.5 cannot convert a lambda
-// to a function pointer in the braced initializer of the format table
-using narrow_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int32_t, std::uint32_t, float>;
-using bytes = std::vector<std::uint8_t>;
-
-bytes encode_cbor(const json& j)
-{
-    return json::to_cbor(j);
-}
-narrow_json decode_cbor(const bytes& v, bool allow_exceptions)
-{
-    return narrow_json::from_cbor(v, true, allow_exceptions);
-}
-
-bytes encode_msgpack(const json& j)
-{
-    return json::to_msgpack(j);
-}
-narrow_json decode_msgpack(const bytes& v, bool allow_exceptions)
-{
-    return narrow_json::from_msgpack(v, true, allow_exceptions);
-}
-
-bytes encode_ubjson(const json& j)
-{
-    return json::to_ubjson(j);
-}
-narrow_json decode_ubjson(const bytes& v, bool allow_exceptions)
-{
-    return narrow_json::from_ubjson(v, true, allow_exceptions);
-}
-
-bytes encode_bjdata(const json& j)
-{
-    return json::to_bjdata(j);
-}
-narrow_json decode_bjdata(const bytes& v, bool allow_exceptions)
-{
-    return narrow_json::from_bjdata(v, true, allow_exceptions);
-}
-
-// BSON can only store numbers as object members
-bytes encode_bson(const json& j)
-{
-    return json::to_bson(json{{"a", j}});
-}
-narrow_json decode_bson(const bytes& v, bool allow_exceptions)
-{
-    const auto result = narrow_json::from_bson(v, true, allow_exceptions);
-    return result.is_discarded() ? result : result.at("a");
-}
-
-bytes encode_bon8(const json& j)
-{
-    return json::to_bon8(j);
-}
-narrow_json decode_bon8(const bytes& v, bool allow_exceptions)
-{
-    return narrow_json::from_bon8(v, true, allow_exceptions);
-}
-
-} // namespace
-
-TEST_CASE("Binary formats with narrow number types")
-{
-    // Numbers that do not fit the number types are handled like the lexer
-    // handles them in JSON text: an integer that fits neither integer type is
-    // stored as a floating-point number, and a finite floating-point number
-    // that overflows number_float_t is rejected with out_of_range.406.
-    struct binary_format
-    {
-        const char* name;
-        bytes (*encode)(const json&);
-        narrow_json (*decode)(const bytes&, bool);
-    };
-
-    const std::vector<binary_format> formats =
-    {
-        {"CBOR", encode_cbor, decode_cbor},
-        {"MessagePack", encode_msgpack, decode_msgpack},
-        {"UBJSON", encode_ubjson, decode_ubjson},
-        {"BJData", encode_bjdata, decode_bjdata},
-        {"BSON", encode_bson, decode_bson},
-        {"BON8", encode_bon8, decode_bon8},
-    };
-
-    for (const auto& format : formats)
-    {
-        const std::string name = format.name;
-        INFO("format := ", name);
-        const auto roundtrip = [&format](const json & j)
-        {
-            return format.decode(format.encode(j), true);
-        };
-
-        // integers that fit keep their type
-        CHECK(roundtrip(json(-5)).is_number_integer());
-        CHECK(roundtrip(json(-5)).get<std::int32_t>() == -5);
-        CHECK(roundtrip(json(3000000000u)).is_number_unsigned());
-        CHECK(roundtrip(json(3000000000u)).get<std::uint32_t>() == 3000000000u);
-
-        // integers that fit neither integer type are stored as float
-        CHECK(roundtrip(json(5000000000u)).is_number_float());
-        CHECK(roundtrip(json(5000000000u)).get<float>() == 5000000000.0f);
-        if (name != "BON8") // BON8 cannot encode integers above INT64_MAX
-        {
-            CHECK(roundtrip(json(10000000000000000000u)).is_number_float());
-            CHECK(roundtrip(json(10000000000000000000u)).get<float>() == 10000000000000000000.0f);
-        }
-        CHECK(roundtrip(json(-3000000000LL)).is_number_float());
-        CHECK(roundtrip(json(-3000000000LL)).get<float>() == -3000000000.0f);
-        CHECK(roundtrip(json(-5000000000LL)).is_number_float());
-        CHECK(roundtrip(json(-5000000000LL)).get<float>() == -5000000000.0f);
-
-        // floating-point numbers that fit
-        CHECK(roundtrip(json(1.5)).get<float>() == 1.5f);
-        const auto just_above_max = std::nextafter(static_cast<double>((std::numeric_limits<float>::max)()),
-                                    std::numeric_limits<double>::infinity());
-        CHECK(roundtrip(json(just_above_max)).get<float>() == (std::numeric_limits<float>::max)());
-
-        // infinity and NaN are passed on
-        CHECK(std::isinf(roundtrip(json(std::numeric_limits<double>::infinity())).get<float>()));
-        CHECK(std::isnan(roundtrip(json(std::numeric_limits<double>::quiet_NaN())).get<float>()));
-
-        // finite floating-point numbers that overflow number_float_t are rejected
-        const std::string message = "[json.exception.out_of_range.406] syntax error while parsing " + name
-                                    + " value: number overflow";
-        CHECK_THROWS_WITH_AS(roundtrip(json(1e300)), message.c_str(), narrow_json::out_of_range&);
-        CHECK_THROWS_WITH_AS(roundtrip(json(-1e300)), message.c_str(), narrow_json::out_of_range&);
-        CHECK(format.decode(format.encode(json(1e300)), false).is_discarded());
-    }
-}
@@ -9,14 +9,6 @@
 #include "doctest_compatibility.h"

 #define JSON_TESTS_PRIVATE
-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;

@@ -114,59 +106,10 @@ TEST_CASE("BJData")
    {
        SECTION("discarded")
        {
-            // a discarded value cannot be serialized to BJData
+            // discarded values are not serialized
            json const j = json::value_t::discarded;
-            CHECK_THROWS_WITH_AS(json::to_bjdata(j), "[json.exception.type_error.321] cannot serialize discarded value to BJData", json::type_error&);
-        }
-
-        SECTION("discarded values nested in a container")
-        {
-            json const discarded = json::value_t::discarded;
-
-            SECTION("in an array")
-            {
-                json const j = {1, discarded, 2};
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_bjdata(j), "[json.exception.type_error.321] (/1) cannot serialize discarded value to BJData", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_bjdata(j), "[json.exception.type_error.321] cannot serialize discarded value to BJData", json::type_error&);
-#endif
-            }
-
-            SECTION("as an object value")
-            {
-                json j;
-                j["a"] = 1;
-                j["b"] = discarded;
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_bjdata(j), "[json.exception.type_error.321] (/b) cannot serialize discarded value to BJData", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_bjdata(j), "[json.exception.type_error.321] cannot serialize discarded value to BJData", json::type_error&);
-#endif
-            }
-
-            SECTION("nested deeper (array in object in array)")
-            {
-                json inner_array = {1, discarded};
-                json middle_object;
-                middle_object["x"] = inner_array;
-                json const j = {middle_object};
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_bjdata(j), "[json.exception.type_error.321] (/0/x/1) cannot serialize discarded value to BJData", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_bjdata(j), "[json.exception.type_error.321] cannot serialize discarded value to BJData", json::type_error&);
-#endif
-            }
-
-            SECTION("optimized array of all-discarded elements")
-            {
-                json const j = {discarded, discarded};
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_bjdata(j, true, true), "[json.exception.type_error.321] (/0) cannot serialize discarded value to BJData", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_bjdata(j, true, true), "[json.exception.type_error.321] cannot serialize discarded value to BJData", json::type_error&);
-#endif
-            }
+            const auto result = json::to_bjdata(j);
+            CHECK(result.empty());
        }

        SECTION("null")
@@ -4547,33 +4490,3 @@ TEST_CASE("BJData roundtrips" * doctest::skip())
        }
    }
 }
-
-TEST_CASE("issue #5648 - from_bjdata(ptr, len) must read len bytes, not treat ptr as a C string")
-{
-    // to_bjdata() encodes the integer 0 as the two bytes 'i' 0x00 (a BJData
-    // type marker followed by the value byte 0x00), so the packed data
-    // below contains a 0x00 byte before its end.
-    const json j = {{"a", 0}};
-    const std::vector<std::uint8_t> packed = json::to_bjdata(j);
-    bool contains_nul = false;
-    for (const auto byte : packed)
-    {
-        contains_nul |= (byte == 0x00);
-    }
-    REQUIRE(contains_nul);
-
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-    // before the fix, from_bjdata had no (ptr, len) overload, so this call
-    // bound to from_bjdata(InputType&&, bool strict) instead: ptr was read
-    // as a NUL-terminated C string (stopping at the embedded 0x00 byte), and
-    // len was silently converted to the strict flag. The deprecated
-    // overload added for this issue forwards to from_bjdata(ptr, ptr + len,
-    // ...) instead, like from_ubjson's deprecated (ptr, len) overload does.
-    json result;
-    CHECK_NOTHROW(result = json::from_bjdata(packed.data(), packed.size()));
-    CHECK(result == j);
-
-    // len must not collapse into the strict flag either
-    CHECK(json::from_bjdata(packed.data(), packed.size(), false) == j);
-#endif
-}
@@ -8,14 +8,6 @@

 #include "doctest_compatibility.h"

-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #ifdef JSON_TEST_NO_GLOBAL_UDLS
@@ -1022,36 +1014,6 @@ TEST_CASE("BON8 roundtrips" * doctest::skip())
    }
 }

-TEST_CASE("issue #5648 - from_bon8(ptr, len) must read len bytes, not treat ptr as a C string")
-{
-    // to_bon8() encodes the integer 40 as the two bytes 0xC2 0x00 (a BON8
-    // lead byte followed by a continuation byte of 0x00), so the packed data
-    // below contains a 0x00 byte before its end.
-    const json j = {{"a", 40}, {"b", "x"}};
-    const std::vector<std::uint8_t> packed = json::to_bon8(j);
-    bool contains_nul = false;
-    for (const auto byte : packed)
-    {
-        contains_nul |= (byte == 0x00);
-    }
-    REQUIRE(contains_nul);
-
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-    // before the fix, from_bon8 had no (ptr, len) overload, so this call
-    // bound to from_bon8(InputType&&, bool strict) instead: ptr was read as
-    // a NUL-terminated C string (stopping at the embedded 0x00 byte), and
-    // len was silently converted to the strict flag. The deprecated
-    // overload added for this issue forwards to from_bon8(ptr, ptr + len,
-    // ...) instead, like from_cbor's deprecated (ptr, len) overload does.
-    json result;
-    CHECK_NOTHROW(result = json::from_bon8(packed.data(), packed.size()));
-    CHECK(result == j);
-
-    // len must not collapse into the strict flag either
-    CHECK(json::from_bon8(packed.data(), packed.size(), false) == j);
-#endif
-}
-
 #ifdef JSON_HAS_CPP_17
 TEST_CASE("BON8 with std::byte")
 {
@@ -8,14 +8,6 @@

 #include "doctest_compatibility.h"

-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;

@@ -149,54 +141,6 @@ TEST_CASE("BSON")
            json const j = std::vector<int> {1, 2, 3, 4, 5, 6, 7};
            CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.317] to serialize to BSON, top-level type must be object, but is array", json::type_error&);
        }
-
-        SECTION("discarded")
-        {
-            json const j = json::value_t::discarded;
-            CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.317] to serialize to BSON, top-level type must be object, but is discarded", json::type_error&);
-        }
-    }
-
-    SECTION("discarded values nested in a container cannot be serialized to BSON")
-    {
-        json const discarded = json::value_t::discarded;
-
-        SECTION("as an object value")
-        {
-            json j;
-            j["a"] = 1;
-            j["b"] = discarded;
-#if JSON_DIAGNOSTICS
-            CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.321] (/b) cannot serialize discarded value to BSON", json::type_error&);
-#else
-            CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.321] cannot serialize discarded value to BSON", json::type_error&);
-#endif
-        }
-
-        SECTION("in an array that is an object value")
-        {
-            json j;
-            j["a"] = json::array({1, discarded, 2});
-#if JSON_DIAGNOSTICS
-            CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.321] (/a/1) cannot serialize discarded value to BSON", json::type_error&);
-#else
-            CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.321] cannot serialize discarded value to BSON", json::type_error&);
-#endif
-        }
-
-        SECTION("nested deeper (array in object in object)")
-        {
-            json inner_array = {1, discarded};
-            json middle_object;
-            middle_object["x"] = inner_array;
-            json j;
-            j["outer"] = middle_object;
-#if JSON_DIAGNOSTICS
-            CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.321] (/outer/x/1) cannot serialize discarded value to BSON", json::type_error&);
-#else
-            CHECK_THROWS_WITH_AS(json::to_bson(j), "[json.exception.type_error.321] cannot serialize discarded value to BSON", json::type_error&);
-#endif
-        }
    }

    SECTION("keys containing code-point U+0000 cannot be serialized to BSON")
@@ -1317,10 +1261,8 @@ TEST_CASE("BSON input that cannot be read is discarded by every overload")
    CHECK_THROWS_AS(_ = json::from_bson(input.begin(), input.end()), json::parse_error&);
    CHECK(json::from_bson(input, true, false).is_discarded());
    CHECK(json::from_bson(input.begin(), input.end(), true, false).is_discarded());
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
    CHECK(json::from_bson(input.data(), input.size(), true, false).is_discarded());
    CHECK(json::from_bson({input.data(), input.size()}, true, false).is_discarded());
-#endif
 }

 TEST_CASE("BSON SAX parsing stops at every event")
@@ -1798,7 +1740,6 @@ TEST_CASE("BSON roundtrips" * doctest::skip())
                CHECK(j1 == j2);
            }

-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
            {
                INFO_WITH_TEMP(filename + ": uint8_t* and size");
                // parse JSON file
@@ -1813,7 +1754,6 @@ TEST_CASE("BSON roundtrips" * doctest::skip())
                // compare parsed JSON values
                CHECK(j1 == j2);
            }
-#endif

            {
                INFO_WITH_TEMP(filename + ": output to output adapters");
@@ -8,14 +8,6 @@

 #include "doctest_compatibility.h"

-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;

@@ -38,49 +30,10 @@ TEST_CASE("CBOR")
    {
        SECTION("discarded")
        {
-            // a discarded value cannot be serialized to CBOR
+            // discarded values are not serialized
            json const j = json::value_t::discarded;
-            CHECK_THROWS_WITH_AS(json::to_cbor(j), "[json.exception.type_error.321] cannot serialize discarded value to CBOR", json::type_error&);
-        }
-
-        SECTION("discarded values nested in a container")
-        {
-            json const discarded = json::value_t::discarded;
-
-            SECTION("in an array")
-            {
-                json const j = {1, discarded, 2};
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_cbor(j), "[json.exception.type_error.321] (/1) cannot serialize discarded value to CBOR", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_cbor(j), "[json.exception.type_error.321] cannot serialize discarded value to CBOR", json::type_error&);
-#endif
-            }
-
-            SECTION("as an object value")
-            {
-                json j;
-                j["a"] = 1;
-                j["b"] = discarded;
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_cbor(j), "[json.exception.type_error.321] (/b) cannot serialize discarded value to CBOR", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_cbor(j), "[json.exception.type_error.321] cannot serialize discarded value to CBOR", json::type_error&);
-#endif
-            }
-
-            SECTION("nested deeper (array in object in array)")
-            {
-                json inner_array = {1, discarded};
-                json middle_object;
-                middle_object["x"] = inner_array;
-                json const j = {middle_object};
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_cbor(j), "[json.exception.type_error.321] (/0/x/1) cannot serialize discarded value to CBOR", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_cbor(j), "[json.exception.type_error.321] cannot serialize discarded value to CBOR", json::type_error&);
-#endif
-            }
+            const auto result = json::to_cbor(j);
+            CHECK(result.empty());
        }

        SECTION("NaN")
@@ -2262,10 +2215,8 @@ TEST_CASE("CBOR input that cannot be read is discarded by every overload")
    CHECK_THROWS_AS(_ = json::from_cbor(input.begin(), input.end()), json::parse_error&);
    CHECK(json::from_cbor(input, true, false).is_discarded());
    CHECK(json::from_cbor(input.begin(), input.end(), true, false).is_discarded());
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
    CHECK(json::from_cbor(input.data(), input.size(), true, false).is_discarded());
    CHECK(json::from_cbor({input.data(), input.size()}, true, false).is_discarded());
-#endif

    // a string that ends early, read through iterators that are not
    // contiguous and have to be copied from one element at a time
@@ -2662,14 +2613,12 @@ TEST_CASE("CBOR roundtrips" * doctest::skip())
                CHECK(j1 == j2);
            }

-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
            {
                INFO_WITH_TEMP(filename + ": uint8_t* and size");
                json j2;
                CHECK_NOTHROW(j2 = json::from_cbor({packed.data(), packed.size()}));
                CHECK(j1 == j2);
            }
-#endif

            {
                INFO_WITH_TEMP(filename + ": output to output adapters");
@@ -3236,8 +3185,7 @@ TEST_CASE("Tagged values")
        // CBOR encodes negative integers as: result = -1 - n
        // For type 0x3B, n is an 8-byte uint64_t. Valid range for n with
        // the default int64_t is [0, INT64_MAX], producing results in [INT64_MIN, -1].
-        // When n > INT64_MAX, the result exceeds int64_t range and is stored
-        // as a floating-point number, as the lexer does for JSON text.
+        // When n > INT64_MAX, the result exceeds int64_t range and is rejected.

        SECTION("n = 0 is valid (result = -1)")
        {
@@ -3258,34 +3206,33 @@ TEST_CASE("Tagged values")
            CHECK(result.get<int64_t>() == (std::numeric_limits<int64_t>::min)());
        }

-        SECTION("n = INT64_MAX + 1 is stored as float")
+        SECTION("n = INT64_MAX + 1 is rejected (overflow)")
        {
            // n = INT64_MAX + 1 (0x8000000000000000)
-            // result = -1 - n = -9223372036854775809, which exceeds int64_t range;
-            // the nearest double is -9223372036854775808.0
+            // result = -1 - n = -9223372036854775809, which exceeds int64_t range
            const std::vector<uint8_t> input = {0x3B, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-            const auto result = json::from_cbor(input);
-            CHECK(result.is_number_float());
-            CHECK(result.get<double>() == -9223372036854775808.0);
-            CHECK(result == json::parse("-9223372036854775809"));
+            json _;
+            CHECK_THROWS_WITH_AS(_ = json::from_cbor(input),
+                                 "[json.exception.parse_error.112] parse error at byte 9: syntax error while parsing CBOR value: negative integer overflow",
+                                 json::parse_error);
        }

-        SECTION("n = UINT64_MAX is stored as float")
+        SECTION("n = UINT64_MAX is rejected (overflow)")
        {
            // n = UINT64_MAX (0xFFFFFFFFFFFFFFFF)
            // result = -1 - n = -18446744073709551616, which exceeds int64_t range
            const std::vector<uint8_t> input = {0x3B, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
-            const auto result = json::from_cbor(input);
-            CHECK(result.is_number_float());
-            CHECK(result.get<double>() == -18446744073709551616.0);
-            CHECK(result == json::parse("-18446744073709551616"));
+            json _;
+            CHECK_THROWS_WITH_AS(_ = json::from_cbor(input),
+                                 "[json.exception.parse_error.112] parse error at byte 9: syntax error while parsing CBOR value: negative integer overflow",
+                                 json::parse_error);
        }

-        SECTION("overflow with allow_exceptions=false is not an error")
+        SECTION("overflow with allow_exceptions=false returns discarded")
        {
            const std::vector<uint8_t> input = {0x3B, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
            const auto result = json::from_cbor(input, true, false);
-            CHECK(result.is_number_float());
+            CHECK(result.is_discarded());
        }
    }

@@ -689,7 +689,7 @@ TEST_CASE("lexer escape fast path")
                    })
            {
                const std::string doc = "[\"" + std::string(offset, 'a') + c.first + "\"]";
-                CAPTURE(doc)
+                CAPTURE(doc);
                CHECK(json::accept(doc) == c.second);
                std::stringstream ss(doc);
                CHECK(json::accept(ss) == c.second);
@@ -748,14 +748,14 @@ TEST_CASE("lexer escape fast path")
                    })
            {
                const std::string doc = "[\"" + std::string(offset, 'a') + escape + "\"]";
-                CAPTURE(doc)
+                CAPTURE(doc);
                CHECK(outcome(doc, false) == outcome(doc, true));
            }

            // the escape is the last thing before end of input: no closing
            // quote at all
            const std::string truncated_doc = "[\"" + escape;
-            CAPTURE(truncated_doc)
+            CAPTURE(truncated_doc);
            CHECK(outcome(truncated_doc, false) == outcome(truncated_doc, true));
        }
    }
@@ -773,7 +773,7 @@ TEST_CASE("lexer escape fast path")
                })
        {
            const std::string doc = "[\"\\u" + tail;
-            CAPTURE(doc)
+            CAPTURE(doc);
            CHECK(outcome(doc, false) == outcome(doc, true));
            CHECK(outcome(doc, false).find("must be followed by 4 hex digits") != std::string::npos);
        }
@@ -789,7 +789,7 @@ TEST_CASE("lexer escape fast path")
            std::string digits = "1234";
            digits[bad_pos] = 'g'; // not a hex digit
            const std::string doc = "[\"\\u" + digits + "\"]";
-            CAPTURE(doc)
+            CAPTURE(doc);
            CHECK(outcome(doc, false) == outcome(doc, true));
            CHECK(outcome(doc, false).find("must be followed by 4 hex digits") != std::string::npos);
        }
@@ -837,7 +837,7 @@ TEST_CASE("lexer escape fast path")
                mismatches.push_back(doc);
            }
        }
-        CAPTURE(mismatches)
+        CAPTURE(mismatches);
        CHECK(mismatches.empty());
    }
 #endif
@@ -970,7 +970,7 @@ TEST_CASE("parse_float_native rounds correctly")
        using long_double_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, long double>;
        for (const auto& t : tokens)
        {
-            CAPTURE(t)
+            CAPTURE(t);
            const auto layout = float_token_layout(t);
            const char* const first = t.data();
            const char* const last = first + t.size();
@@ -1572,7 +1572,7 @@ TEST_CASE("Eisel-Lemire float conversion")
            std::array<char, 64> buffer{};
            const char* end = nlohmann::detail::to_chars(buffer.data(), buffer.data() + buffer.size(), f);
            const std::string token(buffer.data(), static_cast<std::size_t>(end - buffer.data()));
-            CAPTURE(token)
+            CAPTURE(token);
            CHECK(native_bits32(token) == b);
        }
    }
@@ -1626,7 +1626,7 @@ TEST_CASE("float conversion of hard cases")
    for (const auto& c : float_hard_cases::cases())
    {
        const std::string token = c.token;
-        CAPTURE(token)
+        CAPTURE(token);
        CHECK(native_bits64(token) == c.bits64);
        CHECK(native_bits32(token) == c.bits32);
        check_parse<json>(token, c.bits64, std::uint64_t{0x7FF0000000000000u});
@@ -1746,8 +1746,8 @@ TEST_CASE("string scanning kernels")
        for (std::size_t offset = 0; offset < 3 && offset <= text.size(); ++offset)
        {
            const std::size_t n = text.size() - offset;
-            CAPTURE(text)
-            CAPTURE(offset)
+            CAPTURE(text);
+            CAPTURE(offset);
            CHECK(nlohmann::detail::find_string_special(data + offset, n) == reference_special(data + offset, n));
            CHECK(nlohmann::detail::find_ascii_copyable_run(data + offset, n) == reference_copyable(data + offset, n));
            CHECK(nlohmann::detail::scalar_string_bulk_run(data + offset, n) == reference_bulk_run(data + offset, n));
@@ -2317,58 +2317,6 @@ TEST_CASE("parser class")
 #endif
    }

-    SECTION("comments before separators")
-    {
-        // The parser first checks for the expected ':' or ',' and only then
-        // falls back to the full token switch, which skips comments. A comment
-        // directly before a separator takes that fallback.
-        json _;
-
-        SECTION("ignored")
-        {
-            const std::vector<std::pair<std::string, json>> inputs =
-            {
-                {"{\"a\" /* c */ : 1}", {{"a", 1}}},
-                {"{\"a\" // c\n: 1}", {{"a", 1}}},
-                {R"({"a": 1, "b" /* c */ : 2})", {{"a", 1}, {"b", 2}}},
-                {R"({"a": 1 /* c */ , "b": 2})", {{"a", 1}, {"b", 2}}},
-                {"{\"a\": 1 // c\n, \"b\": 2}", {{"a", 1}, {"b", 2}}},
-                {"[1 /* c */ , 2]", {1, 2}},
-                {"[1 // c\n, 2]", {1, 2}},
-                {"{\"a\" /* c */ /* d */ : [1 // c\n , 2 /**/ ] /**/ , \"b\" : 3}", {{"a", {1, 2}}, {"b", 3}}}
-            };
-            for (const auto& input : inputs)
-            {
-                CAPTURE(input.first)
-                CHECK(json::parse(input.first, nullptr, true, true) == input.second);
-                CHECK(json::accept(input.first, true));
-            }
-        }
-
-        SECTION("ignored, with trailing commas")
-        {
-            CHECK(json::parse(std::string("[1 /* c */ , ]"), nullptr, true, true, true) == json({1}));
-            CHECK(json::parse(std::string("{\"a\": 1 /* c */ , }"), nullptr, true, true, true) == json({{"a", 1}}));
-            CHECK_THROWS_WITH_AS(_ = json::parse(std::string("[1 /* c */ , ]"), nullptr, true, true),
-                                 "[json.exception.parse_error.101] parse error at line 1, column 14: syntax error while parsing value - unexpected ']'; expected '[', '{', or a literal", json::parse_error);
-            CHECK_THROWS_WITH_AS(_ = json::parse(std::string("{\"a\": 1 /* c */ , }"), nullptr, true, true),
-                                 "[json.exception.parse_error.101] parse error at line 1, column 19: syntax error while parsing object key - unexpected '}'; expected string literal", json::parse_error);
-        }
-
-        SECTION("not ignored")
-        {
-            CHECK_THROWS_WITH_AS(_ = json::parse(std::string("{\"a\" /* c */ : 1}")),
-                                 "[json.exception.parse_error.101] parse error at line 1, column 6: syntax error while parsing object separator - invalid literal; last read: '\"a\" /'; expected ':'", json::parse_error);
-            CHECK_THROWS_WITH_AS(_ = json::parse(std::string("{\"a\": 1, \"b\" /* c */ : 2}")),
-                                 "[json.exception.parse_error.101] parse error at line 1, column 14: syntax error while parsing object separator - invalid literal; last read: '\"b\" /'; expected ':'", json::parse_error);
-            CHECK_THROWS_WITH_AS(_ = json::parse(std::string("{\"a\": 1 /* c */ , \"b\": 2}")),
-                                 "[json.exception.parse_error.101] parse error at line 1, column 9: syntax error while parsing object - invalid literal; last read: '1 /'; expected '}'", json::parse_error);
-            CHECK_THROWS_WITH_AS(_ = json::parse(std::string("[1 /* c */ , 2]")),
-                                 "[json.exception.parse_error.101] parse error at line 1, column 4: syntax error while parsing array - invalid literal; last read: '1 /'; expected ']'", json::parse_error);
-            CHECK(!json::accept(std::string("[1 /* c */ , 2]")));
-        }
-    }
-
 #if JSON_DIAGNOSTIC_POSITIONS
    // Macro for all test cases for start_pos and end_pos
 #define SETUP_TESTCASES() \
@@ -191,10 +191,8 @@ TEST_CASE("value conversion")
    {
        enum class bool_enum : bool { off, on };

-        // the extra parentheses keep doctest from printing the enum via its
-        // underlying type, which MSVC 2015 reports as C4800
-        CHECK((json(bool_enum::off).get<bool_enum>() == bool_enum::off));
-        CHECK((json(bool_enum::on).get<bool_enum>() == bool_enum::on));
+        CHECK(json(bool_enum::off).get<bool_enum>() == bool_enum::off);
+        CHECK(json(bool_enum::on).get<bool_enum>() == bool_enum::on);
    }
 #endif

@@ -853,11 +851,8 @@ TEST_CASE("std::optional")
        CHECK_THROWS_WITH_AS(json(opt), "cannot serialize throwing_to_json_type", std::runtime_error&);

        // the conversion is noexcept exactly when converting the contained value is
-        // (except with MSVC 2017, where it is never noexcept, see to_json.hpp)
-#if !defined(_MSC_VER) || defined(__clang__) || _MSC_VER >= 1920
        static_assert(!std::is_nothrow_constructible<json, const std::optional<throwing_to_json_type>&>::value);
        static_assert(std::is_nothrow_constructible<json, const std::optional<int>&>::value);
-#endif
    }
 #endif
 }
@@ -1,229 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include "doctest_compatibility.h"
-
-// This file tests the opt-in JSON_DELETE_DEPRECATED_FUNCTIONS, so it defines the
-// macro itself instead of relying on the build configuration.
-#ifdef JSON_DELETE_DEPRECATED_FUNCTIONS
-    #undef JSON_DELETE_DEPRECATED_FUNCTIONS
-#endif
-#define JSON_DELETE_DEPRECATED_FUNCTIONS 1
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-
-#include <cstddef>
-#include <cstdint>
-#include <istream>
-#include <ostream>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-namespace
-{
-template<typename...>
-struct make_void
-{
-    using type = void;
-};
-
-template<typename... Ts>
-using void_t = typename make_void<Ts...>::type;
-
-// A deleted function is still found by overload resolution, but naming it in an
-// unevaluated operand is ill-formed, so each of the following traits is false
-// exactly if the expression selects a deleted (or no) function.
-#define JSON_TEST_DETECT(name, expr)                                 \
-    template<typename J, typename = void>                            \
-    struct name : std::false_type {};                                \
-    template<typename J>                                             \
-    struct name<J, void_t<decltype(expr)>> : std::true_type {}
-
-using ptr_t = const std::uint8_t*;
-
-JSON_TEST_DETECT(from_cbor_ptr_len, J::from_cbor(std::declval<ptr_t>(), std::declval<std::size_t>()));
-JSON_TEST_DETECT(from_msgpack_ptr_len, J::from_msgpack(std::declval<ptr_t>(), std::declval<std::size_t>()));
-JSON_TEST_DETECT(from_ubjson_ptr_len, J::from_ubjson(std::declval<ptr_t>(), std::declval<std::size_t>()));
-JSON_TEST_DETECT(from_bjdata_ptr_len, J::from_bjdata(std::declval<ptr_t>(), std::declval<std::size_t>()));
-JSON_TEST_DETECT(from_bon8_ptr_len, J::from_bon8(std::declval<ptr_t>(), std::declval<std::size_t>()));
-JSON_TEST_DETECT(from_bson_ptr_len, J::from_bson(std::declval<ptr_t>(), std::declval<std::size_t>()));
-
-JSON_TEST_DETECT(from_cbor_ptr_ptr, J::from_cbor(std::declval<ptr_t>(), std::declval<ptr_t>()));
-JSON_TEST_DETECT(from_msgpack_ptr_ptr, J::from_msgpack(std::declval<ptr_t>(), std::declval<ptr_t>()));
-JSON_TEST_DETECT(from_ubjson_ptr_ptr, J::from_ubjson(std::declval<ptr_t>(), std::declval<ptr_t>()));
-JSON_TEST_DETECT(from_bjdata_ptr_ptr, J::from_bjdata(std::declval<ptr_t>(), std::declval<ptr_t>()));
-JSON_TEST_DETECT(from_bon8_ptr_ptr, J::from_bon8(std::declval<ptr_t>(), std::declval<ptr_t>()));
-JSON_TEST_DETECT(from_bson_ptr_ptr, J::from_bson(std::declval<ptr_t>(), std::declval<ptr_t>()));
-
-JSON_TEST_DETECT(from_cbor_init_list, J::from_cbor({std::declval<ptr_t>(), std::declval<std::size_t>()}));
-JSON_TEST_DETECT(from_msgpack_init_list, J::from_msgpack({std::declval<ptr_t>(), std::declval<std::size_t>()}));
-JSON_TEST_DETECT(from_ubjson_init_list, J::from_ubjson({std::declval<ptr_t>(), std::declval<std::size_t>()}));
-JSON_TEST_DETECT(from_bson_init_list, J::from_bson({std::declval<ptr_t>(), std::declval<std::size_t>()}));
-
-JSON_TEST_DETECT(parse_init_list, J::parse({std::declval<ptr_t>(), std::declval<std::size_t>()}));
-JSON_TEST_DETECT(accept_init_list, J::accept({std::declval<ptr_t>(), std::declval<std::size_t>()}));
-JSON_TEST_DETECT(sax_parse_init_list, J::sax_parse({std::declval<ptr_t>(), std::declval<std::size_t>()}, std::declval<nlohmann::json_sax<J>*>()));
-JSON_TEST_DETECT(parse_ptr_ptr, J::parse(std::declval<ptr_t>(), std::declval<ptr_t>()));
-
-JSON_TEST_DETECT(iterator_wrapper, J::iterator_wrapper(std::declval<J&>()));
-JSON_TEST_DETECT(iterator_wrapper_const, J::iterator_wrapper(std::declval<const J&>()));
-JSON_TEST_DETECT(items, std::declval<J&>().items());
-
-JSON_TEST_DETECT(json_ltlt_istream, std::declval<J&>() << std::declval<std::istream&>());
-JSON_TEST_DETECT(istream_gtgt_json, std::declval<std::istream&>() >> std::declval<J&>());
-JSON_TEST_DETECT(json_gtgt_ostream, std::declval<const J&>() >> std::declval<std::ostream&>());
-JSON_TEST_DETECT(ostream_ltlt_json, std::declval<std::ostream&>() << std::declval<const J&>());
-
-JSON_TEST_DETECT(ptr_eq_ptr, std::declval<const typename J::json_pointer&>() == std::declval<const typename J::json_pointer&>());
-JSON_TEST_DETECT(ptr_ne_ptr, std::declval<const typename J::json_pointer&>() != std::declval<const typename J::json_pointer&>());
-JSON_TEST_DETECT(ptr_eq_string, std::declval<const typename J::json_pointer&>() == std::declval<const std::string&>());
-JSON_TEST_DETECT(string_eq_ptr, std::declval<const std::string&>() == std::declval<const typename J::json_pointer&>());
-JSON_TEST_DETECT(ptr_eq_c_string, std::declval<const typename J::json_pointer&>() == std::declval<const char*>());
-JSON_TEST_DETECT(c_string_eq_ptr, std::declval<const char*>() == std::declval<const typename J::json_pointer&>());
-JSON_TEST_DETECT(ptr_ne_string, std::declval<const typename J::json_pointer&>() != std::declval<const std::string&>());
-JSON_TEST_DETECT(string_ne_ptr, std::declval<const std::string&>() != std::declval<const typename J::json_pointer&>());
-JSON_TEST_DETECT(ptr_to_string, std::declval<const typename J::json_pointer&>().to_string());
-
-// json_pointer with a basic_json type as template argument
-template<typename J>
-using legacy_ptr_t = const nlohmann::json_pointer<J>& ;
-JSON_TEST_DETECT(legacy_ptr_value, std::declval<const J&>().value(std::declval<legacy_ptr_t<J>>(), 0));
-JSON_TEST_DETECT(legacy_ptr_value_rvalue, std::declval<const J&>().value(std::declval<legacy_ptr_t<J>>(), std::string()));
-JSON_TEST_DETECT(legacy_ptr_contains, std::declval<const J&>().contains(std::declval<legacy_ptr_t<J>>()));
-JSON_TEST_DETECT(legacy_ptr_subscript, std::declval<J&>()[std::declval<legacy_ptr_t<J>>()]);
-JSON_TEST_DETECT(legacy_ptr_subscript_const, std::declval<const J&>()[std::declval<legacy_ptr_t<J>>()]);
-JSON_TEST_DETECT(legacy_ptr_at, std::declval<J&>().at(std::declval<legacy_ptr_t<J>>()));
-JSON_TEST_DETECT(legacy_ptr_at_const, std::declval<const J&>().at(std::declval<legacy_ptr_t<J>>()));
-JSON_TEST_DETECT(ptr_value, std::declval<const J&>().value(std::declval<const typename J::json_pointer&>(), 0));
-JSON_TEST_DETECT(ptr_at, std::declval<J&>().at(std::declval<const typename J::json_pointer&>()));
-
-#undef JSON_TEST_DETECT
-} // namespace
-
-TEST_CASE("JSON_DELETE_DEPRECATED_FUNCTIONS")
-{
-    // MSVC 2015 does not treat selecting a deleted function in decltype as a
-    // substitution failure, so the traits cannot tell deleted functions apart
-    // there; calling them still fails to compile
-#if !(defined(_MSC_VER) && _MSC_VER < 1910)
-    SECTION("from_* with a pointer and a length")
-    {
-        // the overloads are deleted rather than removed, so the length cannot
-        // silently bind to the strict parameter of from_*(InputType&&, bool)
-        CHECK_FALSE(from_cbor_ptr_len<json>::value);
-        CHECK_FALSE(from_msgpack_ptr_len<json>::value);
-        CHECK_FALSE(from_ubjson_ptr_len<json>::value);
-        CHECK_FALSE(from_bjdata_ptr_len<json>::value);
-        CHECK_FALSE(from_bon8_ptr_len<json>::value);
-        CHECK_FALSE(from_bson_ptr_len<json>::value);
-
-        // the replacement
-        CHECK(from_cbor_ptr_ptr<json>::value);
-        CHECK(from_msgpack_ptr_ptr<json>::value);
-        CHECK(from_ubjson_ptr_ptr<json>::value);
-        CHECK(from_bjdata_ptr_ptr<json>::value);
-        CHECK(from_bon8_ptr_ptr<json>::value);
-        CHECK(from_bson_ptr_ptr<json>::value);
-    }
-
-    SECTION("initializer lists of a pointer and a length")
-    {
-        CHECK_FALSE(from_cbor_init_list<json>::value);
-        CHECK_FALSE(from_msgpack_init_list<json>::value);
-        CHECK_FALSE(from_ubjson_init_list<json>::value);
-        CHECK_FALSE(from_bson_init_list<json>::value);
-        CHECK_FALSE(parse_init_list<json>::value);
-        CHECK_FALSE(accept_init_list<json>::value);
-        CHECK_FALSE(sax_parse_init_list<json>::value);
-
-        // the replacement
-        CHECK(parse_ptr_ptr<json>::value);
-    }
-
-    SECTION("iterator_wrapper")
-    {
-        CHECK_FALSE(iterator_wrapper<json>::value);
-        CHECK_FALSE(iterator_wrapper_const<json>::value);
-
-        // the replacement
-        CHECK(items<json>::value);
-    }
-
-    SECTION("stream operators with reversed operands")
-    {
-        CHECK_FALSE(json_ltlt_istream<json>::value);
-        CHECK_FALSE(json_gtgt_ostream<json>::value);
-
-        // the replacement
-        CHECK(istream_gtgt_json<json>::value);
-        CHECK(ostream_ltlt_json<json>::value);
-    }
-
-    SECTION("json_pointer")
-    {
-        // conversion to a string
-        CHECK_FALSE(std::is_constructible<std::string, json::json_pointer>::value);
-        CHECK_FALSE(std::is_convertible<json::json_pointer, std::string>::value);
-
-        // comparison with a string
-        CHECK_FALSE(ptr_eq_string<json>::value);
-        CHECK_FALSE(string_eq_ptr<json>::value);
-        CHECK_FALSE(ptr_eq_c_string<json>::value);
-        CHECK_FALSE(c_string_eq_ptr<json>::value);
-        CHECK_FALSE(ptr_ne_string<json>::value);
-        CHECK_FALSE(string_ne_ptr<json>::value);
-
-        // the replacement
-        CHECK(ptr_to_string<json>::value);
-        CHECK(ptr_eq_ptr<json>::value);
-        CHECK(ptr_ne_ptr<json>::value);
-    }
-
-    SECTION("json_pointer with a basic_json type as template argument")
-    {
-        CHECK_FALSE(legacy_ptr_value<json>::value);
-        CHECK_FALSE(legacy_ptr_value_rvalue<json>::value);
-        CHECK_FALSE(legacy_ptr_contains<json>::value);
-        CHECK_FALSE(legacy_ptr_subscript<json>::value);
-        CHECK_FALSE(legacy_ptr_subscript_const<json>::value);
-        CHECK_FALSE(legacy_ptr_at<json>::value);
-        CHECK_FALSE(legacy_ptr_at_const<json>::value);
-
-        // the replacement
-        CHECK(ptr_value<json>::value);
-        CHECK(ptr_at<json>::value);
-    }
-
-#endif
-
-    SECTION("the non-deprecated functions still work")
-    {
-        const json j = {{"a", {1, 2}}};
-        const auto cbor = json::to_cbor(j);
-        CHECK(json::from_cbor(cbor.data(), cbor.data() + cbor.size()) == j);
-
-        const json::json_pointer ptr("/a/1");
-        CHECK(ptr == json::json_pointer("/a/1"));
-        CHECK(ptr.to_string() == "/a/1");
-        CHECK(j[ptr] == 2);
-        CHECK(j.at(ptr) == 2);
-        CHECK(j.value(ptr, 0) == 2);
-        CHECK(j.contains(ptr));
-
-        std::ostringstream os;
-        os << j;
-        CHECK(os.str() == R"({"a":[1,2]})");
-        std::istringstream is(os.str());
-        json parsed;
-        is >> parsed;
-        CHECK(parsed == j);
-    }
-}
@@ -16,14 +16,6 @@
    #define JSON_TEST_STRICT_NUL_HANDLING_ENABLED 1
 #endif

-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #ifdef JSON_TEST_NO_GLOBAL_UDLS
@@ -299,7 +291,6 @@ TEST_CASE("deserialization")
            }));
        }

-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
        SECTION("operator<<")
        {
            std::stringstream ss;
@@ -308,7 +299,6 @@ TEST_CASE("deserialization")
            j << ss;
            CHECK(j == json({"foo", 1, 2, 3, false, {{"one", 1}}}));
        }
-#endif

        SECTION("operator>>")
        {
@@ -433,7 +423,6 @@ TEST_CASE("deserialization")
            CHECK_THROWS_WITH_AS(_ = json::parse(nullptr), "[json.exception.parse_error.101] parse error: attempting to parse an empty input; check that your input string or stream contains the expected JSON", json::parse_error&);
        }

-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
        SECTION("operator<<")
        {
            std::stringstream ss;
@@ -441,7 +430,6 @@ TEST_CASE("deserialization")
            json j;
            CHECK_THROWS_WITH_AS(j << ss, "[json.exception.parse_error.101] parse error at line 1, column 29: syntax error while parsing array - unexpected end of input; expected ']'", json::parse_error&);
        }
-#endif

        SECTION("operator>>")
        {
@@ -1160,9 +1148,9 @@ TEST_CASE("deserialization")
        {
            std::istringstream s(bom + "123 456");
            json j;
-            s >> j;
+            j << s;
            CHECK(j == 123);
-            s >> j;
+            j << s;
            CHECK(j == 456);
        }
    }
@@ -1551,10 +1551,6 @@ TEST_CASE_TEMPLATE("element access 2", Json, nlohmann::json, nlohmann::ordered_j
        // count(0) used to compile and then crash instead of failing to compile
        using nlohmann::detail::is_detected;

-        // MSVC 2015 does not treat selecting a deleted function in decltype as
-        // a substitution failure, so it detects the deleted overloads as
-        // callable; calling them still fails to compile
-#if !(defined(_MSC_VER) && _MSC_VER < 1910)
        CHECK_FALSE(is_detected<can_call_find_with_0, Json&>::value);
        CHECK_FALSE(is_detected<can_call_find_with_0, const Json&>::value);
        CHECK_FALSE(is_detected<can_call_count_with_0, Json&>::value);
@@ -1566,7 +1562,6 @@ TEST_CASE_TEMPLATE("element access 2", Json, nlohmann::json, nlohmann::ordered_j

        // another integral literal type must be rejected as well, not just int
        CHECK_FALSE(is_detected<can_call_contains_with_0L, Json&>::value);
-#endif

        // the valid overloads must remain callable
        CHECK(is_detected<can_call_find, Json&, const char*>::value);
@@ -1,246 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include "doctest_compatibility.h"
-
-// skip tests if JSON_DisableEnumSerialization=ON (#4384)
-#if defined(JSON_DISABLE_ENUM_SERIALIZATION) && (JSON_DISABLE_ENUM_SERIALIZATION == 1)
-    #define SKIP_TESTS_FOR_ENUM_SERIALIZATION
-#endif
-
-// This file tests the opt-in JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS, so it defines
-// the macro itself rather than relying on a -D flag, and runs in every build.
-// The default behavior is tested in unit-enum_keyed_maps_default.cpp.
-#ifdef JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-    #undef JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-#endif
-
-#define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS 1
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-using nlohmann::ordered_json;
-
-#include <cstddef>
-#include <functional>
-#include <map>
-#include <string>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-#define STRINGIZE_EX(x) #x
-#define STRINGIZE(x) STRINGIZE_EX(x)
-
-// NLOHMANN_JSON_SERIALIZE_ENUM uses a static std::pair
-DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")
-
-namespace
-{
-// std::hash is only required for enums since C++14
-struct enum_hash
-{
-    template<typename T>
-    std::size_t operator()(T t) const noexcept
-    {
-        return static_cast<std::size_t>(t);
-    }
-};
-} // namespace
-
-// the example from #4378
-enum TaskState // NOLINT(cert-int09-c,readability-enum-initial-value,cppcoreguidelines-use-enum-class)
-{
-    TS_STOPPED,
-    TS_RUNNING,
-    TS_COMPLETED,
-    TS_INVALID = -1,
-};
-
-// NOLINTNEXTLINE(misc-const-correctness,misc-use-internal-linkage,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
-NLOHMANN_JSON_SERIALIZE_ENUM(TaskState,
-{
-    {TS_INVALID, nullptr},
-    {TS_STOPPED, "stopped"},
-    {TS_RUNNING, "running"},
-    {TS_COMPLETED, "completed"},
-})
-
-enum class color {red, green, blue}; // blue is not mapped and falls back to "red"
-
-// NOLINTNEXTLINE(misc-const-correctness,misc-use-internal-linkage,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
-NLOHMANN_JSON_SERIALIZE_ENUM(color,
-{
-    {color::red, "red"},
-    {color::green, "green"},
-})
-
-enum class strict_color {red, green, blue}; // blue is not mapped
-
-// NOLINTNEXTLINE(misc-const-correctness,misc-use-internal-linkage,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
-NLOHMANN_JSON_SERIALIZE_ENUM_STRICT(strict_color,
-{
-    {strict_color::red, "red"},
-    {strict_color::green, "green"},
-})
-
-enum class digit {zero, one};
-
-// NOLINTNEXTLINE(misc-const-correctness,misc-use-internal-linkage,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
-NLOHMANN_JSON_SERIALIZE_ENUM(digit,
-{
-    {digit::zero, 0},
-    {digit::one, 1},
-})
-
-#ifndef SKIP_TESTS_FOR_ENUM_SERIALIZATION
-enum class plain {zero, one}; // serialized as integer
-#endif
-
-TEST_CASE("JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS")
-{
-    SECTION("the macro is part of the ABI tag")
-    {
-        const std::string ns = STRINGIZE(NLOHMANN_JSON_NAMESPACE);
-        CHECK(ns.find("_ekmo") != std::string::npos);
-    }
-
-    SECTION("std::map (#4378)")
-    {
-        using task_map = std::map<TaskState, std::string>;
-        const task_map m = {{TS_STOPPED, "aa"}, {TS_COMPLETED, "bb"}};
-        const json j = m;
-        CHECK(j == json::parse(R"({"stopped":"aa","completed":"bb"})"));
-        CHECK(j.get<task_map>() == m);
-
-        json j2;
-        j2["x"] = m;
-        CHECK(j2.dump() == R"({"x":{"completed":"bb","stopped":"aa"}})");
-    }
-
-    SECTION("std::map with custom comparator")
-    {
-        using task_map = std::map<TaskState, int, std::greater<TaskState>>;
-        const task_map m = {{TS_STOPPED, 1}, {TS_RUNNING, 2}};
-        const json j = m;
-        CHECK(j == json::parse(R"({"stopped":1,"running":2})"));
-        CHECK(j.get<task_map>() == m);
-    }
-
-    SECTION("std::unordered_map")
-    {
-        using task_map = std::unordered_map<TaskState, int, enum_hash>;
-        const task_map m = {{TS_STOPPED, 1}, {TS_RUNNING, 2}};
-        const json j = m;
-        CHECK(j == json::parse(R"({"stopped":1,"running":2})"));
-        CHECK(j.get<task_map>() == m);
-    }
-
-    SECTION("nested maps")
-    {
-        using nested_map = std::map<color, std::map<TaskState, int>>;
-        const nested_map m = {{color::green, {{TS_RUNNING, 1}}}, {color::red, {}}};
-        const json j = m;
-        CHECK(j == json::parse(R"({"green":{"running":1},"red":{}})"));
-        CHECK(j.get<nested_map>() == m);
-    }
-
-    SECTION("ordered_json keeps the order of the map")
-    {
-        using task_map = std::map<TaskState, int>;
-        const task_map m = {{TS_STOPPED, 1}, {TS_RUNNING, 2}, {TS_COMPLETED, 3}};
-        const ordered_json j = m;
-        CHECK(j.dump() == R"({"stopped":1,"running":2,"completed":3})");
-        CHECK(j.get<task_map>() == m);
-    }
-
-    SECTION("empty map")
-    {
-        const json j = std::map<TaskState, int>();
-        CHECK(j.is_object());
-        CHECK(j.empty());
-    }
-
-    SECTION("NLOHMANN_JSON_SERIALIZE_ENUM_STRICT")
-    {
-        using color_map = std::map<strict_color, int>;
-        const color_map m = {{strict_color::red, 1}, {strict_color::green, 2}};
-        const json j = m;
-        CHECK(j == json::parse(R"({"red":1,"green":2})"));
-        CHECK(j.get<color_map>() == m);
-
-        const color_map unmapped = {{strict_color::blue, 1}};
-        json _;
-        CHECK_THROWS_WITH_AS(_ = unmapped,
-                             "[json.exception.out_of_range.410] enum value out of range for strict_color", json::out_of_range&);
-    }
-
-    SECTION("arrays of [key, value] pairs are still read")
-    {
-        using task_map = std::map<TaskState, int>;
-        const task_map m = {{TS_STOPPED, 1}};
-        CHECK(json::parse(R"([["stopped",1]])").get<task_map>() == m);
-    }
-
-    SECTION("other containers are not affected")
-    {
-        const std::vector<std::pair<TaskState, int>> pairs = {{TS_STOPPED, 1}};
-        const std::map<std::string, TaskState> string_keys = {{"a", TS_STOPPED}};
-        const std::map<int, int> int_keys = {{1, 2}};
-        CHECK(json(pairs) == json::parse(R"([["stopped",1]])"));
-        CHECK(json(string_keys) == json::parse(R"({"a":"stopped"})"));
-        CHECK(json(int_keys) == json::parse("[[1,2]]"));
-    }
-
-    SECTION("maps with non-unique keys are still stored as arrays of pairs")
-    {
-        const std::multimap<TaskState, int> mm = {{TS_STOPPED, 1}, {TS_STOPPED, 2}};
-        const std::unordered_multimap<TaskState, int, enum_hash> umm = {{TS_RUNNING, 3}, {TS_RUNNING, 3}};
-        CHECK(json(mm) == json::parse(R"([["stopped",1],["stopped",2]])"));
-        CHECK(json(umm) == json::parse(R"([["running",3],["running",3]])"));
-    }
-
-    SECTION("keys that do not serialize to strings")
-    {
-        const std::map<TaskState, int> null_key = {{TS_INVALID, 1}};
-        const std::map<digit, int> number_key = {{digit::zero, 1}};
-        json j = "unchanged";
-
-        // mapped to null
-        CHECK_THROWS_WITH_AS(j = null_key,
-                             "[json.exception.type_error.302] type must be string, but is null", json::type_error&);
-
-        // mapped to a number
-        CHECK_THROWS_WITH_AS(j = number_key,
-                             "[json.exception.type_error.302] type must be string, but is number", json::type_error&);
-
-#ifndef SKIP_TESTS_FOR_ENUM_SERIALIZATION
-        // enum without NLOHMANN_JSON_SERIALIZE_ENUM
-        const std::map<plain, int> plain_key = {{plain::zero, 1}};
-        CHECK_THROWS_WITH_AS(j = plain_key,
-                             "[json.exception.type_error.302] type must be string, but is number", json::type_error&);
-#endif
-
-        CHECK(j == "unchanged");
-    }
-
-    SECTION("keys that serialize to the same string")
-    {
-        const std::map<color, int> m = {{color::red, 1}, {color::blue, 2}};
-        json j = "unchanged";
-
-        // color::blue is not mapped and falls back to "red"
-        CHECK_THROWS_WITH_AS(j = m,
-                             "[json.exception.type_error.318] duplicate object key 'red'", json::type_error&);
-
-        CHECK(j == "unchanged");
-    }
-}
-
-DOCTEST_CLANG_SUPPRESS_WARNING_POP
@@ -1,144 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include "doctest_compatibility.h"
-
-// This file tests maps with enum keys with the default setting of
-// JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS (or whatever a -D flag sets it to).
-// unit-enum_keyed_maps.cpp tests JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS=1.
-// These tests are not part of unit-conversions.cpp, because that object file
-// is already too big for the MinGW linker of some compilers.
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-
-#include <cstddef>
-#include <functional>
-#include <map>
-#include <string>
-#include <unordered_map>
-
-// NLOHMANN_JSON_SERIALIZE_ENUM uses a static std::pair
-DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")
-
-enum class cards {kreuz, pik, herz, karo};
-
-// NOLINTNEXTLINE(misc-use-internal-linkage,misc-const-correctness,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
-NLOHMANN_JSON_SERIALIZE_ENUM(cards,
-{
-    {cards::kreuz, "kreuz"},
-    {cards::pik, "pik"},
-    {cards::herz, "herz"},
-    {cards::karo, "karo"}
-})
-
-enum TaskState // NOLINT(cert-int09-c,readability-enum-initial-value,cppcoreguidelines-use-enum-class)
-{
-    TS_STOPPED,
-    TS_RUNNING,
-    TS_COMPLETED,
-    TS_INVALID = -1,
-};
-
-// NOLINTNEXTLINE(misc-const-correctness,misc-use-internal-linkage,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
-NLOHMANN_JSON_SERIALIZE_ENUM(TaskState,
-{
-    {TS_INVALID, nullptr},
-    {TS_STOPPED, "stopped"},
-    {TS_RUNNING, "running"},
-    {TS_COMPLETED, "completed"},
-})
-
-enum class strict_cards {kreuz, pik, herz, karo, andere}; // andere not included in mapping
-
-// NOLINTNEXTLINE(misc-use-internal-linkage,misc-const-correctness,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
-NLOHMANN_JSON_SERIALIZE_ENUM_STRICT(strict_cards,
-{
-    {strict_cards::kreuz, "kreuz"},
-    {strict_cards::pik, "pik"},
-    {strict_cards::herz, "herz"},
-    {strict_cards::karo, "karo"}
-})
-
-namespace
-{
-// std::hash is only required for enums since C++14
-struct enum_hash
-{
-    template<typename T>
-    std::size_t operator()(T t) const noexcept
-    {
-        return static_cast<std::size_t>(t);
-    }
-};
-} // namespace
-
-// see unit-enum_keyed_maps.cpp for JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS=1
-TEST_CASE("maps with enum keys")
-{
-    using task_map = std::map<TaskState, std::string>;
-    using task_umap = std::unordered_map<TaskState, std::string, enum_hash>;
-    using task_gmap = std::map<TaskState, std::string, std::greater<TaskState>>;
-    using nested_map = std::map<cards, std::map<TaskState, int>>;
-    using strict_map = std::map<strict_cards, int>;
-    using int_map = std::map<int, int>;
-    using int_umap = std::unordered_map<int, int>;
-
-    const task_map m = {{TS_STOPPED, "aa"}, {TS_COMPLETED, "bb"}};
-
-#if !JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-    SECTION("stored as array of pairs")
-    {
-        CHECK(json(m) == json::parse(R"([["stopped","aa"],["completed","bb"]])"));
-        CHECK(json(task_umap {{TS_RUNNING, "cc"}}) == json::parse(R"([["running","cc"]])"));
-    }
-#endif
-
-    SECTION("read from array of pairs")
-    {
-        CHECK(json::parse(R"([["stopped","aa"],["completed","bb"]])").get<task_map>() == m);
-    }
-
-    SECTION("read from object (#4378)")
-    {
-        const json j = json::parse(R"({"stopped":"aa","completed":"bb"})");
-        CHECK(j.get<task_map>() == m);
-        CHECK(j.get<task_umap>() == task_umap(m.begin(), m.end()));
-        CHECK(j.get<task_gmap>() == task_gmap(m.begin(), m.end()));
-        CHECK(json::parse(R"({"kreuz":{"stopped":1}})").get<nested_map>() == nested_map {{cards::kreuz, {{TS_STOPPED, 1}}}});
-        CHECK(nlohmann::ordered_json::parse(R"({"stopped":"aa","completed":"bb"})").get<task_map>() == m);
-
-        // object keys go through the enum's from_json
-        strict_map sm;
-        CHECK_THROWS_WITH_AS(json::parse(R"({"what?":1})").get_to(sm),
-                             "[json.exception.out_of_range.410] enum value out of range for strict_cards: \"what?\"", json::out_of_range&);
-    }
-
-    SECTION("objects are only read for enum keys")
-    {
-        // built rather than parsed, so that the messages do not gain a byte
-        // range with JSON_DIAGNOSTIC_POSITIONS
-        const json j = {{"1", 2}};
-        int_map im;
-        int_umap ium;
-        CHECK_THROWS_WITH_AS(j.get_to(im),
-                             "[json.exception.type_error.302] type must be array, but is object", json::type_error&);
-        CHECK_THROWS_WITH_AS(j.get_to(ium),
-                             "[json.exception.type_error.302] type must be array, but is object", json::type_error&);
-    }
-
-    SECTION("other types are rejected")
-    {
-        task_map tm;
-        CHECK_THROWS_WITH_AS(json("stopped").get_to(tm),
-                             "[json.exception.type_error.302] type must be array, but is string", json::type_error&);
-    }
-}
-
-DOCTEST_CLANG_SUPPRESS_WARNING_POP
@@ -8,14 +8,6 @@

 #include "doctest_compatibility.h"

-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;

@@ -27,7 +19,6 @@ DOCTEST_GCC_SUPPRESS_WARNING_PUSH
 DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
 DOCTEST_CLANG_SUPPRESS_WARNING("-Wrange-loop-construct")

-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
 TEST_CASE("iterator_wrapper")
 {
    SECTION("object")
@@ -724,7 +715,6 @@ TEST_CASE("iterator_wrapper")
        }
    }
 }
-#endif

 TEST_CASE("items()")
 {
@@ -9,14 +9,6 @@
 #include "doctest_compatibility.h"

 #define JSON_TESTS_PRIVATE
-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #ifdef JSON_TEST_NO_GLOBAL_UDLS
@@ -572,9 +564,7 @@ TEST_CASE("JSON pointers")
            std::stringstream ss;
            ss << ptr;
            CHECK(ptr.to_string() == ptr_str);
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
            CHECK(std::string(ptr) == ptr_str);
-#endif
            CHECK(ss.str() == ptr_str);
        }
    }
@@ -754,6 +744,8 @@ TEST_CASE("JSON pointers")

    SECTION("equality comparison")
    {
+        const char* ptr_cpstring = "/foo/bar";
+        const char ptr_castring[] = "/foo/bar"; // NOLINT(misc-const-correctness,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
        std::string ptr_string{"/foo/bar"};
        auto ptr1 = json::json_pointer(ptr_string);
        auto ptr2 = json::json_pointer(ptr_string);
@@ -763,12 +755,6 @@ TEST_CASE("JSON pointers")

        CHECK(ptr1 == ptr2);

-        CHECK_FALSE(ptr1 != ptr2);
-
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-        const char* ptr_cpstring = "/foo/bar";
-        const char ptr_castring[] = "/foo/bar"; // NOLINT(misc-const-correctness,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
-
        CHECK(ptr1 == "/foo/bar");
        CHECK(ptr1 == ptr_cpstring);
        CHECK(ptr1 == ptr_castring);
@@ -779,6 +765,8 @@ TEST_CASE("JSON pointers")
        CHECK(ptr_castring == ptr1);
        CHECK(ptr_string == ptr1);

+        CHECK_FALSE(ptr1 != ptr2);
+
        CHECK_FALSE(ptr1 != "/foo/bar");
        CHECK_FALSE(ptr1 != ptr_cpstring);
        CHECK_FALSE(ptr1 != ptr_castring);
@@ -800,7 +788,6 @@ TEST_CASE("JSON pointers")
            CHECK_THROWS_WITH_AS("/~~" == ptr1,
                                 "[json.exception.parse_error.108] parse error: escape character '~' must be followed with '0' or '1'", json::parse_error&);
        }
-#endif
    }

    SECTION("less-than comparison")
@@ -852,7 +839,6 @@ TEST_CASE("JSON pointers")
        json_ptr_j ptr_j{ptr_string};
        json_ptr_oj ptr_oj{ptr_string};

-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
        CHECK(j.contains(ptr));
        CHECK(j.contains(ptr_j));
        CHECK(j.contains(ptr_oj));
@@ -865,7 +851,6 @@ TEST_CASE("JSON pointers")

        CHECK(j.value(ptr, "x") == j.value(ptr_j, "x"));
        CHECK(j.value(ptr, "x") == j.value(ptr_oj, "x"));
-#endif

        CHECK(ptr == ptr_j);
        CHECK(ptr == ptr_oj);
@@ -134,7 +134,7 @@ TEST_CASE("json_view")
                 "\"\"", "\"text\"", "[]", "[1,2,3]", "{}", "{\"a\":1,\"b\":2}" // NOLINT(modernize-raw-string-literal)
                })
        {
-            CAPTURE(text)
+            CAPTURE(text);
            const json j = json::parse(text);
            const json_document d = json_document::parse(text);
            const json_view v = d.root();
@@ -175,7 +175,7 @@ TEST_CASE("json_view")
        {
            std::string text;
            g.value(text, 0);
-            CAPTURE(text)
+            CAPTURE(text);
            CHECK(json_document::parse(text).root().materialize() == json::parse(text));
            // member order as ordered_json::parse keeps it
            CHECK(ordered_json_document::parse(text).root().materialize().dump() == ordered_json::parse(text).dump());
@@ -202,7 +202,7 @@ TEST_CASE("json_view")
                    "1e400", "-1e400", "[1.7976931348623159e308]", "{\"a\":\n{\"b\": [1, 2,\n 3 x]}}"
                })
        {
-            CAPTURE(text)
+            CAPTURE(text);
 #if !defined(JSON_NOEXCEPTION)
            const std::string expected = parse_exception(text);
            REQUIRE(!expected.empty());
@@ -226,7 +226,7 @@ TEST_CASE("json_view")
                {"// c\n[1]", "[1, /* c */ 2]", "[1,]", "{\"a\":1,}", "[1,/* c */]", "/", "/* ", "[1,,]"
                })
        {
-            CAPTURE(text)
+            CAPTURE(text);
            for (int options = 0; options < 4; ++options)
            {
                const bool comments = (options & 1) != 0;
@@ -254,7 +254,7 @@ TEST_CASE("json_view")
                    "1e39", "-1e39", "[3.4028235e38]", "[3.4028236e38]", "{\"a\": [1e38, -3.4028235e38]}", "{\"a\": [1e-50, 1e39]}"
                })
        {
-            CAPTURE(text)
+            CAPTURE(text);
            const bool accepted = json_float::accept(text);
            CHECK(float_document::accept(text) == accepted);
            CHECK(float_document::parse(text, false).is_discarded() == !accepted);
@@ -540,7 +540,7 @@ TEST_CASE("json_view element access and iteration")
        {
            std::string text;
            g.value(text, 0);
-            CAPTURE(text)
+            CAPTURE(text);
            const ordered_json_document d = ordered_json_document::parse(text);
            check_access(d.root(), ordered_json::parse(text));
        }
@@ -566,7 +566,7 @@ TEST_CASE("json_view element access and iteration")
        const json_view root = d.root();
        for (std::size_t i = 0; i < keys.size(); ++i)
        {
-            CAPTURE(keys[i])
+            CAPTURE(keys[i]);
            CHECK(root[keys[i]].materialize() == i);
            CHECK(root.at(keys[i]).materialize() == i);
            CHECK(root.find(keys[i]).key() == keys[i]);
@@ -604,7 +604,7 @@ TEST_CASE("json_view element access and iteration")
                {"null", "true", "42", "-1", "1.5", "\"s\"", "[]", "[1,2]", "{}", "{\"a\":1}"
                })
        {
-            CAPTURE(text)
+            CAPTURE(text);
            const json_document d = json_document::parse(text);
            const json_view v = d.root();
            const json j = v.materialize();
@@ -862,7 +862,7 @@ TEST_CASE("json_view values")
        {
            std::string text;
            g.value(text, 0);
-            CAPTURE(text)
+            CAPTURE(text);
            const ordered_json_document d = ordered_json_document::parse(text);
            check_values(d.root(), ordered_json::parse(text), text);
        }
@@ -916,7 +916,7 @@ TEST_CASE("json_view values")
        using json_float = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, float>;
        for (const auto& token : tokens)
        {
-            CAPTURE(token)
+            CAPTURE(token);
            const std::string text = "[" + token + "]";
            const double b = json::parse(text)[0].get<double>();
            CHECK(bits(json_document::parse(text).root()[0].get<double>()) == bits(b));
@@ -1025,7 +1025,7 @@ TEST_CASE("json_view JSON pointers")
            {
                continue;
            }
-            CAPTURE(text)
+            CAPTURE(text);
            const ordered_json j = ordered_json::parse(text);
            const ordered_json flat = j.flatten();
            for (const auto& leaf : flat.items())
@@ -1033,7 +1033,7 @@ TEST_CASE("json_view JSON pointers")
                // the leaf and each of its parents
                for (ordered_json::json_pointer p(leaf.key());; p = p.parent_pointer())
                {
-                    CAPTURE(p.to_string())
+                    CAPTURE(p.to_string());
                    CHECK(d.root()[p].materialize() == j[p]);
                    CHECK(d.root().at(p).materialize() == j.at(p));
                    CHECK(d.root().contains(p));
@@ -1058,7 +1058,7 @@ TEST_CASE("json_view JSON pointers")
                 "/a/18446744073709551615", "/a/-1", "/a/+1", "/a/ 1", "/x", "/c/x", "/a/0/x", "/a/1/b/c", "/a~0b", "/c~1d", "/c~1d/x", "/a/1/-"
                })
        {
-            CAPTURE(pointer)
+            CAPTURE(pointer);
            const json::json_pointer p(pointer);
            const std::string at_error = without_path(exception_of([&] { static_cast<void>(j.at(p)); }));
            CHECK(exception_of([&] { static_cast<void>(v.at(p)); }) == at_error);
@@ -1105,7 +1105,7 @@ TEST_CASE("json_view dump")
            {
                continue;
            }
-            CAPTURE(text)
+            CAPTURE(text);
            const ordered_json j = ordered_json::parse(text);
            for (const int indent :
                    {
@@ -1212,8 +1212,8 @@ TEST_CASE("json_view comparison")
        {
            for (std::size_t k = i; k < i + 3; ++k)
            {
-                CAPTURE(texts[i])
-                CAPTURE(texts[k])
+                CAPTURE(texts[i]);
+                CAPTURE(texts[k]);
                const json_document a = json_document::parse(texts[i]);
                const json_document b = json_document::parse(texts[k]);
                const json ja = json::parse(texts[i]);
@@ -121,7 +121,7 @@ json value_of(const built& b)
 // with and without a NUL after the text
 void check_same(const std::string& text)
 {
-    CAPTURE(text)
+    CAPTURE(text);
    for (int options = 0; options < 4; ++options)
    {
        const bool comments = (options & 1) != 0;
@@ -276,7 +276,7 @@ TEST_CASE("json_view builder")
                    "[1.5e38, 3.5e38]", "{\"a\": 1e-50, \"b\": 1e39}"
                })
        {
-            CAPTURE(text)
+            CAPTURE(text);
            const bool float_accepted = float_json::accept(text);
            for (const bool sentinel :
                    {
@@ -389,7 +389,7 @@ TEST_CASE("json_view builder")
                    "/nativejson-benchmark/twitter.json", "/json_tests/pass1.json", "/json_tests/pass2.json", "/json_tests/pass3.json"
                })
        {
-            CAPTURE(name)
+            CAPTURE(name);
            std::ifstream f(std::string(TEST_DATA_DIRECTORY) + name, std::ios::binary);
            std::stringstream ss;
            ss << f.rdbuf();
@@ -8,14 +8,6 @@

 #include "doctest_compatibility.h"

-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #ifdef JSON_TEST_NO_GLOBAL_UDLS
@@ -41,49 +33,10 @@ TEST_CASE("MessagePack")
    {
        SECTION("discarded")
        {
-            // a discarded value cannot be serialized to MessagePack
+            // discarded values are not serialized
            json const j = json::value_t::discarded;
-            CHECK_THROWS_WITH_AS(json::to_msgpack(j), "[json.exception.type_error.321] cannot serialize discarded value to MessagePack", json::type_error&);
-        }
-
-        SECTION("discarded values nested in a container")
-        {
-            json const discarded = json::value_t::discarded;
-
-            SECTION("in an array")
-            {
-                json const j = {1, discarded, 2};
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_msgpack(j), "[json.exception.type_error.321] (/1) cannot serialize discarded value to MessagePack", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_msgpack(j), "[json.exception.type_error.321] cannot serialize discarded value to MessagePack", json::type_error&);
-#endif
-            }
-
-            SECTION("as an object value")
-            {
-                json j;
-                j["a"] = 1;
-                j["b"] = discarded;
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_msgpack(j), "[json.exception.type_error.321] (/b) cannot serialize discarded value to MessagePack", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_msgpack(j), "[json.exception.type_error.321] cannot serialize discarded value to MessagePack", json::type_error&);
-#endif
-            }
-
-            SECTION("nested deeper (array in object in array)")
-            {
-                json inner_array = {1, discarded};
-                json middle_object;
-                middle_object["x"] = inner_array;
-                json const j = {middle_object};
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_msgpack(j), "[json.exception.type_error.321] (/0/x/1) cannot serialize discarded value to MessagePack", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_msgpack(j), "[json.exception.type_error.321] cannot serialize discarded value to MessagePack", json::type_error&);
-#endif
-            }
+            const auto result = json::to_msgpack(j);
+            CHECK(result.empty());
        }

        SECTION("null")
@@ -1842,10 +1795,8 @@ TEST_CASE("MessagePack input that cannot be read is discarded by every overload"
    CHECK_THROWS_AS(_ = json::from_msgpack(input.begin(), input.end()), json::parse_error&);
    CHECK(json::from_msgpack(input, true, false).is_discarded());
    CHECK(json::from_msgpack(input.begin(), input.end(), true, false).is_discarded());
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
    CHECK(json::from_msgpack(input.data(), input.size(), true, false).is_discarded());
    CHECK(json::from_msgpack({input.data(), input.size()}, true, false).is_discarded());
-#endif
 }

 TEST_CASE("MessagePack SAX parsing stops at every event")
@@ -2148,14 +2099,12 @@ TEST_CASE("MessagePack roundtrips" * doctest::skip())
                CHECK(j1 == j2);
            }

-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
            {
                INFO_WITH_TEMP(filename + ": uint8_t* and size");
                json j2;
                CHECK_NOTHROW(j2 = json::from_msgpack({packed.data(), packed.size()}));
                CHECK(j1 == j2);
            }
-#endif

            {
                INFO_WITH_TEMP(filename + ": output to output adapters");
@@ -40,9 +40,7 @@ using ordered_json = nlohmann::ordered_json;
 #endif

 #include <cstdio>
-#include <cstdlib>
 #include <list>
-#include <new>
 #include <tuple>
 #include <type_traits>
 #include <utility>
@@ -109,84 +107,6 @@ DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")

 using float_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, float>;

-#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
-namespace
-{
-// An allocator whose allocate() can be told to fail on demand, so tests can
-// check that ~basic_json() tolerates - in fact, after #5135, never even
-// triggers - an allocation failure. This replaces an earlier version of
-// this test that overrode the process-wide ::operator new/::operator
-// delete, which affected every allocation in the whole unit-regression2
-// binary rather than just the values under test.
-std::size_t failing_allocator_allocations = 0;
-std::size_t failing_allocator_deallocations = 0;
-bool fail_next_allocation = false;
-
-template<class T>
-struct failing_allocator : std::allocator<T>
-{
-    using std::allocator<T>::allocator;
-
-    failing_allocator() noexcept = default;
-    template<class U>
-    failing_allocator(const failing_allocator<U>& /*unused*/) noexcept {} // NOLINT(google-explicit-constructor)
-
-    T* allocate(std::size_t n)
-    {
-        if (fail_next_allocation)
-        {
-            fail_next_allocation = false;
-            throw std::bad_alloc();
-        }
-        ++failing_allocator_allocations;
-        return std::allocator<T>::allocate(n);
-    }
-
-    void deallocate(T* p, std::size_t n)
-    {
-        ++failing_allocator_deallocations;
-        std::allocator<T>::deallocate(p, n);
-    }
-
-    template<class U>
-    struct rebind
-    {
-        using other = failing_allocator<U>;
-    };
-};
-
-using failing_json = nlohmann::basic_json<std::map, std::vector, std::string, bool,
-      std::int64_t, std::uint64_t, double, failing_allocator>;
-using failing_ordered_json = nlohmann::basic_json<nlohmann::ordered_map, std::vector, std::string, bool,
-      std::int64_t, std::uint64_t, double, failing_allocator>;
-
-// builds `depth` levels of nesting around a scalar, iteratively (never
-// recursing: each wrap only moves the previous, already-built value, which
-// is O(1)), each level an array or an object depending on `nest_objects`
-template<class BasicJsonType>
-BasicJsonType make_deep_nest(std::size_t depth, bool nest_objects)
-{
-    BasicJsonType v = 0;
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        if (nest_objects)
-        {
-            BasicJsonType wrapper = BasicJsonType::object();
-            wrapper["x"] = std::move(v);
-            v = std::move(wrapper);
-        }
-        else
-        {
-            BasicJsonType wrapper = BasicJsonType::array();
-            wrapper.push_back(std::move(v));
-            v = std::move(wrapper);
-        }
-    }
-    return v;
-}
-} // namespace
-#endif
-
 /////////////////////////////////////////////////////////////////////
 // for #1647
 /////////////////////////////////////////////////////////////////////
@@ -649,7 +569,7 @@ TEST_CASE("regression tests 2")
    SECTION("issue #2067 - cannot serialize binary data to text JSON")
    {
        const std::array<unsigned char, 23> data = {{0x81, 0xA4, 0x64, 0x61, 0x74, 0x61, 0xC4, 0x0F, 0x33, 0x30, 0x30, 0x32, 0x33, 0x34, 0x30, 0x31, 0x30, 0x37, 0x30, 0x35, 0x30, 0x31, 0x30}};
-        const json j = json::from_msgpack(data.begin(), data.end());
+        const json j = json::from_msgpack(data.data(), data.size());
        // dump() is nodiscard; this only checks that dumping does not throw
        CHECK_NOTHROW(
            utils::ignore_return_value(
@@ -1020,211 +940,4 @@ TEST_CASE("regression test - excessive binary container size honors allow_except
    CHECK(json::from_cbor(std::vector<std::uint8_t> {0x9b, 0, 0, 0, 0, 0, 0, 0, 0x02}, true, false).is_discarded());
 }

-#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
-TEST_CASE("regression test #5135 - destructor never allocates, even under memory pressure")
-{
-    // Before the fix, ~basic_json() flattened a nested array/object into a
-    // heap-allocated std::vector to avoid recursing; that allocation could
-    // itself throw bad_alloc, which escapes a noexcept destructor and
-    // terminates the program. destroy() no longer allocates anything, so
-    // none of the sections below ever observe fail_next_allocation being
-    // consumed: CHECK(fail_next_allocation) confirms it was never touched.
-
-    SECTION("the original report: a small, mixed array/object nest")
-    {
-        failing_allocator_allocations = 0;
-        failing_allocator_deallocations = 0;
-        {
-            failing_json j = failing_json::array(
-            {
-                failing_json::array({1, 2}),
-                failing_json::object({{"key", failing_json::array({3})}})
-            });
-            fail_next_allocation = true;
-        } // j is destroyed here, with every further allocation set to fail
-
-        CHECK(fail_next_allocation);
-        fail_next_allocation = false;
-        CHECK(failing_allocator_deallocations > 0);
-    }
-
-    SECTION("100000-deep nested array")
-    {
-        std::size_t allocations_before = 0;
-        {
-            failing_json j = make_deep_nest<failing_json>(100000, false);
-            allocations_before = failing_allocator_allocations;
-            fail_next_allocation = true;
-        }
-
-        CHECK(fail_next_allocation);
-        fail_next_allocation = false;
-        CHECK(failing_allocator_allocations == allocations_before);
-    }
-
-    SECTION("100000-deep nested object")
-    {
-        std::size_t allocations_before = 0;
-        {
-            failing_json j = make_deep_nest<failing_json>(100000, true);
-            allocations_before = failing_allocator_allocations;
-            fail_next_allocation = true;
-        }
-
-        CHECK(fail_next_allocation);
-        fail_next_allocation = false;
-        CHECK(failing_allocator_allocations == allocations_before);
-    }
-
-    SECTION("100000-deep nested ordered_json")
-    {
-        std::size_t allocations_before = 0;
-        {
-            failing_ordered_json j = make_deep_nest<failing_ordered_json>(100000, true);
-            allocations_before = failing_allocator_allocations;
-            fail_next_allocation = true;
-        }
-
-        CHECK(fail_next_allocation);
-        fail_next_allocation = false;
-        CHECK(failing_allocator_allocations == allocations_before);
-    }
-
-    SECTION("wide and deep: 1000 arrays of 1000 elements, each a small nested object")
-    {
-        std::size_t allocations_before = 0;
-        {
-            failing_json wide = failing_json::array();
-            for (std::size_t i = 0; i < 1000; ++i)
-            {
-                failing_json inner = failing_json::array();
-                for (std::size_t k = 0; k < 1000; ++k)
-                {
-                    inner.push_back(failing_json::object({{"a", 1}, {"b", failing_json::array({1, 2, 3})}}));
-                }
-                wide.push_back(std::move(inner));
-            }
-
-            allocations_before = failing_allocator_allocations;
-            fail_next_allocation = true;
-        }
-
-        CHECK(fail_next_allocation);
-        fail_next_allocation = false;
-        CHECK(failing_allocator_allocations == allocations_before);
-    }
-}
-#endif
-
-namespace
-{
-// a single-element chain of `depth` arrays, built iteratively (never
-// recursing: each wrap only moves the previous, already-built value)
-template<class BasicJsonType>
-BasicJsonType make_single_chain(std::size_t depth)
-{
-    BasicJsonType v = 1;
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        BasicJsonType wrapper = BasicJsonType::array();
-        wrapper.push_back(std::move(v));
-        v = std::move(wrapper);
-    }
-    return v;
-}
-
-// copies value first, to make sure nothing was corrupted by building it,
-// then lets both the copy and the original destruct via normal scope exit
-template<class BasicJsonType>
-void check_destroy_edge_case(const BasicJsonType& value)
-{
-    const BasicJsonType copy = value;
-    CHECK(copy == value);
-}
-} // namespace
-
-TEST_CASE_TEMPLATE("regression test #5135 - destroy() edge cases", BasicJsonType, json, ordered_json)
-{
-    using binary_t = typename BasicJsonType::binary_t;
-
-    SECTION("mix of empty objects, empty arrays, non-empty containers, and scalars")
-    {
-        BasicJsonType root = BasicJsonType::array();
-        root.push_back(BasicJsonType::object());
-        root.push_back(BasicJsonType::array());
-        root.push_back(BasicJsonType::object({{"k", 1}}));
-        root.push_back(BasicJsonType::array({1, 2, 3}));
-        root.push_back(nullptr);
-        root.push_back(true);
-        root.push_back(42);
-        root.push_back(3.14);
-        root.push_back("a string");
-        root.push_back(BasicJsonType(binary_t({1, 2, 3})));
-        check_destroy_edge_case(root);
-    }
-
-    SECTION("container child in first position only")
-    {
-        BasicJsonType root = BasicJsonType::array({BasicJsonType::array({1, 2}), 3, 4, 5});
-        check_destroy_edge_case(root);
-    }
-
-    SECTION("container child in last position only")
-    {
-        BasicJsonType root = BasicJsonType::array({1, 2, 3, BasicJsonType::array({4, 5})});
-        check_destroy_edge_case(root);
-    }
-
-    SECTION("container children in first and last position")
-    {
-        BasicJsonType root = BasicJsonType::array({BasicJsonType::array({1}), 2, 3, BasicJsonType::array({4})});
-        check_destroy_edge_case(root);
-    }
-
-    SECTION("single-element chain, 1000 levels deep")
-    {
-        BasicJsonType root = make_single_chain<BasicJsonType>(1000);
-        check_destroy_edge_case(root);
-    }
-
-    SECTION("top-level empty array")
-    {
-        BasicJsonType root = BasicJsonType::array();
-        check_destroy_edge_case(root);
-    }
-
-    SECTION("top-level empty object")
-    {
-        BasicJsonType root = BasicJsonType::object();
-        check_destroy_edge_case(root);
-    }
-
-    SECTION("object whose last child is a non-empty array whose last child is an empty object")
-    {
-        BasicJsonType inner_array = BasicJsonType::array({1, 2, BasicJsonType::object()});
-        BasicJsonType root = BasicJsonType::object({{"a", 1}, {"b", inner_array}});
-        check_destroy_edge_case(root);
-    }
-
-    SECTION("destruction via erase() on a deeply nested child")
-    {
-        BasicJsonType root = BasicJsonType::array();
-        root.push_back(make_single_chain<BasicJsonType>(500));
-        root.push_back(BasicJsonType::object({{"k", BasicJsonType::array({1, 2, 3})}}));
-        // erase() must destroy the removed subtree without recursing or
-        // allocating beyond what erase() itself needs
-        root.erase(0);
-        CAPTURE(root.size())
-        CHECK(root.size() == 1);
-    }
-
-    SECTION("destruction via assignment on a deep tree")
-    {
-        BasicJsonType root = make_single_chain<BasicJsonType>(2000);
-        // assigning a new value destroys the old one in place
-        root = nullptr;
-        CHECK(root.is_null());
-    }
-}
-
 DOCTEST_CLANG_SUPPRESS_WARNING_POP
@@ -8,14 +8,6 @@

 #include "doctest_compatibility.h"

-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;

@@ -56,7 +48,6 @@ TEST_CASE("serialization")
        }
    }

-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
    SECTION("operator>>")
    {
        SECTION("no given width")
@@ -88,7 +79,6 @@ TEST_CASE("serialization")
                  "[\n\t\"foo\",\n\t1,\n\t2,\n\t3,\n\tfalse,\n\t{\n\t\t\"one\": 1\n\t}\n]");
        }
    }
-#endif

    SECTION("dump")
    {
@@ -15,23 +15,6 @@
 #include <nlohmann/json.hpp>
 using nlohmann::detail::dtoa_impl::reinterpret_bits;

-#include <array>
-#include <cmath>
-#include <cstdint>
-#include <cstdio>
-#include <cstdlib>
-#include <iomanip>
-#include <limits>
-#include <locale>
-#include <random>
-#include <sstream>
-#include <string>
-#include <utility>
-#include <vector>
-#if defined(JSON_HAS_CPP_17)
-    #include <charconv>
-#endif
-
 namespace
 {
 float make_float(uint32_t sign_bit, uint32_t biased_exponent, uint32_t significand)
@@ -467,7 +450,7 @@ TEST_CASE("formatting")
        check_double(  1.2345e+18,   "1.2345e+18"             ); //  1.2345e+18                1.2345e+18                1.2345e18
        check_double(  1.2345e+19,   "1.2345e+19"             ); //  1.2345e+19                1.2345e+19                1.2345e19
        check_double(  1.2345e+20,   "1.2345e+20"             ); //  1.2345e+20                1.2345e+20                1.2345e20
-        check_double(  1.2345e+21,   "1.2345e+21"             ); //  1.2345e+21                1.2344999999999999e+21    1.2345e21
+        check_double(  1.2345e+21,   "1.2344999999999999e+21" ); //  1.2345e+21                1.2344999999999999e+21    1.2345e21
        check_double(  1.2345e+22,   "1.2345e+22"             ); //  1.2345e+22                1.2345e+22                1.2345e22
    }

@@ -531,246 +514,3 @@ TEST_CASE("formatting")
        check_integer(1000000000000000000LL, "1000000000000000000");
    }
 }
-
-namespace
-{
-// a small unsigned big integer (32-bit limbs, least significant first), to
-// recompute the powers of ten of the shortest double conversion
-using big = std::vector<std::uint32_t>;
-
-void big_mul_small(big& x, std::uint32_t m)
-{
-    std::uint64_t carry = 0;
-    for (auto& limb : x)
-    {
-        const std::uint64_t v = (static_cast<std::uint64_t>(limb) * m) + carry;
-        limb = static_cast<std::uint32_t>(v);
-        carry = v >> 32u;
-    }
-    if (carry != 0)
-    {
-        x.push_back(static_cast<std::uint32_t>(carry));
-    }
-}
-
-void big_div_small(big& x, std::uint32_t d)
-{
-    std::uint64_t rest = 0;
-    for (std::size_t i = x.size(); i-- > 0;)
-    {
-        const std::uint64_t v = (rest << 32u) | x[i];
-        x[i] = static_cast<std::uint32_t>(v / d);
-        rest = v % d;
-    }
-    while (!x.empty() && x.back() == 0)
-    {
-        x.pop_back();
-    }
-}
-
-std::size_t big_bit_length(const big& x)
-{
-    std::size_t n = 32 * x.size();
-    for (std::uint32_t top = x.back(); (top & 0x80000000u) == 0; top <<= 1u)
-    {
-        --n;
-    }
-    return n;
-}
-
-bool big_bit(const big& x, std::size_t i)
-{
-    return ((x[i / 32] >> (i % 32)) & 1u) != 0;
-}
-
-/// the 128 most significant bits of x (floor), shifted left if x has fewer bits
-std::pair<std::uint64_t, std::uint64_t> big_top128(const big& x)
-{
-    const std::size_t n = big_bit_length(x);
-    std::uint64_t high = 0;
-    std::uint64_t low = 0;
-    for (std::size_t k = 0; k < 128; ++k)
-    {
-        const bool bit = k < n && big_bit(x, n - 1 - k);
-        if (k < 64)
-        {
-            high = (high << 1u) | (bit ? 1u : 0u);
-        }
-        else
-        {
-            low = (low << 1u) | (bit ? 1u : 0u);
-        }
-    }
-    return {high, low};
-}
-
-/// the digits (without trailing zeros) and the decimal exponent of a
-/// representation "[-]d[.ddd][e[+-]x]"
-std::pair<std::string, int> digits_and_exponent(const std::string& s)
-{
-    std::string digits;
-    int point = -1;
-    int exponent = 0;
-    for (std::size_t i = 0; i < s.size(); ++i)
-    {
-        const char c = s[i];
-        if (c >= '0' && c <= '9')
-        {
-            digits += c;
-        }
-        else if (c == '.')
-        {
-            point = static_cast<int>(digits.size());
-        }
-        else if (c == 'e' || c == 'E')
-        {
-            exponent = std::stoi(s.substr(i + 1));
-            break;
-        }
-    }
-    int e = exponent + (point < 0 ? static_cast<int>(digits.size()) : point) - static_cast<int>(digits.size());
-    const std::size_t first = digits.find_first_not_of('0');
-    digits = first == std::string::npos ? "0" : digits.substr(first);
-    while (digits.size() > 1 && digits.back() == '0')
-    {
-        digits.pop_back();
-        ++e;
-    }
-    return {digits, e};
-}
-
-/// whether the decimal digits * 10^e reads back as v
-bool reads_back(const std::string& digits, int e, double v)
-{
-    const std::string text = digits + "e" + std::to_string(e);
-    // (compared bit for bit: v is positive and finite, and -Wfloat-equal)
-    return reinterpret_bits<std::uint64_t>(std::strtod(text.c_str(), nullptr)) == reinterpret_bits<std::uint64_t>(v);
-}
-
-/// Check the representation of a positive finite double: it reads back as
-/// the same value, and no representation with fewer digits does.
-void check_shortest(double v)
-{
-    std::array<char, 33> buf{};
-    char* end = nlohmann::detail::to_chars(buf.data(), buf.data() + 32, v);
-    const std::string text(buf.data(), end);
-    CAPTURE(text)
-    CHECK(std::strtod(text.c_str(), nullptr) == v);
-    // the layout is that of format_buffer() for the same digits
-    std::array<char, 64> reference{};
-    int len = 0;
-    int exponent = 0;
-    nlohmann::detail::dtoa_impl::shortest_digits(reference.data(), len, exponent, v);
-    const char* const reference_end = nlohmann::detail::dtoa_impl::format_buffer(reference.data(), len, exponent, -4, 15);
-    CHECK(text == std::string(reference.data(), static_cast<std::size_t>(reference_end - reference.data())));
-    const auto de = digits_and_exponent(text);
-    const std::string& digits = de.first;
-    if (digits.size() > 1)
-    {
-        // the decimals of one digit fewer next to the value
-        // (a stream rather than snprintf("%.*e"), whose output GCC cannot bound)
-        std::ostringstream shorter;
-        shorter.imbue(std::locale::classic());
-        shorter << std::scientific << std::setprecision(static_cast<int>(digits.size()) - 2) << v;
-        const auto near = digits_and_exponent(shorter.str());
-        // as an integer with digits.size() - 1 digits
-        std::string m = near.first;
-        int e = near.second;
-        while (m.size() < digits.size() - 1)
-        {
-            m += '0';
-            --e;
-        }
-        const std::uint64_t mid = std::stoull(m);
-        for (const std::uint64_t candidate :
-                {
-                    mid - 1, mid, mid + 1
-                })
-        {
-            CAPTURE(candidate)
-            CHECK(!reads_back(std::to_string(candidate), e, v));
-        }
-    }
-#if defined(JSON_HAS_CPP_17) && defined(__cpp_lib_to_chars)
-    // the closest of the shortest representations, as std::to_chars finds it
-    std::array<char, 64> std_text{};
-    const auto r = std::to_chars(std_text.data(), std_text.data() + std_text.size(), v, std::chars_format::scientific);
-    CHECK(digits_and_exponent(std::string(std_text.data(), r.ptr)) == de);
-#endif
-}
-} // namespace
-
-TEST_CASE("shortest digits of doubles")
-{
-    SECTION("powers of ten")
-    {
-        // the 128-bit significands of 10^k, rounded down, recomputed
-        for (int k = -342; k <= 341; ++k)
-        {
-            CAPTURE(k)
-            big x{1};
-            if (k >= 0)
-            {
-                for (int i = 0; i < k; ++i)
-                {
-                    big_mul_small(x, 10);
-                }
-            }
-            else
-            {
-                // floor(2^b / 10^-k) for a b that leaves more than 128 bits
-                const int b = 128 + 64 + (4 * -k);
-                x.assign(static_cast<std::size_t>(b / 32) + 1, 0);
-                x.back() = 1u << (b % 32);
-                for (int i = 0; i < -k; ++i)
-                {
-                    big_div_small(x, 10);
-                }
-            }
-            const auto expected = big_top128(x);
-            const auto actual = nlohmann::detail::zmij::pow10(k);
-            CHECK(actual.high == expected.first);
-            CHECK(actual.low == expected.second);
-        }
-    }
-
-    SECTION("boundary values")
-    {
-        for (const double v :
-                {
-                    std::numeric_limits<double>::min(), std::numeric_limits<double>::max(), std::numeric_limits<double>::denorm_min(),
-                    std::nextafter(std::numeric_limits<double>::min(), 0.0), 1.0, 2.0, 0.1, 0.3, 1e21, 1e22, 1e23, 5e-324, 9007199254740993.0,
-                    1.2345e+21, 2.2250738585072014e-308, 1.7976931348623157e308, 4.9406564584124654e-324, 123456789012345680.0
-                })
-        {
-            check_shortest(v);
-        }
-        // all powers of two (their rounding interval is narrower below)
-        for (int e = -1074; e <= 1023; ++e)
-        {
-            check_shortest(std::ldexp(1.0, e));
-        }
-        // powers of ten and their neighbors
-        for (int e = -323; e <= 308; ++e)
-        {
-            const double p = std::strtod(("1e" + std::to_string(e)).c_str(), nullptr);
-            check_shortest(p);
-            check_shortest(std::nextafter(p, 0.0));
-            check_shortest(std::nextafter(p, std::numeric_limits<double>::infinity()));
-        }
-    }
-
-    SECTION("random doubles")
-    {
-        std::mt19937_64 rng(5295); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed): reproducible
-        for (int i = 0; i < 100000; ++i)
-        {
-            const std::uint64_t bits = rng() & 0x7FFFFFFFFFFFFFFFu;
-            const auto v = reinterpret_bits<double>(bits);
-            if (std::isfinite(v) && bits != 0)
-            {
-                check_shortest(v);
-            }
-        }
-    }
-}
@@ -8,14 +8,6 @@

 #include "doctest_compatibility.h"

-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;

@@ -35,59 +27,10 @@ TEST_CASE("UBJSON")
    {
        SECTION("discarded")
        {
-            // a discarded value cannot be serialized to UBJSON
+            // discarded values are not serialized
            json const j = json::value_t::discarded;
-            CHECK_THROWS_WITH_AS(json::to_ubjson(j), "[json.exception.type_error.321] cannot serialize discarded value to UBJSON", json::type_error&);
-        }
-
-        SECTION("discarded values nested in a container")
-        {
-            json const discarded = json::value_t::discarded;
-
-            SECTION("in an array")
-            {
-                json const j = {1, discarded, 2};
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_ubjson(j), "[json.exception.type_error.321] (/1) cannot serialize discarded value to UBJSON", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_ubjson(j), "[json.exception.type_error.321] cannot serialize discarded value to UBJSON", json::type_error&);
-#endif
-            }
-
-            SECTION("as an object value")
-            {
-                json j;
-                j["a"] = 1;
-                j["b"] = discarded;
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_ubjson(j), "[json.exception.type_error.321] (/b) cannot serialize discarded value to UBJSON", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_ubjson(j), "[json.exception.type_error.321] cannot serialize discarded value to UBJSON", json::type_error&);
-#endif
-            }
-
-            SECTION("nested deeper (array in object in array)")
-            {
-                json inner_array = {1, discarded};
-                json middle_object;
-                middle_object["x"] = inner_array;
-                json const j = {middle_object};
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_ubjson(j), "[json.exception.type_error.321] (/0/x/1) cannot serialize discarded value to UBJSON", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_ubjson(j), "[json.exception.type_error.321] cannot serialize discarded value to UBJSON", json::type_error&);
-#endif
-            }
-
-            SECTION("optimized array of all-discarded elements")
-            {
-                json const j = {discarded, discarded};
-#if JSON_DIAGNOSTICS
-                CHECK_THROWS_WITH_AS(json::to_ubjson(j, true, true), "[json.exception.type_error.321] (/0) cannot serialize discarded value to UBJSON", json::type_error&);
-#else
-                CHECK_THROWS_WITH_AS(json::to_ubjson(j, true, true), "[json.exception.type_error.321] cannot serialize discarded value to UBJSON", json::type_error&);
-#endif
-            }
+            const auto result = json::to_ubjson(j);
+            CHECK(result.empty());
        }

        SECTION("null")
@@ -2148,14 +2091,9 @@ TEST_CASE("UBJSON")

        SECTION("discarded")
        {
-            // a discarded value cannot be serialized to UBJSON, even as part
-            // of an optimized array of a single (here: valueless) type
            json const j = {json::value_t::discarded, json::value_t::discarded};
-#if JSON_DIAGNOSTICS
-            CHECK_THROWS_WITH_AS(json::to_ubjson(j, true, true), "[json.exception.type_error.321] (/0) cannot serialize discarded value to UBJSON", json::type_error&);
-#else
-            CHECK_THROWS_WITH_AS(json::to_ubjson(j, true, true), "[json.exception.type_error.321] cannot serialize discarded value to UBJSON", json::type_error&);
-#endif
+            std::vector<uint8_t> expected = {'[', '$', 'N', '#', 'i', 2};
+            CHECK(json::to_ubjson(j, true, true) == expected);
        }
    }
 }
@@ -2274,10 +2212,8 @@ TEST_CASE("UBJSON input that cannot be read is discarded by every overload")
    CHECK_THROWS_AS(_ = json::from_ubjson(input.begin(), input.end()), json::parse_error&);
    CHECK(json::from_ubjson(input, true, false).is_discarded());
    CHECK(json::from_ubjson(input.begin(), input.end(), true, false).is_discarded());
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
    CHECK(json::from_ubjson(input.data(), input.size(), true, false).is_discarded());
    CHECK(json::from_ubjson({input.data(), input.size()}, true, false).is_discarded());
-#endif
 }

 TEST_CASE("UBJSON SAX parsing stops at every event")
@@ -3025,14 +2961,12 @@ TEST_CASE("UBJSON roundtrips" * doctest::skip())
                CHECK(j1 == j2);
            }

-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
            {
                INFO_WITH_TEMP(filename + ": uint8_t* and size");
                json j2;
                CHECK_NOTHROW(j2 = json::from_ubjson({packed.data(), packed.size()}));
                CHECK(j1 == j2);
            }
-#endif

            {
                INFO_WITH_TEMP(filename + ": output to output adapters");