From 2577b18b433c9ed4fd62f7b36d1bba9fd61764ac Mon Sep 17 00:00:00 2001
From: kin-fuyuki <jktechsoftwares@gmail.com>
Date: Sun, 22 Feb 2026 04:07:00 -0300
Subject: [PATCH] stuf i forgor

---
 engine/test/test                 |   Bin 0 -> 1220648 bytes
 include/enginend/graph/noise.h   |     1 +
 include/enginend/scenes/node3d.h |     1 +
 include/json.h                   | 25712 +++++++++++++++++++++++++++++
 include/luajit/lauxlib.h         |     1 +
 include/luajit/lua.h             |     1 +
 include/luajit/lua.hpp           |     1 +
 include/luajit/luaconf.h         |     1 +
 include/luajit/lualib.h          |     1 +
 9 files changed, 25719 insertions(+)
 create mode 100755 engine/test/test
 create mode 120000 include/enginend/graph/noise.h
 create mode 120000 include/enginend/scenes/node3d.h
 create mode 100644 include/json.h
 create mode 120000 include/luajit/lauxlib.h
 create mode 120000 include/luajit/lua.h
 create mode 120000 include/luajit/lua.hpp
 create mode 120000 include/luajit/luaconf.h
 create mode 120000 include/luajit/lualib.h

diff --git a/engine/test/test b/engine/test/test
new file mode 100755
index 0000000000000000000000000000000000000000..3a8659e3fc471f768de561377ca9fef36c542991
GIT binary patch
literal 1220648
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%0D*2y`{DX5K_rVF2cd3S&uJ}(w{82iu@n#C*
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
Cg(X%1

literal 0
HcmV?d00001

diff --git a/include/enginend/graph/noise.h b/include/enginend/graph/noise.h
new file mode 120000
index 0000000..8299c7b
--- /dev/null
+++ b/include/enginend/graph/noise.h
@@ -0,0 +1 @@
+../../../engine/src/graph/noise.h
\ No newline at end of file
diff --git a/include/enginend/scenes/node3d.h b/include/enginend/scenes/node3d.h
new file mode 120000
index 0000000..503c667
--- /dev/null
+++ b/include/enginend/scenes/node3d.h
@@ -0,0 +1 @@
+../../../engine/src/scenes/node3d.h
\ No newline at end of file
diff --git a/include/json.h b/include/json.h
new file mode 100644
index 0000000..27986ed
--- /dev/null
+++ b/include/json.h
@@ -0,0 +1,25712 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+/****************************************************************************\
+ * Note on documentation: The source files contain links to the online      *
+ * documentation of the public API at https://json.nlohmann.me. This URL    *
+ * contains the most recent documentation and should also be applicable to  *
+ * previous versions; documentation for deprecated functions is not         *
+ * removed, but marked deprecated. See "Generate documentation" section in  *
+ * file docs/README.md.                                                     *
+\****************************************************************************/
+
+#ifndef INCLUDE_NLOHMANN_JSON_HPP_
+#define INCLUDE_NLOHMANN_JSON_HPP_
+
+#include <algorithm> // all_of, find, for_each
+#include <cstddef> // nullptr_t, ptrdiff_t, size_t
+#include <functional> // hash, less
+#include <initializer_list> // initializer_list
+#ifndef JSON_NO_IO
+    #include <iosfwd> // istream, ostream
+#endif  // JSON_NO_IO
+#include <iterator> // random_access_iterator_tag
+#include <memory> // unique_ptr
+#include <string> // string, stoi, to_string
+#include <utility> // declval, forward, move, pair, swap
+#include <vector> // vector
+
+// #include <nlohmann/adl_serializer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <utility>
+
+// #include <nlohmann/detail/abi_macros.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// This file contains all macro definitions affecting or depending on the ABI
+
+#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK
+    #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH)
+        #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 12 || NLOHMANN_JSON_VERSION_PATCH != 0
+            #warning "Already included a different version of the library!"
+        #endif
+    #endif
+#endif
+
+#define NLOHMANN_JSON_VERSION_MAJOR 3   // NOLINT(modernize-macro-to-enum)
+#define NLOHMANN_JSON_VERSION_MINOR 12  // NOLINT(modernize-macro-to-enum)
+#define NLOHMANN_JSON_VERSION_PATCH 0   // NOLINT(modernize-macro-to-enum)
+
+#ifndef JSON_DIAGNOSTICS
+    #define JSON_DIAGNOSTICS 0
+#endif
+
+#ifndef JSON_DIAGNOSTIC_POSITIONS
+    #define JSON_DIAGNOSTIC_POSITIONS 0
+#endif
+
+#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0
+#endif
+
+#if JSON_DIAGNOSTICS
+    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
+#else
+    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS
+#endif
+
+#if JSON_DIAGNOSTIC_POSITIONS
+    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS _dp
+#else
+    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS
+#endif
+
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp
+#else
+    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON
+#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) json_abi ## a ## b ## c
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c)
+
+#define NLOHMANN_JSON_ABI_TAGS                                       \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
+            NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
+            NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \
+            NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS)
+
+// Construct the namespace version component
+#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
+    _v ## major ## _ ## minor ## _ ## patch
+#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \
+    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)
+
+#if NLOHMANN_JSON_NAMESPACE_NO_VERSION
+#define NLOHMANN_JSON_NAMESPACE_VERSION
+#else
+#define NLOHMANN_JSON_NAMESPACE_VERSION                                 \
+    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \
+                                           NLOHMANN_JSON_VERSION_MINOR, \
+                                           NLOHMANN_JSON_VERSION_PATCH)
+#endif
+
+// Combine namespace components
+#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b
+#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \
+    NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b)
+
+#ifndef NLOHMANN_JSON_NAMESPACE
+#define NLOHMANN_JSON_NAMESPACE               \
+    nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \
+            NLOHMANN_JSON_ABI_TAGS,           \
+            NLOHMANN_JSON_NAMESPACE_VERSION)
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN
+#define NLOHMANN_JSON_NAMESPACE_BEGIN                \
+    namespace nlohmann                               \
+    {                                                \
+    inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \
+                NLOHMANN_JSON_ABI_TAGS,              \
+                NLOHMANN_JSON_NAMESPACE_VERSION)     \
+    {
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_END
+#define NLOHMANN_JSON_NAMESPACE_END                                     \
+    }  /* namespace (inline namespace) NOLINT(readability/namespace) */ \
+    }  // namespace nlohmann
+#endif
+
+// #include <nlohmann/detail/conversions/from_json.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // transform
+#include <array> // array
+#include <forward_list> // forward_list
+#include <iterator> // inserter, front_inserter, end
+#include <map> // map
+#include <string> // string
+#include <tuple> // tuple, make_tuple
+#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
+#include <unordered_map> // unordered_map
+#include <utility> // pair, declval
+#include <valarray> // valarray
+
+// #include <nlohmann/detail/exceptions.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // nullptr_t
+#include <exception> // exception
+#if JSON_DIAGNOSTICS
+    #include <numeric> // accumulate
+#endif
+#include <stdexcept> // runtime_error
+#include <string> // to_string
+#include <vector> // vector
+
+// #include <nlohmann/detail/value_t.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t
+#include <string> // string
+
+// #include <nlohmann/detail/macro_scope.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <utility> // declval, pair
+// #include <nlohmann/detail/meta/detected.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <type_traits>
+
+// #include <nlohmann/detail/meta/void_t.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename ...Ts> struct make_void
+{
+    using type = void;
+};
+template<typename ...Ts> using void_t = typename make_void<Ts...>::type;
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+// https://en.cppreference.com/w/cpp/experimental/is_detected
+struct nonesuch
+{
+    nonesuch() = delete;
+    ~nonesuch() = delete;
+    nonesuch(nonesuch const&) = delete;
+    nonesuch(nonesuch const&&) = delete;
+    void operator=(nonesuch const&) = delete;
+    void operator=(nonesuch&&) = delete;
+};
+
+template<class Default,
+         class AlwaysVoid,
+         template<class...> class Op,
+         class... Args>
+struct detector
+{
+    using value_t = std::false_type;
+    using type = Default;
+};
+
+template<class Default, template<class...> class Op, class... Args>
+struct detector<Default, void_t<Op<Args...>>, Op, Args...>
+{
+    using value_t = std::true_type;
+    using type = Op<Args...>;
+};
+
+template<template<class...> class Op, class... Args>
+using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
+
+template<template<class...> class Op, class... Args>
+struct is_detected_lazy : is_detected<Op, Args...> { };
+
+template<template<class...> class Op, class... Args>
+using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
+
+template<class Default, template<class...> class Op, class... Args>
+using detected_or = detector<Default, void, Op, Args...>;
+
+template<class Default, template<class...> class Op, class... Args>
+using detected_or_t = typename detected_or<Default, Op, Args...>::type;
+
+template<class Expected, template<class...> class Op, class... Args>
+using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
+
+template<class To, template<class...> class Op, class... Args>
+using is_detected_convertible =
+    std::is_convertible<detected_t<Op, Args...>, To>;
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/thirdparty/hedley/hedley.hpp>
+
+
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-FileCopyrightText: 2016-2021 Evan Nemerson <evan@nemerson.com>
+// SPDX-License-Identifier: MIT
+
+/* Hedley - https://nemequ.github.io/hedley
+ * Created by Evan Nemerson <evan@nemerson.com>
+ * SPDX-License-Identifier: CC0-1.0
+ */
+
+#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)
+#if defined(JSON_HEDLEY_VERSION)
+    #undef JSON_HEDLEY_VERSION
+#endif
+#define JSON_HEDLEY_VERSION 15
+
+#if defined(JSON_HEDLEY_STRINGIFY_EX)
+    #undef JSON_HEDLEY_STRINGIFY_EX
+#endif
+#define JSON_HEDLEY_STRINGIFY_EX(x) #x
+
+#if defined(JSON_HEDLEY_STRINGIFY)
+    #undef JSON_HEDLEY_STRINGIFY
+#endif
+#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
+
+#if defined(JSON_HEDLEY_CONCAT_EX)
+    #undef JSON_HEDLEY_CONCAT_EX
+#endif
+#define JSON_HEDLEY_CONCAT_EX(a,b) a##b
+
+#if defined(JSON_HEDLEY_CONCAT)
+    #undef JSON_HEDLEY_CONCAT
+#endif
+#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
+
+#if defined(JSON_HEDLEY_CONCAT3_EX)
+    #undef JSON_HEDLEY_CONCAT3_EX
+#endif
+#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
+
+#if defined(JSON_HEDLEY_CONCAT3)
+    #undef JSON_HEDLEY_CONCAT3
+#endif
+#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
+
+#if defined(JSON_HEDLEY_VERSION_ENCODE)
+    #undef JSON_HEDLEY_VERSION_ENCODE
+#endif
+#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
+    #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
+    #undef JSON_HEDLEY_VERSION_DECODE_MINOR
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
+    #undef JSON_HEDLEY_VERSION_DECODE_REVISION
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
+
+#if defined(JSON_HEDLEY_GNUC_VERSION)
+    #undef JSON_HEDLEY_GNUC_VERSION
+#endif
+#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
+    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
+#elif defined(__GNUC__)
+    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
+    #undef JSON_HEDLEY_GNUC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_GNUC_VERSION)
+    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_MSVC_VERSION)
+    #undef JSON_HEDLEY_MSVC_VERSION
+#endif
+#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
+#elif defined(_MSC_FULL_VER) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
+#elif defined(_MSC_VER) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
+    #undef JSON_HEDLEY_MSVC_VERSION_CHECK
+#endif
+#if !defined(JSON_HEDLEY_MSVC_VERSION)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
+#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
+#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
+#else
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_VERSION)
+    #undef JSON_HEDLEY_INTEL_VERSION
+#endif
+#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)
+    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
+#elif defined(__INTEL_COMPILER) && !defined(__ICL)
+    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
+    #undef JSON_HEDLEY_INTEL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_INTEL_VERSION)
+    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
+    #undef JSON_HEDLEY_INTEL_CL_VERSION
+#endif
+#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)
+    #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)
+    #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
+    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_PGI_VERSION)
+    #undef JSON_HEDLEY_PGI_VERSION
+#endif
+#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
+    #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
+#endif
+
+#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
+    #undef JSON_HEDLEY_PGI_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_PGI_VERSION)
+    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_SUNPRO_VERSION)
+    #undef JSON_HEDLEY_SUNPRO_VERSION
+#endif
+#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)
+#elif defined(__SUNPRO_C)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
+#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)
+#elif defined(__SUNPRO_CC)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
+#endif
+
+#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
+    #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_SUNPRO_VERSION)
+    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
+    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
+#endif
+#if defined(__EMSCRIPTEN__)
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
+#endif
+
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
+    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_ARM_VERSION)
+    #undef JSON_HEDLEY_ARM_VERSION
+#endif
+#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
+#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
+#endif
+
+#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
+    #undef JSON_HEDLEY_ARM_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_ARM_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_IBM_VERSION)
+    #undef JSON_HEDLEY_IBM_VERSION
+#endif
+#if defined(__ibmxl__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
+#elif defined(__xlC__) && defined(__xlC_ver__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
+#elif defined(__xlC__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
+#endif
+
+#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
+    #undef JSON_HEDLEY_IBM_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_IBM_VERSION)
+    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_VERSION)
+    #undef JSON_HEDLEY_TI_VERSION
+#endif
+#if \
+    defined(__TI_COMPILER_VERSION__) && \
+    ( \
+      defined(__TMS470__) || defined(__TI_ARM__) || \
+      defined(__MSP430__) || \
+      defined(__TMS320C2000__) \
+    )
+#if (__TI_COMPILER_VERSION__ >= 16000000)
+    #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+#endif
+
+#if defined(JSON_HEDLEY_TI_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_VERSION)
+    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
+    #undef JSON_HEDLEY_TI_CL2000_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
+    #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
+    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL430_VERSION)
+    #undef JSON_HEDLEY_TI_CL430_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
+    #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL430_VERSION)
+    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
+    #undef JSON_HEDLEY_TI_ARMCL_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
+    #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
+    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
+    #undef JSON_HEDLEY_TI_CL6X_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
+    #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
+    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
+    #undef JSON_HEDLEY_TI_CL7X_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
+    #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
+    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
+    #undef JSON_HEDLEY_TI_CLPRU_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
+    #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
+    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_CRAY_VERSION)
+    #undef JSON_HEDLEY_CRAY_VERSION
+#endif
+#if defined(_CRAYC)
+    #if defined(_RELEASE_PATCHLEVEL)
+        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
+    #else
+        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
+    #endif
+#endif
+
+#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
+    #undef JSON_HEDLEY_CRAY_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_CRAY_VERSION)
+    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_IAR_VERSION)
+    #undef JSON_HEDLEY_IAR_VERSION
+#endif
+#if defined(__IAR_SYSTEMS_ICC__)
+    #if __VER__ > 1000
+        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
+    #else
+        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)
+    #endif
+#endif
+
+#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
+    #undef JSON_HEDLEY_IAR_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_IAR_VERSION)
+    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TINYC_VERSION)
+    #undef JSON_HEDLEY_TINYC_VERSION
+#endif
+#if defined(__TINYC__)
+    #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
+#endif
+
+#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
+    #undef JSON_HEDLEY_TINYC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TINYC_VERSION)
+    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_DMC_VERSION)
+    #undef JSON_HEDLEY_DMC_VERSION
+#endif
+#if defined(__DMC__)
+    #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
+#endif
+
+#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
+    #undef JSON_HEDLEY_DMC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_DMC_VERSION)
+    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_COMPCERT_VERSION)
+    #undef JSON_HEDLEY_COMPCERT_VERSION
+#endif
+#if defined(__COMPCERT_VERSION__)
+    #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
+#endif
+
+#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
+    #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_COMPCERT_VERSION)
+    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_PELLES_VERSION)
+    #undef JSON_HEDLEY_PELLES_VERSION
+#endif
+#if defined(__POCC__)
+    #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
+    #undef JSON_HEDLEY_PELLES_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_PELLES_VERSION)
+    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
+    #undef JSON_HEDLEY_MCST_LCC_VERSION
+#endif
+#if defined(__LCC__) && defined(__LCC_MINOR__)
+    #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)
+#endif
+
+#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)
+    #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
+    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_VERSION)
+    #undef JSON_HEDLEY_GCC_VERSION
+#endif
+#if \
+    defined(JSON_HEDLEY_GNUC_VERSION) && \
+    !defined(__clang__) && \
+    !defined(JSON_HEDLEY_INTEL_VERSION) && \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_ARM_VERSION) && \
+    !defined(JSON_HEDLEY_CRAY_VERSION) && \
+    !defined(JSON_HEDLEY_TI_VERSION) && \
+    !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
+    !defined(__COMPCERT__) && \
+    !defined(JSON_HEDLEY_MCST_LCC_VERSION)
+    #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
+#endif
+
+#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
+    #undef JSON_HEDLEY_GCC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_GCC_VERSION)
+    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_ATTRIBUTE
+#endif
+#if \
+  defined(__has_attribute) && \
+  ( \
+    (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \
+  )
+#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
+#else
+#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
+#endif
+#if \
+    defined(__has_cpp_attribute) && \
+    defined(__cplusplus) && \
+    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
+    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
+#endif
+#if !defined(__cplusplus) || !defined(__has_cpp_attribute)
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
+#elif \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_IAR_VERSION) && \
+    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
+    (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
+#else
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
+#endif
+#if defined(__has_cpp_attribute) && defined(__cplusplus)
+    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
+#endif
+#if defined(__has_cpp_attribute) && defined(__cplusplus)
+    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_BUILTIN)
+    #undef JSON_HEDLEY_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
+    #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
+    #undef JSON_HEDLEY_GCC_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_FEATURE)
+    #undef JSON_HEDLEY_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
+    #undef JSON_HEDLEY_GNUC_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
+    #undef JSON_HEDLEY_GCC_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_EXTENSION)
+    #undef JSON_HEDLEY_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
+    #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
+    #undef JSON_HEDLEY_GCC_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_WARNING)
+    #undef JSON_HEDLEY_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_HAS_WARNING(warning) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
+    #undef JSON_HEDLEY_GNUC_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_WARNING)
+    #undef JSON_HEDLEY_GCC_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if \
+    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
+    defined(__clang__) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
+    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
+    (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
+    #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
+#else
+    #define JSON_HEDLEY_PRAGMA(value)
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
+    #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
+#endif
+#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
+    #undef JSON_HEDLEY_DIAGNOSTIC_POP
+#endif
+#if defined(__clang__)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
+    #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
+#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH
+    #define JSON_HEDLEY_DIAGNOSTIC_POP
+#endif
+
+/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
+   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
+#endif
+#if defined(__cplusplus)
+#  if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
+#    if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
+#      if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")
+#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#      else
+#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#      endif
+#    else
+#      define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#    endif
+#  endif
+#endif
+#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
+#endif
+
+#if defined(JSON_HEDLEY_CONST_CAST)
+    #undef JSON_HEDLEY_CONST_CAST
+#endif
+#if defined(__cplusplus)
+#  define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
+#elif \
+  JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
+        JSON_HEDLEY_DIAGNOSTIC_PUSH \
+        JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
+        ((T) (expr)); \
+        JSON_HEDLEY_DIAGNOSTIC_POP \
+    }))
+#else
+#  define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_REINTERPRET_CAST)
+    #undef JSON_HEDLEY_REINTERPRET_CAST
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
+#else
+    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_STATIC_CAST)
+    #undef JSON_HEDLEY_STATIC_CAST
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
+#else
+    #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_CPP_CAST)
+    #undef JSON_HEDLEY_CPP_CAST
+#endif
+#if defined(__cplusplus)
+#  if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
+#    define JSON_HEDLEY_CPP_CAST(T, expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
+    ((T) (expr)) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
+#    define JSON_HEDLEY_CPP_CAST(T, expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("diag_suppress=Pe137") \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  else
+#    define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
+#  endif
+#else
+#  define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292))
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunused-function")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505))
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
+#endif
+
+#if defined(JSON_HEDLEY_DEPRECATED)
+    #undef JSON_HEDLEY_DEPRECATED
+#endif
+#if defined(JSON_HEDLEY_DEPRECATED_FOR)
+    #undef JSON_HEDLEY_DEPRECATED_FOR
+#endif
+#if \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
+#elif \
+    (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
+#elif defined(__cplusplus) && (__cplusplus >= 201402L)
+    #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
+#else
+    #define JSON_HEDLEY_DEPRECATED(since)
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
+#endif
+
+#if defined(JSON_HEDLEY_UNAVAILABLE)
+    #undef JSON_HEDLEY_UNAVAILABLE
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
+#else
+    #define JSON_HEDLEY_UNAVAILABLE(available_since)
+#endif
+
+#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
+    #undef JSON_HEDLEY_WARN_UNUSED_RESULT
+#endif
+#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
+    #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
+#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+#elif defined(_Check_return_) /* SAL */
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
+#else
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
+#endif
+
+#if defined(JSON_HEDLEY_SENTINEL)
+    #undef JSON_HEDLEY_SENTINEL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
+#else
+    #define JSON_HEDLEY_SENTINEL(position)
+#endif
+
+#if defined(JSON_HEDLEY_NO_RETURN)
+    #undef JSON_HEDLEY_NO_RETURN
+#endif
+#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_NO_RETURN __noreturn
+#elif \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+    #define JSON_HEDLEY_NO_RETURN _Noreturn
+#elif defined(__cplusplus) && (__cplusplus >= 201103L)
+    #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
+#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
+    #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
+    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
+#else
+    #define JSON_HEDLEY_NO_RETURN
+#endif
+
+#if defined(JSON_HEDLEY_NO_ESCAPE)
+    #undef JSON_HEDLEY_NO_ESCAPE
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
+    #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
+#else
+    #define JSON_HEDLEY_NO_ESCAPE
+#endif
+
+#if defined(JSON_HEDLEY_UNREACHABLE)
+    #undef JSON_HEDLEY_UNREACHABLE
+#endif
+#if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
+    #undef JSON_HEDLEY_UNREACHABLE_RETURN
+#endif
+#if defined(JSON_HEDLEY_ASSUME)
+    #undef JSON_HEDLEY_ASSUME
+#endif
+#if \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
+#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
+    #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
+#elif \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
+    #if defined(__cplusplus)
+        #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
+    #else
+        #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
+    #endif
+#endif
+#if \
+    (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
+#elif defined(JSON_HEDLEY_ASSUME)
+    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
+#endif
+#if !defined(JSON_HEDLEY_ASSUME)
+    #if defined(JSON_HEDLEY_UNREACHABLE)
+        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
+    #else
+        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
+    #endif
+#endif
+#if defined(JSON_HEDLEY_UNREACHABLE)
+    #if  \
+        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
+        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
+    #else
+        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
+    #endif
+#else
+    #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
+#endif
+#if !defined(JSON_HEDLEY_UNREACHABLE)
+    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
+#endif
+
+JSON_HEDLEY_DIAGNOSTIC_PUSH
+#if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
+    #pragma clang diagnostic ignored "-Wpedantic"
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
+    #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
+#endif
+#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
+    #if defined(__clang__)
+        #pragma clang diagnostic ignored "-Wvariadic-macros"
+    #elif defined(JSON_HEDLEY_GCC_VERSION)
+        #pragma GCC diagnostic ignored "-Wvariadic-macros"
+    #endif
+#endif
+#if defined(JSON_HEDLEY_NON_NULL)
+    #undef JSON_HEDLEY_NON_NULL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
+    #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
+#else
+    #define JSON_HEDLEY_NON_NULL(...)
+#endif
+JSON_HEDLEY_DIAGNOSTIC_POP
+
+#if defined(JSON_HEDLEY_PRINTF_FORMAT)
+    #undef JSON_HEDLEY_PRINTF_FORMAT
+#endif
+#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
+#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
+#else
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
+#endif
+
+#if defined(JSON_HEDLEY_CONSTEXPR)
+    #undef JSON_HEDLEY_CONSTEXPR
+#endif
+#if defined(__cplusplus)
+    #if __cplusplus >= 201103L
+        #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
+    #endif
+#endif
+#if !defined(JSON_HEDLEY_CONSTEXPR)
+    #define JSON_HEDLEY_CONSTEXPR
+#endif
+
+#if defined(JSON_HEDLEY_PREDICT)
+    #undef JSON_HEDLEY_PREDICT
+#endif
+#if defined(JSON_HEDLEY_LIKELY)
+    #undef JSON_HEDLEY_LIKELY
+#endif
+#if defined(JSON_HEDLEY_UNLIKELY)
+    #undef JSON_HEDLEY_UNLIKELY
+#endif
+#if defined(JSON_HEDLEY_UNPREDICTABLE)
+    #undef JSON_HEDLEY_UNPREDICTABLE
+#endif
+#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
+    #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
+#endif
+#if \
+  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#  define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(  (expr), (value), (probability))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability)   __builtin_expect_with_probability(!!(expr),    1   , (probability))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability)  __builtin_expect_with_probability(!!(expr),    0   , (probability))
+#  define JSON_HEDLEY_LIKELY(expr)                      __builtin_expect                 (!!(expr),    1                  )
+#  define JSON_HEDLEY_UNLIKELY(expr)                    __builtin_expect                 (!!(expr),    0                  )
+#elif \
+  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
+  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#  define JSON_HEDLEY_PREDICT(expr, expected, probability) \
+    (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
+    (__extension__ ({ \
+        double hedley_probability_ = (probability); \
+        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
+    }))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
+    (__extension__ ({ \
+        double hedley_probability_ = (probability); \
+        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
+    }))
+#  define JSON_HEDLEY_LIKELY(expr)   __builtin_expect(!!(expr), 1)
+#  define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
+#else
+#  define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
+#  define JSON_HEDLEY_LIKELY(expr) (!!(expr))
+#  define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
+#endif
+#if !defined(JSON_HEDLEY_UNPREDICTABLE)
+    #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
+#endif
+
+#if defined(JSON_HEDLEY_MALLOC)
+    #undef JSON_HEDLEY_MALLOC
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_MALLOC __declspec(restrict)
+#else
+    #define JSON_HEDLEY_MALLOC
+#endif
+
+#if defined(JSON_HEDLEY_PURE)
+    #undef JSON_HEDLEY_PURE
+#endif
+#if \
+  JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#  define JSON_HEDLEY_PURE __attribute__((__pure__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+#  define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
+#elif defined(__cplusplus) && \
+    ( \
+      JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
+      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
+      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
+    )
+#  define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
+#else
+#  define JSON_HEDLEY_PURE
+#endif
+
+#if defined(JSON_HEDLEY_CONST)
+    #undef JSON_HEDLEY_CONST
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_CONST __attribute__((__const__))
+#elif \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
+#else
+    #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
+#endif
+
+#if defined(JSON_HEDLEY_RESTRICT)
+    #undef JSON_HEDLEY_RESTRICT
+#endif
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
+    #define JSON_HEDLEY_RESTRICT restrict
+#elif \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
+    defined(__clang__) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_RESTRICT __restrict
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
+    #define JSON_HEDLEY_RESTRICT _Restrict
+#else
+    #define JSON_HEDLEY_RESTRICT
+#endif
+
+#if defined(JSON_HEDLEY_INLINE)
+    #undef JSON_HEDLEY_INLINE
+#endif
+#if \
+    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
+    (defined(__cplusplus) && (__cplusplus >= 199711L))
+    #define JSON_HEDLEY_INLINE inline
+#elif \
+    defined(JSON_HEDLEY_GCC_VERSION) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
+    #define JSON_HEDLEY_INLINE __inline__
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_INLINE __inline
+#else
+    #define JSON_HEDLEY_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_ALWAYS_INLINE)
+    #undef JSON_HEDLEY_ALWAYS_INLINE
+#endif
+#if \
+  JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
+  JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
+#elif \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE __forceinline
+#elif defined(__cplusplus) && \
+    ( \
+      JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+      JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+      JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+      JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
+    )
+#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
+#else
+#  define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_NEVER_INLINE)
+    #undef JSON_HEDLEY_NEVER_INLINE
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+    #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
+#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
+    #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
+    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
+#else
+    #define JSON_HEDLEY_NEVER_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_PRIVATE)
+    #undef JSON_HEDLEY_PRIVATE
+#endif
+#if defined(JSON_HEDLEY_PUBLIC)
+    #undef JSON_HEDLEY_PUBLIC
+#endif
+#if defined(JSON_HEDLEY_IMPORT)
+    #undef JSON_HEDLEY_IMPORT
+#endif
+#if defined(_WIN32) || defined(__CYGWIN__)
+#  define JSON_HEDLEY_PRIVATE
+#  define JSON_HEDLEY_PUBLIC   __declspec(dllexport)
+#  define JSON_HEDLEY_IMPORT   __declspec(dllimport)
+#else
+#  if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+    ( \
+      defined(__TI_EABI__) && \
+      ( \
+        (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
+      ) \
+    ) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#    define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
+#    define JSON_HEDLEY_PUBLIC  __attribute__((__visibility__("default")))
+#  else
+#    define JSON_HEDLEY_PRIVATE
+#    define JSON_HEDLEY_PUBLIC
+#  endif
+#  define JSON_HEDLEY_IMPORT    extern
+#endif
+
+#if defined(JSON_HEDLEY_NO_THROW)
+    #undef JSON_HEDLEY_NO_THROW
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
+    #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
+#else
+    #define JSON_HEDLEY_NO_THROW
+#endif
+
+#if defined(JSON_HEDLEY_FALL_THROUGH)
+    #undef JSON_HEDLEY_FALL_THROUGH
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
+    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
+    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
+#elif defined(__fallthrough) /* SAL */
+    #define JSON_HEDLEY_FALL_THROUGH __fallthrough
+#else
+    #define JSON_HEDLEY_FALL_THROUGH
+#endif
+
+#if defined(JSON_HEDLEY_RETURNS_NON_NULL)
+    #undef JSON_HEDLEY_RETURNS_NON_NULL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
+#elif defined(_Ret_notnull_) /* SAL */
+    #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
+#else
+    #define JSON_HEDLEY_RETURNS_NON_NULL
+#endif
+
+#if defined(JSON_HEDLEY_ARRAY_PARAM)
+    #undef JSON_HEDLEY_ARRAY_PARAM
+#endif
+#if \
+    defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
+    !defined(__STDC_NO_VLA__) && \
+    !defined(__cplusplus) && \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_TINYC_VERSION)
+    #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
+#else
+    #define JSON_HEDLEY_ARRAY_PARAM(name)
+#endif
+
+#if defined(JSON_HEDLEY_IS_CONSTANT)
+    #undef JSON_HEDLEY_IS_CONSTANT
+#endif
+#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
+    #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
+#endif
+/* JSON_HEDLEY_IS_CONSTEXPR_ is for
+   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
+#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
+    #undef JSON_HEDLEY_IS_CONSTEXPR_
+#endif
+#if \
+    JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
+#endif
+#if !defined(__cplusplus)
+#  if \
+       JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
+       JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+       JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+       JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+       JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+       JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
+       JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
+#if defined(__INTPTR_TYPE__)
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
+#else
+    #include <stdint.h>
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
+#endif
+#  elif \
+       ( \
+          defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
+          !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
+          !defined(JSON_HEDLEY_PGI_VERSION) && \
+          !defined(JSON_HEDLEY_IAR_VERSION)) || \
+       (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
+       JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
+       JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
+       JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
+       JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
+#if defined(__INTPTR_TYPE__)
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
+#else
+    #include <stdint.h>
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
+#endif
+#  elif \
+       defined(JSON_HEDLEY_GCC_VERSION) || \
+       defined(JSON_HEDLEY_INTEL_VERSION) || \
+       defined(JSON_HEDLEY_TINYC_VERSION) || \
+       defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
+       JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
+       defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
+       defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
+       defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
+       defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
+       defined(__clang__)
+#    define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
+        sizeof(void) != \
+        sizeof(*( \
+                  1 ? \
+                  ((void*) ((expr) * 0L) ) : \
+((struct { char v[sizeof(void) * 2]; } *) 1) \
+                ) \
+              ) \
+                                            )
+#  endif
+#endif
+#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
+    #if !defined(JSON_HEDLEY_IS_CONSTANT)
+        #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
+    #endif
+    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
+#else
+    #if !defined(JSON_HEDLEY_IS_CONSTANT)
+        #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
+    #endif
+    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
+#endif
+
+#if defined(JSON_HEDLEY_BEGIN_C_DECLS)
+    #undef JSON_HEDLEY_BEGIN_C_DECLS
+#endif
+#if defined(JSON_HEDLEY_END_C_DECLS)
+    #undef JSON_HEDLEY_END_C_DECLS
+#endif
+#if defined(JSON_HEDLEY_C_DECL)
+    #undef JSON_HEDLEY_C_DECL
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
+    #define JSON_HEDLEY_END_C_DECLS }
+    #define JSON_HEDLEY_C_DECL extern "C"
+#else
+    #define JSON_HEDLEY_BEGIN_C_DECLS
+    #define JSON_HEDLEY_END_C_DECLS
+    #define JSON_HEDLEY_C_DECL
+#endif
+
+#if defined(JSON_HEDLEY_STATIC_ASSERT)
+    #undef JSON_HEDLEY_STATIC_ASSERT
+#endif
+#if \
+  !defined(__cplusplus) && ( \
+      (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
+      (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
+      JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
+      JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+      defined(_Static_assert) \
+    )
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
+#elif \
+  (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
+#else
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message)
+#endif
+
+#if defined(JSON_HEDLEY_NULL)
+    #undef JSON_HEDLEY_NULL
+#endif
+#if defined(__cplusplus)
+    #if __cplusplus >= 201103L
+        #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
+    #elif defined(NULL)
+        #define JSON_HEDLEY_NULL NULL
+    #else
+        #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
+    #endif
+#elif defined(NULL)
+    #define JSON_HEDLEY_NULL NULL
+#else
+    #define JSON_HEDLEY_NULL ((void*) 0)
+#endif
+
+#if defined(JSON_HEDLEY_MESSAGE)
+    #undef JSON_HEDLEY_MESSAGE
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+#  define JSON_HEDLEY_MESSAGE(msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
+    JSON_HEDLEY_PRAGMA(message msg) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#elif \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
+#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#else
+#  define JSON_HEDLEY_MESSAGE(msg)
+#endif
+
+#if defined(JSON_HEDLEY_WARNING)
+    #undef JSON_HEDLEY_WARNING
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+#  define JSON_HEDLEY_WARNING(msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
+    JSON_HEDLEY_PRAGMA(clang warning msg) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#elif \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
+  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
+#elif \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#else
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
+#endif
+
+#if defined(JSON_HEDLEY_REQUIRE)
+    #undef JSON_HEDLEY_REQUIRE
+#endif
+#if defined(JSON_HEDLEY_REQUIRE_MSG)
+    #undef JSON_HEDLEY_REQUIRE_MSG
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
+#  if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
+#    define JSON_HEDLEY_REQUIRE(expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
+    __attribute__((diagnose_if(!(expr), #expr, "error"))) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
+    __attribute__((diagnose_if(!(expr), msg, "error"))) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  else
+#    define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
+#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
+#  endif
+#else
+#  define JSON_HEDLEY_REQUIRE(expr)
+#  define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
+#endif
+
+#if defined(JSON_HEDLEY_FLAGS)
+    #undef JSON_HEDLEY_FLAGS
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
+    #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
+#else
+    #define JSON_HEDLEY_FLAGS
+#endif
+
+#if defined(JSON_HEDLEY_FLAGS_CAST)
+    #undef JSON_HEDLEY_FLAGS_CAST
+#endif
+#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
+#  define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
+        JSON_HEDLEY_DIAGNOSTIC_PUSH \
+        _Pragma("warning(disable:188)") \
+        ((T) (expr)); \
+        JSON_HEDLEY_DIAGNOSTIC_POP \
+    }))
+#else
+#  define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
+#endif
+
+#if defined(JSON_HEDLEY_EMPTY_BASES)
+    #undef JSON_HEDLEY_EMPTY_BASES
+#endif
+#if \
+    (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
+#else
+    #define JSON_HEDLEY_EMPTY_BASES
+#endif
+
+/* Remaining macros are deprecated. */
+
+#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
+    #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
+#endif
+#if defined(__clang__)
+    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
+#else
+    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
+    #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
+#endif
+#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
+    #undef JSON_HEDLEY_CLANG_HAS_FEATURE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
+    #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
+#endif
+#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
+    #undef JSON_HEDLEY_CLANG_HAS_WARNING
+#endif
+#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
+
+#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
+
+
+// This file contains all internal macro definitions (except those affecting ABI)
+// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+// exclude unsupported compilers
+#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
+    #if defined(__clang__)
+        #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
+            #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
+        #endif
+    #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
+        #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
+            #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
+        #endif
+    #endif
+#endif
+
+// C++ language standard detection
+// if the user manually specified the used C++ version, this is skipped
+#if !defined(JSON_HAS_CPP_26) && !defined(JSON_HAS_CPP_23) && !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)
+    #if (defined(__cplusplus) && __cplusplus > 202302L) || (defined(_MSVC_LANG) && _MSVC_LANG > 202302L)
+        #define JSON_HAS_CPP_26
+        #define JSON_HAS_CPP_23
+        #define JSON_HAS_CPP_20
+        #define JSON_HAS_CPP_17
+        #define JSON_HAS_CPP_14
+    #elif (defined(__cplusplus) && __cplusplus > 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG > 202002L)
+        #define JSON_HAS_CPP_23
+        #define JSON_HAS_CPP_20
+        #define JSON_HAS_CPP_17
+        #define JSON_HAS_CPP_14
+    #elif (defined(__cplusplus) && __cplusplus > 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG > 201703L)
+        #define JSON_HAS_CPP_20
+        #define JSON_HAS_CPP_17
+        #define JSON_HAS_CPP_14
+    #elif (defined(__cplusplus) && __cplusplus > 201402L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
+        #define JSON_HAS_CPP_17
+        #define JSON_HAS_CPP_14
+    #elif (defined(__cplusplus) && __cplusplus > 201103L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
+        #define JSON_HAS_CPP_14
+    #endif
+    // the cpp 11 flag is always specified because it is the minimal required version
+    #define JSON_HAS_CPP_11
+#endif
+
+#ifdef __has_include
+    #if __has_include(<version>)
+        #include <version>
+    #endif
+#endif
+
+#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM)
+    #ifdef JSON_HAS_CPP_17
+        #if defined(__cpp_lib_filesystem)
+            #define JSON_HAS_FILESYSTEM 1
+        #elif defined(__cpp_lib_experimental_filesystem)
+            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
+        #elif !defined(__has_include)
+            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
+        #elif __has_include(<filesystem>)
+            #define JSON_HAS_FILESYSTEM 1
+        #elif __has_include(<experimental/filesystem>)
+            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
+        #endif
+
+        // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/
+        #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support
+        #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support
+        #if defined(__clang_major__) && __clang_major__ < 7
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support
+        #if defined(_MSC_VER) && _MSC_VER < 1914
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before iOS 13
+        #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before macOS Catalina
+        #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+    #endif
+#endif
+
+#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+    #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0
+#endif
+
+#ifndef JSON_HAS_FILESYSTEM
+    #define JSON_HAS_FILESYSTEM 0
+#endif
+
+#ifndef JSON_HAS_THREE_WAY_COMPARISON
+    #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \
+        && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L
+        #define JSON_HAS_THREE_WAY_COMPARISON 1
+    #else
+        #define JSON_HAS_THREE_WAY_COMPARISON 0
+    #endif
+#endif
+
+#ifndef JSON_HAS_RANGES
+    // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has a syntax error
+    #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427
+        #define JSON_HAS_RANGES 0
+    #elif defined(__cpp_lib_ranges)
+        #define JSON_HAS_RANGES 1
+    #else
+        #define JSON_HAS_RANGES 0
+    #endif
+#endif
+
+#ifndef JSON_HAS_STATIC_RTTI
+    #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0
+        #define JSON_HAS_STATIC_RTTI 1
+    #else
+        #define JSON_HAS_STATIC_RTTI 0
+    #endif
+#endif
+
+#ifdef JSON_HAS_CPP_17
+    #define JSON_INLINE_VARIABLE inline
+#else
+    #define JSON_INLINE_VARIABLE
+#endif
+
+#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address)
+    #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]]
+#else
+    #define JSON_NO_UNIQUE_ADDRESS
+#endif
+
+// disable documentation warnings on clang
+#if defined(__clang__)
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wdocumentation"
+    #pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
+#endif
+
+// allow disabling exceptions
+#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
+    #define JSON_THROW(exception) throw exception
+    #define JSON_TRY try
+    #define JSON_CATCH(exception) catch(exception)
+    #define JSON_INTERNAL_CATCH(exception) catch(exception)
+#else
+    #include <cstdlib>
+    #define JSON_THROW(exception) std::abort()
+    #define JSON_TRY if(true)
+    #define JSON_CATCH(exception) if(false)
+    #define JSON_INTERNAL_CATCH(exception) if(false)
+#endif
+
+// override exception macros
+#if defined(JSON_THROW_USER)
+    #undef JSON_THROW
+    #define JSON_THROW JSON_THROW_USER
+#endif
+#if defined(JSON_TRY_USER)
+    #undef JSON_TRY
+    #define JSON_TRY JSON_TRY_USER
+#endif
+#if defined(JSON_CATCH_USER)
+    #undef JSON_CATCH
+    #define JSON_CATCH JSON_CATCH_USER
+    #undef JSON_INTERNAL_CATCH
+    #define JSON_INTERNAL_CATCH JSON_CATCH_USER
+#endif
+#if defined(JSON_INTERNAL_CATCH_USER)
+    #undef JSON_INTERNAL_CATCH
+    #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
+#endif
+
+// allow overriding assert
+#if !defined(JSON_ASSERT)
+    #include <cassert> // assert
+    #define JSON_ASSERT(x) assert(x)
+#endif
+
+// allow accessing some private functions (needed by the test suite)
+#if defined(JSON_TESTS_PRIVATE)
+    #define JSON_PRIVATE_UNLESS_TESTED public
+#else
+    #define JSON_PRIVATE_UNLESS_TESTED private
+#endif
+
+/*!
+@brief macro to briefly define a mapping between an enum and JSON
+@def NLOHMANN_JSON_SERIALIZE_ENUM
+@since version 3.4.0
+*/
+#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...)                                            \
+    template<typename BasicJsonType>                                                            \
+    inline void to_json(BasicJsonType& j, const ENUM_TYPE& e)                                   \
+    {                                                                                           \
+        /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */                                \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
+        /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on <array> */       \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
+        auto it = std::find_if(std::begin(m), std::end(m),                                      \
+                               [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool  \
+        {                                                                                       \
+            return ej_pair.first == e;                                                          \
+        });                                                                                     \
+        j = ((it != std::end(m)) ? it : std::begin(m))->second;                                 \
+    }                                                                                           \
+    template<typename BasicJsonType>                                                            \
+    inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                 \
+    {                                                                                           \
+        /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */                                \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
+        /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on <array> */       \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
+        auto it = std::find_if(std::begin(m), std::end(m),                                      \
+                               [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
+        {                                                                                       \
+            return ej_pair.second == j;                                                         \
+        });                                                                                     \
+        e = ((it != std::end(m)) ? it : std::begin(m))->first;                                  \
+    }
+
+// Ugly macros to avoid uglier copy-paste when specializing basic_json. They
+// may be removed in the future once the class is split.
+
+#define NLOHMANN_BASIC_JSON_TPL_DECLARATION                                \
+    template<template<typename, typename, typename...> class ObjectType,   \
+             template<typename, typename...> class ArrayType,              \
+             class StringType, class BooleanType, class NumberIntegerType, \
+             class NumberUnsignedType, class NumberFloatType,              \
+             template<typename> class AllocatorType,                       \
+             template<typename, typename = void> class JSONSerializer,     \
+             class BinaryType,                                             \
+             class CustomBaseClass>
+
+#define NLOHMANN_BASIC_JSON_TPL                                            \
+    basic_json<ObjectType, ArrayType, StringType, BooleanType,             \
+    NumberIntegerType, NumberUnsignedType, NumberFloatType,                \
+    AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>
+
+// Macros to simplify conversion from/to types
+
+#define NLOHMANN_JSON_EXPAND( x ) x
+#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME
+#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
+        NLOHMANN_JSON_PASTE64, \
+        NLOHMANN_JSON_PASTE63, \
+        NLOHMANN_JSON_PASTE62, \
+        NLOHMANN_JSON_PASTE61, \
+        NLOHMANN_JSON_PASTE60, \
+        NLOHMANN_JSON_PASTE59, \
+        NLOHMANN_JSON_PASTE58, \
+        NLOHMANN_JSON_PASTE57, \
+        NLOHMANN_JSON_PASTE56, \
+        NLOHMANN_JSON_PASTE55, \
+        NLOHMANN_JSON_PASTE54, \
+        NLOHMANN_JSON_PASTE53, \
+        NLOHMANN_JSON_PASTE52, \
+        NLOHMANN_JSON_PASTE51, \
+        NLOHMANN_JSON_PASTE50, \
+        NLOHMANN_JSON_PASTE49, \
+        NLOHMANN_JSON_PASTE48, \
+        NLOHMANN_JSON_PASTE47, \
+        NLOHMANN_JSON_PASTE46, \
+        NLOHMANN_JSON_PASTE45, \
+        NLOHMANN_JSON_PASTE44, \
+        NLOHMANN_JSON_PASTE43, \
+        NLOHMANN_JSON_PASTE42, \
+        NLOHMANN_JSON_PASTE41, \
+        NLOHMANN_JSON_PASTE40, \
+        NLOHMANN_JSON_PASTE39, \
+        NLOHMANN_JSON_PASTE38, \
+        NLOHMANN_JSON_PASTE37, \
+        NLOHMANN_JSON_PASTE36, \
+        NLOHMANN_JSON_PASTE35, \
+        NLOHMANN_JSON_PASTE34, \
+        NLOHMANN_JSON_PASTE33, \
+        NLOHMANN_JSON_PASTE32, \
+        NLOHMANN_JSON_PASTE31, \
+        NLOHMANN_JSON_PASTE30, \
+        NLOHMANN_JSON_PASTE29, \
+        NLOHMANN_JSON_PASTE28, \
+        NLOHMANN_JSON_PASTE27, \
+        NLOHMANN_JSON_PASTE26, \
+        NLOHMANN_JSON_PASTE25, \
+        NLOHMANN_JSON_PASTE24, \
+        NLOHMANN_JSON_PASTE23, \
+        NLOHMANN_JSON_PASTE22, \
+        NLOHMANN_JSON_PASTE21, \
+        NLOHMANN_JSON_PASTE20, \
+        NLOHMANN_JSON_PASTE19, \
+        NLOHMANN_JSON_PASTE18, \
+        NLOHMANN_JSON_PASTE17, \
+        NLOHMANN_JSON_PASTE16, \
+        NLOHMANN_JSON_PASTE15, \
+        NLOHMANN_JSON_PASTE14, \
+        NLOHMANN_JSON_PASTE13, \
+        NLOHMANN_JSON_PASTE12, \
+        NLOHMANN_JSON_PASTE11, \
+        NLOHMANN_JSON_PASTE10, \
+        NLOHMANN_JSON_PASTE9, \
+        NLOHMANN_JSON_PASTE8, \
+        NLOHMANN_JSON_PASTE7, \
+        NLOHMANN_JSON_PASTE6, \
+        NLOHMANN_JSON_PASTE5, \
+        NLOHMANN_JSON_PASTE4, \
+        NLOHMANN_JSON_PASTE3, \
+        NLOHMANN_JSON_PASTE2, \
+        NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
+#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
+#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
+#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
+#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
+#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
+#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6)
+#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7)
+#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8)
+#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9)
+#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10)
+#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
+#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
+#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
+#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
+#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)
+#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)
+#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)
+#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)
+#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
+#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)
+#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)
+#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
+#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)
+#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)
+#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
+#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)
+#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)
+#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)
+#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)
+#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)
+#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)
+#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32)
+#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33)
+#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34)
+#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35)
+#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36)
+#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37)
+#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38)
+#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39)
+#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40)
+#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41)
+#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42)
+#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43)
+#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)
+#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45)
+#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46)
+#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47)
+#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48)
+#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49)
+#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50)
+#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51)
+#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52)
+#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53)
+#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54)
+#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)
+#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)
+#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)
+#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)
+#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59)
+#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60)
+#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61)
+#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62)
+#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63)
+
+#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
+#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
+#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = !nlohmann_json_j.is_null() ? nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1) : nlohmann_json_default_obj.v1;
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_INTRUSIVE
+@since version 3.9.0
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/
+*/
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT
+@since version 3.11.0
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/
+*/
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE
+@since version 3.11.3
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/
+*/
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE
+@since version 3.9.0
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/
+*/
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT
+@since version 3.11.0
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/
+*/
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE
+@since version 3.11.3
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/
+*/
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE
+@since version 3.12.0
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
+*/
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(Type, BaseType, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT
+@since version 3.12.0
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
+*/
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE
+@since version 3.12.0
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
+*/
+#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE
+@since version 3.12.0
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
+*/
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(Type, BaseType, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT
+@since version 3.12.0
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
+*/
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast<BaseType&>(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE
+@since version 3.12.0
+@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/
+*/
+#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...)  \
+    template<typename BasicJsonType, nlohmann::detail::enable_if_t<nlohmann::detail::is_basic_json<BasicJsonType>::value, int> = 0> \
+    void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast<const BaseType &>(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
+
+// inspired from https://stackoverflow.com/a/26745591
+// allows calling any std function as if (e.g., with begin):
+// using std::begin; begin(x);
+//
+// it allows using the detected idiom to retrieve the return type
+// of such an expression
+#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name)                                 \
+    namespace detail {                                                            \
+    using std::std_name;                                                          \
+    \
+    template<typename... T>                                                       \
+    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
+    }                                                                             \
+    \
+    namespace detail2 {                                                           \
+    struct std_name##_tag                                                         \
+    {                                                                             \
+    };                                                                            \
+    \
+    template<typename... T>                                                       \
+    std_name##_tag std_name(T&&...);                                              \
+    \
+    template<typename... T>                                                       \
+    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
+    \
+    template<typename... T>                                                       \
+    struct would_call_std_##std_name                                              \
+    {                                                                             \
+        static constexpr auto const value = ::nlohmann::detail::                  \
+                                            is_detected_exact<std_name##_tag, result_of_##std_name, T...>::value; \
+    };                                                                            \
+    } /* namespace detail2 */ \
+    \
+    template<typename... T>                                                       \
+    struct would_call_std_##std_name : detail2::would_call_std_##std_name<T...>   \
+    {                                                                             \
+    }
+
+#ifndef JSON_USE_IMPLICIT_CONVERSIONS
+    #define JSON_USE_IMPLICIT_CONVERSIONS 1
+#endif
+
+#if JSON_USE_IMPLICIT_CONVERSIONS
+    #define JSON_EXPLICIT
+#else
+    #define JSON_EXPLICIT explicit
+#endif
+
+#ifndef JSON_DISABLE_ENUM_SERIALIZATION
+    #define JSON_DISABLE_ENUM_SERIALIZATION 0
+#endif
+
+#ifndef JSON_USE_GLOBAL_UDLS
+    #define JSON_USE_GLOBAL_UDLS 1
+#endif
+
+#if JSON_HAS_THREE_WAY_COMPARISON
+    #include <compare> // partial_ordering
+#endif
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+///////////////////////////
+// JSON type enumeration //
+///////////////////////////
+
+/*!
+@brief the JSON type enumeration
+
+This enumeration collects the different JSON types. It is internally used to
+distinguish the stored values, and the functions @ref basic_json::is_null(),
+@ref basic_json::is_object(), @ref basic_json::is_array(),
+@ref basic_json::is_string(), @ref basic_json::is_boolean(),
+@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
+@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
+@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
+@ref basic_json::is_structured() rely on it.
+
+@note There are three enumeration entries (number_integer, number_unsigned, and
+number_float), because the library distinguishes these three types for numbers:
+@ref basic_json::number_unsigned_t is used for unsigned integers,
+@ref basic_json::number_integer_t is used for signed integers, and
+@ref basic_json::number_float_t is used for floating-point numbers or to
+approximate integers which do not fit in the limits of their respective type.
+
+@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON
+value with the default value for a given type
+
+@since version 1.0.0
+*/
+enum class value_t : std::uint8_t
+{
+    null,             ///< null value
+    object,           ///< object (unordered set of name/value pairs)
+    array,            ///< array (ordered collection of values)
+    string,           ///< string value
+    boolean,          ///< boolean value
+    number_integer,   ///< number value (signed integer)
+    number_unsigned,  ///< number value (unsigned integer)
+    number_float,     ///< number value (floating-point)
+    binary,           ///< binary array (ordered collection of bytes)
+    discarded         ///< discarded by the parser callback function
+};
+
+/*!
+@brief comparison operator for JSON types
+
+Returns an ordering that is similar to Python:
+- order: null < boolean < number < object < array < string < binary
+- furthermore, each type is not smaller than itself
+- discarded values are not comparable
+- binary is represented as a b"" string in python and directly comparable to a
+  string; however, making a binary array directly comparable with a string would
+  be surprising behavior in a JSON file.
+
+@since version 1.0.0
+*/
+#if JSON_HAS_THREE_WAY_COMPARISON
+    inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD*
+#else
+    inline bool operator<(const value_t lhs, const value_t rhs) noexcept
+#endif
+{
+    static constexpr std::array<std::uint8_t, 9> order = {{
+            0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
+            1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
+            6 /* binary */
+        }
+    };
+
+    const auto l_index = static_cast<std::size_t>(lhs);
+    const auto r_index = static_cast<std::size_t>(rhs);
+#if JSON_HAS_THREE_WAY_COMPARISON
+    if (l_index < order.size() && r_index < order.size())
+    {
+        return order[l_index] <=> order[r_index]; // *NOPAD*
+    }
+    return std::partial_ordering::unordered;
+#else
+    return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
+#endif
+}
+
+// GCC selects the built-in operator< over an operator rewritten from
+// a user-defined spaceship operator
+// Clang, MSVC, and ICC select the rewritten candidate
+// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200)
+#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__)
+inline bool operator<(const value_t lhs, const value_t rhs) noexcept
+{
+    return std::is_lt(lhs <=> rhs); // *NOPAD*
+}
+#endif
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/string_escape.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief replace all occurrences of a substring by another string
+
+@param[in,out] s  the string to manipulate; changed so that all
+               occurrences of @a f are replaced with @a t
+@param[in]     f  the substring to replace with @a t
+@param[in]     t  the string to replace @a f
+
+@pre The search string @a f must not be empty. **This precondition is
+enforced with an assertion.**
+
+@since version 2.0.0
+*/
+template<typename StringType>
+inline void replace_substring(StringType& s, const StringType& f,
+                              const StringType& t)
+{
+    JSON_ASSERT(!f.empty());
+    for (auto pos = s.find(f);                // find the first occurrence of f
+            pos != StringType::npos;          // make sure f was found
+            s.replace(pos, f.size(), t),      // replace with t, and
+            pos = s.find(f, pos + t.size()))  // find the next occurrence of f
+    {}
+}
+
+/*!
+ * @brief string escaping as described in RFC 6901 (Sect. 4)
+ * @param[in] s string to escape
+ * @return    escaped string
+ *
+ * Note the order of escaping "~" to "~0" and "/" to "~1" is important.
+ */
+template<typename StringType>
+inline StringType escape(StringType s)
+{
+    replace_substring(s, StringType{"~"}, StringType{"~0"});
+    replace_substring(s, StringType{"/"}, StringType{"~1"});
+    return s;
+}
+
+/*!
+ * @brief string unescaping as described in RFC 6901 (Sect. 4)
+ * @param[in] s string to unescape
+ * @return    unescaped string
+ *
+ * Note the order of escaping "~1" to "/" and "~0" to "~" is important.
+ */
+template<typename StringType>
+inline void unescape(StringType& s)
+{
+    replace_substring(s, StringType{"~1"}, StringType{"/"});
+    replace_substring(s, StringType{"~0"}, StringType{"~"});
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/input/position_t.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // size_t
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// struct to capture the start position of the current token
+struct position_t
+{
+    /// the total number of characters read
+    std::size_t chars_read_total = 0;
+    /// the number of characters read in the current line
+    std::size_t chars_read_current_line = 0;
+    /// the number of lines read
+    std::size_t lines_read = 0;
+
+    /// conversion to size_t to preserve SAX interface
+    constexpr operator size_t() const
+    {
+        return chars_read_total;
+    }
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-FileCopyrightText: 2018 The Abseil Authors
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
+#include <utility> // index_sequence, make_index_sequence, index_sequence_for
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename T>
+using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+
+#ifdef JSON_HAS_CPP_14
+
+// the following utilities are natively available in C++14
+using std::enable_if_t;
+using std::index_sequence;
+using std::make_index_sequence;
+using std::index_sequence_for;
+
+#else
+
+// alias templates to reduce boilerplate
+template<bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
+// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h
+// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0.
+
+//// START OF CODE FROM GOOGLE ABSEIL
+
+// integer_sequence
+//
+// Class template representing a compile-time integer sequence. An instantiation
+// of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its
+// type through its template arguments (which is a common need when
+// working with C++11 variadic templates). `absl::integer_sequence` is designed
+// to be a drop-in replacement for C++14's `std::integer_sequence`.
+//
+// Example:
+//
+//   template< class T, T... Ints >
+//   void user_function(integer_sequence<T, Ints...>);
+//
+//   int main()
+//   {
+//     // user_function's `T` will be deduced to `int` and `Ints...`
+//     // will be deduced to `0, 1, 2, 3, 4`.
+//     user_function(make_integer_sequence<int, 5>());
+//   }
+template <typename T, T... Ints>
+struct integer_sequence
+{
+    using value_type = T;
+    static constexpr std::size_t size() noexcept
+    {
+        return sizeof...(Ints);
+    }
+};
+
+// index_sequence
+//
+// A helper template for an `integer_sequence` of `size_t`,
+// `absl::index_sequence` is designed to be a drop-in replacement for C++14's
+// `std::index_sequence`.
+template <size_t... Ints>
+using index_sequence = integer_sequence<size_t, Ints...>;
+
+namespace utility_internal
+{
+
+template <typename Seq, size_t SeqSize, size_t Rem>
+struct Extend;
+
+// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
+template <typename T, T... Ints, size_t SeqSize>
+struct Extend<integer_sequence<T, Ints...>, SeqSize, 0>
+{
+    using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >;
+};
+
+template <typename T, T... Ints, size_t SeqSize>
+struct Extend<integer_sequence<T, Ints...>, SeqSize, 1>
+{
+    using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >;
+};
+
+// Recursion helper for 'make_integer_sequence<T, N>'.
+// 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
+template <typename T, size_t N>
+struct Gen
+{
+    using type =
+        typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type;
+};
+
+template <typename T>
+struct Gen<T, 0>
+{
+    using type = integer_sequence<T>;
+};
+
+}  // namespace utility_internal
+
+// Compile-time sequences of integers
+
+// make_integer_sequence
+//
+// This template alias is equivalent to
+// `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in
+// replacement for C++14's `std::make_integer_sequence`.
+template <typename T, T N>
+using make_integer_sequence = typename utility_internal::Gen<T, N>::type;
+
+// make_index_sequence
+//
+// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,
+// and is designed to be a drop-in replacement for C++14's
+// `std::make_index_sequence`.
+template <size_t N>
+using make_index_sequence = make_integer_sequence<size_t, N>;
+
+// index_sequence_for
+//
+// Converts a typename pack into an index sequence of the same length, and
+// is designed to be a drop-in replacement for C++14's
+// `std::index_sequence_for()`
+template <typename... Ts>
+using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+
+//// END OF CODE FROM GOOGLE ABSEIL
+
+#endif
+
+// dispatch utility (taken from ranges-v3)
+template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
+template<> struct priority_tag<0> {};
+
+// taken from ranges-v3
+template<typename T>
+struct static_const
+{
+    static JSON_INLINE_VARIABLE constexpr T value{};
+};
+
+#ifndef JSON_HAS_CPP_17
+    template<typename T>
+    constexpr T static_const<T>::value;
+#endif
+
+template<typename T, typename... Args>
+constexpr std::array<T, sizeof...(Args)> make_array(Args&& ... args)
+{
+    return std::array<T, sizeof...(Args)> {{static_cast<T>(std::forward<Args>(args))...}};
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <limits> // numeric_limits
+#include <string> // char_traits
+#include <tuple> // tuple
+#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
+#include <utility> // declval
+#if defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603L
+    #include <cstddef> // byte
+#endif
+// #include <nlohmann/detail/iterators/iterator_traits.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <iterator> // random_access_iterator_tag
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/meta/void_t.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename It, typename = void>
+struct iterator_types {};
+
+template<typename It>
+struct iterator_types <
+    It,
+    void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
+    typename It::reference, typename It::iterator_category >>
+{
+    using difference_type = typename It::difference_type;
+    using value_type = typename It::value_type;
+    using pointer = typename It::pointer;
+    using reference = typename It::reference;
+    using iterator_category = typename It::iterator_category;
+};
+
+// This is required as some compilers implement std::iterator_traits in a way that
+// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
+template<typename T, typename = void>
+struct iterator_traits
+{
+};
+
+template<typename T>
+struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
+    : iterator_types<T>
+{
+};
+
+template<typename T>
+struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
+{
+    using iterator_category = std::random_access_iterator_tag;
+    using value_type = T;
+    using difference_type = ptrdiff_t;
+    using pointer = T*;
+    using reference = T&;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/call_std/begin.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin);
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/call_std/end.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end);
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+// #include <nlohmann/json_fwd.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
+    #define INCLUDE_NLOHMANN_JSON_FWD_HPP_
+
+    #include <cstdint> // int64_t, uint64_t
+    #include <map> // map
+    #include <memory> // allocator
+    #include <string> // string
+    #include <vector> // vector
+
+    // #include <nlohmann/detail/abi_macros.hpp>
+
+
+    /*!
+    @brief namespace for Niels Lohmann
+    @see https://github.com/nlohmann
+    @since version 1.0.0
+    */
+    NLOHMANN_JSON_NAMESPACE_BEGIN
+
+    /*!
+    @brief default JSONSerializer template argument
+
+    This serializer ignores the template arguments and uses ADL
+    ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
+    for serialization.
+    */
+    template<typename T = void, typename SFINAE = void>
+    struct adl_serializer;
+
+    /// a class to store JSON values
+    /// @sa https://json.nlohmann.me/api/basic_json/
+    template<template<typename U, typename V, typename... Args> class ObjectType =
+    std::map,
+    template<typename U, typename... Args> class ArrayType = std::vector,
+    class StringType = std::string, class BooleanType = bool,
+    class NumberIntegerType = std::int64_t,
+    class NumberUnsignedType = std::uint64_t,
+    class NumberFloatType = double,
+    template<typename U> class AllocatorType = std::allocator,
+    template<typename T, typename SFINAE = void> class JSONSerializer =
+    adl_serializer,
+    class BinaryType = std::vector<std::uint8_t>, // cppcheck-suppress syntaxError
+    class CustomBaseClass = void>
+    class basic_json;
+
+    /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
+    /// @sa https://json.nlohmann.me/api/json_pointer/
+    template<typename RefStringType>
+    class json_pointer;
+
+    /*!
+    @brief default specialization
+    @sa https://json.nlohmann.me/api/json/
+    */
+    using json = basic_json<>;
+
+    /// @brief a minimal map-like container that preserves insertion order
+    /// @sa https://json.nlohmann.me/api/ordered_map/
+    template<class Key, class T, class IgnoredLess, class Allocator>
+    struct ordered_map;
+
+    /// @brief specialization that maintains the insertion order of object keys
+    /// @sa https://json.nlohmann.me/api/ordered_json/
+    using ordered_json = basic_json<nlohmann::ordered_map>;
+
+    NLOHMANN_JSON_NAMESPACE_END
+
+#endif  // INCLUDE_NLOHMANN_JSON_FWD_HPP_
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+/*!
+@brief detail namespace with internal helper functions
+
+This namespace collects functions that should not be exposed,
+implementations of some @ref basic_json methods, and meta-programming helpers.
+
+@since version 2.1.0
+*/
+namespace detail
+{
+
+/////////////
+// helpers //
+/////////////
+
+// Note to maintainers:
+//
+// Every trait in this file expects a non-CV-qualified type.
+// The only exceptions are in the 'aliases for detected' section
+// (i.e., those of the form: decltype(T::member_function(std::declval<T>())))
+//
+// In this case, T has to be properly CV-qualified to constraint the function arguments
+// (e.g., to_json(BasicJsonType&, const T&))
+
+template<typename> struct is_basic_json : std::false_type {};
+
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
+
+// used by exceptions create() member functions
+// true_type for the pointer to possibly cv-qualified basic_json or std::nullptr_t
+// false_type otherwise
+template<typename BasicJsonContext>
+struct is_basic_json_context :
+    std::integral_constant < bool,
+    is_basic_json<typename std::remove_cv<typename std::remove_pointer<BasicJsonContext>::type>::type>::value
+    || std::is_same<BasicJsonContext, std::nullptr_t>::value >
+{};
+
+//////////////////////
+// json_ref helpers //
+//////////////////////
+
+template<typename>
+class json_ref;
+
+template<typename>
+struct is_json_ref : std::false_type {};
+
+template<typename T>
+struct is_json_ref<json_ref<T>> : std::true_type {};
+
+//////////////////////////
+// aliases for detected //
+//////////////////////////
+
+template<typename T>
+using mapped_type_t = typename T::mapped_type;
+
+template<typename T>
+using key_type_t = typename T::key_type;
+
+template<typename T>
+using value_type_t = typename T::value_type;
+
+template<typename T>
+using difference_type_t = typename T::difference_type;
+
+template<typename T>
+using pointer_t = typename T::pointer;
+
+template<typename T>
+using reference_t = typename T::reference;
+
+template<typename T>
+using iterator_category_t = typename T::iterator_category;
+
+template<typename T, typename... Args>
+using to_json_function = decltype(T::to_json(std::declval<Args>()...));
+
+template<typename T, typename... Args>
+using from_json_function = decltype(T::from_json(std::declval<Args>()...));
+
+template<typename T, typename U>
+using get_template_function = decltype(std::declval<T>().template get<U>());
+
+// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
+template<typename BasicJsonType, typename T, typename = void>
+struct has_from_json : std::false_type {};
+
+// trait checking if j.get<T> is valid
+// use this trait instead of std::is_constructible or std::is_convertible,
+// both rely on, or make use of implicit conversions, and thus fail when T
+// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)
+template <typename BasicJsonType, typename T>
+struct is_getable
+{
+    static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
+};
+
+template<typename BasicJsonType, typename T>
+struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<void, from_json_function, serializer,
+        const BasicJsonType&, T&>::value;
+};
+
+// This trait checks if JSONSerializer<T>::from_json(json const&) exists
+// this overload is used for non-default-constructible user-defined-types
+template<typename BasicJsonType, typename T, typename = void>
+struct has_non_default_from_json : std::false_type {};
+
+template<typename BasicJsonType, typename T>
+struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<T, from_json_function, serializer,
+        const BasicJsonType&>::value;
+};
+
+// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
+// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
+template<typename BasicJsonType, typename T, typename = void>
+struct has_to_json : std::false_type {};
+
+template<typename BasicJsonType, typename T>
+struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
+        T>::value;
+};
+
+template<typename T>
+using detect_key_compare = typename T::key_compare;
+
+template<typename T>
+struct has_key_compare : std::integral_constant<bool, is_detected<detect_key_compare, T>::value> {};
+
+// obtains the actual object key comparator
+template<typename BasicJsonType>
+struct actual_object_comparator
+{
+    using object_t = typename BasicJsonType::object_t;
+    using object_comparator_t = typename BasicJsonType::default_object_comparator_t;
+    using type = typename std::conditional < has_key_compare<object_t>::value,
+          typename object_t::key_compare, object_comparator_t>::type;
+};
+
+template<typename BasicJsonType>
+using actual_object_comparator_t = typename actual_object_comparator<BasicJsonType>::type;
+
+/////////////////
+// char_traits //
+/////////////////
+
+// Primary template of char_traits calls std char_traits
+template<typename T>
+struct char_traits : std::char_traits<T>
+{};
+
+// Explicitly define char traits for unsigned char since it is not standard
+template<>
+struct char_traits<unsigned char> : std::char_traits<char>
+{
+    using char_type = unsigned char;
+    using int_type = uint64_t;
+
+    // Redefine to_int_type function
+    static int_type to_int_type(char_type c) noexcept
+    {
+        return static_cast<int_type>(c);
+    }
+
+    static char_type to_char_type(int_type i) noexcept
+    {
+        return static_cast<char_type>(i);
+    }
+
+    static constexpr int_type eof() noexcept
+    {
+        return static_cast<int_type>(std::char_traits<char>::eof());
+    }
+};
+
+// Explicitly define char traits for signed char since it is not standard
+template<>
+struct char_traits<signed char> : std::char_traits<char>
+{
+    using char_type = signed char;
+    using int_type = uint64_t;
+
+    // Redefine to_int_type function
+    static int_type to_int_type(char_type c) noexcept
+    {
+        return static_cast<int_type>(c);
+    }
+
+    static char_type to_char_type(int_type i) noexcept
+    {
+        return static_cast<char_type>(i);
+    }
+
+    static constexpr int_type eof() noexcept
+    {
+        return static_cast<int_type>(std::char_traits<char>::eof());
+    }
+};
+
+#if defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603L
+template<>
+struct char_traits<std::byte> : std::char_traits<char>
+{
+    using char_type = std::byte;
+    using int_type = uint64_t;
+
+    static int_type to_int_type(char_type c) noexcept
+    {
+        return static_cast<int_type>(std::to_integer<unsigned char>(c));
+    }
+
+    static char_type to_char_type(int_type i) noexcept
+    {
+        return std::byte(static_cast<unsigned char>(i));
+    }
+
+    static constexpr int_type eof() noexcept
+    {
+        return static_cast<int_type>(std::char_traits<char>::eof());
+    }
+};
+#endif
+
+///////////////////
+// is_ functions //
+///////////////////
+
+// https://en.cppreference.com/w/cpp/types/conjunction
+template<class...> struct conjunction : std::true_type { };
+template<class B> struct conjunction<B> : B { };
+template<class B, class... Bn>
+struct conjunction<B, Bn...>
+: std::conditional<static_cast<bool>(B::value), conjunction<Bn...>, B>::type {};
+
+// https://en.cppreference.com/w/cpp/types/negation
+template<class B> struct negation : std::integral_constant < bool, !B::value > { };
+
+// Reimplementation of is_constructible and is_default_constructible, due to them being broken for
+// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367).
+// This causes compile errors in e.g., Clang 3.5 or GCC 4.9.
+template <typename T>
+struct is_default_constructible : std::is_default_constructible<T> {};
+
+template <typename T1, typename T2>
+struct is_default_constructible<std::pair<T1, T2>>
+    : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
+
+template <typename T1, typename T2>
+struct is_default_constructible<const std::pair<T1, T2>>
+    : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
+
+template <typename... Ts>
+struct is_default_constructible<std::tuple<Ts...>>
+    : conjunction<is_default_constructible<Ts>...> {};
+
+template <typename... Ts>
+struct is_default_constructible<const std::tuple<Ts...>>
+    : conjunction<is_default_constructible<Ts>...> {};
+
+template <typename T, typename... Args>
+struct is_constructible : std::is_constructible<T, Args...> {};
+
+template <typename T1, typename T2>
+struct is_constructible<std::pair<T1, T2>> : is_default_constructible<std::pair<T1, T2>> {};
+
+template <typename T1, typename T2>
+struct is_constructible<const std::pair<T1, T2>> : is_default_constructible<const std::pair<T1, T2>> {};
+
+template <typename... Ts>
+struct is_constructible<std::tuple<Ts...>> : is_default_constructible<std::tuple<Ts...>> {};
+
+template <typename... Ts>
+struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};
+
+template<typename T, typename = void>
+struct is_iterator_traits : std::false_type {};
+
+template<typename T>
+struct is_iterator_traits<iterator_traits<T>>
+{
+  private:
+    using traits = iterator_traits<T>;
+
+  public:
+    static constexpr auto value =
+        is_detected<value_type_t, traits>::value &&
+        is_detected<difference_type_t, traits>::value &&
+        is_detected<pointer_t, traits>::value &&
+        is_detected<iterator_category_t, traits>::value &&
+        is_detected<reference_t, traits>::value;
+};
+
+template<typename T>
+struct is_range
+{
+  private:
+    using t_ref = typename std::add_lvalue_reference<T>::type;
+
+    using iterator = detected_t<result_of_begin, t_ref>;
+    using sentinel = detected_t<result_of_end, t_ref>;
+
+    // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator
+    // and https://en.cppreference.com/w/cpp/iterator/sentinel_for
+    // but reimplementing these would be too much work, as a lot of other concepts are used underneath
+    static constexpr auto is_iterator_begin =
+        is_iterator_traits<iterator_traits<iterator>>::value;
+
+  public:
+    static constexpr bool value = !std::is_same<iterator, nonesuch>::value && !std::is_same<sentinel, nonesuch>::value && is_iterator_begin;
+};
+
+template<typename R>
+using iterator_t = enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())>>;
+
+template<typename T>
+using range_value_t = value_type_t<iterator_traits<iterator_t<T>>>;
+
+// The following implementation of is_complete_type is taken from
+// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/
+// and is written by Xiang Fan who agreed to use it in this library.
+
+template<typename T, typename = void>
+struct is_complete_type : std::false_type {};
+
+template<typename T>
+struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
+
+template<typename BasicJsonType, typename CompatibleObjectType,
+         typename = void>
+struct is_compatible_object_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleObjectType>
+struct is_compatible_object_type_impl <
+    BasicJsonType, CompatibleObjectType,
+    enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
+    is_detected<key_type_t, CompatibleObjectType>::value >>
+{
+    using object_t = typename BasicJsonType::object_t;
+
+    // macOS's is_constructible does not play well with nonesuch...
+    static constexpr bool value =
+        is_constructible<typename object_t::key_type,
+        typename CompatibleObjectType::key_type>::value &&
+        is_constructible<typename object_t::mapped_type,
+        typename CompatibleObjectType::mapped_type>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleObjectType>
+struct is_compatible_object_type
+    : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
+
+template<typename BasicJsonType, typename ConstructibleObjectType,
+         typename = void>
+struct is_constructible_object_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename ConstructibleObjectType>
+struct is_constructible_object_type_impl <
+    BasicJsonType, ConstructibleObjectType,
+    enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
+    is_detected<key_type_t, ConstructibleObjectType>::value >>
+{
+    using object_t = typename BasicJsonType::object_t;
+
+    static constexpr bool value =
+        (is_default_constructible<ConstructibleObjectType>::value &&
+         (std::is_move_assignable<ConstructibleObjectType>::value ||
+          std::is_copy_assignable<ConstructibleObjectType>::value) &&
+         (is_constructible<typename ConstructibleObjectType::key_type,
+          typename object_t::key_type>::value &&
+          std::is_same <
+          typename object_t::mapped_type,
+          typename ConstructibleObjectType::mapped_type >::value)) ||
+        (has_from_json<BasicJsonType,
+         typename ConstructibleObjectType::mapped_type>::value ||
+         has_non_default_from_json <
+         BasicJsonType,
+         typename ConstructibleObjectType::mapped_type >::value);
+};
+
+template<typename BasicJsonType, typename ConstructibleObjectType>
+struct is_constructible_object_type
+    : is_constructible_object_type_impl<BasicJsonType,
+      ConstructibleObjectType> {};
+
+template<typename BasicJsonType, typename CompatibleStringType>
+struct is_compatible_string_type
+{
+    static constexpr auto value =
+        is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
+};
+
+template<typename BasicJsonType, typename ConstructibleStringType>
+struct is_constructible_string_type
+{
+    // launder type through decltype() to fix compilation failure on ICPC
+#ifdef __INTEL_COMPILER
+    using laundered_type = decltype(std::declval<ConstructibleStringType>());
+#else
+    using laundered_type = ConstructibleStringType;
+#endif
+
+    static constexpr auto value =
+        conjunction <
+        is_constructible<laundered_type, typename BasicJsonType::string_t>,
+        is_detected_exact<typename BasicJsonType::string_t::value_type,
+        value_type_t, laundered_type >>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleArrayType, typename = void>
+struct is_compatible_array_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleArrayType>
+struct is_compatible_array_type_impl <
+    BasicJsonType, CompatibleArrayType,
+    enable_if_t <
+    is_detected<iterator_t, CompatibleArrayType>::value&&
+    is_iterator_traits<iterator_traits<detected_t<iterator_t, CompatibleArrayType>>>::value&&
+// special case for types like std::filesystem::path whose iterator's value_type are themselves
+// c.f. https://github.com/nlohmann/json/pull/3073
+    !std::is_same<CompatibleArrayType, detected_t<range_value_t, CompatibleArrayType>>::value >>
+{
+    static constexpr bool value =
+        is_constructible<BasicJsonType,
+        range_value_t<CompatibleArrayType>>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleArrayType>
+struct is_compatible_array_type
+    : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>
+struct is_constructible_array_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type_impl <
+    BasicJsonType, ConstructibleArrayType,
+    enable_if_t<std::is_same<ConstructibleArrayType,
+    typename BasicJsonType::value_type>::value >>
+            : std::true_type {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type_impl <
+    BasicJsonType, ConstructibleArrayType,
+    enable_if_t < !std::is_same<ConstructibleArrayType,
+    typename BasicJsonType::value_type>::value&&
+    !is_compatible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
+    is_default_constructible<ConstructibleArrayType>::value&&
+(std::is_move_assignable<ConstructibleArrayType>::value ||
+ std::is_copy_assignable<ConstructibleArrayType>::value)&&
+is_detected<iterator_t, ConstructibleArrayType>::value&&
+is_iterator_traits<iterator_traits<detected_t<iterator_t, ConstructibleArrayType>>>::value&&
+is_detected<range_value_t, ConstructibleArrayType>::value&&
+// special case for types like std::filesystem::path whose iterator's value_type are themselves
+// c.f. https://github.com/nlohmann/json/pull/3073
+!std::is_same<ConstructibleArrayType, detected_t<range_value_t, ConstructibleArrayType>>::value&&
+is_complete_type <
+detected_t<range_value_t, ConstructibleArrayType >>::value >>
+{
+    using value_type = range_value_t<ConstructibleArrayType>;
+
+    static constexpr bool value =
+        std::is_same<value_type,
+        typename BasicJsonType::array_t::value_type>::value ||
+        has_from_json<BasicJsonType,
+        value_type>::value ||
+        has_non_default_from_json <
+        BasicJsonType,
+        value_type >::value;
+};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type
+    : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType,
+         typename = void>
+struct is_compatible_integer_type_impl : std::false_type {};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type_impl <
+    RealIntegerType, CompatibleNumberIntegerType,
+    enable_if_t < std::is_integral<RealIntegerType>::value&&
+    std::is_integral<CompatibleNumberIntegerType>::value&&
+    !std::is_same<bool, CompatibleNumberIntegerType>::value >>
+{
+    // is there an assert somewhere on overflows?
+    using RealLimits = std::numeric_limits<RealIntegerType>;
+    using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
+
+    static constexpr auto value =
+        is_constructible<RealIntegerType,
+        CompatibleNumberIntegerType>::value &&
+        CompatibleLimits::is_integer &&
+        RealLimits::is_signed == CompatibleLimits::is_signed;
+};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type
+    : is_compatible_integer_type_impl<RealIntegerType,
+      CompatibleNumberIntegerType> {};
+
+template<typename BasicJsonType, typename CompatibleType, typename = void>
+struct is_compatible_type_impl: std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleType>
+struct is_compatible_type_impl <
+    BasicJsonType, CompatibleType,
+    enable_if_t<is_complete_type<CompatibleType>::value >>
+{
+    static constexpr bool value =
+        has_to_json<BasicJsonType, CompatibleType>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleType>
+struct is_compatible_type
+    : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
+
+template<typename T1, typename T2>
+struct is_constructible_tuple : std::false_type {};
+
+template<typename T1, typename... Args>
+struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<is_constructible<T1, Args>...> {};
+
+template<typename BasicJsonType, typename T>
+struct is_json_iterator_of : std::false_type {};
+
+template<typename BasicJsonType>
+struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::iterator> : std::true_type {};
+
+template<typename BasicJsonType>
+struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::const_iterator> : std::true_type
+{};
+
+// checks if a given type T is a template specialization of Primary
+template<template <typename...> class Primary, typename T>
+struct is_specialization_of : std::false_type {};
+
+template<template <typename...> class Primary, typename... Args>
+struct is_specialization_of<Primary, Primary<Args...>> : std::true_type {};
+
+template<typename T>
+using is_json_pointer = is_specialization_of<::nlohmann::json_pointer, uncvref_t<T>>;
+
+// checks if B is a json_pointer<A>
+template <typename A, typename B>
+struct is_json_pointer_of : std::false_type {};
+
+template <typename A>
+struct is_json_pointer_of<A, ::nlohmann::json_pointer<A>> : std::true_type {};
+
+template <typename A>
+struct is_json_pointer_of<A, ::nlohmann::json_pointer<A>&> : std::true_type {};
+
+// checks if A and B are comparable using Compare functor
+template<typename Compare, typename A, typename B, typename = void>
+struct is_comparable : std::false_type {};
+
+// We exclude json_pointer here, because the checks using Compare(A, B) will
+// use json_pointer::operator string_t() which triggers a deprecation warning
+// for GCC. See https://github.com/nlohmann/json/issues/4621. The call to
+// is_json_pointer_of can be removed once the deprecated function has been
+// removed.
+template<typename Compare, typename A, typename B>
+struct is_comparable < Compare, A, B, enable_if_t < !is_json_pointer_of<A, B>::value
+&& std::is_constructible <decltype(std::declval<Compare>()(std::declval<A>(), std::declval<B>()))>::value
+&& std::is_constructible <decltype(std::declval<Compare>()(std::declval<B>(), std::declval<A>()))>::value
+>> : std::true_type {};
+
+template<typename T>
+using detect_is_transparent = typename T::is_transparent;
+
+// type trait to check if KeyType can be used as an object key (without a BasicJsonType)
+// see is_usable_as_basic_json_key_type below
+template<typename Comparator, typename ObjectKeyType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,
+         bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
+using is_usable_as_key_type = typename std::conditional <
+                              is_comparable<Comparator, ObjectKeyType, KeyTypeCVRef>::value
+                              && !(ExcludeObjectKeyType && std::is_same<KeyType,
+                                   ObjectKeyType>::value)
+                              && (!RequireTransparentComparator
+                                  || is_detected <detect_is_transparent, Comparator>::value)
+                              && !is_json_pointer<KeyType>::value,
+                              std::true_type,
+                              std::false_type >::type;
+
+// type trait to check if KeyType can be used as an object key
+// true if:
+//   - KeyType is comparable with BasicJsonType::object_t::key_type
+//   - if ExcludeObjectKeyType is true, KeyType is not BasicJsonType::object_t::key_type
+//   - the comparator is transparent or RequireTransparentComparator is false
+//   - KeyType is not a JSON iterator or json_pointer
+template<typename BasicJsonType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,
+         bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
+using is_usable_as_basic_json_key_type = typename std::conditional <
+    is_usable_as_key_type<typename BasicJsonType::object_comparator_t,
+    typename BasicJsonType::object_t::key_type, KeyTypeCVRef,
+    RequireTransparentComparator, ExcludeObjectKeyType>::value
+    && !is_json_iterator_of<BasicJsonType, KeyType>::value,
+    std::true_type,
+    std::false_type >::type;
+
+template<typename ObjectType, typename KeyType>
+using detect_erase_with_key_type = decltype(std::declval<ObjectType&>().erase(std::declval<KeyType>()));
+
+// type trait to check if object_t has an erase() member functions accepting KeyType
+template<typename BasicJsonType, typename KeyType>
+using has_erase_with_key_type = typename std::conditional <
+                                is_detected <
+                                detect_erase_with_key_type,
+                                typename BasicJsonType::object_t, KeyType >::value,
+                                std::true_type,
+                                std::false_type >::type;
+
+// a naive helper to check if a type is an ordered_map (exploits the fact that
+// ordered_map inherits capacity() from std::vector)
+template <typename T>
+struct is_ordered_map
+{
+    using one = char;
+
+    struct two
+    {
+        char x[2]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+    };
+
+    template <typename C> static one test( decltype(&C::capacity) ) ;
+    template <typename C> static two test(...);
+
+    enum { value = sizeof(test<T>(nullptr)) == sizeof(char) }; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg,cppcoreguidelines-use-enum-class)
+};
+
+// to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324)
+template < typename T, typename U, enable_if_t < !std::is_same<T, U>::value, int > = 0 >
+T conditional_static_cast(U value)
+{
+    return static_cast<T>(value);
+}
+
+template<typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>
+T conditional_static_cast(U value)
+{
+    return value;
+}
+
+template<typename... Types>
+using all_integral = conjunction<std::is_integral<Types>...>;
+
+template<typename... Types>
+using all_signed = conjunction<std::is_signed<Types>...>;
+
+template<typename... Types>
+using all_unsigned = conjunction<std::is_unsigned<Types>...>;
+
+// there's a disjunction trait in another PR; replace when merged
+template<typename... Types>
+using same_sign = std::integral_constant < bool,
+      all_signed<Types...>::value || all_unsigned<Types...>::value >;
+
+template<typename OfType, typename T>
+using never_out_of_range = std::integral_constant < bool,
+      (std::is_signed<OfType>::value && (sizeof(T) < sizeof(OfType)))
+      || (same_sign<OfType, T>::value && sizeof(OfType) == sizeof(T)) >;
+
+template<typename OfType, typename T,
+         bool OfTypeSigned = std::is_signed<OfType>::value,
+         bool TSigned = std::is_signed<T>::value>
+struct value_in_range_of_impl2;
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl2<OfType, T, false, false>
+{
+    static constexpr bool test(T val)
+    {
+        using CommonType = typename std::common_type<OfType, T>::type;
+        return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
+    }
+};
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl2<OfType, T, true, false>
+{
+    static constexpr bool test(T val)
+    {
+        using CommonType = typename std::common_type<OfType, T>::type;
+        return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
+    }
+};
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl2<OfType, T, false, true>
+{
+    static constexpr bool test(T val)
+    {
+        using CommonType = typename std::common_type<OfType, T>::type;
+        return val >= 0 && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
+    }
+};
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl2<OfType, T, true, true>
+{
+    static constexpr bool test(T val)
+    {
+        using CommonType = typename std::common_type<OfType, T>::type;
+        return static_cast<CommonType>(val) >= static_cast<CommonType>((std::numeric_limits<OfType>::min)())
+               && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
+    }
+};
+
+template<typename OfType, typename T,
+         bool NeverOutOfRange = never_out_of_range<OfType, T>::value,
+         typename = detail::enable_if_t<all_integral<OfType, T>::value>>
+struct value_in_range_of_impl1;
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl1<OfType, T, false>
+{
+    static constexpr bool test(T val)
+    {
+        return value_in_range_of_impl2<OfType, T>::test(val);
+    }
+};
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl1<OfType, T, true>
+{
+    static constexpr bool test(T /*val*/)
+    {
+        return true;
+    }
+};
+
+template<typename OfType, typename T>
+constexpr bool value_in_range_of(T val)
+{
+    return value_in_range_of_impl1<OfType, T>::test(val);
+}
+
+template<bool Value>
+using bool_constant = std::integral_constant<bool, Value>;
+
+///////////////////////////////////////////////////////////////////////////////
+// is_c_string
+///////////////////////////////////////////////////////////////////////////////
+
+namespace impl
+{
+
+template<typename T>
+constexpr bool is_c_string()
+{
+    using TUnExt = typename std::remove_extent<T>::type;
+    using TUnCVExt = typename std::remove_cv<TUnExt>::type;
+    using TUnPtr = typename std::remove_pointer<T>::type;
+    using TUnCVPtr = typename std::remove_cv<TUnPtr>::type;
+    return
+        (std::is_array<T>::value && std::is_same<TUnCVExt, char>::value)
+        || (std::is_pointer<T>::value && std::is_same<TUnCVPtr, char>::value);
+}
+
+}  // namespace impl
+
+// checks whether T is a [cv] char */[cv] char[] C string
+template<typename T>
+struct is_c_string : bool_constant<impl::is_c_string<T>()> {};
+
+template<typename T>
+using is_c_string_uncvref = is_c_string<uncvref_t<T>>;
+
+///////////////////////////////////////////////////////////////////////////////
+// is_transparent
+///////////////////////////////////////////////////////////////////////////////
+
+namespace impl
+{
+
+template<typename T>
+constexpr bool is_transparent()
+{
+    return is_detected<detect_is_transparent, T>::value;
+}
+
+}  // namespace impl
+
+// checks whether T has a member named is_transparent
+template<typename T>
+struct is_transparent : bool_constant<impl::is_transparent<T>()> {};
+
+///////////////////////////////////////////////////////////////////////////////
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/string_concat.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstring> // strlen
+#include <string> // string
+#include <utility> // forward
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+inline std::size_t concat_length()
+{
+    return 0;
+}
+
+template<typename... Args>
+inline std::size_t concat_length(const char* cstr, const Args& ... rest);
+
+template<typename StringType, typename... Args>
+inline std::size_t concat_length(const StringType& str, const Args& ... rest);
+
+template<typename... Args>
+inline std::size_t concat_length(const char /*c*/, const Args& ... rest)
+{
+    return 1 + concat_length(rest...);
+}
+
+template<typename... Args>
+inline std::size_t concat_length(const char* cstr, const Args& ... rest)
+{
+    // cppcheck-suppress ignoredReturnValue
+    return ::strlen(cstr) + concat_length(rest...);
+}
+
+template<typename StringType, typename... Args>
+inline std::size_t concat_length(const StringType& str, const Args& ... rest)
+{
+    return str.size() + concat_length(rest...);
+}
+
+template<typename OutStringType>
+inline void concat_into(OutStringType& /*out*/)
+{}
+
+template<typename StringType, typename Arg>
+using string_can_append = decltype(std::declval<StringType&>().append(std::declval < Arg && > ()));
+
+template<typename StringType, typename Arg>
+using detect_string_can_append = is_detected<string_can_append, StringType, Arg>;
+
+template<typename StringType, typename Arg>
+using string_can_append_op = decltype(std::declval<StringType&>() += std::declval < Arg && > ());
+
+template<typename StringType, typename Arg>
+using detect_string_can_append_op = is_detected<string_can_append_op, StringType, Arg>;
+
+template<typename StringType, typename Arg>
+using string_can_append_iter = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().begin(), std::declval<const Arg&>().end()));
+
+template<typename StringType, typename Arg>
+using detect_string_can_append_iter = is_detected<string_can_append_iter, StringType, Arg>;
+
+template<typename StringType, typename Arg>
+using string_can_append_data = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().data(), std::declval<const Arg&>().size()));
+
+template<typename StringType, typename Arg>
+using detect_string_can_append_data = is_detected<string_can_append_data, StringType, Arg>;
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && detect_string_can_append_op<OutStringType, Arg>::value, int > = 0 >
+inline void concat_into(OutStringType& out, Arg && arg, Args && ... rest);
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && !detect_string_can_append_op<OutStringType, Arg>::value
+                         && detect_string_can_append_iter<OutStringType, Arg>::value, int > = 0 >
+inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && !detect_string_can_append_op<OutStringType, Arg>::value
+                         && !detect_string_can_append_iter<OutStringType, Arg>::value
+                         && detect_string_can_append_data<OutStringType, Arg>::value, int > = 0 >
+inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);
+
+template<typename OutStringType, typename Arg, typename... Args,
+         enable_if_t<detect_string_can_append<OutStringType, Arg>::value, int> = 0>
+inline void concat_into(OutStringType& out, Arg && arg, Args && ... rest)
+{
+    out.append(std::forward<Arg>(arg));
+    concat_into(out, std::forward<Args>(rest)...);
+}
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && detect_string_can_append_op<OutStringType, Arg>::value, int > >
+inline void concat_into(OutStringType& out, Arg&& arg, Args&& ... rest)
+{
+    out += std::forward<Arg>(arg);
+    concat_into(out, std::forward<Args>(rest)...);
+}
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && !detect_string_can_append_op<OutStringType, Arg>::value
+                         && detect_string_can_append_iter<OutStringType, Arg>::value, int > >
+inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)
+{
+    out.append(arg.begin(), arg.end());
+    concat_into(out, std::forward<Args>(rest)...);
+}
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && !detect_string_can_append_op<OutStringType, Arg>::value
+                         && !detect_string_can_append_iter<OutStringType, Arg>::value
+                         && detect_string_can_append_data<OutStringType, Arg>::value, int > >
+inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)
+{
+    out.append(arg.data(), arg.size());
+    concat_into(out, std::forward<Args>(rest)...);
+}
+
+template<typename OutStringType = std::string, typename... Args>
+inline OutStringType concat(Args && ... args)
+{
+    OutStringType str;
+    str.reserve(concat_length(args...));
+    concat_into(str, std::forward<Args>(args)...);
+    return str;
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+
+// With -Wweak-vtables, Clang will complain about the exception classes as they
+// have no out-of-line virtual method definitions and their vtable will be
+// emitted in every translation unit. This issue cannot be fixed with a
+// header-only library as there is no implementation file to move these
+// functions to. As a result, we suppress this warning here to avoid client
+// code stumbling over this. See https://github.com/nlohmann/json/issues/4087
+// for a discussion.
+#if defined(__clang__)
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+////////////////
+// exceptions //
+////////////////
+
+/// @brief general exception of the @ref basic_json class
+/// @sa https://json.nlohmann.me/api/basic_json/exception/
+class exception : public std::exception
+{
+  public:
+    /// returns the explanatory string
+    const char* what() const noexcept override
+    {
+        return m.what();
+    }
+
+    /// the id of the exception
+    const int id; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
+
+  protected:
+    JSON_HEDLEY_NON_NULL(3)
+    exception(int id_, const char* what_arg) : id(id_), m(what_arg) {} // NOLINT(bugprone-throw-keyword-missing)
+
+    static std::string name(const std::string& ename, int id_)
+    {
+        return concat("[json.exception.", ename, '.', std::to_string(id_), "] ");
+    }
+
+    static std::string diagnostics(std::nullptr_t /*leaf_element*/)
+    {
+        return "";
+    }
+
+    template<typename BasicJsonType>
+    static std::string diagnostics(const BasicJsonType* leaf_element)
+    {
+#if JSON_DIAGNOSTICS
+        std::vector<std::string> tokens;
+        for (const auto* current = leaf_element; current != nullptr && current->m_parent != nullptr; current = current->m_parent)
+        {
+            switch (current->m_parent->type())
+            {
+                case value_t::array:
+                {
+                    for (std::size_t i = 0; i < current->m_parent->m_data.m_value.array->size(); ++i)
+                    {
+                        if (&current->m_parent->m_data.m_value.array->operator[](i) == current)
+                        {
+                            tokens.emplace_back(std::to_string(i));
+                            break;
+                        }
+                    }
+                    break;
+                }
+
+                case value_t::object:
+                {
+                    for (const auto& element : *current->m_parent->m_data.m_value.object)
+                    {
+                        if (&element.second == current)
+                        {
+                            tokens.emplace_back(element.first.c_str());
+                            break;
+                        }
+                    }
+                    break;
+                }
+
+                case value_t::null: // LCOV_EXCL_LINE
+                case value_t::string: // LCOV_EXCL_LINE
+                case value_t::boolean: // LCOV_EXCL_LINE
+                case value_t::number_integer: // LCOV_EXCL_LINE
+                case value_t::number_unsigned: // LCOV_EXCL_LINE
+                case value_t::number_float: // LCOV_EXCL_LINE
+                case value_t::binary: // LCOV_EXCL_LINE
+                case value_t::discarded: // LCOV_EXCL_LINE
+                default:   // LCOV_EXCL_LINE
+                    break; // LCOV_EXCL_LINE
+            }
+        }
+
+        if (tokens.empty())
+        {
+            return "";
+        }
+
+        auto str = std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},
+                                   [](const std::string & a, const std::string & b)
+        {
+            return concat(a, '/', detail::escape(b));
+        });
+
+        return concat('(', str, ") ", get_byte_positions(leaf_element));
+#else
+        return get_byte_positions(leaf_element);
+#endif
+    }
+
+  private:
+    /// an exception object as storage for error messages
+    std::runtime_error m;
+#if JSON_DIAGNOSTIC_POSITIONS
+    template<typename BasicJsonType>
+    static std::string get_byte_positions(const BasicJsonType* leaf_element)
+    {
+        if ((leaf_element->start_pos() != std::string::npos) && (leaf_element->end_pos() != std::string::npos))
+        {
+            return concat("(bytes ", std::to_string(leaf_element->start_pos()), "-", std::to_string(leaf_element->end_pos()), ") ");
+        }
+        return "";
+    }
+#else
+    template<typename BasicJsonType>
+    static std::string get_byte_positions(const BasicJsonType* leaf_element)
+    {
+        static_cast<void>(leaf_element);
+        return "";
+    }
+#endif
+};
+
+/// @brief exception indicating a parse error
+/// @sa https://json.nlohmann.me/api/basic_json/parse_error/
+class parse_error : public exception
+{
+  public:
+    /*!
+    @brief create a parse error exception
+    @param[in] id_       the id of the exception
+    @param[in] pos       the position where the error occurred (or with
+                         chars_read_total=0 if the position cannot be
+                         determined)
+    @param[in] what_arg  the explanatory string
+    @return parse_error object
+    */
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static parse_error create(int id_, const position_t& pos, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("parse_error", id_), "parse error",
+                                     position_string(pos), ": ", exception::diagnostics(context), what_arg);
+        return {id_, pos.chars_read_total, w.c_str()};
+    }
+
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static parse_error create(int id_, std::size_t byte_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("parse_error", id_), "parse error",
+                                     (byte_ != 0 ? (concat(" at byte ", std::to_string(byte_))) : ""),
+                                     ": ", exception::diagnostics(context), what_arg);
+        return {id_, byte_, w.c_str()};
+    }
+
+    /*!
+    @brief byte index of the parse error
+
+    The byte index of the last read character in the input file.
+
+    @note For an input with n bytes, 1 is the index of the first character and
+          n+1 is the index of the terminating null byte or the end of file.
+          This also holds true when reading a byte vector (CBOR or MessagePack).
+    */
+    const std::size_t byte;
+
+  private:
+    parse_error(int id_, std::size_t byte_, const char* what_arg)
+        : exception(id_, what_arg), byte(byte_) {}
+
+    static std::string position_string(const position_t& pos)
+    {
+        return concat(" at line ", std::to_string(pos.lines_read + 1),
+                      ", column ", std::to_string(pos.chars_read_current_line));
+    }
+};
+
+/// @brief exception indicating errors with iterators
+/// @sa https://json.nlohmann.me/api/basic_json/invalid_iterator/
+class invalid_iterator : public exception
+{
+  public:
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static invalid_iterator create(int id_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("invalid_iterator", id_), exception::diagnostics(context), what_arg);
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    invalid_iterator(int id_, const char* what_arg)
+        : exception(id_, what_arg) {}
+};
+
+/// @brief exception indicating executing a member function with a wrong type
+/// @sa https://json.nlohmann.me/api/basic_json/type_error/
+class type_error : public exception
+{
+  public:
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static type_error create(int id_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg);
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+/// @brief exception indicating access out of the defined range
+/// @sa https://json.nlohmann.me/api/basic_json/out_of_range/
+class out_of_range : public exception
+{
+  public:
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static out_of_range create(int id_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("out_of_range", id_), exception::diagnostics(context), what_arg);
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+/// @brief exception indicating other library errors
+/// @sa https://json.nlohmann.me/api/basic_json/other_error/
+class other_error : public exception
+{
+  public:
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static other_error create(int id_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("other_error", id_), exception::diagnostics(context), what_arg);
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/identity_tag.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+// dispatching helper struct
+template <class T> struct identity_tag {};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/std_fs.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+#if JSON_HAS_EXPERIMENTAL_FILESYSTEM
+#include <experimental/filesystem>
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace std_fs = std::experimental::filesystem;
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+#elif JSON_HAS_FILESYSTEM
+#include <filesystem> // NOLINT(build/c++17)
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace std_fs = std::filesystem;
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+#endif
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+// include after macro_scope.hpp
+#ifdef JSON_HAS_CPP_17
+    #include <optional> // optional
+#endif
+
+#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
+    #include <string_view> // u8string_view
+#endif
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be null, but is ", j.type_name()), &j));
+    }
+    n = nullptr;
+}
+
+#ifdef JSON_HAS_CPP_17
+template<typename BasicJsonType, typename T>
+void from_json(const BasicJsonType& j, std::optional<T>& opt)
+{
+    if (j.is_null())
+    {
+        opt = std::nullopt;
+    }
+    else
+    {
+        opt.emplace(j.template get<T>());
+    }
+}
+#endif // JSON_HAS_CPP_17
+
+// overloads for basic_json template parameters
+template < typename BasicJsonType, typename ArithmeticType,
+           enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
+                         !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+                         int > = 0 >
+void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
+{
+    switch (static_cast<value_t>(j))
+    {
+        case value_t::number_unsigned:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            break;
+        }
+        case value_t::number_integer:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            break;
+        }
+        case value_t::number_float:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            break;
+        }
+
+        case value_t::null:
+        case value_t::object:
+        case value_t::array:
+        case value_t::string:
+        case value_t::boolean:
+        case value_t::binary:
+        case value_t::discarded:
+        default:
+            JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
+    }
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be boolean, but is ", j.type_name()), &j));
+    }
+    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
+    }
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template <
+    typename BasicJsonType, typename StringType,
+    enable_if_t <
+        std::is_assignable<StringType&, const typename BasicJsonType::string_t>::value
+        && is_detected_exact<typename BasicJsonType::string_t::value_type, value_type_t, StringType>::value
+        && !std::is_same<typename BasicJsonType::string_t, StringType>::value
+        && !is_json_ref<StringType>::value, int > = 0 >
+inline void from_json(const BasicJsonType& j, StringType& s)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
+    }
+
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+#if !JSON_DISABLE_ENUM_SERIALIZATION
+template<typename BasicJsonType, typename EnumType,
+         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
+inline void from_json(const BasicJsonType& j, EnumType& e)
+{
+    typename std::underlying_type<EnumType>::type val;
+    get_arithmetic_value(j, val);
+    e = static_cast<EnumType>(val);
+}
+#endif  // JSON_DISABLE_ENUM_SERIALIZATION
+
+// forward_list doesn't have an insert method
+template<typename BasicJsonType, typename T, typename Allocator,
+         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
+inline void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+    l.clear();
+    std::transform(j.rbegin(), j.rend(),
+                   std::front_inserter(l), [](const BasicJsonType & i)
+    {
+        return i.template get<T>();
+    });
+}
+
+// valarray doesn't have an insert method
+template<typename BasicJsonType, typename T,
+         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
+inline void from_json(const BasicJsonType& j, std::valarray<T>& l)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+    l.resize(j.size());
+    std::transform(j.begin(), j.end(), std::begin(l),
+                   [](const BasicJsonType & elem)
+    {
+        return elem.template get<T>();
+    });
+}
+
+template<typename BasicJsonType, typename T, std::size_t N>
+auto from_json(const BasicJsonType& j, T (&arr)[N])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        arr[i] = j.at(i).template get<T>();
+    }
+}
+
+template<typename BasicJsonType, typename T, std::size_t N1, std::size_t N2>
+auto from_json(const BasicJsonType& j, T (&arr)[N1][N2])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i1 = 0; i1 < N1; ++i1)
+    {
+        for (std::size_t i2 = 0; i2 < N2; ++i2)
+        {
+            arr[i1][i2] = j.at(i1).at(i2).template get<T>();
+        }
+    }
+}
+
+template<typename BasicJsonType, typename T, std::size_t N1, std::size_t N2, std::size_t N3>
+auto from_json(const BasicJsonType& j, T (&arr)[N1][N2][N3])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i1 = 0; i1 < N1; ++i1)
+    {
+        for (std::size_t i2 = 0; i2 < N2; ++i2)
+        {
+            for (std::size_t i3 = 0; i3 < N3; ++i3)
+            {
+                arr[i1][i2][i3] = j.at(i1).at(i2).at(i3).template get<T>();
+            }
+        }
+    }
+}
+
+template<typename BasicJsonType, typename T, std::size_t N1, std::size_t N2, std::size_t N3, std::size_t N4>
+auto from_json(const BasicJsonType& j, T (&arr)[N1][N2][N3][N4])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i1 = 0; i1 < N1; ++i1)
+    {
+        for (std::size_t i2 = 0; i2 < N2; ++i2)
+        {
+            for (std::size_t i3 = 0; i3 < N3; ++i3)
+            {
+                for (std::size_t i4 = 0; i4 < N4; ++i4)
+                {
+                    arr[i1][i2][i3][i4] = j.at(i1).at(i2).at(i3).at(i4).template get<T>();
+                }
+            }
+        }
+    }
+}
+
+template<typename BasicJsonType>
+inline void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
+{
+    arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
+}
+
+template<typename BasicJsonType, typename T, std::size_t N>
+auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
+                          priority_tag<2> /*unused*/)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        arr[i] = j.at(i).template get<T>();
+    }
+}
+
+template<typename BasicJsonType, typename ConstructibleArrayType,
+         enable_if_t<
+             std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
+             int> = 0>
+auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
+-> decltype(
+    arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
+    j.template get<typename ConstructibleArrayType::value_type>(),
+    void())
+{
+    using std::end;
+
+    ConstructibleArrayType ret;
+    ret.reserve(j.size());
+    std::transform(j.begin(), j.end(),
+                   std::inserter(ret, end(ret)), [](const BasicJsonType & i)
+    {
+        // get<BasicJsonType>() returns *this, this won't call a from_json
+        // method when value_type is BasicJsonType
+        return i.template get<typename ConstructibleArrayType::value_type>();
+    });
+    arr = std::move(ret);
+}
+
+template<typename BasicJsonType, typename ConstructibleArrayType,
+         enable_if_t<
+             std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
+             int> = 0>
+inline void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
+                                 priority_tag<0> /*unused*/)
+{
+    using std::end;
+
+    ConstructibleArrayType ret;
+    std::transform(
+        j.begin(), j.end(), std::inserter(ret, end(ret)),
+        [](const BasicJsonType & i)
+    {
+        // get<BasicJsonType>() returns *this, this won't call a from_json
+        // method when value_type is BasicJsonType
+        return i.template get<typename ConstructibleArrayType::value_type>();
+    });
+    arr = std::move(ret);
+}
+
+template < typename BasicJsonType, typename ConstructibleArrayType,
+           enable_if_t <
+               is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
+               !is_basic_json<ConstructibleArrayType>::value,
+               int > = 0 >
+auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
+-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
+j.template get<typename ConstructibleArrayType::value_type>(),
+void())
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+
+    from_json_array_impl(j, arr, priority_tag<3> {});
+}
+
+template < typename BasicJsonType, typename T, std::size_t... Idx >
+std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
+                     identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
+{
+    return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
+}
+
+template < typename BasicJsonType, typename T, std::size_t N >
+auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag)
+-> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+
+    return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {});
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be binary, but is ", j.type_name()), &j));
+    }
+
+    bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
+}
+
+template<typename BasicJsonType, typename ConstructibleObjectType,
+         enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
+inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be object, but is ", j.type_name()), &j));
+    }
+
+    ConstructibleObjectType ret;
+    const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
+    using value_type = typename ConstructibleObjectType::value_type;
+    std::transform(
+        inner_object->begin(), inner_object->end(),
+        std::inserter(ret, ret.begin()),
+        [](typename BasicJsonType::object_t::value_type const & p)
+    {
+        return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
+    });
+    obj = std::move(ret);
+}
+
+// overload for arithmetic types, not chosen for basic_json template arguments
+// (BooleanType, etc.); note: Is it really necessary to provide explicit
+// overloads for boolean_t etc. in case of a custom BooleanType which is not
+// an arithmetic type?
+template < typename BasicJsonType, typename ArithmeticType,
+           enable_if_t <
+               std::is_arithmetic<ArithmeticType>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+               int > = 0 >
+inline void from_json(const BasicJsonType& j, ArithmeticType& val)
+{
+    switch (static_cast<value_t>(j))
+    {
+        case value_t::number_unsigned:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            break;
+        }
+        case value_t::number_integer:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            break;
+        }
+        case value_t::number_float:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            break;
+        }
+        case value_t::boolean:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
+            break;
+        }
+
+        case value_t::null:
+        case value_t::object:
+        case value_t::array:
+        case value_t::string:
+        case value_t::binary:
+        case value_t::discarded:
+        default:
+            JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
+    }
+}
+
+template<typename BasicJsonType, typename... Args, std::size_t... Idx>
+std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> /*unused*/)
+{
+    return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).template get<Args>()...);
+}
+
+template<typename BasicJsonType>
+std::tuple<> from_json_tuple_impl_base(BasicJsonType& /*unused*/, index_sequence<> /*unused*/)
+{
+    return {};
+}
+
+template < typename BasicJsonType, class A1, class A2 >
+std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/)
+{
+    return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
+            std::forward<BasicJsonType>(j).at(1).template get<A2>()};
+}
+
+template<typename BasicJsonType, typename A1, typename A2>
+inline void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> /*unused*/)
+{
+    p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});
+}
+
+template<typename BasicJsonType, typename... Args>
+std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/)
+{
+    return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
+}
+
+template<typename BasicJsonType, typename... Args>
+inline void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> /*unused*/)
+{
+    t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
+}
+
+template<typename BasicJsonType, typename TupleRelated>
+auto from_json(BasicJsonType&& j, TupleRelated&& t)
+-> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+
+    return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});
+}
+
+template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
+           typename = enable_if_t < !std::is_constructible <
+                                        typename BasicJsonType::string_t, Key >::value >>
+inline void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+    m.clear();
+    for (const auto& p : j)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
+           typename = enable_if_t < !std::is_constructible <
+                                        typename BasicJsonType::string_t, Key >::value >>
+inline void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+    m.clear();
+    for (const auto& p : j)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, std_fs::path& p)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
+    }
+    const auto& s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+    // Checking for C++20 standard or later can be insufficient in case the
+    // library support for char8_t is either incomplete or was disabled
+    // altogether. Use the __cpp_lib_char8_t feature test instead.
+#if defined(__cpp_lib_char8_t) && (__cpp_lib_char8_t >= 201907L)
+    p = std_fs::path(std::u8string_view(reinterpret_cast<const char8_t*>(s.data()), s.size()));
+#else
+    p = std_fs::u8path(s); // accepts UTF-8 encoded std::string in C++17, deprecated in C++20
+#endif
+}
+#endif
+
+struct from_json_fn
+{
+    template<typename BasicJsonType, typename T>
+    auto operator()(const BasicJsonType& j, T&& val) const
+    noexcept(noexcept(from_json(j, std::forward<T>(val))))
+    -> decltype(from_json(j, std::forward<T>(val)))
+    {
+        return from_json(j, std::forward<T>(val));
+    }
+};
+
+}  // namespace detail
+
+#ifndef JSON_HAS_CPP_17
+/// namespace to hold default `from_json` function
+/// to see why this is required:
+/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
+namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
+{
+#endif
+JSON_INLINE_VARIABLE constexpr const auto& from_json = // NOLINT(misc-definitions-in-headers)
+    detail::static_const<detail::from_json_fn>::value;
+#ifndef JSON_HAS_CPP_17
+}  // namespace
+#endif
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/conversions/to_json.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/macro_scope.hpp>
+// JSON_HAS_CPP_17
+#ifdef JSON_HAS_CPP_17
+    #include <optional> // optional
+#endif
+
+#include <algorithm> // copy
+#include <iterator> // begin, end
+#include <memory> // allocator_traits
+#include <string> //  basic_string, char_traits
+#include <tuple> // tuple, get
+#include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
+#include <utility> // move, forward, declval, pair
+#include <valarray> // valarray
+#include <vector> // vector
+
+// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // size_t
+#include <iterator> // forward_iterator_tag
+#include <tuple> // tuple_size, get, tuple_element
+#include <utility> // move
+
+#if JSON_HAS_RANGES
+    #include <ranges> // enable_borrowed_range
+#endif
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/string_utils.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // size_t
+#include <string> // string, to_string
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename StringType>
+void int_to_string(StringType& target, std::size_t value)
+{
+    // For ADL
+    using std::to_string;
+    target = to_string(value);
+}
+
+template<typename StringType>
+StringType to_string(std::size_t value)
+{
+    StringType result;
+    int_to_string(result, value);
+    return result;
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename IteratorType> class iteration_proxy_value
+{
+  public:
+    using difference_type = std::ptrdiff_t;
+    using value_type = iteration_proxy_value;
+    using pointer = value_type *;
+    using reference = value_type &;
+    using iterator_category = std::forward_iterator_tag;
+    using string_type = typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;
+
+  private:
+    /// the iterator
+    IteratorType anchor{};
+    /// an index for arrays (used to create key names)
+    std::size_t array_index = 0;
+    /// last stringified array index
+    mutable std::size_t array_index_last = 0;
+    /// a string representation of the array index
+    mutable string_type array_index_str = "0";
+    /// an empty string (to return a reference for primitive values)
+    string_type empty_str{};
+
+  public:
+    explicit iteration_proxy_value() = default;
+    explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)
+    noexcept(std::is_nothrow_move_constructible<IteratorType>::value
+             && std::is_nothrow_default_constructible<string_type>::value)
+        : anchor(std::move(it))
+        , array_index(array_index_)
+    {}
+
+    iteration_proxy_value(iteration_proxy_value const&) = default;
+    iteration_proxy_value& operator=(iteration_proxy_value const&) = default;
+    // older GCCs are a bit fussy and require explicit noexcept specifiers on defaulted functions
+    iteration_proxy_value(iteration_proxy_value&&)
+    noexcept(std::is_nothrow_move_constructible<IteratorType>::value
+             && std::is_nothrow_move_constructible<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
+    iteration_proxy_value& operator=(iteration_proxy_value&&)
+    noexcept(std::is_nothrow_move_assignable<IteratorType>::value
+             && std::is_nothrow_move_assignable<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
+    ~iteration_proxy_value() = default;
+
+    /// dereference operator (needed for range-based for)
+    const iteration_proxy_value& operator*() const
+    {
+        return *this;
+    }
+
+    /// increment operator (needed for range-based for)
+    iteration_proxy_value& operator++()
+    {
+        ++anchor;
+        ++array_index;
+
+        return *this;
+    }
+
+    iteration_proxy_value operator++(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        auto tmp = iteration_proxy_value(anchor, array_index);
+        ++anchor;
+        ++array_index;
+        return tmp;
+    }
+
+    /// equality operator (needed for InputIterator)
+    bool operator==(const iteration_proxy_value& o) const
+    {
+        return anchor == o.anchor;
+    }
+
+    /// inequality operator (needed for range-based for)
+    bool operator!=(const iteration_proxy_value& o) const
+    {
+        return anchor != o.anchor;
+    }
+
+    /// return key of the iterator
+    const string_type& key() const
+    {
+        JSON_ASSERT(anchor.m_object != nullptr);
+
+        switch (anchor.m_object->type())
+        {
+            // use integer array index as key
+            case value_t::array:
+            {
+                if (array_index != array_index_last)
+                {
+                    int_to_string( array_index_str, array_index );
+                    array_index_last = array_index;
+                }
+                return array_index_str;
+            }
+
+            // use key from the object
+            case value_t::object:
+                return anchor.key();
+
+            // use an empty key for all primitive types
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return empty_str;
+        }
+    }
+
+    /// return value of the iterator
+    typename IteratorType::reference value() const
+    {
+        return anchor.value();
+    }
+};
+
+/// proxy class for the items() function
+template<typename IteratorType> class iteration_proxy
+{
+  private:
+    /// the container to iterate
+    typename IteratorType::pointer container = nullptr;
+
+  public:
+    explicit iteration_proxy() = default;
+
+    /// construct iteration proxy from a container
+    explicit iteration_proxy(typename IteratorType::reference cont) noexcept
+        : container(&cont) {}
+
+    iteration_proxy(iteration_proxy const&) = default;
+    iteration_proxy& operator=(iteration_proxy const&) = default;
+    iteration_proxy(iteration_proxy&&) noexcept = default;
+    iteration_proxy& operator=(iteration_proxy&&) noexcept = default;
+    ~iteration_proxy() = default;
+
+    /// return iterator begin (needed for range-based for)
+    iteration_proxy_value<IteratorType> begin() const noexcept
+    {
+        return iteration_proxy_value<IteratorType>(container->begin());
+    }
+
+    /// return iterator end (needed for range-based for)
+    iteration_proxy_value<IteratorType> end() const noexcept
+    {
+        return iteration_proxy_value<IteratorType>(container->end());
+    }
+};
+
+// Structured Bindings Support
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
+auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
+{
+    return i.key();
+}
+// Structured Bindings Support
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
+auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
+{
+    return i.value();
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// The Addition to the STD Namespace is required to add
+// Structured Bindings Support to the iteration_proxy_value class
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+namespace std
+{
+
+#if defined(__clang__)
+    // Fix: https://github.com/nlohmann/json/issues/1401
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wmismatched-tags"
+#endif
+template<typename IteratorType>
+class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> // NOLINT(cert-dcl58-cpp)
+    : public std::integral_constant<std::size_t, 2> {};
+
+template<std::size_t N, typename IteratorType>
+class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >> // NOLINT(cert-dcl58-cpp)
+{
+  public:
+    using type = decltype(
+                     get<N>(std::declval <
+                            ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
+};
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
+
+}  // namespace std
+
+#if JSON_HAS_RANGES
+    template <typename IteratorType>
+    inline constexpr bool ::std::ranges::enable_borrowed_range<::nlohmann::detail::iteration_proxy<IteratorType>> = true;
+#endif
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/std_fs.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+//////////////////
+// constructors //
+//////////////////
+
+/*
+ * Note all external_constructor<>::construct functions need to call
+ * j.m_data.m_value.destroy(j.m_data.m_type) to avoid a memory leak in case j contains an
+ * allocated value (e.g., a string). See bug issue
+ * https://github.com/nlohmann/json/issues/2865 for more information.
+ */
+
+template<value_t> struct external_constructor;
+
+template<>
+struct external_constructor<value_t::boolean>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::boolean;
+        j.m_data.m_value = b;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::string>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::string;
+        j.m_data.m_value = s;
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::string;
+        j.m_data.m_value = std::move(s);
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleStringType,
+               enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
+                             int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleStringType& str)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::string;
+        j.m_data.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::binary>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::binary;
+        j.m_data.m_value = typename BasicJsonType::binary_t(b);
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::binary;
+        j.m_data.m_value = typename BasicJsonType::binary_t(std::move(b));
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_float>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::number_float;
+        j.m_data.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_unsigned>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::number_unsigned;
+        j.m_data.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_integer>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::number_integer;
+        j.m_data.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::array>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = arr;
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = std::move(arr);
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleArrayType,
+               enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
+                             int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
+    {
+        using std::begin;
+        using std::end;
+
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const std::vector<bool>& arr)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = value_t::array;
+        j.m_data.m_value.array->reserve(arr.size());
+        for (const bool x : arr)
+        {
+            j.m_data.m_value.array->push_back(x);
+            j.set_parent(j.m_data.m_value.array->back());
+        }
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType, typename T,
+             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
+    static void construct(BasicJsonType& j, const std::valarray<T>& arr)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = value_t::array;
+        j.m_data.m_value.array->resize(arr.size());
+        if (arr.size() > 0)
+        {
+            std::copy(std::begin(arr), std::end(arr), j.m_data.m_value.array->begin());
+        }
+        j.set_parents();
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::object>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::object;
+        j.m_data.m_value = obj;
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::object;
+        j.m_data.m_value = std::move(obj);
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleObjectType,
+               enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
+    {
+        using std::begin;
+        using std::end;
+
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::object;
+        j.m_data.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
+        j.set_parents();
+        j.assert_invariant();
+    }
+};
+
+/////////////
+// to_json //
+/////////////
+
+#ifdef JSON_HAS_CPP_17
+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
+{
+    if (opt.has_value())
+    {
+        j = *opt;
+    }
+    else
+    {
+        j = nullptr;
+    }
+}
+#endif
+
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
+inline void to_json(BasicJsonType& j, T b) noexcept
+{
+    external_constructor<value_t::boolean>::construct(j, b);
+}
+
+template < typename BasicJsonType, typename BoolRef,
+           enable_if_t <
+               ((std::is_same<std::vector<bool>::reference, BoolRef>::value
+                 && !std::is_same <std::vector<bool>::reference, typename BasicJsonType::boolean_t&>::value)
+                || (std::is_same<std::vector<bool>::const_reference, BoolRef>::value
+                    && !std::is_same <detail::uncvref_t<std::vector<bool>::const_reference>,
+                                      typename BasicJsonType::boolean_t >::value))
+               && std::is_convertible<const BoolRef&, typename BasicJsonType::boolean_t>::value, int > = 0 >
+inline void to_json(BasicJsonType& j, const BoolRef& b) noexcept
+{
+    external_constructor<value_t::boolean>::construct(j, static_cast<typename BasicJsonType::boolean_t>(b));
+}
+
+template<typename BasicJsonType, typename CompatibleString,
+         enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
+inline void to_json(BasicJsonType& j, const CompatibleString& s)
+{
+    external_constructor<value_t::string>::construct(j, s);
+}
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
+{
+    external_constructor<value_t::string>::construct(j, std::move(s));
+}
+
+template<typename BasicJsonType, typename FloatType,
+         enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, FloatType val) noexcept
+{
+    external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
+}
+
+template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
+         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
+{
+    external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
+}
+
+template<typename BasicJsonType, typename CompatibleNumberIntegerType,
+         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
+{
+    external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
+}
+
+#if !JSON_DISABLE_ENUM_SERIALIZATION
+template<typename BasicJsonType, typename EnumType,
+         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
+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, static_cast<underlying_type>(e));
+}
+#endif  // JSON_DISABLE_ENUM_SERIALIZATION
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, const std::vector<bool>& e)
+{
+    external_constructor<value_t::array>::construct(j, e);
+}
+
+template < typename BasicJsonType, typename CompatibleArrayType,
+           enable_if_t < is_compatible_array_type<BasicJsonType,
+                         CompatibleArrayType>::value&&
+                         !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
+                         !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
+                         !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
+                         !is_basic_json<CompatibleArrayType>::value,
+                         int > = 0 >
+inline void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
+{
+    external_constructor<value_t::array>::construct(j, arr);
+}
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
+{
+    external_constructor<value_t::binary>::construct(j, bin);
+}
+
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, const std::valarray<T>& arr)
+{
+    external_constructor<value_t::array>::construct(j, std::move(arr));
+}
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
+{
+    external_constructor<value_t::array>::construct(j, std::move(arr));
+}
+
+template < typename BasicJsonType, typename CompatibleObjectType,
+           enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value, int > = 0 >
+inline void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
+{
+    external_constructor<value_t::object>::construct(j, obj);
+}
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
+{
+    external_constructor<value_t::object>::construct(j, std::move(obj));
+}
+
+template <
+    typename BasicJsonType, typename T, std::size_t N,
+    enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,
+                  const T(&)[N]>::value, // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+                  int > = 0 >
+inline void to_json(BasicJsonType& j, const T(&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+{
+    external_constructor<value_t::array>::construct(j, arr);
+}
+
+template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value, int > = 0 >
+inline void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
+{
+    j = { p.first, p.second };
+}
+
+// for https://github.com/nlohmann/json/pull/1134
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
+inline void to_json(BasicJsonType& j, const T& b)
+{
+    j = { {b.key(), b.value()} };
+}
+
+template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
+inline void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
+{
+    j = { std::get<Idx>(t)... };
+}
+
+template<typename BasicJsonType, typename Tuple>
+inline void to_json_tuple_impl(BasicJsonType& j, const Tuple& /*unused*/, index_sequence<> /*unused*/)
+{
+    using array_t = typename BasicJsonType::array_t;
+    j = array_t();
+}
+
+template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value, int > = 0>
+inline void to_json(BasicJsonType& j, const T& t)
+{
+    to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
+}
+
+#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
+#if defined(__cpp_lib_char8_t)
+template<typename BasicJsonType, typename Tr, typename Allocator>
+inline void to_json(BasicJsonType& j, const std::basic_string<char8_t, Tr, Allocator>& s)
+{
+    using OtherAllocator = typename std::allocator_traits<Allocator>::template rebind_alloc<char>;
+    j = std::basic_string<char, std::char_traits<char>, OtherAllocator>(s.begin(), s.end(), s.get_allocator());
+}
+#endif
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, const std_fs::path& p)
+{
+    // Returns either a std::string or a std::u8string depending whether library
+    // support for char8_t is enabled.
+    j = p.u8string();
+}
+#endif
+
+struct to_json_fn
+{
+    template<typename BasicJsonType, typename T>
+    auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
+    -> decltype(to_json(j, std::forward<T>(val)), void())
+    {
+        return to_json(j, std::forward<T>(val));
+    }
+};
+}  // namespace detail
+
+#ifndef JSON_HAS_CPP_17
+/// namespace to hold default `to_json` function
+/// to see why this is required:
+/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
+namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
+{
+#endif
+JSON_INLINE_VARIABLE constexpr const auto& to_json = // NOLINT(misc-definitions-in-headers)
+    detail::static_const<detail::to_json_fn>::value;
+#ifndef JSON_HAS_CPP_17
+}  // namespace
+#endif
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/identity_tag.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// @sa https://json.nlohmann.me/api/adl_serializer/
+template<typename ValueType, typename>
+struct adl_serializer
+{
+    /// @brief convert a JSON value to any value type
+    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto from_json(BasicJsonType && j, TargetType& val) noexcept(
+        noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
+    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
+    {
+        ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
+    }
+
+    /// @brief convert a JSON value to any value type
+    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto from_json(BasicJsonType && j) noexcept(
+    noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {})))
+    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))
+    {
+        return ::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {});
+    }
+
+    /// @brief convert any value type to a JSON value
+    /// @sa https://json.nlohmann.me/api/adl_serializer/to_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto to_json(BasicJsonType& j, TargetType && val) noexcept(
+        noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))
+    -> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void())
+    {
+        ::nlohmann::to_json(j, std::forward<TargetType>(val));
+    }
+};
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/byte_container_with_subtype.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstdint> // uint8_t, uint64_t
+#include <tuple> // tie
+#include <utility> // move
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// @brief an internal type for a backed binary type
+/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/
+template<typename BinaryType>
+class byte_container_with_subtype : public BinaryType
+{
+  public:
+    using container_type = BinaryType;
+    using subtype_type = std::uint64_t;
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype() noexcept(noexcept(container_type()))
+        : container_type()
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b)))
+        : container_type(b)
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b))))
+        : container_type(std::move(b))
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(const container_type& b, subtype_type subtype_) noexcept(noexcept(container_type(b)))
+        : container_type(b)
+        , m_subtype(subtype_)
+        , m_has_subtype(true)
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(container_type&& b, subtype_type subtype_) noexcept(noexcept(container_type(std::move(b))))
+        : container_type(std::move(b))
+        , m_subtype(subtype_)
+        , m_has_subtype(true)
+    {}
+
+    bool operator==(const byte_container_with_subtype& rhs) const
+    {
+        return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) ==
+               std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype);
+    }
+
+    bool operator!=(const byte_container_with_subtype& rhs) const
+    {
+        return !(rhs == *this);
+    }
+
+    /// @brief sets the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/set_subtype/
+    void set_subtype(subtype_type subtype_) noexcept
+    {
+        m_subtype = subtype_;
+        m_has_subtype = true;
+    }
+
+    /// @brief return the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/subtype/
+    constexpr subtype_type subtype() const noexcept
+    {
+        return m_has_subtype ? m_subtype : static_cast<subtype_type>(-1);
+    }
+
+    /// @brief return whether the value has a subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/has_subtype/
+    constexpr bool has_subtype() const noexcept
+    {
+        return m_has_subtype;
+    }
+
+    /// @brief clears the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/clear_subtype/
+    void clear_subtype() noexcept
+    {
+        m_subtype = 0;
+        m_has_subtype = false;
+    }
+
+  private:
+    subtype_type m_subtype = 0;
+    bool m_has_subtype = false;
+};
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/conversions/from_json.hpp>
+
+// #include <nlohmann/detail/conversions/to_json.hpp>
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/hash.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstdint> // uint8_t
+#include <cstddef> // size_t
+#include <functional> // hash
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+// boost::hash_combine
+inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
+{
+    seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
+    return seed;
+}
+
+/*!
+@brief hash a JSON value
+
+The hash function tries to rely on std::hash where possible. Furthermore, the
+type of the JSON value is taken into account to have different hash values for
+null, 0, 0U, and false, etc.
+
+@tparam BasicJsonType basic_json specialization
+@param j JSON value to hash
+@return hash value of j
+*/
+template<typename BasicJsonType>
+std::size_t hash(const BasicJsonType& j)
+{
+    using string_t = typename BasicJsonType::string_t;
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+
+    const auto type = static_cast<std::size_t>(j.type());
+    switch (j.type())
+    {
+        case BasicJsonType::value_t::null:
+        case BasicJsonType::value_t::discarded:
+        {
+            return combine(type, 0);
+        }
+
+        case BasicJsonType::value_t::object:
+        {
+            auto seed = combine(type, j.size());
+            for (const auto& element : j.items())
+            {
+                const auto h = std::hash<string_t> {}(element.key());
+                seed = combine(seed, h);
+                seed = combine(seed, hash(element.value()));
+            }
+            return seed;
+        }
+
+        case BasicJsonType::value_t::array:
+        {
+            auto seed = combine(type, j.size());
+            for (const auto& element : j)
+            {
+                seed = combine(seed, hash(element));
+            }
+            return seed;
+        }
+
+        case BasicJsonType::value_t::string:
+        {
+            const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::boolean:
+        {
+            const auto h = std::hash<bool> {}(j.template get<bool>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_integer:
+        {
+            const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_unsigned:
+        {
+            const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_float:
+        {
+            const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::binary:
+        {
+            auto seed = combine(type, j.get_binary().size());
+            const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
+            seed = combine(seed, h);
+            seed = combine(seed, static_cast<std::size_t>(j.get_binary().subtype()));
+            for (const auto byte : j.get_binary())
+            {
+                seed = combine(seed, std::hash<std::uint8_t> {}(byte));
+            }
+            return seed;
+        }
+
+        default:                   // LCOV_EXCL_LINE
+            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+            return 0;              // LCOV_EXCL_LINE
+    }
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/input/binary_reader.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // generate_n
+#include <array> // array
+#include <cmath> // ldexp
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstdio> // snprintf
+#include <cstring> // memcpy
+#include <iterator> // back_inserter
+#include <limits> // numeric_limits
+#include <string> // char_traits, string
+#include <utility> // make_pair, move
+#include <vector> // vector
+#ifdef __cpp_lib_byteswap
+    #include <bit>  //byteswap
+#endif
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <cstring> // strlen
+#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
+#include <memory> // shared_ptr, make_shared, addressof
+#include <numeric> // accumulate
+#include <streambuf> // streambuf
+#include <string> // string, char_traits
+#include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
+#include <utility> // pair, declval
+
+#ifndef JSON_NO_IO
+    #include <cstdio>   // FILE *
+    #include <istream>  // istream
+#endif                  // JSON_NO_IO
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/iterators/iterator_traits.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// the supported input formats
+enum class input_format_t { json, cbor, msgpack, ubjson, bson, bjdata };
+
+////////////////////
+// input adapters //
+////////////////////
+
+#ifndef JSON_NO_IO
+/*!
+Input adapter for stdio file access. This adapter read only 1 byte and do not use any
+ buffer. This adapter is a very low level adapter.
+*/
+class file_input_adapter
+{
+  public:
+    using char_type = char;
+
+    JSON_HEDLEY_NON_NULL(2)
+    explicit file_input_adapter(std::FILE* f) noexcept
+        : m_file(f)
+    {
+        JSON_ASSERT(m_file != nullptr);
+    }
+
+    // make class move-only
+    file_input_adapter(const file_input_adapter&) = delete;
+    file_input_adapter(file_input_adapter&&) noexcept = default;
+    file_input_adapter& operator=(const file_input_adapter&) = delete;
+    file_input_adapter& operator=(file_input_adapter&&) = delete;
+    ~file_input_adapter() = default;
+
+    std::char_traits<char>::int_type get_character() noexcept
+    {
+        return std::fgetc(m_file);
+    }
+
+    // returns the number of characters successfully read
+    template<class T>
+    std::size_t get_elements(T* dest, std::size_t count = 1)
+    {
+        return fread(dest, 1, sizeof(T) * count, m_file);
+    }
+
+  private:
+    /// the file pointer to read from
+    std::FILE* m_file;
+};
+
+/*!
+Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
+beginning of input. Does not support changing the underlying std::streambuf
+in mid-input. Maintains underlying std::istream and std::streambuf to support
+subsequent use of standard std::istream operations to process any input
+characters following those used in parsing the JSON input.  Clears the
+std::istream flags; any input errors (e.g., EOF) will be detected by the first
+subsequent call for input from the std::istream.
+*/
+class input_stream_adapter
+{
+  public:
+    using char_type = char;
+
+    ~input_stream_adapter()
+    {
+        // clear stream flags; we use underlying streambuf I/O, do not
+        // maintain ifstream flags, except eof
+        if (is != nullptr)
+        {
+            is->clear(is->rdstate() & std::ios::eofbit);
+        }
+    }
+
+    explicit input_stream_adapter(std::istream& i)
+        : is(&i), sb(i.rdbuf())
+    {}
+
+    // deleted because of pointer members
+    input_stream_adapter(const input_stream_adapter&) = delete;
+    input_stream_adapter& operator=(input_stream_adapter&) = delete;
+    input_stream_adapter& operator=(input_stream_adapter&&) = delete;
+
+    input_stream_adapter(input_stream_adapter&& rhs) noexcept
+        : is(rhs.is), sb(rhs.sb)
+    {
+        rhs.is = nullptr;
+        rhs.sb = nullptr;
+    }
+
+    // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
+    // ensure that std::char_traits<char>::eof() and the character 0xFF do not
+    // end up as the same value, e.g., 0xFFFFFFFF.
+    std::char_traits<char>::int_type get_character()
+    {
+        auto res = sb->sbumpc();
+        // set eof manually, as we don't use the istream interface.
+        if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
+        {
+            is->clear(is->rdstate() | std::ios::eofbit);
+        }
+        return res;
+    }
+
+    template<class T>
+    std::size_t get_elements(T* dest, std::size_t count = 1)
+    {
+        auto res = static_cast<std::size_t>(sb->sgetn(reinterpret_cast<char*>(dest), static_cast<std::streamsize>(count * sizeof(T))));
+        if (JSON_HEDLEY_UNLIKELY(res < count * sizeof(T)))
+        {
+            is->clear(is->rdstate() | std::ios::eofbit);
+        }
+        return res;
+    }
+
+  private:
+    /// the associated input stream
+    std::istream* is = nullptr;
+    std::streambuf* sb = nullptr;
+};
+#endif  // JSON_NO_IO
+
+// General-purpose iterator-based adapter. It might not be as fast as
+// theoretically possible for some containers, but it is extremely versatile.
+template<typename IteratorType>
+class iterator_input_adapter
+{
+  public:
+    using char_type = typename std::iterator_traits<IteratorType>::value_type;
+
+    iterator_input_adapter(IteratorType first, IteratorType last)
+        : current(std::move(first)), end(std::move(last))
+    {}
+
+    typename char_traits<char_type>::int_type get_character()
+    {
+        if (JSON_HEDLEY_LIKELY(current != end))
+        {
+            auto result = char_traits<char_type>::to_int_type(*current);
+            std::advance(current, 1);
+            return result;
+        }
+
+        return char_traits<char_type>::eof();
+    }
+
+    // for general iterators, we cannot really do something better than falling back to processing the range one-by-one
+    template<class T>
+    std::size_t get_elements(T* dest, std::size_t count = 1)
+    {
+        auto* ptr = reinterpret_cast<char*>(dest);
+        for (std::size_t read_index = 0; read_index < count * sizeof(T); ++read_index)
+        {
+            if (JSON_HEDLEY_LIKELY(current != end))
+            {
+                ptr[read_index] = static_cast<char>(*current);
+                std::advance(current, 1);
+            }
+            else
+            {
+                return read_index;
+            }
+        }
+        return count * sizeof(T);
+    }
+
+  private:
+    IteratorType current;
+    IteratorType end;
+
+    template<typename BaseInputAdapter, size_t T>
+    friend struct wide_string_input_helper;
+
+    bool empty() const
+    {
+        return current == end;
+    }
+};
+
+template<typename BaseInputAdapter, size_t T>
+struct wide_string_input_helper;
+
+template<typename BaseInputAdapter>
+struct wide_string_input_helper<BaseInputAdapter, 4>
+{
+    // UTF-32
+    static void fill_buffer(BaseInputAdapter& input,
+                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+                            size_t& utf8_bytes_index,
+                            size_t& utf8_bytes_filled)
+    {
+        utf8_bytes_index = 0;
+
+        if (JSON_HEDLEY_UNLIKELY(input.empty()))
+        {
+            utf8_bytes[0] = std::char_traits<char>::eof();
+            utf8_bytes_filled = 1;
+        }
+        else
+        {
+            // get the current character
+            const auto wc = input.get_character();
+
+            // UTF-32 to UTF-8 encoding
+            if (wc < 0x80)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+            else if (wc <= 0x7FF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 2;
+            }
+            else if (wc <= 0xFFFF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 3;
+            }
+            else if (wc <= 0x10FFFF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((static_cast<unsigned int>(wc) >> 18u) & 0x07u));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 4;
+            }
+            else
+            {
+                // unknown character
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+        }
+    }
+};
+
+template<typename BaseInputAdapter>
+struct wide_string_input_helper<BaseInputAdapter, 2>
+{
+    // UTF-16
+    static void fill_buffer(BaseInputAdapter& input,
+                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+                            size_t& utf8_bytes_index,
+                            size_t& utf8_bytes_filled)
+    {
+        utf8_bytes_index = 0;
+
+        if (JSON_HEDLEY_UNLIKELY(input.empty()))
+        {
+            utf8_bytes[0] = std::char_traits<char>::eof();
+            utf8_bytes_filled = 1;
+        }
+        else
+        {
+            // get the current character
+            const auto wc = input.get_character();
+
+            // UTF-16 to UTF-8 encoding
+            if (wc < 0x80)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+            else if (wc <= 0x7FF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u)));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 2;
+            }
+            else if (0xD800 > wc || wc >= 0xE000)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 3;
+            }
+            else
+            {
+                if (JSON_HEDLEY_UNLIKELY(!input.empty()))
+                {
+                    const auto wc2 = static_cast<unsigned int>(input.get_character());
+                    const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
+                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
+                    utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
+                    utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
+                    utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
+                    utf8_bytes_filled = 4;
+                }
+                else
+                {
+                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                    utf8_bytes_filled = 1;
+                }
+            }
+        }
+    }
+};
+
+// Wraps another input adapter to convert wide character types into individual bytes.
+template<typename BaseInputAdapter, typename WideCharType>
+class wide_string_input_adapter
+{
+  public:
+    using char_type = char;
+
+    wide_string_input_adapter(BaseInputAdapter base)
+        : base_adapter(base) {}
+
+    typename std::char_traits<char>::int_type get_character() noexcept
+    {
+        // check if the buffer needs to be filled
+        if (utf8_bytes_index == utf8_bytes_filled)
+        {
+            fill_buffer<sizeof(WideCharType)>();
+
+            JSON_ASSERT(utf8_bytes_filled > 0);
+            JSON_ASSERT(utf8_bytes_index == 0);
+        }
+
+        // use buffer
+        JSON_ASSERT(utf8_bytes_filled > 0);
+        JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
+        return utf8_bytes[utf8_bytes_index++];
+    }
+
+    // parsing binary with wchar doesn't make sense, but since the parsing mode can be runtime, we need something here
+    template<class T>
+    std::size_t get_elements(T* /*dest*/, std::size_t /*count*/ = 1)
+    {
+        JSON_THROW(parse_error::create(112, 1, "wide string type cannot be interpreted as binary data", nullptr));
+    }
+
+  private:
+    BaseInputAdapter base_adapter;
+
+    template<size_t T>
+    void fill_buffer()
+    {
+        wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
+    }
+
+    /// a buffer for UTF-8 bytes
+    std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
+
+    /// index to the utf8_codes array for the next valid byte
+    std::size_t utf8_bytes_index = 0;
+    /// number of valid bytes in the utf8_codes array
+    std::size_t utf8_bytes_filled = 0;
+};
+
+template<typename IteratorType, typename Enable = void>
+struct iterator_input_adapter_factory
+{
+    using iterator_type = IteratorType;
+    using char_type = typename std::iterator_traits<iterator_type>::value_type;
+    using adapter_type = iterator_input_adapter<iterator_type>;
+
+    static adapter_type create(IteratorType first, IteratorType last)
+    {
+        return adapter_type(std::move(first), std::move(last));
+    }
+};
+
+template<typename T>
+struct is_iterator_of_multibyte
+{
+    using value_type = typename std::iterator_traits<T>::value_type;
+    enum // NOLINT(cppcoreguidelines-use-enum-class)
+    {
+        value = sizeof(value_type) > 1
+    };
+};
+
+template<typename IteratorType>
+struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
+{
+    using iterator_type = IteratorType;
+    using char_type = typename std::iterator_traits<iterator_type>::value_type;
+    using base_adapter_type = iterator_input_adapter<iterator_type>;
+    using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;
+
+    static adapter_type create(IteratorType first, IteratorType last)
+    {
+        return adapter_type(base_adapter_type(std::move(first), std::move(last)));
+    }
+};
+
+// General purpose iterator-based input
+template<typename IteratorType>
+typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)
+{
+    using factory_type = iterator_input_adapter_factory<IteratorType>;
+    return factory_type::create(first, last);
+}
+
+// Convenience shorthand from container to iterator
+// Enables ADL on begin(container) and end(container)
+// Encloses the using declarations in namespace for not to leak them to outside scope
+
+namespace container_input_adapter_factory_impl
+{
+
+using std::begin;
+using std::end;
+
+template<typename ContainerType, typename Enable = void>
+struct container_input_adapter_factory {};
+
+template<typename ContainerType>
+struct container_input_adapter_factory< ContainerType,
+       void_t<decltype(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>()))>>
+       {
+           using adapter_type = decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));
+
+           static adapter_type create(const ContainerType& container)
+{
+    return input_adapter(begin(container), end(container));
+}
+       };
+
+}  // namespace container_input_adapter_factory_impl
+
+template<typename ContainerType>
+typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(const ContainerType& container)
+{
+    return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(container);
+}
+
+// specialization for std::string
+using string_input_adapter_type = decltype(input_adapter(std::declval<std::string>()));
+
+#ifndef JSON_NO_IO
+// Special cases with fast paths
+inline file_input_adapter input_adapter(std::FILE* file)
+{
+    if (file == nullptr)
+    {
+        JSON_THROW(parse_error::create(101, 0, "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
+    }
+    return file_input_adapter(file);
+}
+
+inline input_stream_adapter input_adapter(std::istream& stream)
+{
+    return input_stream_adapter(stream);
+}
+
+inline input_stream_adapter input_adapter(std::istream&& stream)
+{
+    return input_stream_adapter(stream);
+}
+#endif  // JSON_NO_IO
+
+using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
+
+// Null-delimited strings, and the like.
+template < typename CharT,
+           typename std::enable_if <
+               std::is_pointer<CharT>::value&&
+               !std::is_array<CharT>::value&&
+               std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
+               sizeof(typename std::remove_pointer<CharT>::type) == 1,
+               int >::type = 0 >
+contiguous_bytes_input_adapter input_adapter(CharT b)
+{
+    if (b == nullptr)
+    {
+        JSON_THROW(parse_error::create(101, 0, "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
+    }
+    auto length = std::strlen(reinterpret_cast<const char*>(b));
+    const auto* ptr = reinterpret_cast<const char*>(b);
+    return input_adapter(ptr, ptr + length); // cppcheck-suppress[nullPointerArithmeticRedundantCheck]
+}
+
+template<typename T, std::size_t N>
+auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N)) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+{
+    return input_adapter(array, array + N);
+}
+
+// This class only handles inputs of input_buffer_adapter type.
+// It's required so that expressions like {ptr, len} can be implicitly cast
+// to the correct adapter.
+class span_input_adapter
+{
+  public:
+    template < typename CharT,
+               typename std::enable_if <
+                   std::is_pointer<CharT>::value&&
+                   std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
+                   sizeof(typename std::remove_pointer<CharT>::type) == 1,
+                   int >::type = 0 >
+    span_input_adapter(CharT b, std::size_t l)
+        : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
+
+    template<class IteratorType,
+             typename std::enable_if<
+                 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
+                 int>::type = 0>
+    span_input_adapter(IteratorType first, IteratorType last)
+        : ia(input_adapter(first, last)) {}
+
+    contiguous_bytes_input_adapter&& get()
+    {
+        return std::move(ia); // NOLINT(hicpp-move-const-arg,performance-move-const-arg)
+    }
+
+  private:
+    contiguous_bytes_input_adapter ia;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/input/json_sax.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef>
+#include <string> // string
+#include <type_traits> // enable_if_t
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/input/lexer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <clocale> // localeconv
+#include <cstddef> // size_t
+#include <cstdio> // snprintf
+#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
+#include <initializer_list> // initializer_list
+#include <string> // char_traits, string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/position_t.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+///////////
+// lexer //
+///////////
+
+template<typename BasicJsonType>
+class lexer_base
+{
+  public:
+    /// token types for the parser
+    enum class token_type
+    {
+        uninitialized,    ///< indicating the scanner is uninitialized
+        literal_true,     ///< the `true` literal
+        literal_false,    ///< the `false` literal
+        literal_null,     ///< the `null` literal
+        value_string,     ///< a string -- use get_string() for actual value
+        value_unsigned,   ///< an unsigned integer -- use get_number_unsigned() for actual value
+        value_integer,    ///< a signed integer -- use get_number_integer() for actual value
+        value_float,      ///< an floating point number -- use get_number_float() for actual value
+        begin_array,      ///< the character for array begin `[`
+        begin_object,     ///< the character for object begin `{`
+        end_array,        ///< the character for array end `]`
+        end_object,       ///< the character for object end `}`
+        name_separator,   ///< the name separator `:`
+        value_separator,  ///< the value separator `,`
+        parse_error,      ///< indicating a parse error
+        end_of_input,     ///< indicating the end of the input buffer
+        literal_or_value  ///< a literal or the begin of a value (only for diagnostics)
+    };
+
+    /// return name of values of type token_type (only used for errors)
+    JSON_HEDLEY_RETURNS_NON_NULL
+    JSON_HEDLEY_CONST
+    static const char* token_type_name(const token_type t) noexcept
+    {
+        switch (t)
+        {
+            case token_type::uninitialized:
+                return "<uninitialized>";
+            case token_type::literal_true:
+                return "true literal";
+            case token_type::literal_false:
+                return "false literal";
+            case token_type::literal_null:
+                return "null literal";
+            case token_type::value_string:
+                return "string literal";
+            case token_type::value_unsigned:
+            case token_type::value_integer:
+            case token_type::value_float:
+                return "number literal";
+            case token_type::begin_array:
+                return "'['";
+            case token_type::begin_object:
+                return "'{'";
+            case token_type::end_array:
+                return "']'";
+            case token_type::end_object:
+                return "'}'";
+            case token_type::name_separator:
+                return "':'";
+            case token_type::value_separator:
+                return "','";
+            case token_type::parse_error:
+                return "<parse error>";
+            case token_type::end_of_input:
+                return "end of input";
+            case token_type::literal_or_value:
+                return "'[', '{', or a literal";
+            // LCOV_EXCL_START
+            default: // catch non-enum values
+                return "unknown token";
+                // LCOV_EXCL_STOP
+        }
+    }
+};
+/*!
+@brief lexical analysis
+
+This class organizes the lexical analysis during JSON deserialization.
+*/
+template<typename BasicJsonType, typename InputAdapterType>
+class lexer : public lexer_base<BasicJsonType>
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using char_type = typename InputAdapterType::char_type;
+    using char_int_type = typename char_traits<char_type>::int_type;
+
+  public:
+    using token_type = typename lexer_base<BasicJsonType>::token_type;
+
+    explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
+        : ia(std::move(adapter))
+        , ignore_comments(ignore_comments_)
+        , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
+    {}
+
+    // deleted because of pointer members
+    lexer(const lexer&) = delete;
+    lexer(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    lexer& operator=(lexer&) = delete;
+    lexer& operator=(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~lexer() = default;
+
+  private:
+    /////////////////////
+    // locales
+    /////////////////////
+
+    /// return the locale-dependent decimal point
+    JSON_HEDLEY_PURE
+    static char get_decimal_point() noexcept
+    {
+        const auto* loc = localeconv();
+        JSON_ASSERT(loc != nullptr);
+        return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
+    }
+
+    /////////////////////
+    // scan functions
+    /////////////////////
+
+    /*!
+    @brief get codepoint from 4 hex characters following `\u`
+
+    For input "\u c1 c2 c3 c4" the codepoint is:
+      (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
+    = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)
+
+    Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'
+    must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The
+    conversion is done by subtracting the offset (0x30, 0x37, and 0x57)
+    between the ASCII value of the character and the desired integer value.
+
+    @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or
+            non-hex character)
+    */
+    int get_codepoint()
+    {
+        // this function only makes sense after reading `\u`
+        JSON_ASSERT(current == 'u');
+        int codepoint = 0;
+
+        const auto factors = { 12u, 8u, 4u, 0u };
+        for (const auto factor : factors)
+        {
+            get();
+
+            if (current >= '0' && current <= '9')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
+            }
+            else if (current >= 'A' && current <= 'F')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
+            }
+            else if (current >= 'a' && current <= 'f')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
+            }
+            else
+            {
+                return -1;
+            }
+        }
+
+        JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
+        return codepoint;
+    }
+
+    /*!
+    @brief check if the next byte(s) are inside a given range
+
+    Adds the current byte and, for each passed range, reads a new byte and
+    checks if it is inside the range. If a violation was detected, set up an
+    error message and return false. Otherwise, return true.
+
+    @param[in] ranges  list of integers; interpreted as list of pairs of
+                       inclusive lower and upper bound, respectively
+
+    @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,
+         1, 2, or 3 pairs. This precondition is enforced by an assertion.
+
+    @return true if and only if no range violation was detected
+    */
+    bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
+    {
+        JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
+        add(current);
+
+        for (auto range = ranges.begin(); range != ranges.end(); ++range)
+        {
+            get();
+            if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range))) // NOLINT(bugprone-inc-dec-in-conditions)
+            {
+                add(current);
+            }
+            else
+            {
+                error_message = "invalid string: ill-formed UTF-8 byte";
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief scan a string literal
+
+    This function scans a string according to Sect. 7 of RFC 8259. While
+    scanning, bytes are escaped and copied into buffer token_buffer. Then the
+    function returns successfully, token_buffer is *not* null-terminated (as it
+    may contain \0 bytes), and token_buffer.size() is the number of bytes in the
+    string.
+
+    @return token_type::value_string if string could be successfully scanned,
+            token_type::parse_error otherwise
+
+    @note In case of errors, variable error_message contains a textual
+          description.
+    */
+    token_type scan_string()
+    {
+        // reset token_buffer (ignore opening quote)
+        reset();
+
+        // we entered the function by reading an open quote
+        JSON_ASSERT(current == '\"');
+
+        while (true)
+        {
+            // get the next character
+            switch (get())
+            {
+                // end of file while parsing the string
+                case char_traits<char_type>::eof():
+                {
+                    error_message = "invalid string: missing closing quote";
+                    return token_type::parse_error;
+                }
+
+                // closing quote
+                case '\"':
+                {
+                    return token_type::value_string;
+                }
+
+                // escapes
+                case '\\':
+                {
+                    switch (get())
+                    {
+                        // quotation mark
+                        case '\"':
+                            add('\"');
+                            break;
+                        // reverse solidus
+                        case '\\':
+                            add('\\');
+                            break;
+                        // solidus
+                        case '/':
+                            add('/');
+                            break;
+                        // backspace
+                        case 'b':
+                            add('\b');
+                            break;
+                        // form feed
+                        case 'f':
+                            add('\f');
+                            break;
+                        // line feed
+                        case 'n':
+                            add('\n');
+                            break;
+                        // carriage return
+                        case 'r':
+                            add('\r');
+                            break;
+                        // tab
+                        case 't':
+                            add('\t');
+                            break;
+
+                        // unicode escapes
+                        case 'u':
+                        {
+                            const int codepoint1 = get_codepoint();
+                            int codepoint = codepoint1; // start with codepoint1
+
+                            if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
+                            {
+                                error_message = "invalid string: '\\u' must be followed by 4 hex digits";
+                                return token_type::parse_error;
+                            }
+
+                            // check if code point is a high surrogate
+                            if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
+                            {
+                                // expect next \uxxxx entry
+                                if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
+                                {
+                                    const int codepoint2 = get_codepoint();
+
+                                    if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
+                                    {
+                                        error_message = "invalid string: '\\u' must be followed by 4 hex digits";
+                                        return token_type::parse_error;
+                                    }
+
+                                    // check if codepoint2 is a low surrogate
+                                    if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
+                                    {
+                                        // overwrite codepoint
+                                        codepoint = static_cast<int>(
+                                                        // high surrogate occupies the most significant 22 bits
+                                                        (static_cast<unsigned int>(codepoint1) << 10u)
+                                                        // low surrogate occupies the least significant 15 bits
+                                                        + static_cast<unsigned int>(codepoint2)
+                                                        // there is still the 0xD800, 0xDC00, and 0x10000 noise
+                                                        // in the result, so we have to subtract with:
+                                                        // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
+                                                        - 0x35FDC00u);
+                                    }
+                                    else
+                                    {
+                                        error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
+                                        return token_type::parse_error;
+                                    }
+                                }
+                                else
+                                {
+                                    error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
+                                    return token_type::parse_error;
+                                }
+                            }
+                            else
+                            {
+                                if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
+                                {
+                                    error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
+                                    return token_type::parse_error;
+                                }
+                            }
+
+                            // the result of the above calculation yields a proper codepoint
+                            JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
+
+                            // translate codepoint into bytes
+                            if (codepoint < 0x80)
+                            {
+                                // 1-byte characters: 0xxxxxxx (ASCII)
+                                add(static_cast<char_int_type>(codepoint));
+                            }
+                            else if (codepoint <= 0x7FF)
+                            {
+                                // 2-byte characters: 110xxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+                            else if (codepoint <= 0xFFFF)
+                            {
+                                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+                            else
+                            {
+                                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+
+                            break;
+                        }
+
+                        // other characters after escape
+                        default:
+                            error_message = "invalid string: forbidden character after backslash";
+                            return token_type::parse_error;
+                    }
+
+                    break;
+                }
+
+                // invalid control characters
+                case 0x00:
+                {
+                    error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
+                    return token_type::parse_error;
+                }
+
+                case 0x01:
+                {
+                    error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
+                    return token_type::parse_error;
+                }
+
+                case 0x02:
+                {
+                    error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
+                    return token_type::parse_error;
+                }
+
+                case 0x03:
+                {
+                    error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
+                    return token_type::parse_error;
+                }
+
+                case 0x04:
+                {
+                    error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
+                    return token_type::parse_error;
+                }
+
+                case 0x05:
+                {
+                    error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
+                    return token_type::parse_error;
+                }
+
+                case 0x06:
+                {
+                    error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
+                    return token_type::parse_error;
+                }
+
+                case 0x07:
+                {
+                    error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
+                    return token_type::parse_error;
+                }
+
+                case 0x08:
+                {
+                    error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
+                    return token_type::parse_error;
+                }
+
+                case 0x09:
+                {
+                    error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
+                    return token_type::parse_error;
+                }
+
+                case 0x0A:
+                {
+                    error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
+                    return token_type::parse_error;
+                }
+
+                case 0x0B:
+                {
+                    error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
+                    return token_type::parse_error;
+                }
+
+                case 0x0C:
+                {
+                    error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
+                    return token_type::parse_error;
+                }
+
+                case 0x0D:
+                {
+                    error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
+                    return token_type::parse_error;
+                }
+
+                case 0x0E:
+                {
+                    error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
+                    return token_type::parse_error;
+                }
+
+                case 0x0F:
+                {
+                    error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
+                    return token_type::parse_error;
+                }
+
+                case 0x10:
+                {
+                    error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
+                    return token_type::parse_error;
+                }
+
+                case 0x11:
+                {
+                    error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
+                    return token_type::parse_error;
+                }
+
+                case 0x12:
+                {
+                    error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
+                    return token_type::parse_error;
+                }
+
+                case 0x13:
+                {
+                    error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
+                    return token_type::parse_error;
+                }
+
+                case 0x14:
+                {
+                    error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
+                    return token_type::parse_error;
+                }
+
+                case 0x15:
+                {
+                    error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
+                    return token_type::parse_error;
+                }
+
+                case 0x16:
+                {
+                    error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
+                    return token_type::parse_error;
+                }
+
+                case 0x17:
+                {
+                    error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
+                    return token_type::parse_error;
+                }
+
+                case 0x18:
+                {
+                    error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
+                    return token_type::parse_error;
+                }
+
+                case 0x19:
+                {
+                    error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
+                    return token_type::parse_error;
+                }
+
+                case 0x1A:
+                {
+                    error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
+                    return token_type::parse_error;
+                }
+
+                case 0x1B:
+                {
+                    error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
+                    return token_type::parse_error;
+                }
+
+                case 0x1C:
+                {
+                    error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
+                    return token_type::parse_error;
+                }
+
+                case 0x1D:
+                {
+                    error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
+                    return token_type::parse_error;
+                }
+
+                case 0x1E:
+                {
+                    error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
+                    return token_type::parse_error;
+                }
+
+                case 0x1F:
+                {
+                    error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
+                    return token_type::parse_error;
+                }
+
+                // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
+                case 0x20:
+                case 0x21:
+                case 0x23:
+                case 0x24:
+                case 0x25:
+                case 0x26:
+                case 0x27:
+                case 0x28:
+                case 0x29:
+                case 0x2A:
+                case 0x2B:
+                case 0x2C:
+                case 0x2D:
+                case 0x2E:
+                case 0x2F:
+                case 0x30:
+                case 0x31:
+                case 0x32:
+                case 0x33:
+                case 0x34:
+                case 0x35:
+                case 0x36:
+                case 0x37:
+                case 0x38:
+                case 0x39:
+                case 0x3A:
+                case 0x3B:
+                case 0x3C:
+                case 0x3D:
+                case 0x3E:
+                case 0x3F:
+                case 0x40:
+                case 0x41:
+                case 0x42:
+                case 0x43:
+                case 0x44:
+                case 0x45:
+                case 0x46:
+                case 0x47:
+                case 0x48:
+                case 0x49:
+                case 0x4A:
+                case 0x4B:
+                case 0x4C:
+                case 0x4D:
+                case 0x4E:
+                case 0x4F:
+                case 0x50:
+                case 0x51:
+                case 0x52:
+                case 0x53:
+                case 0x54:
+                case 0x55:
+                case 0x56:
+                case 0x57:
+                case 0x58:
+                case 0x59:
+                case 0x5A:
+                case 0x5B:
+                case 0x5D:
+                case 0x5E:
+                case 0x5F:
+                case 0x60:
+                case 0x61:
+                case 0x62:
+                case 0x63:
+                case 0x64:
+                case 0x65:
+                case 0x66:
+                case 0x67:
+                case 0x68:
+                case 0x69:
+                case 0x6A:
+                case 0x6B:
+                case 0x6C:
+                case 0x6D:
+                case 0x6E:
+                case 0x6F:
+                case 0x70:
+                case 0x71:
+                case 0x72:
+                case 0x73:
+                case 0x74:
+                case 0x75:
+                case 0x76:
+                case 0x77:
+                case 0x78:
+                case 0x79:
+                case 0x7A:
+                case 0x7B:
+                case 0x7C:
+                case 0x7D:
+                case 0x7E:
+                case 0x7F:
+                {
+                    add(current);
+                    break;
+                }
+
+                // U+0080..U+07FF: bytes C2..DF 80..BF
+                case 0xC2:
+                case 0xC3:
+                case 0xC4:
+                case 0xC5:
+                case 0xC6:
+                case 0xC7:
+                case 0xC8:
+                case 0xC9:
+                case 0xCA:
+                case 0xCB:
+                case 0xCC:
+                case 0xCD:
+                case 0xCE:
+                case 0xCF:
+                case 0xD0:
+                case 0xD1:
+                case 0xD2:
+                case 0xD3:
+                case 0xD4:
+                case 0xD5:
+                case 0xD6:
+                case 0xD7:
+                case 0xD8:
+                case 0xD9:
+                case 0xDA:
+                case 0xDB:
+                case 0xDC:
+                case 0xDD:
+                case 0xDE:
+                case 0xDF:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
+                case 0xE0:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
+                // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
+                case 0xE1:
+                case 0xE2:
+                case 0xE3:
+                case 0xE4:
+                case 0xE5:
+                case 0xE6:
+                case 0xE7:
+                case 0xE8:
+                case 0xE9:
+                case 0xEA:
+                case 0xEB:
+                case 0xEC:
+                case 0xEE:
+                case 0xEF:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+D000..U+D7FF: bytes ED 80..9F 80..BF
+                case 0xED:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
+                case 0xF0:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
+                case 0xF1:
+                case 0xF2:
+                case 0xF3:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
+                case 0xF4:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // the remaining bytes (80..C1 and F5..FF) are ill-formed
+                default:
+                {
+                    error_message = "invalid string: ill-formed UTF-8 byte";
+                    return token_type::parse_error;
+                }
+            }
+        }
+    }
+
+    /*!
+     * @brief scan a comment
+     * @return whether comment could be scanned successfully
+     */
+    bool scan_comment()
+    {
+        switch (get())
+        {
+            // single-line comments skip input until a newline or EOF is read
+            case '/':
+            {
+                while (true)
+                {
+                    switch (get())
+                    {
+                        case '\n':
+                        case '\r':
+                        case char_traits<char_type>::eof():
+                        case '\0':
+                            return true;
+
+                        default:
+                            break;
+                    }
+                }
+            }
+
+            // multi-line comments skip input until */ is read
+            case '*':
+            {
+                while (true)
+                {
+                    switch (get())
+                    {
+                        case char_traits<char_type>::eof():
+                        case '\0':
+                        {
+                            error_message = "invalid comment; missing closing '*/'";
+                            return false;
+                        }
+
+                        case '*':
+                        {
+                            switch (get())
+                            {
+                                case '/':
+                                    return true;
+
+                                default:
+                                {
+                                    unget();
+                                    continue;
+                                }
+                            }
+                        }
+
+                        default:
+                            continue;
+                    }
+                }
+            }
+
+            // unexpected character after reading '/'
+            default:
+            {
+                error_message = "invalid comment; expecting '/' or '*' after '/'";
+                return false;
+            }
+        }
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(float& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtof(str, endptr);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtod(str, endptr);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(long double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtold(str, endptr);
+    }
+
+    /*!
+    @brief scan a number literal
+
+    This function scans a string according to Sect. 6 of RFC 8259.
+
+    The function is realized with a deterministic finite state machine derived
+    from the grammar described in RFC 8259. Starting in state "init", the
+    input is read and used to determined the next state. Only state "done"
+    accepts the number. State "error" is a trap state to model errors. In the
+    table below, "anything" means any character but the ones listed before.
+
+    state    | 0        | 1-9      | e E      | +       | -       | .        | anything
+    ---------|----------|----------|----------|---------|---------|----------|-----------
+    init     | zero     | any1     | [error]  | [error] | minus   | [error]  | [error]
+    minus    | zero     | any1     | [error]  | [error] | [error] | [error]  | [error]
+    zero     | done     | done     | exponent | done    | done    | decimal1 | done
+    any1     | any1     | any1     | exponent | done    | done    | decimal1 | done
+    decimal1 | decimal2 | decimal2 | [error]  | [error] | [error] | [error]  | [error]
+    decimal2 | decimal2 | decimal2 | exponent | done    | done    | done     | done
+    exponent | any2     | any2     | [error]  | sign    | sign    | [error]  | [error]
+    sign     | any2     | any2     | [error]  | [error] | [error] | [error]  | [error]
+    any2     | any2     | any2     | done     | done    | done    | done     | done
+
+    The state machine is realized with one label per state (prefixed with
+    "scan_number_") and `goto` statements between them. The state machine
+    contains cycles, but any cycle can be left when EOF is read. Therefore,
+    the function is guaranteed to terminate.
+
+    During scanning, the read bytes are stored in token_buffer. This string is
+    then converted to a signed integer, an unsigned integer, or a
+    floating-point number.
+
+    @return token_type::value_unsigned, token_type::value_integer, or
+            token_type::value_float if number could be successfully scanned,
+            token_type::parse_error otherwise
+
+    @note The scanner is independent of the current locale. Internally, the
+          locale's decimal point is used instead of `.` to work with the
+          locale-dependent converters.
+    */
+    token_type scan_number()  // lgtm [cpp/use-of-goto] `goto` is used in this function to implement the number-parsing state machine described above. By design, any finite input will eventually reach the "done" state or return token_type::parse_error. In each intermediate state, 1 byte of the input is appended to the token_buffer vector, and only the already initialized variables token_buffer, number_type, and error_message are manipulated.
+    {
+        // reset token_buffer to store the number's bytes
+        reset();
+
+        // the type of the parsed number; initially set to unsigned; will be
+        // changed if minus sign, decimal point, or exponent is read
+        token_type number_type = token_type::value_unsigned;
+
+        // state (init): we just found out we need to scan a number
+        switch (current)
+        {
+            case '-':
+            {
+                add(current);
+                goto scan_number_minus;
+            }
+
+            case '0':
+            {
+                add(current);
+                goto scan_number_zero;
+            }
+
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            // all other characters are rejected outside scan_number()
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+
+scan_number_minus:
+        // state: we just parsed a leading minus sign
+        number_type = token_type::value_integer;
+        switch (get())
+        {
+            case '0':
+            {
+                add(current);
+                goto scan_number_zero;
+            }
+
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after '-'";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_zero:
+        // state: we just parse a zero (maybe with a leading minus sign)
+        switch (get())
+        {
+            case '.':
+            {
+                add(decimal_point_char);
+                decimal_point_position = token_buffer.size() - 1;
+                goto scan_number_decimal1;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_any1:
+        // state: we just parsed a number 0-9 (maybe with a leading minus sign)
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            case '.':
+            {
+                add(decimal_point_char);
+                decimal_point_position = token_buffer.size() - 1;
+                goto scan_number_decimal1;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_decimal1:
+        // state: we just parsed a decimal point
+        number_type = token_type::value_float;
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_decimal2;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after '.'";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_decimal2:
+        // we just parsed at least one number after a decimal point
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_decimal2;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_exponent:
+        // we just parsed an exponent
+        number_type = token_type::value_float;
+        switch (get())
+        {
+            case '+':
+            case '-':
+            {
+                add(current);
+                goto scan_number_sign;
+            }
+
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+            {
+                error_message =
+                    "invalid number; expected '+', '-', or digit after exponent";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_sign:
+        // we just parsed an exponent sign
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after exponent sign";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_any2:
+        // we just parsed a number after the exponent or exponent sign
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_done:
+        // unget the character after the number (we only read it to know that
+        // we are done scanning a number)
+        unget();
+
+        char* endptr = nullptr; // NOLINT(misc-const-correctness,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        errno = 0;
+
+        // try to parse integers first and fall back to floats
+        if (number_type == token_type::value_unsigned)
+        {
+            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno != ERANGE)
+            {
+                value_unsigned = static_cast<number_unsigned_t>(x);
+                if (value_unsigned == x)
+                {
+                    return token_type::value_unsigned;
+                }
+            }
+        }
+        else if (number_type == token_type::value_integer)
+        {
+            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno != ERANGE)
+            {
+                value_integer = static_cast<number_integer_t>(x);
+                if (value_integer == x)
+                {
+                    return token_type::value_integer;
+                }
+            }
+        }
+
+        // this code is reached if we parse a floating-point number or if an
+        // integer conversion above failed
+        strtof(value_float, token_buffer.data(), &endptr);
+
+        // we checked the number format before
+        JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+        return token_type::value_float;
+    }
+
+    /*!
+    @param[in] literal_text  the literal text to expect
+    @param[in] length        the length of the passed literal text
+    @param[in] return_type   the token type to return on success
+    */
+    JSON_HEDLEY_NON_NULL(2)
+    token_type scan_literal(const char_type* literal_text, const std::size_t length,
+                            token_type return_type)
+    {
+        JSON_ASSERT(char_traits<char_type>::to_char_type(current) == literal_text[0]);
+        for (std::size_t i = 1; i < length; ++i)
+        {
+            if (JSON_HEDLEY_UNLIKELY(char_traits<char_type>::to_char_type(get()) != literal_text[i]))
+            {
+                error_message = "invalid literal";
+                return token_type::parse_error;
+            }
+        }
+        return return_type;
+    }
+
+    /////////////////////
+    // input management
+    /////////////////////
+
+    /// reset token_buffer; current character is beginning of token
+    void reset() noexcept
+    {
+        token_buffer.clear();
+        token_string.clear();
+        decimal_point_position = std::string::npos;
+        token_string.push_back(char_traits<char_type>::to_char_type(current));
+    }
+
+    /*
+    @brief get next character from the input
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns a
+    `char_traits<char>::eof()` in that case.  Stores the scanned characters
+    for use in error messages.
+
+    @return character read from the input
+    */
+    char_int_type get()
+    {
+        ++position.chars_read_total;
+        ++position.chars_read_current_line;
+
+        if (next_unget)
+        {
+            // only reset the next_unget variable and work with current
+            next_unget = false;
+        }
+        else
+        {
+            current = ia.get_character();
+        }
+
+        if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
+        {
+            token_string.push_back(char_traits<char_type>::to_char_type(current));
+        }
+
+        if (current == '\n')
+        {
+            ++position.lines_read;
+            position.chars_read_current_line = 0;
+        }
+
+        return current;
+    }
+
+    /*!
+    @brief unget current character (read it again on next get)
+
+    We implement unget by setting variable next_unget to true. The input is not
+    changed - we just simulate ungetting by modifying chars_read_total,
+    chars_read_current_line, and token_string. The next call to get() will
+    behave as if the unget character is read again.
+    */
+    void unget()
+    {
+        next_unget = true;
+
+        --position.chars_read_total;
+
+        // in case we "unget" a newline, we have to also decrement the lines_read
+        if (position.chars_read_current_line == 0)
+        {
+            if (position.lines_read > 0)
+            {
+                --position.lines_read;
+            }
+        }
+        else
+        {
+            --position.chars_read_current_line;
+        }
+
+        if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
+        {
+            JSON_ASSERT(!token_string.empty());
+            token_string.pop_back();
+        }
+    }
+
+    /// add a character to token_buffer
+    void add(char_int_type c)
+    {
+        token_buffer.push_back(static_cast<typename string_t::value_type>(c));
+    }
+
+  public:
+    /////////////////////
+    // value getters
+    /////////////////////
+
+    /// return integer value
+    constexpr number_integer_t get_number_integer() const noexcept
+    {
+        return value_integer;
+    }
+
+    /// return unsigned integer value
+    constexpr number_unsigned_t get_number_unsigned() const noexcept
+    {
+        return value_unsigned;
+    }
+
+    /// return floating-point value
+    constexpr number_float_t get_number_float() const noexcept
+    {
+        return value_float;
+    }
+
+    /// return current string value (implicitly resets the token; useful only once)
+    string_t& get_string()
+    {
+        // translate decimal points from locale back to '.' (#4084)
+        if (decimal_point_char != '.' && decimal_point_position != std::string::npos)
+        {
+            token_buffer[decimal_point_position] = '.';
+        }
+        return token_buffer;
+    }
+
+    /////////////////////
+    // diagnostics
+    /////////////////////
+
+    /// return position of last read token
+    constexpr position_t get_position() const noexcept
+    {
+        return position;
+    }
+
+    /// return the last read token (for errors only).  Will never contain EOF
+    /// (an arbitrary value that is not a valid char value, often -1), because
+    /// 255 may legitimately occur.  May contain NUL, which should be escaped.
+    std::string get_token_string() const
+    {
+        // escape control characters
+        std::string result;
+        for (const auto c : token_string)
+        {
+            if (static_cast<unsigned char>(c) <= '\x1F')
+            {
+                // escape control characters
+                std::array<char, 9> cs{{}};
+                static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                result += cs.data();
+            }
+            else
+            {
+                // add character as is
+                result.push_back(static_cast<std::string::value_type>(c));
+            }
+        }
+
+        return result;
+    }
+
+    /// return syntax error message
+    JSON_HEDLEY_RETURNS_NON_NULL
+    constexpr const char* get_error_message() const noexcept
+    {
+        return error_message;
+    }
+
+    /////////////////////
+    // actual scanner
+    /////////////////////
+
+    /*!
+    @brief skip the UTF-8 byte order mark
+    @return true iff there is no BOM or the correct BOM has been skipped
+    */
+    bool skip_bom()
+    {
+        if (get() == 0xEF)
+        {
+            // check if we completely parse the BOM
+            return get() == 0xBB && get() == 0xBF;
+        }
+
+        // the first character is not the beginning of the BOM; unget it to
+        // process is later
+        unget();
+        return true;
+    }
+
+    void skip_whitespace()
+    {
+        do
+        {
+            get();
+        }
+        while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
+    }
+
+    token_type scan()
+    {
+        // initially, skip the BOM
+        if (position.chars_read_total == 0 && !skip_bom())
+        {
+            error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
+            return token_type::parse_error;
+        }
+
+        // read the next character and ignore whitespace
+        skip_whitespace();
+
+        // ignore comments
+        while (ignore_comments && current == '/')
+        {
+            if (!scan_comment())
+            {
+                return token_type::parse_error;
+            }
+
+            // skip following whitespace
+            skip_whitespace();
+        }
+
+        switch (current)
+        {
+            // structural characters
+            case '[':
+                return token_type::begin_array;
+            case ']':
+                return token_type::end_array;
+            case '{':
+                return token_type::begin_object;
+            case '}':
+                return token_type::end_object;
+            case ':':
+                return token_type::name_separator;
+            case ',':
+                return token_type::value_separator;
+
+            // literals
+            case 't':
+            {
+                std::array<char_type, 4> true_literal = {{static_cast<char_type>('t'), static_cast<char_type>('r'), static_cast<char_type>('u'), static_cast<char_type>('e')}};
+                return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
+            }
+            case 'f':
+            {
+                std::array<char_type, 5> false_literal = {{static_cast<char_type>('f'), static_cast<char_type>('a'), static_cast<char_type>('l'), static_cast<char_type>('s'), static_cast<char_type>('e')}};
+                return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
+            }
+            case 'n':
+            {
+                std::array<char_type, 4> null_literal = {{static_cast<char_type>('n'), static_cast<char_type>('u'), static_cast<char_type>('l'), static_cast<char_type>('l')}};
+                return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
+            }
+
+            // string
+            case '\"':
+                return scan_string();
+
+            // number
+            case '-':
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+                return scan_number();
+
+            // end of input (the null byte is needed when parsing from
+            // string literals)
+            case '\0':
+            case char_traits<char_type>::eof():
+                return token_type::end_of_input;
+
+            // error
+            default:
+                error_message = "invalid literal";
+                return token_type::parse_error;
+        }
+    }
+
+  private:
+    /// input adapter
+    InputAdapterType ia;
+
+    /// whether comments should be ignored (true) or signaled as errors (false)
+    const bool ignore_comments = false;
+
+    /// the current character
+    char_int_type current = char_traits<char_type>::eof();
+
+    /// whether the next get() call should just return current
+    bool next_unget = false;
+
+    /// the start position of the current token
+    position_t position {};
+
+    /// raw input token string (for error messages)
+    std::vector<char_type> token_string {};
+
+    /// buffer for variable-length tokens (numbers, strings)
+    string_t token_buffer {};
+
+    /// a description of occurred lexer errors
+    const char* error_message = "";
+
+    // number values
+    number_integer_t value_integer = 0;
+    number_unsigned_t value_unsigned = 0;
+    number_float_t value_float = 0;
+
+    /// the decimal point
+    const char_int_type decimal_point_char = '.';
+    /// the position of the decimal point in the input
+    std::size_t decimal_point_position = std::string::npos;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/*!
+@brief SAX interface
+
+This class describes the SAX interface used by @ref nlohmann::json::sax_parse.
+Each function is called in different situations while the input is parsed. The
+boolean return value informs the parser whether to continue processing the
+input.
+*/
+template<typename BasicJsonType>
+struct json_sax
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    /*!
+    @brief a null value was read
+    @return whether parsing should proceed
+    */
+    virtual bool null() = 0;
+
+    /*!
+    @brief a boolean value was read
+    @param[in] val  boolean value
+    @return whether parsing should proceed
+    */
+    virtual bool boolean(bool val) = 0;
+
+    /*!
+    @brief an integer number was read
+    @param[in] val  integer value
+    @return whether parsing should proceed
+    */
+    virtual bool number_integer(number_integer_t val) = 0;
+
+    /*!
+    @brief an unsigned integer number was read
+    @param[in] val  unsigned integer value
+    @return whether parsing should proceed
+    */
+    virtual bool number_unsigned(number_unsigned_t val) = 0;
+
+    /*!
+    @brief a floating-point number was read
+    @param[in] val  floating-point value
+    @param[in] s    raw token value
+    @return whether parsing should proceed
+    */
+    virtual bool number_float(number_float_t val, const string_t& s) = 0;
+
+    /*!
+    @brief a string value was read
+    @param[in] val  string value
+    @return whether parsing should proceed
+    @note It is safe to move the passed string value.
+    */
+    virtual bool string(string_t& val) = 0;
+
+    /*!
+    @brief a binary value was read
+    @param[in] val  binary value
+    @return whether parsing should proceed
+    @note It is safe to move the passed binary value.
+    */
+    virtual bool binary(binary_t& val) = 0;
+
+    /*!
+    @brief the beginning of an object was read
+    @param[in] elements  number of object elements or -1 if unknown
+    @return whether parsing should proceed
+    @note binary formats may report the number of elements
+    */
+    virtual bool start_object(std::size_t elements) = 0;
+
+    /*!
+    @brief an object key was read
+    @param[in] val  object key
+    @return whether parsing should proceed
+    @note It is safe to move the passed string.
+    */
+    virtual bool key(string_t& val) = 0;
+
+    /*!
+    @brief the end of an object was read
+    @return whether parsing should proceed
+    */
+    virtual bool end_object() = 0;
+
+    /*!
+    @brief the beginning of an array was read
+    @param[in] elements  number of array elements or -1 if unknown
+    @return whether parsing should proceed
+    @note binary formats may report the number of elements
+    */
+    virtual bool start_array(std::size_t elements) = 0;
+
+    /*!
+    @brief the end of an array was read
+    @return whether parsing should proceed
+    */
+    virtual bool end_array() = 0;
+
+    /*!
+    @brief a parse error occurred
+    @param[in] position    the position in the input where the error occurs
+    @param[in] last_token  the last read token
+    @param[in] ex          an exception object describing the error
+    @return whether parsing should proceed (must return false)
+    */
+    virtual bool parse_error(std::size_t position,
+                             const std::string& last_token,
+                             const detail::exception& ex) = 0;
+
+    json_sax() = default;
+    json_sax(const json_sax&) = default;
+    json_sax(json_sax&&) noexcept = default;
+    json_sax& operator=(const json_sax&) = default;
+    json_sax& operator=(json_sax&&) noexcept = default;
+    virtual ~json_sax() = default;
+};
+
+namespace detail
+{
+constexpr std::size_t unknown_size()
+{
+    return (std::numeric_limits<std::size_t>::max)();
+}
+
+/*!
+@brief SAX implementation to create a JSON value from SAX events
+
+This class implements the @ref json_sax interface and processes the SAX events
+to create a JSON value which makes it basically a DOM parser. The structure or
+hierarchy of the JSON value is managed by the stack `ref_stack` which contains
+a pointer to the respective array or object for each recursion depth.
+
+After successful parsing, the value that is passed by reference to the
+constructor contains the parsed value.
+
+@tparam BasicJsonType  the JSON type
+*/
+template<typename BasicJsonType, typename InputAdapterType>
+class json_sax_dom_parser
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using lexer_t = lexer<BasicJsonType, InputAdapterType>;
+
+    /*!
+    @param[in,out] r  reference to a JSON value that is manipulated while
+                       parsing
+    @param[in] allow_exceptions_  whether parse errors yield exceptions
+    */
+    explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true, lexer_t* lexer_ = nullptr)
+        : root(r), allow_exceptions(allow_exceptions_), m_lexer_ref(lexer_)
+    {}
+
+    // make class move-only
+    json_sax_dom_parser(const json_sax_dom_parser&) = delete;
+    json_sax_dom_parser(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;
+    json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~json_sax_dom_parser() = default;
+
+    bool null()
+    {
+        handle_value(nullptr);
+        return true;
+    }
+
+    bool boolean(bool val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_integer(number_integer_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t& /*unused*/)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool string(string_t& val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool binary(binary_t& val)
+    {
+        handle_value(std::move(val));
+        return true;
+    }
+
+    bool start_object(std::size_t len)
+    {
+        ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
+
+#if JSON_DIAGNOSTIC_POSITIONS
+        // Manually set the start position of the object here.
+        // Ensure this is after the call to handle_value to ensure correct start position.
+        if (m_lexer_ref)
+        {
+            // Lexer has read the first character of the object, so
+            // subtract 1 from the position to get the correct start position.
+            ref_stack.back()->start_position = m_lexer_ref->get_position() - 1;
+        }
+#endif
+
+        if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
+        }
+
+        return true;
+    }
+
+    bool key(string_t& val)
+    {
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(ref_stack.back()->is_object());
+
+        // add null at the given key and store the reference for later
+        object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val));
+        return true;
+    }
+
+    bool end_object()
+    {
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(ref_stack.back()->is_object());
+
+#if JSON_DIAGNOSTIC_POSITIONS
+        if (m_lexer_ref)
+        {
+            // Lexer's position is past the closing brace, so set that as the end position.
+            ref_stack.back()->end_position = m_lexer_ref->get_position();
+        }
+#endif
+
+        ref_stack.back()->set_parents();
+        ref_stack.pop_back();
+        return true;
+    }
+
+    bool start_array(std::size_t len)
+    {
+        ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
+
+#if JSON_DIAGNOSTIC_POSITIONS
+        // Manually set the start position of the array here.
+        // Ensure this is after the call to handle_value to ensure correct start position.
+        if (m_lexer_ref)
+        {
+            ref_stack.back()->start_position = m_lexer_ref->get_position() - 1;
+        }
+#endif
+
+        if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
+        }
+
+        return true;
+    }
+
+    bool end_array()
+    {
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(ref_stack.back()->is_array());
+
+#if JSON_DIAGNOSTIC_POSITIONS
+        if (m_lexer_ref)
+        {
+            // Lexer's position is past the closing bracket, so set that as the end position.
+            ref_stack.back()->end_position = m_lexer_ref->get_position();
+        }
+#endif
+
+        ref_stack.back()->set_parents();
+        ref_stack.pop_back();
+        return true;
+    }
+
+    template<class Exception>
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
+                     const Exception& ex)
+    {
+        errored = true;
+        static_cast<void>(ex);
+        if (allow_exceptions)
+        {
+            JSON_THROW(ex);
+        }
+        return false;
+    }
+
+    constexpr bool is_errored() const
+    {
+        return errored;
+    }
+
+  private:
+
+#if JSON_DIAGNOSTIC_POSITIONS
+    void handle_diagnostic_positions_for_json_value(BasicJsonType& v)
+    {
+        if (m_lexer_ref)
+        {
+            // Lexer has read past the current field value, so set the end position to the current position.
+            // The start position will be set below based on the length of the string representation
+            // of the value.
+            v.end_position = m_lexer_ref->get_position();
+
+            switch (v.type())
+            {
+                case value_t::boolean:
+                {
+                    // 4 and 5 are the string length of "true" and "false"
+                    v.start_position = v.end_position - (v.m_data.m_value.boolean ? 4 : 5);
+                    break;
+                }
+
+                case value_t::null:
+                {
+                    // 4 is the string length of "null"
+                    v.start_position = v.end_position - 4;
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    // include the length of the quotes, which is 2
+                    v.start_position = v.end_position - v.m_data.m_value.string->size() - 2;
+                    break;
+                }
+
+                // As we handle the start and end positions for values created during parsing,
+                // we do not expect the following value type to be called. Regardless, set the positions
+                // in case this is created manually or through a different constructor. Exclude from lcov
+                // since the exact condition of this switch is esoteric.
+                // LCOV_EXCL_START
+                case value_t::discarded:
+                {
+                    v.end_position = std::string::npos;
+                    v.start_position = v.end_position;
+                    break;
+                }
+                // LCOV_EXCL_STOP
+                case value_t::binary:
+                case value_t::number_integer:
+                case value_t::number_unsigned:
+                case value_t::number_float:
+                {
+                    v.start_position = v.end_position - m_lexer_ref->get_string().size();
+                    break;
+                }
+                case value_t::object:
+                case value_t::array:
+                {
+                    // object and array are handled in start_object() and start_array() handlers
+                    // skip setting the values here.
+                    break;
+                }
+                default: // LCOV_EXCL_LINE
+                    // Handle all possible types discretely, default handler should never be reached.
+                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert,-warnings-as-errors) LCOV_EXCL_LINE
+            }
+        }
+    }
+#endif
+
+    /*!
+    @invariant If the ref stack is empty, then the passed value will be the new
+               root.
+    @invariant If the ref stack contains a value, then it is an array or an
+               object to which we can add elements
+    */
+    template<typename Value>
+    JSON_HEDLEY_RETURNS_NON_NULL
+    BasicJsonType* handle_value(Value&& v)
+    {
+        if (ref_stack.empty())
+        {
+            root = BasicJsonType(std::forward<Value>(v));
+
+#if JSON_DIAGNOSTIC_POSITIONS
+            handle_diagnostic_positions_for_json_value(root);
+#endif
+
+            return &root;
+        }
+
+        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
+
+        if (ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_data.m_value.array->emplace_back(std::forward<Value>(v));
+
+#if JSON_DIAGNOSTIC_POSITIONS
+            handle_diagnostic_positions_for_json_value(ref_stack.back()->m_data.m_value.array->back());
+#endif
+
+            return &(ref_stack.back()->m_data.m_value.array->back());
+        }
+
+        JSON_ASSERT(ref_stack.back()->is_object());
+        JSON_ASSERT(object_element);
+        *object_element = BasicJsonType(std::forward<Value>(v));
+
+#if JSON_DIAGNOSTIC_POSITIONS
+        handle_diagnostic_positions_for_json_value(*object_element);
+#endif
+
+        return object_element;
+    }
+
+    /// the parsed JSON value
+    BasicJsonType& root;
+    /// stack to model hierarchy of values
+    std::vector<BasicJsonType*> ref_stack {};
+    /// helper to hold the reference for the next object element
+    BasicJsonType* object_element = nullptr;
+    /// whether a syntax error occurred
+    bool errored = false;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+    /// the lexer reference to obtain the current position
+    lexer_t* m_lexer_ref = nullptr;
+};
+
+template<typename BasicJsonType, typename InputAdapterType>
+class json_sax_dom_callback_parser
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using parser_callback_t = typename BasicJsonType::parser_callback_t;
+    using parse_event_t = typename BasicJsonType::parse_event_t;
+    using lexer_t = lexer<BasicJsonType, InputAdapterType>;
+
+    json_sax_dom_callback_parser(BasicJsonType& r,
+                                 parser_callback_t cb,
+                                 const bool allow_exceptions_ = true,
+                                 lexer_t* lexer_ = nullptr)
+        : root(r), callback(std::move(cb)), allow_exceptions(allow_exceptions_), m_lexer_ref(lexer_)
+    {
+        keep_stack.push_back(true);
+    }
+
+    // make class move-only
+    json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete;
+    json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;
+    json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~json_sax_dom_callback_parser() = default;
+
+    bool null()
+    {
+        handle_value(nullptr);
+        return true;
+    }
+
+    bool boolean(bool val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_integer(number_integer_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t& /*unused*/)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool string(string_t& val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool binary(binary_t& val)
+    {
+        handle_value(std::move(val));
+        return true;
+    }
+
+    bool start_object(std::size_t len)
+    {
+        // check callback for object start
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
+        keep_stack.push_back(keep);
+
+        auto val = handle_value(BasicJsonType::value_t::object, true);
+        ref_stack.push_back(val.second);
+
+        if (ref_stack.back())
+        {
+
+#if JSON_DIAGNOSTIC_POSITIONS
+            // Manually set the start position of the object here.
+            // Ensure this is after the call to handle_value to ensure correct start position.
+            if (m_lexer_ref)
+            {
+                // Lexer has read the first character of the object, so
+                // subtract 1 from the position to get the correct start position.
+                ref_stack.back()->start_position = m_lexer_ref->get_position() - 1;
+            }
+#endif
+
+            // check object limit
+            if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
+            {
+                JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
+            }
+        }
+        return true;
+    }
+
+    bool key(string_t& val)
+    {
+        BasicJsonType k = BasicJsonType(val);
+
+        // check callback for the key
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
+        key_keep_stack.push_back(keep);
+
+        // add discarded value at the given key and store the reference for later
+        if (keep && ref_stack.back())
+        {
+            object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded);
+        }
+
+        return true;
+    }
+
+    bool end_object()
+    {
+        if (ref_stack.back())
+        {
+            if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
+            {
+                // discard object
+                *ref_stack.back() = discarded;
+
+#if JSON_DIAGNOSTIC_POSITIONS
+                // Set start/end positions for discarded object.
+                handle_diagnostic_positions_for_json_value(*ref_stack.back());
+#endif
+            }
+            else
+            {
+
+#if JSON_DIAGNOSTIC_POSITIONS
+                if (m_lexer_ref)
+                {
+                    // Lexer's position is past the closing brace, so set that as the end position.
+                    ref_stack.back()->end_position = m_lexer_ref->get_position();
+                }
+#endif
+
+                ref_stack.back()->set_parents();
+            }
+        }
+
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(!keep_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+
+        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
+        {
+            // remove discarded value
+            for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
+            {
+                if (it->is_discarded())
+                {
+                    ref_stack.back()->erase(it);
+                    break;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    bool start_array(std::size_t len)
+    {
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
+        keep_stack.push_back(keep);
+
+        auto val = handle_value(BasicJsonType::value_t::array, true);
+        ref_stack.push_back(val.second);
+
+        if (ref_stack.back())
+        {
+
+#if JSON_DIAGNOSTIC_POSITIONS
+            // Manually set the start position of the array here.
+            // Ensure this is after the call to handle_value to ensure correct start position.
+            if (m_lexer_ref)
+            {
+                // Lexer has read the first character of the array, so
+                // subtract 1 from the position to get the correct start position.
+                ref_stack.back()->start_position = m_lexer_ref->get_position() - 1;
+            }
+#endif
+
+            // check array limit
+            if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
+            {
+                JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
+            }
+        }
+
+        return true;
+    }
+
+    bool end_array()
+    {
+        bool keep = true;
+
+        if (ref_stack.back())
+        {
+            keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
+            if (keep)
+            {
+
+#if JSON_DIAGNOSTIC_POSITIONS
+                if (m_lexer_ref)
+                {
+                    // Lexer's position is past the closing bracket, so set that as the end position.
+                    ref_stack.back()->end_position = m_lexer_ref->get_position();
+                }
+#endif
+
+                ref_stack.back()->set_parents();
+            }
+            else
+            {
+                // discard array
+                *ref_stack.back() = discarded;
+
+#if JSON_DIAGNOSTIC_POSITIONS
+                // Set start/end positions for discarded array.
+                handle_diagnostic_positions_for_json_value(*ref_stack.back());
+#endif
+            }
+        }
+
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(!keep_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+
+        // remove discarded value
+        if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_data.m_value.array->pop_back();
+        }
+
+        return true;
+    }
+
+    template<class Exception>
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
+                     const Exception& ex)
+    {
+        errored = true;
+        static_cast<void>(ex);
+        if (allow_exceptions)
+        {
+            JSON_THROW(ex);
+        }
+        return false;
+    }
+
+    constexpr bool is_errored() const
+    {
+        return errored;
+    }
+
+  private:
+
+#if JSON_DIAGNOSTIC_POSITIONS
+    void handle_diagnostic_positions_for_json_value(BasicJsonType& v)
+    {
+        if (m_lexer_ref)
+        {
+            // Lexer has read past the current field value, so set the end position to the current position.
+            // The start position will be set below based on the length of the string representation
+            // of the value.
+            v.end_position = m_lexer_ref->get_position();
+
+            switch (v.type())
+            {
+                case value_t::boolean:
+                {
+                    // 4 and 5 are the string length of "true" and "false"
+                    v.start_position = v.end_position - (v.m_data.m_value.boolean ? 4 : 5);
+                    break;
+                }
+
+                case value_t::null:
+                {
+                    // 4 is the string length of "null"
+                    v.start_position = v.end_position - 4;
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    // include the length of the quotes, which is 2
+                    v.start_position = v.end_position - v.m_data.m_value.string->size() - 2;
+                    break;
+                }
+
+                case value_t::discarded:
+                {
+                    v.end_position = std::string::npos;
+                    v.start_position = v.end_position;
+                    break;
+                }
+
+                case value_t::binary:
+                case value_t::number_integer:
+                case value_t::number_unsigned:
+                case value_t::number_float:
+                {
+                    v.start_position = v.end_position - m_lexer_ref->get_string().size();
+                    break;
+                }
+
+                case value_t::object:
+                case value_t::array:
+                {
+                    // object and array are handled in start_object() and start_array() handlers
+                    // skip setting the values here.
+                    break;
+                }
+                default: // LCOV_EXCL_LINE
+                    // Handle all possible types discretely, default handler should never be reached.
+                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert,-warnings-as-errors) LCOV_EXCL_LINE
+            }
+        }
+    }
+#endif
+
+    /*!
+    @param[in] v  value to add to the JSON value we build during parsing
+    @param[in] skip_callback  whether we should skip calling the callback
+               function; this is required after start_array() and
+               start_object() SAX events, because otherwise we would call the
+               callback function with an empty array or object, respectively.
+
+    @invariant If the ref stack is empty, then the passed value will be the new
+               root.
+    @invariant If the ref stack contains a value, then it is an array or an
+               object to which we can add elements
+
+    @return pair of boolean (whether value should be kept) and pointer (to the
+            passed value in the ref_stack hierarchy; nullptr if not kept)
+    */
+    template<typename Value>
+    std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
+    {
+        JSON_ASSERT(!keep_stack.empty());
+
+        // do not handle this value if we know it would be added to a discarded
+        // container
+        if (!keep_stack.back())
+        {
+            return {false, nullptr};
+        }
+
+        // create value
+        auto value = BasicJsonType(std::forward<Value>(v));
+
+#if JSON_DIAGNOSTIC_POSITIONS
+        handle_diagnostic_positions_for_json_value(value);
+#endif
+
+        // check callback
+        const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
+
+        // do not handle this value if we just learnt it shall be discarded
+        if (!keep)
+        {
+            return {false, nullptr};
+        }
+
+        if (ref_stack.empty())
+        {
+            root = std::move(value);
+            return {true, & root};
+        }
+
+        // skip this value if we already decided to skip the parent
+        // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
+        if (!ref_stack.back())
+        {
+            return {false, nullptr};
+        }
+
+        // we now only expect arrays and objects
+        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
+
+        // array
+        if (ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
+            return {true, & (ref_stack.back()->m_data.m_value.array->back())};
+        }
+
+        // object
+        JSON_ASSERT(ref_stack.back()->is_object());
+        // check if we should store an element for the current key
+        JSON_ASSERT(!key_keep_stack.empty());
+        const bool store_element = key_keep_stack.back();
+        key_keep_stack.pop_back();
+
+        if (!store_element)
+        {
+            return {false, nullptr};
+        }
+
+        JSON_ASSERT(object_element);
+        *object_element = std::move(value);
+        return {true, object_element};
+    }
+
+    /// the parsed JSON value
+    BasicJsonType& root;
+    /// stack to model hierarchy of values
+    std::vector<BasicJsonType*> ref_stack {};
+    /// stack to manage which values to keep
+    std::vector<bool> keep_stack {}; // NOLINT(readability-redundant-member-init)
+    /// stack to manage which object keys to keep
+    std::vector<bool> key_keep_stack {}; // NOLINT(readability-redundant-member-init)
+    /// helper to hold the reference for the next object element
+    BasicJsonType* object_element = nullptr;
+    /// whether a syntax error occurred
+    bool errored = false;
+    /// callback function
+    const parser_callback_t callback = nullptr;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+    /// a discarded value for the callback
+    BasicJsonType discarded = BasicJsonType::value_t::discarded;
+    /// the lexer reference to obtain the current position
+    lexer_t* m_lexer_ref = nullptr;
+};
+
+template<typename BasicJsonType>
+class json_sax_acceptor
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    bool null()
+    {
+        return true;
+    }
+
+    bool boolean(bool /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_integer(number_integer_t /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool string(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool binary(binary_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool start_object(std::size_t /*unused*/ = detail::unknown_size())
+    {
+        return true;
+    }
+
+    bool key(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool end_object()
+    {
+        return true;
+    }
+
+    bool start_array(std::size_t /*unused*/ = detail::unknown_size())
+    {
+        return true;
+    }
+
+    bool end_array()
+    {
+        return true;
+    }
+
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
+    {
+        return false;
+    }
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/is_sax.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstdint> // size_t
+#include <utility> // declval
+#include <string> // string
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename T>
+using null_function_t = decltype(std::declval<T&>().null());
+
+template<typename T>
+using boolean_function_t =
+    decltype(std::declval<T&>().boolean(std::declval<bool>()));
+
+template<typename T, typename Integer>
+using number_integer_function_t =
+    decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
+
+template<typename T, typename Unsigned>
+using number_unsigned_function_t =
+    decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
+
+template<typename T, typename Float, typename String>
+using number_float_function_t = decltype(std::declval<T&>().number_float(
+                                    std::declval<Float>(), std::declval<const String&>()));
+
+template<typename T, typename String>
+using string_function_t =
+    decltype(std::declval<T&>().string(std::declval<String&>()));
+
+template<typename T, typename Binary>
+using binary_function_t =
+    decltype(std::declval<T&>().binary(std::declval<Binary&>()));
+
+template<typename T>
+using start_object_function_t =
+    decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
+
+template<typename T, typename String>
+using key_function_t =
+    decltype(std::declval<T&>().key(std::declval<String&>()));
+
+template<typename T>
+using end_object_function_t = decltype(std::declval<T&>().end_object());
+
+template<typename T>
+using start_array_function_t =
+    decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
+
+template<typename T>
+using end_array_function_t = decltype(std::declval<T&>().end_array());
+
+template<typename T, typename Exception>
+using parse_error_function_t = decltype(std::declval<T&>().parse_error(
+        std::declval<std::size_t>(), std::declval<const std::string&>(),
+        std::declval<const Exception&>()));
+
+template<typename SAX, typename BasicJsonType>
+struct is_sax
+{
+  private:
+    static_assert(is_basic_json<BasicJsonType>::value,
+                  "BasicJsonType must be of type basic_json<...>");
+
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using exception_t = typename BasicJsonType::exception;
+
+  public:
+    static constexpr bool value =
+        is_detected_exact<bool, null_function_t, SAX>::value &&
+        is_detected_exact<bool, boolean_function_t, SAX>::value &&
+        is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
+        is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
+        is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
+        is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
+        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
+        is_detected_exact<bool, start_object_function_t, SAX>::value &&
+        is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
+        is_detected_exact<bool, end_object_function_t, SAX>::value &&
+        is_detected_exact<bool, start_array_function_t, SAX>::value &&
+        is_detected_exact<bool, end_array_function_t, SAX>::value &&
+        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
+};
+
+template<typename SAX, typename BasicJsonType>
+struct is_sax_static_asserts
+{
+  private:
+    static_assert(is_basic_json<BasicJsonType>::value,
+                  "BasicJsonType must be of type basic_json<...>");
+
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using exception_t = typename BasicJsonType::exception;
+
+  public:
+    static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
+                  "Missing/invalid function: bool null()");
+    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+                  "Missing/invalid function: bool boolean(bool)");
+    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+                  "Missing/invalid function: bool boolean(bool)");
+    static_assert(
+        is_detected_exact<bool, number_integer_function_t, SAX,
+        number_integer_t>::value,
+        "Missing/invalid function: bool number_integer(number_integer_t)");
+    static_assert(
+        is_detected_exact<bool, number_unsigned_function_t, SAX,
+        number_unsigned_t>::value,
+        "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
+    static_assert(is_detected_exact<bool, number_float_function_t, SAX,
+                  number_float_t, string_t>::value,
+                  "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
+    static_assert(
+        is_detected_exact<bool, string_function_t, SAX, string_t>::value,
+        "Missing/invalid function: bool string(string_t&)");
+    static_assert(
+        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
+        "Missing/invalid function: bool binary(binary_t&)");
+    static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
+                  "Missing/invalid function: bool start_object(std::size_t)");
+    static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
+                  "Missing/invalid function: bool key(string_t&)");
+    static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
+                  "Missing/invalid function: bool end_object()");
+    static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
+                  "Missing/invalid function: bool start_array(std::size_t)");
+    static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
+                  "Missing/invalid function: bool end_array()");
+    static_assert(
+        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
+        "Missing/invalid function: bool parse_error(std::size_t, const "
+        "std::string&, const exception&)");
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// how to treat CBOR tags
+enum class cbor_tag_handler_t
+{
+    error,   ///< throw a parse_error exception in case of a tag
+    ignore,  ///< ignore tags
+    store    ///< store tags as binary type
+};
+
+/*!
+@brief determine system byte order
+
+@return true if and only if system's byte order is little endian
+
+@note from https://stackoverflow.com/a/1001328/266378
+*/
+inline bool little_endianness(int num = 1) noexcept
+{
+    return *reinterpret_cast<char*>(&num) == 1;
+}
+
+///////////////////
+// binary reader //
+///////////////////
+
+/*!
+@brief deserialization of CBOR, MessagePack, and UBJSON values
+*/
+template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType, InputAdapterType>>
+class binary_reader
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using json_sax_t = SAX;
+    using char_type = typename InputAdapterType::char_type;
+    using char_int_type = typename char_traits<char_type>::int_type;
+
+  public:
+    /*!
+    @brief create a binary reader
+
+    @param[in] adapter  input adapter to read from
+    */
+    explicit binary_reader(InputAdapterType&& adapter, const input_format_t format = input_format_t::json) noexcept : ia(std::move(adapter)), input_format(format)
+    {
+        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+    }
+
+    // make class move-only
+    binary_reader(const binary_reader&) = delete;
+    binary_reader(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    binary_reader& operator=(const binary_reader&) = delete;
+    binary_reader& operator=(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~binary_reader() = default;
+
+    /*!
+    @param[in] format  the binary format to parse
+    @param[in] sax_    a SAX event processor
+    @param[in] strict  whether to expect the input to be consumed completed
+    @param[in] tag_handler  how to treat CBOR tags
+
+    @return whether parsing was successful
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    bool sax_parse(const input_format_t format,
+                   json_sax_t* sax_,
+                   const bool strict = true,
+                   const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        sax = sax_;
+        bool result = false;
+
+        switch (format)
+        {
+            case input_format_t::bson:
+                result = parse_bson_internal();
+                break;
+
+            case input_format_t::cbor:
+                result = parse_cbor_internal(true, tag_handler);
+                break;
+
+            case input_format_t::msgpack:
+                result = parse_msgpack_internal();
+                break;
+
+            case input_format_t::ubjson:
+            case input_format_t::bjdata:
+                result = parse_ubjson_internal();
+                break;
+
+            case input_format_t::json: // LCOV_EXCL_LINE
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+
+        // strict mode: next byte must be EOF
+        if (result && strict)
+        {
+            if (input_format == input_format_t::ubjson || input_format == input_format_t::bjdata)
+            {
+                get_ignore_noop();
+            }
+            else
+            {
+                get();
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(current != char_traits<char_type>::eof()))
+            {
+                return sax->parse_error(chars_read, get_token_string(), parse_error::create(110, chars_read,
+                                        exception_message(input_format, concat("expected end of input; last byte: 0x", get_token_string()), "value"), nullptr));
+            }
+        }
+
+        return result;
+    }
+
+  private:
+    //////////
+    // BSON //
+    //////////
+
+    /*!
+    @brief Reads in a BSON-object and passes it to the SAX-parser.
+    @return whether a valid BSON-value was passed to the SAX parser
+    */
+    bool parse_bson_internal()
+    {
+        std::int32_t document_size{};
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))
+        {
+            return false;
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))
+        {
+            return false;
+        }
+
+        return sax->end_object();
+    }
+
+    /*!
+    @brief Parses a C-style string from the BSON input.
+    @param[in,out] result  A reference to the string variable where the read
+                            string is to be stored.
+    @return `true` if the \x00-byte indicating the end of the string was
+             encountered before the EOF; false` indicates an unexpected EOF.
+    */
+    bool get_bson_cstr(string_t& result)
+    {
+        auto out = std::back_inserter(result);
+        while (true)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))
+            {
+                return false;
+            }
+            if (current == 0x00)
+            {
+                return true;
+            }
+            *out++ = static_cast<typename string_t::value_type>(current);
+        }
+    }
+
+    /*!
+    @brief Parses a zero-terminated string of length @a len from the BSON
+           input.
+    @param[in] len  The length (including the zero-byte at the end) of the
+                    string to be read.
+    @param[in,out] result  A reference to the string variable where the read
+                            string is to be stored.
+    @tparam NumberType The type of the length @a len
+    @pre len >= 1
+    @return `true` if the string was successfully parsed
+    */
+    template<typename NumberType>
+    bool get_bson_string(const NumberType len, string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(len < 1))
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                    exception_message(input_format_t::bson, concat("string length must be at least 1, is ", std::to_string(len)), "string"), nullptr));
+        }
+
+        return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != char_traits<char_type>::eof();
+    }
+
+    /*!
+    @brief Parses a byte array input of length @a len from the BSON input.
+    @param[in] len  The length of the byte array to be read.
+    @param[in,out] result  A reference to the binary variable where the read
+                            array is to be stored.
+    @tparam NumberType The type of the length @a len
+    @pre len >= 0
+    @return `true` if the byte array was successfully parsed
+    */
+    template<typename NumberType>
+    bool get_bson_binary(const NumberType len, binary_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(len < 0))
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                    exception_message(input_format_t::bson, concat("byte array length cannot be negative, is ", std::to_string(len)), "binary"), nullptr));
+        }
+
+        // All BSON binary values have a subtype
+        std::uint8_t subtype{};
+        get_number<std::uint8_t>(input_format_t::bson, subtype);
+        result.set_subtype(subtype);
+
+        return get_binary(input_format_t::bson, len, result);
+    }
+
+    /*!
+    @brief Read a BSON document element of the given @a element_type.
+    @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html
+    @param[in] element_type_parse_position The position in the input stream,
+               where the `element_type` was read.
+    @warning Not all BSON element types are supported yet. An unsupported
+             @a element_type will give rise to a parse_error.114:
+             Unsupported BSON record type 0x...
+    @return whether a valid BSON-object/array was passed to the SAX parser
+    */
+    bool parse_bson_element_internal(const char_int_type element_type,
+                                     const std::size_t element_type_parse_position)
+    {
+        switch (element_type)
+        {
+            case 0x01: // double
+            {
+                double number{};
+                return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0x02: // string
+            {
+                std::int32_t len{};
+                string_t value;
+                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
+            }
+
+            case 0x03: // object
+            {
+                return parse_bson_internal();
+            }
+
+            case 0x04: // array
+            {
+                return parse_bson_array();
+            }
+
+            case 0x05: // binary
+            {
+                std::int32_t len{};
+                binary_t value;
+                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
+            }
+
+            case 0x08: // boolean
+            {
+                return sax->boolean(get() != 0);
+            }
+
+            case 0x0A: // null
+            {
+                return sax->null();
+            }
+
+            case 0x10: // int32
+            {
+                std::int32_t value{};
+                return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
+            }
+
+            case 0x12: // int64
+            {
+                std::int64_t value{};
+                return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
+            }
+
+            case 0x11: // uint64
+            {
+                std::uint64_t value{};
+                return get_number<std::uint64_t, true>(input_format_t::bson, value) && sax->number_unsigned(value);
+            }
+
+            default: // anything else is not supported (yet)
+            {
+                std::array<char, 3> cr{{}};
+                static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                const std::string cr_str{cr.data()};
+                return sax->parse_error(element_type_parse_position, cr_str,
+                                        parse_error::create(114, element_type_parse_position, concat("Unsupported BSON record type 0x", cr_str), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief Read a BSON element list (as specified in the BSON-spec)
+
+    The same binary layout is used for objects and arrays, hence it must be
+    indicated with the argument @a is_array which one is expected
+    (true --> array, false --> object).
+
+    @param[in] is_array Determines if the element list being read is to be
+                        treated as an object (@a is_array == false), or as an
+                        array (@a is_array == true).
+    @return whether a valid BSON-object/array was passed to the SAX parser
+    */
+    bool parse_bson_element_list(const bool is_array)
+    {
+        string_t key;
+
+        while (auto element_type = get())
+        {
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))
+            {
+                return false;
+            }
+
+            const std::size_t element_type_parse_position = chars_read;
+            if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
+            {
+                return false;
+            }
+
+            if (!is_array && !sax->key(key))
+            {
+                return false;
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
+            {
+                return false;
+            }
+
+            // get_bson_cstr only appends
+            key.clear();
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief Reads an array from the BSON input and passes it to the SAX-parser.
+    @return whether a valid BSON-array was passed to the SAX parser
+    */
+    bool parse_bson_array()
+    {
+        std::int32_t document_size{};
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))
+        {
+            return false;
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))
+        {
+            return false;
+        }
+
+        return sax->end_array();
+    }
+
+    //////////
+    // CBOR //
+    //////////
+
+    /*!
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true) or whether the last read character should
+                         be considered instead (false)
+    @param[in] tag_handler how CBOR tags should be treated
+
+    @return whether a valid CBOR value was passed to the SAX parser
+    */
+    bool parse_cbor_internal(const bool get_char,
+                             const cbor_tag_handler_t tag_handler)
+    {
+        switch (get_char ? get() : current)
+        {
+            // EOF
+            case char_traits<char_type>::eof():
+                return unexpect_eof(input_format_t::cbor, "value");
+
+            // Integer 0x00..0x17 (0..23)
+            case 0x00:
+            case 0x01:
+            case 0x02:
+            case 0x03:
+            case 0x04:
+            case 0x05:
+            case 0x06:
+            case 0x07:
+            case 0x08:
+            case 0x09:
+            case 0x0A:
+            case 0x0B:
+            case 0x0C:
+            case 0x0D:
+            case 0x0E:
+            case 0x0F:
+            case 0x10:
+            case 0x11:
+            case 0x12:
+            case 0x13:
+            case 0x14:
+            case 0x15:
+            case 0x16:
+            case 0x17:
+                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+            case 0x18: // Unsigned integer (one-byte uint8_t follows)
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x19: // Unsigned integer (two-byte uint16_t follows)
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x1A: // Unsigned integer (four-byte uint32_t follows)
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            // Negative integer -1-0x00..-1-0x17 (-1..-24)
+            case 0x20:
+            case 0x21:
+            case 0x22:
+            case 0x23:
+            case 0x24:
+            case 0x25:
+            case 0x26:
+            case 0x27:
+            case 0x28:
+            case 0x29:
+            case 0x2A:
+            case 0x2B:
+            case 0x2C:
+            case 0x2D:
+            case 0x2E:
+            case 0x2F:
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+                return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
+
+            case 0x38: // Negative integer (one-byte uint8_t follows)
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
+                        - static_cast<number_integer_t>(number));
+            }
+
+            // Binary data (0x00..0x17 bytes follow)
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            case 0x58: // Binary data (one-byte uint8_t for n follows)
+            case 0x59: // Binary data (two-byte uint16_t for n follow)
+            case 0x5A: // Binary data (four-byte uint32_t for n follow)
+            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
+            case 0x5F: // Binary data (indefinite length)
+            {
+                binary_t b;
+                return get_cbor_binary(b) && sax->binary(b);
+            }
+
+            // UTF-8 string (0x00..0x17 bytes follow)
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+            case 0x7F: // UTF-8 string (indefinite length)
+            {
+                string_t s;
+                return get_cbor_string(s) && sax->string(s);
+            }
+
+            // array (0x00..0x17 data items follow)
+            case 0x80:
+            case 0x81:
+            case 0x82:
+            case 0x83:
+            case 0x84:
+            case 0x85:
+            case 0x86:
+            case 0x87:
+            case 0x88:
+            case 0x89:
+            case 0x8A:
+            case 0x8B:
+            case 0x8C:
+            case 0x8D:
+            case 0x8E:
+            case 0x8F:
+            case 0x90:
+            case 0x91:
+            case 0x92:
+            case 0x93:
+            case 0x94:
+            case 0x95:
+            case 0x96:
+            case 0x97:
+                return get_cbor_array(
+                           conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+
+            case 0x98: // array (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x99: // array (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9A: // array (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9B: // array (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9F: // array (indefinite length)
+                return get_cbor_array(detail::unknown_size(), tag_handler);
+
+            // map (0x00..0x17 pairs of data items follow)
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+                return get_cbor_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+
+            case 0xB8: // map (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xB9: // map (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBA: // map (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBB: // map (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBF: // map (indefinite length)
+                return get_cbor_object(detail::unknown_size(), tag_handler);
+
+            case 0xC6: // tagged item
+            case 0xC7:
+            case 0xC8:
+            case 0xC9:
+            case 0xCA:
+            case 0xCB:
+            case 0xCC:
+            case 0xCD:
+            case 0xCE:
+            case 0xCF:
+            case 0xD0:
+            case 0xD1:
+            case 0xD2:
+            case 0xD3:
+            case 0xD4:
+            case 0xD8: // tagged item (1 byte follows)
+            case 0xD9: // tagged item (2 bytes follow)
+            case 0xDA: // tagged item (4 bytes follow)
+            case 0xDB: // tagged item (8 bytes follow)
+            {
+                switch (tag_handler)
+                {
+                    case cbor_tag_handler_t::error:
+                    {
+                        auto last_token = get_token_string();
+                        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                                exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr));
+                    }
+
+                    case cbor_tag_handler_t::ignore:
+                    {
+                        // ignore binary subtype
+                        switch (current)
+                        {
+                            case 0xD8:
+                            {
+                                std::uint8_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            case 0xD9:
+                            {
+                                std::uint16_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            case 0xDA:
+                            {
+                                std::uint32_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            case 0xDB:
+                            {
+                                std::uint64_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            default:
+                                break;
+                        }
+                        return parse_cbor_internal(true, tag_handler);
+                    }
+
+                    case cbor_tag_handler_t::store:
+                    {
+                        binary_t b;
+                        // use binary subtype and store in a binary container
+                        switch (current)
+                        {
+                            case 0xD8:
+                            {
+                                std::uint8_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            case 0xD9:
+                            {
+                                std::uint16_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            case 0xDA:
+                            {
+                                std::uint32_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            case 0xDB:
+                            {
+                                std::uint64_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            default:
+                                return parse_cbor_internal(true, tag_handler);
+                        }
+                        get();
+                        return get_cbor_binary(b) && sax->binary(b);
+                    }
+
+                    default:                 // LCOV_EXCL_LINE
+                        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+                        return false;        // LCOV_EXCL_LINE
+                }
+            }
+
+            case 0xF4: // false
+                return sax->boolean(false);
+
+            case 0xF5: // true
+                return sax->boolean(true);
+
+            case 0xF6: // null
+                return sax->null();
+
+            case 0xF9: // Half-Precision Float (two-byte IEEE 754)
+            {
+                const auto byte1_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
+                {
+                    return false;
+                }
+                const auto byte2_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
+                {
+                    return false;
+                }
+
+                const auto byte1 = static_cast<unsigned char>(byte1_raw);
+                const auto byte2 = static_cast<unsigned char>(byte2_raw);
+
+                // Code from RFC 7049, Appendix D, Figure 3:
+                // As half-precision floating-point numbers were only added
+                // to IEEE 754 in 2008, today's programming platforms often
+                // still only have limited support for them. It is very
+                // easy to include at least decoding support for them even
+                // without such support. An example of a small decoder for
+                // half-precision floating-point numbers in the C language
+                // is shown in Fig. 3.
+                const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
+                const double val = [&half]
+                {
+                    const int exp = (half >> 10u) & 0x1Fu;
+                    const unsigned int mant = half & 0x3FFu;
+                    JSON_ASSERT(0 <= exp&& exp <= 32);
+                    JSON_ASSERT(mant <= 1024);
+                    switch (exp)
+                    {
+                        case 0:
+                            return std::ldexp(mant, -24);
+                        case 31:
+                            return (mant == 0)
+                            ? std::numeric_limits<double>::infinity()
+                            : std::numeric_limits<double>::quiet_NaN();
+                        default:
+                            return std::ldexp(mant + 1024, exp - 25);
+                    }
+                }();
+                return sax->number_float((half & 0x8000u) != 0
+                                         ? static_cast<number_float_t>(-val)
+                                         : static_cast<number_float_t>(val), "");
+            }
+
+            case 0xFA: // Single-Precision Float (four-byte IEEE 754)
+            {
+                float number{};
+                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
+            {
+                double number{};
+                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            default: // anything else (0xFF is handled inside the other types)
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a CBOR string
+
+    This function first reads starting bytes to determine the expected
+    string length and then copies this number of bytes into a string.
+    Additionally, CBOR's strings with indefinite lengths are supported.
+
+    @param[out] result  created string
+
+    @return whether string creation completed
+    */
+    bool get_cbor_string(string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // UTF-8 string (0x00..0x17 bytes follow)
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            {
+                return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7F: // UTF-8 string (indefinite length)
+            {
+                while (get() != 0xFF)
+                {
+                    string_t chunk;
+                    if (!get_cbor_string(chunk))
+                    {
+                        return false;
+                    }
+                    result.append(chunk);
+                }
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                        exception_message(input_format_t::cbor, concat("expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x", last_token), "string"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a CBOR byte array
+
+    This function first reads starting bytes to determine the expected
+    byte array length and then copies this number of bytes into the byte array.
+    Additionally, CBOR's byte arrays with indefinite lengths are supported.
+
+    @param[out] result  created byte array
+
+    @return whether byte array creation completed
+    */
+    bool get_cbor_binary(binary_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // Binary data (0x00..0x17 bytes follow)
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            {
+                return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0x58: // Binary data (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x59: // Binary data (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5A: // Binary data (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5F: // Binary data (indefinite length)
+            {
+                while (get() != 0xFF)
+                {
+                    binary_t chunk;
+                    if (!get_cbor_binary(chunk))
+                    {
+                        return false;
+                    }
+                    result.insert(result.end(), chunk.begin(), chunk.end());
+                }
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                        exception_message(input_format_t::cbor, concat("expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x", last_token), "binary"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @param[in] len  the length of the array or detail::unknown_size() for an
+                    array of indefinite size
+    @param[in] tag_handler how CBOR tags should be treated
+    @return whether array creation completed
+    */
+    bool get_cbor_array(const std::size_t len,
+                        const cbor_tag_handler_t tag_handler)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
+        {
+            return false;
+        }
+
+        if (len != detail::unknown_size())
+        {
+            for (std::size_t i = 0; i < len; ++i)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                {
+                    return false;
+                }
+            }
+        }
+        else
+        {
+            while (get() != 0xFF)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
+                {
+                    return false;
+                }
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @param[in] len  the length of the object or detail::unknown_size() for an
+                    object of indefinite size
+    @param[in] tag_handler how CBOR tags should be treated
+    @return whether object creation completed
+    */
+    bool get_cbor_object(const std::size_t len,
+                         const cbor_tag_handler_t tag_handler)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
+        {
+            return false;
+        }
+
+        if (len != 0)
+        {
+            string_t key;
+            if (len != detail::unknown_size())
+            {
+                for (std::size_t i = 0; i < len; ++i)
+                {
+                    get();
+                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+
+                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+            else
+            {
+                while (get() != 0xFF)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+
+                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+        }
+
+        return sax->end_object();
+    }
+
+    /////////////
+    // MsgPack //
+    /////////////
+
+    /*!
+    @return whether a valid MessagePack value was passed to the SAX parser
+    */
+    bool parse_msgpack_internal()
+    {
+        switch (get())
+        {
+            // EOF
+            case char_traits<char_type>::eof():
+                return unexpect_eof(input_format_t::msgpack, "value");
+
+            // positive fixint
+            case 0x00:
+            case 0x01:
+            case 0x02:
+            case 0x03:
+            case 0x04:
+            case 0x05:
+            case 0x06:
+            case 0x07:
+            case 0x08:
+            case 0x09:
+            case 0x0A:
+            case 0x0B:
+            case 0x0C:
+            case 0x0D:
+            case 0x0E:
+            case 0x0F:
+            case 0x10:
+            case 0x11:
+            case 0x12:
+            case 0x13:
+            case 0x14:
+            case 0x15:
+            case 0x16:
+            case 0x17:
+            case 0x18:
+            case 0x19:
+            case 0x1A:
+            case 0x1B:
+            case 0x1C:
+            case 0x1D:
+            case 0x1E:
+            case 0x1F:
+            case 0x20:
+            case 0x21:
+            case 0x22:
+            case 0x23:
+            case 0x24:
+            case 0x25:
+            case 0x26:
+            case 0x27:
+            case 0x28:
+            case 0x29:
+            case 0x2A:
+            case 0x2B:
+            case 0x2C:
+            case 0x2D:
+            case 0x2E:
+            case 0x2F:
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+            case 0x38:
+            case 0x39:
+            case 0x3A:
+            case 0x3B:
+            case 0x3C:
+            case 0x3D:
+            case 0x3E:
+            case 0x3F:
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            case 0x58:
+            case 0x59:
+            case 0x5A:
+            case 0x5B:
+            case 0x5C:
+            case 0x5D:
+            case 0x5E:
+            case 0x5F:
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            case 0x78:
+            case 0x79:
+            case 0x7A:
+            case 0x7B:
+            case 0x7C:
+            case 0x7D:
+            case 0x7E:
+            case 0x7F:
+                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+            // fixmap
+            case 0x80:
+            case 0x81:
+            case 0x82:
+            case 0x83:
+            case 0x84:
+            case 0x85:
+            case 0x86:
+            case 0x87:
+            case 0x88:
+            case 0x89:
+            case 0x8A:
+            case 0x8B:
+            case 0x8C:
+            case 0x8D:
+            case 0x8E:
+            case 0x8F:
+                return get_msgpack_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+
+            // fixarray
+            case 0x90:
+            case 0x91:
+            case 0x92:
+            case 0x93:
+            case 0x94:
+            case 0x95:
+            case 0x96:
+            case 0x97:
+            case 0x98:
+            case 0x99:
+            case 0x9A:
+            case 0x9B:
+            case 0x9C:
+            case 0x9D:
+            case 0x9E:
+            case 0x9F:
+                return get_msgpack_array(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+
+            // fixstr
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+            case 0xB8:
+            case 0xB9:
+            case 0xBA:
+            case 0xBB:
+            case 0xBC:
+            case 0xBD:
+            case 0xBE:
+            case 0xBF:
+            case 0xD9: // str 8
+            case 0xDA: // str 16
+            case 0xDB: // str 32
+            {
+                string_t s;
+                return get_msgpack_string(s) && sax->string(s);
+            }
+
+            case 0xC0: // nil
+                return sax->null();
+
+            case 0xC2: // false
+                return sax->boolean(false);
+
+            case 0xC3: // true
+                return sax->boolean(true);
+
+            case 0xC4: // bin 8
+            case 0xC5: // bin 16
+            case 0xC6: // bin 32
+            case 0xC7: // ext 8
+            case 0xC8: // ext 16
+            case 0xC9: // ext 32
+            case 0xD4: // fixext 1
+            case 0xD5: // fixext 2
+            case 0xD6: // fixext 4
+            case 0xD7: // fixext 8
+            case 0xD8: // fixext 16
+            {
+                binary_t b;
+                return get_msgpack_binary(b) && sax->binary(b);
+            }
+
+            case 0xCA: // float 32
+            {
+                float number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xCB: // float 64
+            {
+                double number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xCC: // uint 8
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCD: // uint 16
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCE: // uint 32
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCF: // uint 64
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xD0: // int 8
+            {
+                std::int8_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD1: // int 16
+            {
+                std::int16_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD2: // int 32
+            {
+                std::int32_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD3: // int 64
+            {
+                std::int64_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xDC: // array 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
+            }
+
+            case 0xDD: // array 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_array(conditional_static_cast<std::size_t>(len));
+            }
+
+            case 0xDE: // map 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
+            }
+
+            case 0xDF: // map 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_object(conditional_static_cast<std::size_t>(len));
+            }
+
+            // negative fixint
+            case 0xE0:
+            case 0xE1:
+            case 0xE2:
+            case 0xE3:
+            case 0xE4:
+            case 0xE5:
+            case 0xE6:
+            case 0xE7:
+            case 0xE8:
+            case 0xE9:
+            case 0xEA:
+            case 0xEB:
+            case 0xEC:
+            case 0xED:
+            case 0xEE:
+            case 0xEF:
+            case 0xF0:
+            case 0xF1:
+            case 0xF2:
+            case 0xF3:
+            case 0xF4:
+            case 0xF5:
+            case 0xF6:
+            case 0xF7:
+            case 0xF8:
+            case 0xF9:
+            case 0xFA:
+            case 0xFB:
+            case 0xFC:
+            case 0xFD:
+            case 0xFE:
+            case 0xFF:
+                return sax->number_integer(static_cast<std::int8_t>(current));
+
+            default: // anything else
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format_t::msgpack, concat("invalid byte: 0x", last_token), "value"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a MessagePack string
+
+    This function first reads starting bytes to determine the expected
+    string length and then copies this number of bytes into a string.
+
+    @param[out] result  created string
+
+    @return whether string creation completed
+    */
+    bool get_msgpack_string(string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // fixstr
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+            case 0xB8:
+            case 0xB9:
+            case 0xBA:
+            case 0xBB:
+            case 0xBC:
+            case 0xBD:
+            case 0xBE:
+            case 0xBF:
+            {
+                return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0xD9: // str 8
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            case 0xDA: // str 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            case 0xDB: // str 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                        exception_message(input_format_t::msgpack, concat("expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x", last_token), "string"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a MessagePack byte array
+
+    This function first reads starting bytes to determine the expected
+    byte array length and then copies this number of bytes into a byte array.
+
+    @param[out] result  created byte array
+
+    @return whether byte array creation completed
+    */
+    bool get_msgpack_binary(binary_t& result)
+    {
+        // helper function to set the subtype
+        auto assign_and_return_true = [&result](std::int8_t subtype)
+        {
+            result.set_subtype(static_cast<std::uint8_t>(subtype));
+            return true;
+        };
+
+        switch (current)
+        {
+            case 0xC4: // bin 8
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC5: // bin 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC6: // bin 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC7: // ext 8
+            {
+                std::uint8_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xC8: // ext 16
+            {
+                std::uint16_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xC9: // ext 32
+            {
+                std::uint32_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD4: // fixext 1
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 1, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD5: // fixext 2
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 2, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD6: // fixext 4
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 4, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD7: // fixext 8
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 8, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD8: // fixext 16
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 16, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            default:           // LCOV_EXCL_LINE
+                return false;  // LCOV_EXCL_LINE
+        }
+    }
+
+    /*!
+    @param[in] len  the length of the array
+    @return whether array creation completed
+    */
+    bool get_msgpack_array(const std::size_t len)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
+        {
+            return false;
+        }
+
+        for (std::size_t i = 0; i < len; ++i)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
+            {
+                return false;
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @param[in] len  the length of the object
+    @return whether object creation completed
+    */
+    bool get_msgpack_object(const std::size_t len)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
+        {
+            return false;
+        }
+
+        string_t key;
+        for (std::size_t i = 0; i < len; ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
+            {
+                return false;
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
+            {
+                return false;
+            }
+            key.clear();
+        }
+
+        return sax->end_object();
+    }
+
+    ////////////
+    // UBJSON //
+    ////////////
+
+    /*!
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether a valid UBJSON value was passed to the SAX parser
+    */
+    bool parse_ubjson_internal(const bool get_char = true)
+    {
+        return get_ubjson_value(get_char ? get_ignore_noop() : current);
+    }
+
+    /*!
+    @brief reads a UBJSON string
+
+    This function is either called after reading the 'S' byte explicitly
+    indicating a string, or in case of an object key where the 'S' byte can be
+    left out.
+
+    @param[out] result   created string
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether string creation completed
+    */
+    bool get_ubjson_string(string_t& result, const bool get_char = true)
+    {
+        if (get_char)
+        {
+            get();  // TODO(niels): may we ignore N here?
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            case 'U':
+            {
+                std::uint8_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'i':
+            {
+                std::int8_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'I':
+            {
+                std::int16_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'l':
+            {
+                std::int32_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'L':
+            {
+                std::int64_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'u':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint16_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'm':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint32_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'M':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint64_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            default:
+                break;
+        }
+        auto last_token = get_token_string();
+        std::string message;
+
+        if (input_format != input_format_t::bjdata)
+        {
+            message = "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token;
+        }
+        else
+        {
+            message = "expected length type specification (U, i, u, I, m, l, M, L); last byte: 0x" + last_token;
+        }
+        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "string"), nullptr));
+    }
+
+    /*!
+    @param[out] dim  an integer vector storing the ND array dimensions
+    @return whether reading ND array size vector is successful
+    */
+    bool get_ubjson_ndarray_size(std::vector<size_t>& dim)
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        size_t dimlen = 0;
+        bool no_ndarray = true;
+
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type, no_ndarray)))
+        {
+            return false;
+        }
+
+        if (size_and_type.first != npos)
+        {
+            if (size_and_type.second != 0)
+            {
+                if (size_and_type.second != 'N')
+                {
+                    for (std::size_t i = 0; i < size_and_type.first; ++i)
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, size_and_type.second)))
+                        {
+                            return false;
+                        }
+                        dim.push_back(dimlen);
+                    }
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray)))
+                    {
+                        return false;
+                    }
+                    dim.push_back(dimlen);
+                }
+            }
+        }
+        else
+        {
+            while (current != ']')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, current)))
+                {
+                    return false;
+                }
+                dim.push_back(dimlen);
+                get_ignore_noop();
+            }
+        }
+        return true;
+    }
+
+    /*!
+    @param[out] result  determined size
+    @param[in,out] is_ndarray  for input, `true` means already inside an ndarray vector
+                               or ndarray dimension is not allowed; `false` means ndarray
+                               is allowed; for output, `true` means an ndarray is found;
+                               is_ndarray can only return `true` when its initial value
+                               is `false`
+    @param[in] prefix  type marker if already read, otherwise set to 0
+
+    @return whether size determination completed
+    */
+    bool get_ubjson_size_value(std::size_t& result, bool& is_ndarray, char_int_type prefix = 0)
+    {
+        if (prefix == 0)
+        {
+            prefix = get_ignore_noop();
+        }
+
+        switch (prefix)
+        {
+            case 'U':
+            {
+                std::uint8_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'i':
+            {
+                std::int8_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (number < 0)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
+                }
+                result = static_cast<std::size_t>(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c): number is not a char
+                return true;
+            }
+
+            case 'I':
+            {
+                std::int16_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (number < 0)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'l':
+            {
+                std::int32_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (number < 0)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'L':
+            {
+                std::int64_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (number < 0)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
+                }
+                if (!value_in_range_of<std::size_t>(number))
+                {
+                    return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
+                                            exception_message(input_format, "integer value overflow", "size"), nullptr));
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'u':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint16_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'm':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint32_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                result = conditional_static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'M':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint64_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (!value_in_range_of<std::size_t>(number))
+                {
+                    return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
+                                            exception_message(input_format, "integer value overflow", "size"), nullptr));
+                }
+                result = detail::conditional_static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case '[':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                if (is_ndarray) // ndarray dimensional vector can only contain integers and cannot embed another array
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, exception_message(input_format, "ndarray dimensional vector is not allowed", "size"), nullptr));
+                }
+                std::vector<size_t> dim;
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_ndarray_size(dim)))
+                {
+                    return false;
+                }
+                if (dim.size() == 1 || (dim.size() == 2 && dim.at(0) == 1)) // return normal array size if 1D row vector
+                {
+                    result = dim.at(dim.size() - 1);
+                    return true;
+                }
+                if (!dim.empty())  // if ndarray, convert to an object in JData annotated array format
+                {
+                    for (auto i : dim) // test if any dimension in an ndarray is 0, if so, return a 1D empty container
+                    {
+                        if ( i == 0 )
+                        {
+                            result = 0;
+                            return true;
+                        }
+                    }
+
+                    string_t key = "_ArraySize_";
+                    if (JSON_HEDLEY_UNLIKELY(!sax->start_object(3) || !sax->key(key) || !sax->start_array(dim.size())))
+                    {
+                        return false;
+                    }
+                    result = 1;
+                    for (auto i : dim)
+                    {
+                        // Pre-multiplication overflow check: if i > 0 and result > SIZE_MAX/i, then result*i would overflow.
+                        // This check must happen before multiplication since overflow detection after the fact is unreliable
+                        // as modular arithmetic can produce any value, not just 0 or SIZE_MAX.
+                        if (JSON_HEDLEY_UNLIKELY(i > 0 && result > (std::numeric_limits<std::size_t>::max)() / i))
+                        {
+                            return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message(input_format, "excessive ndarray size caused overflow", "size"), nullptr));
+                        }
+                        result *= i;
+                        // Additional post-multiplication check to catch any edge cases the pre-check might miss
+                        if (result == 0 || result == npos)
+                        {
+                            return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message(input_format, "excessive ndarray size caused overflow", "size"), nullptr));
+                        }
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(static_cast<number_unsigned_t>(i))))
+                        {
+                            return false;
+                        }
+                    }
+                    is_ndarray = true;
+                    return sax->end_array();
+                }
+                result = 0;
+                return true;
+            }
+
+            default:
+                break;
+        }
+        auto last_token = get_token_string();
+        std::string message;
+
+        if (input_format != input_format_t::bjdata)
+        {
+            message = "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token;
+        }
+        else
+        {
+            message = "expected length type specification (U, i, u, I, m, l, M, L) after '#'; last byte: 0x" + last_token;
+        }
+        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "size"), nullptr));
+    }
+
+    /*!
+    @brief determine the type and size for a container
+
+    In the optimized UBJSON format, a type and a size can be provided to allow
+    for a more compact representation.
+
+    @param[out] result  pair of the size and the type
+    @param[in] inside_ndarray  whether the parser is parsing an ND array dimensional vector
+
+    @return whether pair creation completed
+    */
+    bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result, bool inside_ndarray = false)
+    {
+        result.first = npos; // size
+        result.second = 0; // type
+        bool is_ndarray = false;
+
+        get_ignore_noop();
+
+        if (current == '$')
+        {
+            result.second = get();  // must not ignore 'N', because 'N' maybe the type
+            if (input_format == input_format_t::bjdata
+                    && JSON_HEDLEY_UNLIKELY(std::binary_search(bjd_optimized_type_markers.begin(), bjd_optimized_type_markers.end(), result.second)))
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format, concat("marker 0x", last_token, " is not a permitted optimized array type"), "type"), nullptr));
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "type")))
+            {
+                return false;
+            }
+
+            get_ignore_noop();
+            if (JSON_HEDLEY_UNLIKELY(current != '#'))
+            {
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value")))
+                {
+                    return false;
+                }
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format, concat("expected '#' after type information; last byte: 0x", last_token), "size"), nullptr));
+            }
+
+            const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
+            if (input_format == input_format_t::bjdata && is_ndarray)
+            {
+                if (inside_ndarray)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
+                                            exception_message(input_format, "ndarray can not be recursive", "size"), nullptr));
+                }
+                result.second |= (1 << 8); // use bit 8 to indicate ndarray, all UBJSON and BJData markers should be ASCII letters
+            }
+            return is_error;
+        }
+
+        if (current == '#')
+        {
+            const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
+            if (input_format == input_format_t::bjdata && is_ndarray)
+            {
+                return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
+                                        exception_message(input_format, "ndarray requires both type and size", "size"), nullptr));
+            }
+            return is_error;
+        }
+
+        return true;
+    }
+
+    /*!
+    @param prefix  the previously read or set type prefix
+    @return whether value creation completed
+    */
+    bool get_ubjson_value(const char_int_type prefix)
+    {
+        switch (prefix)
+        {
+            case char_traits<char_type>::eof():  // EOF
+                return unexpect_eof(input_format, "value");
+
+            case 'T':  // true
+                return sax->boolean(true);
+            case 'F':  // false
+                return sax->boolean(false);
+
+            case 'Z':  // null
+                return sax->null();
+
+            case 'B':  // byte
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint8_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'U':
+            {
+                std::uint8_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'i':
+            {
+                std::int8_t number{};
+                return get_number(input_format, number) && sax->number_integer(number);
+            }
+
+            case 'I':
+            {
+                std::int16_t number{};
+                return get_number(input_format, number) && sax->number_integer(number);
+            }
+
+            case 'l':
+            {
+                std::int32_t number{};
+                return get_number(input_format, number) && sax->number_integer(number);
+            }
+
+            case 'L':
+            {
+                std::int64_t number{};
+                return get_number(input_format, number) && sax->number_integer(number);
+            }
+
+            case 'u':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint16_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'm':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint32_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'M':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint64_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'h':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                const auto byte1_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
+                {
+                    return false;
+                }
+                const auto byte2_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
+                {
+                    return false;
+                }
+
+                const auto byte1 = static_cast<unsigned char>(byte1_raw);
+                const auto byte2 = static_cast<unsigned char>(byte2_raw);
+
+                // Code from RFC 7049, Appendix D, Figure 3:
+                // As half-precision floating-point numbers were only added
+                // to IEEE 754 in 2008, today's programming platforms often
+                // still only have limited support for them. It is very
+                // easy to include at least decoding support for them even
+                // without such support. An example of a small decoder for
+                // half-precision floating-point numbers in the C language
+                // is shown in Fig. 3.
+                const auto half = static_cast<unsigned int>((byte2 << 8u) + byte1);
+                const double val = [&half]
+                {
+                    const int exp = (half >> 10u) & 0x1Fu;
+                    const unsigned int mant = half & 0x3FFu;
+                    JSON_ASSERT(0 <= exp&& exp <= 32);
+                    JSON_ASSERT(mant <= 1024);
+                    switch (exp)
+                    {
+                        case 0:
+                            return std::ldexp(mant, -24);
+                        case 31:
+                            return (mant == 0)
+                            ? std::numeric_limits<double>::infinity()
+                            : std::numeric_limits<double>::quiet_NaN();
+                        default:
+                            return std::ldexp(mant + 1024, exp - 25);
+                    }
+                }();
+                return sax->number_float((half & 0x8000u) != 0
+                                         ? static_cast<number_float_t>(-val)
+                                         : static_cast<number_float_t>(val), "");
+            }
+
+            case 'd':
+            {
+                float number{};
+                return get_number(input_format, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 'D':
+            {
+                double number{};
+                return get_number(input_format, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 'H':
+            {
+                return get_ubjson_high_precision_number();
+            }
+
+            case 'C':  // char
+            {
+                get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "char")))
+                {
+                    return false;
+                }
+                if (JSON_HEDLEY_UNLIKELY(current > 127))
+                {
+                    auto last_token = get_token_string();
+                    return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                            exception_message(input_format, concat("byte after 'C' must be in range 0x00..0x7F; last byte: 0x", last_token), "char"), nullptr));
+                }
+                string_t s(1, static_cast<typename string_t::value_type>(current));
+                return sax->string(s);
+            }
+
+            case 'S':  // string
+            {
+                string_t s;
+                return get_ubjson_string(s) && sax->string(s);
+            }
+
+            case '[':  // array
+                return get_ubjson_array();
+
+            case '{':  // object
+                return get_ubjson_object();
+
+            default: // anything else
+                break;
+        }
+        auto last_token = get_token_string();
+        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format, "invalid byte: 0x" + last_token, "value"), nullptr));
+    }
+
+    /*!
+    @return whether array creation completed
+    */
+    bool get_ubjson_array()
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
+        {
+            return false;
+        }
+
+        // if bit-8 of size_and_type.second is set to 1, encode bjdata ndarray as an object in JData annotated array format (https://github.com/NeuroJSON/jdata):
+        // {"_ArrayType_" : "typeid", "_ArraySize_" : [n1, n2, ...], "_ArrayData_" : [v1, v2, ...]}
+
+        if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0)
+        {
+            size_and_type.second &= ~(static_cast<char_int_type>(1) << 8);  // use bit 8 to indicate ndarray, here we remove the bit to restore the type marker
+            auto it = std::lower_bound(bjd_types_map.begin(), bjd_types_map.end(), size_and_type.second, [](const bjd_type & p, char_int_type t)
+            {
+                return p.first < t;
+            });
+            string_t key = "_ArrayType_";
+            if (JSON_HEDLEY_UNLIKELY(it == bjd_types_map.end() || it->first != size_and_type.second))
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format, "invalid byte: 0x" + last_token, "type"), nullptr));
+            }
+
+            string_t type = it->second; // sax->string() takes a reference
+            if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->string(type)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second == 'C' || size_and_type.second == 'B')
+            {
+                size_and_type.second = 'U';
+            }
+
+            key = "_ArrayData_";
+            if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->start_array(size_and_type.first) ))
+            {
+                return false;
+            }
+
+            for (std::size_t i = 0; i < size_and_type.first; ++i)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                {
+                    return false;
+                }
+            }
+
+            return (sax->end_array() && sax->end_object());
+        }
+
+        // If BJData type marker is 'B' decode as binary
+        if (input_format == input_format_t::bjdata && size_and_type.first != npos && size_and_type.second == 'B')
+        {
+            binary_t result;
+            return get_binary(input_format, size_and_type.first, result) && sax->binary(result);
+        }
+
+        if (size_and_type.first != npos)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second != 0)
+            {
+                if (size_and_type.second != 'N')
+                {
+                    for (std::size_t i = 0; i < size_and_type.first; ++i)
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                        {
+                            return false;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                    {
+                        return false;
+                    }
+                }
+            }
+        }
+        else
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))
+            {
+                return false;
+            }
+
+            while (current != ']')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))
+                {
+                    return false;
+                }
+                get_ignore_noop();
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @return whether object creation completed
+    */
+    bool get_ubjson_object()
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
+        {
+            return false;
+        }
+
+        // do not accept ND-array size in objects in BJData
+        if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0)
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                    exception_message(input_format, "BJData object does not support ND-array size in optimized format", "object"), nullptr));
+        }
+
+        string_t key;
+        if (size_and_type.first != npos)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second != 0)
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+        }
+        else
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))
+            {
+                return false;
+            }
+
+            while (current != '}')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
+                {
+                    return false;
+                }
+                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                {
+                    return false;
+                }
+                get_ignore_noop();
+                key.clear();
+            }
+        }
+
+        return sax->end_object();
+    }
+
+    // Note, no reader for UBJSON binary types is implemented because they do
+    // not exist
+
+    bool get_ubjson_high_precision_number()
+    {
+        // get the size of the following number string
+        std::size_t size{};
+        bool no_ndarray = true;
+        auto res = get_ubjson_size_value(size, no_ndarray);
+        if (JSON_HEDLEY_UNLIKELY(!res))
+        {
+            return res;
+        }
+
+        // get number string
+        std::vector<char> number_vector;
+        for (std::size_t i = 0; i < size; ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
+            {
+                return false;
+            }
+            number_vector.push_back(static_cast<char>(current));
+        }
+
+        // parse number string
+        using ia_type = decltype(detail::input_adapter(number_vector));
+        auto number_lexer = detail::lexer<BasicJsonType, ia_type>(detail::input_adapter(number_vector), false);
+        const auto result_number = number_lexer.scan();
+        const auto number_string = number_lexer.get_token_string();
+        const auto result_remainder = number_lexer.scan();
+
+        using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
+
+        if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
+        {
+            return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read,
+                                    exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr));
+        }
+
+        switch (result_number)
+        {
+            case token_type::value_integer:
+                return sax->number_integer(number_lexer.get_number_integer());
+            case token_type::value_unsigned:
+                return sax->number_unsigned(number_lexer.get_number_unsigned());
+            case token_type::value_float:
+                return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
+            case token_type::uninitialized:
+            case token_type::literal_true:
+            case token_type::literal_false:
+            case token_type::literal_null:
+            case token_type::value_string:
+            case token_type::begin_array:
+            case token_type::begin_object:
+            case token_type::end_array:
+            case token_type::end_object:
+            case token_type::name_separator:
+            case token_type::value_separator:
+            case token_type::parse_error:
+            case token_type::end_of_input:
+            case token_type::literal_or_value:
+            default:
+                return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read,
+                                        exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr));
+        }
+    }
+
+    ///////////////////////
+    // Utility functions //
+    ///////////////////////
+
+    /*!
+    @brief get next character from the input
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns a -'ve valued
+    `char_traits<char_type>::eof()` in that case.
+
+    @return character read from the input
+    */
+    char_int_type get()
+    {
+        ++chars_read;
+        return current = ia.get_character();
+    }
+
+    /*!
+    @brief get_to read into a primitive type
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns false instead
+
+    @return bool, whether the read was successful
+    */
+    template<class T>
+    bool get_to(T& dest, const input_format_t format, const char* context)
+    {
+        auto new_chars_read = ia.get_elements(&dest);
+        chars_read += new_chars_read;
+        if (JSON_HEDLEY_UNLIKELY(new_chars_read < sizeof(T)))
+        {
+            // in case of failure, advance position by 1 to report the failing location
+            ++chars_read;
+            sax->parse_error(chars_read, "<end of file>", parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), nullptr));
+            return false;
+        }
+        return true;
+    }
+
+    /*!
+    @return character read from the input after ignoring all 'N' entries
+    */
+    char_int_type get_ignore_noop()
+    {
+        do
+        {
+            get();
+        }
+        while (current == 'N');
+
+        return current;
+    }
+
+    template<class NumberType>
+    static void byte_swap(NumberType& number)
+    {
+        constexpr std::size_t sz = sizeof(number);
+#ifdef __cpp_lib_byteswap
+        if constexpr (sz == 1)
+        {
+            return;
+        }
+        else if constexpr(std::is_integral_v<NumberType>)
+        {
+            number = std::byteswap(number);
+            return;
+        }
+        else
+        {
+#endif
+            auto* ptr = reinterpret_cast<std::uint8_t*>(&number);
+            for (std::size_t i = 0; i < sz / 2; ++i)
+            {
+                std::swap(ptr[i], ptr[sz - i - 1]);
+            }
+#ifdef __cpp_lib_byteswap
+        }
+#endif
+    }
+
+    /*
+    @brief read a number from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format   the current format (for diagnostics)
+    @param[out] result  number of type @a NumberType
+
+    @return whether conversion completed
+
+    @note This function needs to respect the system's endianness, because
+          bytes in CBOR, MessagePack, and UBJSON are stored in network order
+          (big endian) and therefore need reordering on little endian systems.
+          On the other hand, BSON and BJData use little endian and should reorder
+          on big endian systems.
+    */
+    template<typename NumberType, bool InputIsLittleEndian = false>
+    bool get_number(const input_format_t format, NumberType& result)
+    {
+        // read in the original format
+
+        if (JSON_HEDLEY_UNLIKELY(!get_to(result, format, "number")))
+        {
+            return false;
+        }
+        if (is_little_endian != (InputIsLittleEndian || format == input_format_t::bjdata))
+        {
+            byte_swap(result);
+        }
+        return true;
+    }
+
+    /*!
+    @brief create a string by reading characters from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format the current format (for diagnostics)
+    @param[in] len number of characters to read
+    @param[out] result string created by reading @a len bytes
+
+    @return whether string creation completed
+
+    @note We can not reserve @a len bytes for the result, because @a len
+          may be too large. Usually, @ref unexpect_eof() detects the end of
+          the input before we run out of string memory.
+    */
+    template<typename NumberType>
+    bool get_string(const input_format_t format,
+                    const NumberType len,
+                    string_t& result)
+    {
+        bool success = true;
+        for (NumberType i = 0; i < len; i++)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
+            {
+                success = false;
+                break;
+            }
+            result.push_back(static_cast<typename string_t::value_type>(current));
+        }
+        return success;
+    }
+
+    /*!
+    @brief create a byte array by reading bytes from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format the current format (for diagnostics)
+    @param[in] len number of bytes to read
+    @param[out] result byte array created by reading @a len bytes
+
+    @return whether byte array creation completed
+
+    @note We can not reserve @a len bytes for the result, because @a len
+          may be too large. Usually, @ref unexpect_eof() detects the end of
+          the input before we run out of memory.
+    */
+    template<typename NumberType>
+    bool get_binary(const input_format_t format,
+                    const NumberType len,
+                    binary_t& result)
+    {
+        bool success = true;
+        for (NumberType i = 0; i < len; i++)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
+            {
+                success = false;
+                break;
+            }
+            result.push_back(static_cast<typename binary_t::value_type>(current));
+        }
+        return success;
+    }
+
+    /*!
+    @param[in] format   the current format (for diagnostics)
+    @param[in] context  further context information (for diagnostics)
+    @return whether the last read character is not EOF
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    bool unexpect_eof(const input_format_t format, const char* context) const
+    {
+        if (JSON_HEDLEY_UNLIKELY(current == char_traits<char_type>::eof()))
+        {
+            return sax->parse_error(chars_read, "<end of file>",
+                                    parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), nullptr));
+        }
+        return true;
+    }
+
+    /*!
+    @return a string representation of the last read byte
+    */
+    std::string get_token_string() const
+    {
+        std::array<char, 3> cr{{}};
+        static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        return std::string{cr.data()};
+    }
+
+    /*!
+    @param[in] format   the current format
+    @param[in] detail   a detailed error message
+    @param[in] context  further context information
+    @return a message string to use in the parse_error exceptions
+    */
+    std::string exception_message(const input_format_t format,
+                                  const std::string& detail,
+                                  const std::string& context) const
+    {
+        std::string error_msg = "syntax error while parsing ";
+
+        switch (format)
+        {
+            case input_format_t::cbor:
+                error_msg += "CBOR";
+                break;
+
+            case input_format_t::msgpack:
+                error_msg += "MessagePack";
+                break;
+
+            case input_format_t::ubjson:
+                error_msg += "UBJSON";
+                break;
+
+            case input_format_t::bson:
+                error_msg += "BSON";
+                break;
+
+            case input_format_t::bjdata:
+                error_msg += "BJData";
+                break;
+
+            case input_format_t::json: // LCOV_EXCL_LINE
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+
+        return concat(error_msg, ' ', context, ": ", detail);
+    }
+
+  private:
+    static JSON_INLINE_VARIABLE constexpr std::size_t npos = detail::unknown_size();
+
+    /// input adapter
+    InputAdapterType ia;
+
+    /// the current character
+    char_int_type current = char_traits<char_type>::eof();
+
+    /// the number of characters read
+    std::size_t chars_read = 0;
+
+    /// whether we can assume little endianness
+    const bool is_little_endian = little_endianness();
+
+    /// input format
+    const input_format_t input_format = input_format_t::json;
+
+    /// the SAX parser
+    json_sax_t* sax = nullptr;
+
+    // excluded markers in bjdata optimized type
+#define JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_ \
+    make_array<char_int_type>('F', 'H', 'N', 'S', 'T', 'Z', '[', '{')
+
+#define JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_ \
+    make_array<bjd_type>(                      \
+    bjd_type{'B', "byte"},                     \
+    bjd_type{'C', "char"},                     \
+    bjd_type{'D', "double"},                   \
+    bjd_type{'I', "int16"},                    \
+    bjd_type{'L', "int64"},                    \
+    bjd_type{'M', "uint64"},                   \
+    bjd_type{'U', "uint8"},                    \
+    bjd_type{'d', "single"},                   \
+    bjd_type{'i', "int8"},                     \
+    bjd_type{'l', "int32"},                    \
+    bjd_type{'m', "uint32"},                   \
+    bjd_type{'u', "uint16"})
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    // lookup tables
+    // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)
+    const decltype(JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_) bjd_optimized_type_markers =
+        JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_;
+
+    using bjd_type = std::pair<char_int_type, string_t>;
+    // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)
+    const decltype(JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_) bjd_types_map =
+        JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_;
+
+#undef JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_
+#undef JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_
+};
+
+#ifndef JSON_HAS_CPP_17
+    template<typename BasicJsonType, typename InputAdapterType, typename SAX>
+    constexpr std::size_t binary_reader<BasicJsonType, InputAdapterType, SAX>::npos;
+#endif
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+// #include <nlohmann/detail/input/parser.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cmath> // isfinite
+#include <cstdint> // uint8_t
+#include <functional> // function
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/json_sax.hpp>
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/is_sax.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+////////////
+// parser //
+////////////
+
+enum class parse_event_t : std::uint8_t
+{
+    /// the parser read `{` and started to process a JSON object
+    object_start,
+    /// the parser read `}` and finished processing a JSON object
+    object_end,
+    /// the parser read `[` and started to process a JSON array
+    array_start,
+    /// the parser read `]` and finished processing a JSON array
+    array_end,
+    /// the parser read a key of a value in an object
+    key,
+    /// the parser finished reading a JSON value
+    value
+};
+
+template<typename BasicJsonType>
+using parser_callback_t =
+    std::function<bool(int /*depth*/, parse_event_t /*event*/, BasicJsonType& /*parsed*/)>;
+
+/*!
+@brief syntax analysis
+
+This class implements a recursive descent parser.
+*/
+template<typename BasicJsonType, typename InputAdapterType>
+class parser
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using lexer_t = lexer<BasicJsonType, InputAdapterType>;
+    using token_type = typename lexer_t::token_type;
+
+  public:
+    /// a parser reading from an input adapter
+    explicit parser(InputAdapterType&& adapter,
+                    parser_callback_t<BasicJsonType> cb = nullptr,
+                    const bool allow_exceptions_ = true,
+                    const bool ignore_comments = false,
+                    const bool ignore_trailing_commas_ = false)
+        : callback(std::move(cb))
+        , m_lexer(std::move(adapter), ignore_comments)
+        , allow_exceptions(allow_exceptions_)
+        , ignore_trailing_commas(ignore_trailing_commas_)
+    {
+        // read first token
+        get_token();
+    }
+
+    /*!
+    @brief public parser interface
+
+    @param[in] strict      whether to expect the last token to be EOF
+    @param[in,out] result  parsed JSON value
+
+    @throw parse_error.101 in case of an unexpected token
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+    */
+    void parse(const bool strict, BasicJsonType& result)
+    {
+        if (callback)
+        {
+            json_sax_dom_callback_parser<BasicJsonType, InputAdapterType> sdp(result, callback, allow_exceptions, &m_lexer);
+            sax_parse_internal(&sdp);
+
+            // in strict mode, input must be completely read
+            if (strict && (get_token() != token_type::end_of_input))
+            {
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(),
+                                                    exception_message(token_type::end_of_input, "value"), nullptr));
+            }
+
+            // in case of an error, return a discarded value
+            if (sdp.is_errored())
+            {
+                result = value_t::discarded;
+                return;
+            }
+
+            // set top-level value to null if it was discarded by the callback
+            // function
+            if (result.is_discarded())
+            {
+                result = nullptr;
+            }
+        }
+        else
+        {
+            json_sax_dom_parser<BasicJsonType, InputAdapterType> sdp(result, allow_exceptions, &m_lexer);
+            sax_parse_internal(&sdp);
+
+            // in strict mode, input must be completely read
+            if (strict && (get_token() != token_type::end_of_input))
+            {
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
+            }
+
+            // in case of an error, return a discarded value
+            if (sdp.is_errored())
+            {
+                result = value_t::discarded;
+                return;
+            }
+        }
+
+        result.assert_invariant();
+    }
+
+    /*!
+    @brief public accept interface
+
+    @param[in] strict  whether to expect the last token to be EOF
+    @return whether the input is a proper JSON text
+    */
+    bool accept(const bool strict = true)
+    {
+        json_sax_acceptor<BasicJsonType> sax_acceptor;
+        return sax_parse(&sax_acceptor, strict);
+    }
+
+    template<typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    bool sax_parse(SAX* sax, const bool strict = true)
+    {
+        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+        const bool result = sax_parse_internal(sax);
+
+        // strict mode: next byte must be EOF
+        if (result && strict && (get_token() != token_type::end_of_input))
+        {
+            return sax->parse_error(m_lexer.get_position(),
+                                    m_lexer.get_token_string(),
+                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
+        }
+
+        return result;
+    }
+
+  private:
+    template<typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    bool sax_parse_internal(SAX* sax)
+    {
+        // stack to remember the hierarchy of structured values we are parsing
+        // true = array; false = object
+        std::vector<bool> states;
+        // value to avoid a goto (see comment where set to true)
+        bool skip_to_state_evaluation = false;
+
+        while (true)
+        {
+            if (!skip_to_state_evaluation)
+            {
+                // invariant: get_token() was called before each iteration
+                switch (last_token)
+                {
+                    case token_type::begin_object:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(detail::unknown_size())))
+                        {
+                            return false;
+                        }
+
+                        // closing } -> we are done
+                        if (get_token() == token_type::end_object)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+
+                        // parse key
+                        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
+                        }
+                        if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+
+                        // parse separator (:)
+                        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
+                        }
+
+                        // remember we are now inside an object
+                        states.push_back(false);
+
+                        // parse values
+                        get_token();
+                        continue;
+                    }
+
+                    case token_type::begin_array:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(detail::unknown_size())))
+                        {
+                            return false;
+                        }
+
+                        // closing ] -> we are done
+                        if (get_token() == token_type::end_array)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+
+                        // remember we are now inside an array
+                        states.push_back(true);
+
+                        // parse values (no need to call get_token)
+                        continue;
+                    }
+
+                    case token_type::value_float:
+                    {
+                        const auto res = m_lexer.get_number_float();
+
+                        if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    out_of_range::create(406, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr));
+                        }
+
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+
+                        break;
+                    }
+
+                    case token_type::literal_false:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::literal_null:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->null()))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::literal_true:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_integer:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_string:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_unsigned:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::parse_error:
+                    {
+                        // using "uninitialized" to avoid an "expected" message
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), nullptr));
+                    }
+                    case token_type::end_of_input:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(m_lexer.get_position().chars_read_total == 1))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(),
+                                                            "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
+                        }
+
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
+                    }
+                    case token_type::uninitialized:
+                    case token_type::end_array:
+                    case token_type::end_object:
+                    case token_type::name_separator:
+                    case token_type::value_separator:
+                    case token_type::literal_or_value:
+                    default: // the last token was unexpected
+                    {
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
+                    }
+                }
+            }
+            else
+            {
+                skip_to_state_evaluation = false;
+            }
+
+            // we reached this line after we successfully parsed a value
+            if (states.empty())
+            {
+                // empty stack: we reached the end of the hierarchy: done
+                return true;
+            }
+
+            if (states.back())  // array
+            {
+                // comma -> next value
+                // or end of array (ignore_trailing_commas = true)
+                if (get_token() == token_type::value_separator)
+                {
+                    // parse a new value
+                    get_token();
+
+                    // if ignore_trailing_commas and last_token is ], we can continue to "closing ]"
+                    if (!(ignore_trailing_commas && last_token == token_type::end_array))
+                    {
+                        continue;
+                    }
+                }
+
+                // closing ]
+                if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
+                    {
+                        return false;
+                    }
+
+                    // We are done with this array. Before we can parse a
+                    // new value, we need to evaluate the new state first.
+                    // By setting skip_to_state_evaluation to false, we
+                    // are effectively jumping to the beginning of this if.
+                    JSON_ASSERT(!states.empty());
+                    states.pop_back();
+                    skip_to_state_evaluation = true;
+                    continue;
+                }
+
+                return sax->parse_error(m_lexer.get_position(),
+                                        m_lexer.get_token_string(),
+                                        parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array, "array"), nullptr));
+            }
+
+            // states.back() is false -> object
+
+            // comma -> next value
+            // or end of object (ignore_trailing_commas = true)
+            if (get_token() == token_type::value_separator)
+            {
+                get_token();
+
+                // if ignore_trailing_commas and last_token is }, we can continue to "closing }"
+                if (!(ignore_trailing_commas && last_token == token_type::end_object))
+                {
+                    // parse key
+                    if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
+                    {
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
+                    }
+
+                    if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
+                    {
+                        return false;
+                    }
+
+                    // parse separator (:)
+                    if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+                    {
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
+                    }
+
+                    // parse values
+                    get_token();
+                    continue;
+                }
+            }
+
+            // closing }
+            if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
+            {
+                if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
+                {
+                    return false;
+                }
+
+                // We are done with this object. Before we can parse a
+                // new value, we need to evaluate the new state first.
+                // By setting skip_to_state_evaluation to false, we
+                // are effectively jumping to the beginning of this if.
+                JSON_ASSERT(!states.empty());
+                states.pop_back();
+                skip_to_state_evaluation = true;
+                continue;
+            }
+
+            return sax->parse_error(m_lexer.get_position(),
+                                    m_lexer.get_token_string(),
+                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object, "object"), nullptr));
+        }
+    }
+
+    /// get next token from lexer
+    token_type get_token()
+    {
+        return last_token = m_lexer.scan();
+    }
+
+    std::string exception_message(const token_type expected, const std::string& context)
+    {
+        std::string error_msg = "syntax error ";
+
+        if (!context.empty())
+        {
+            error_msg += concat("while parsing ", context, ' ');
+        }
+
+        error_msg += "- ";
+
+        if (last_token == token_type::parse_error)
+        {
+            error_msg += concat(m_lexer.get_error_message(), "; last read: '",
+                                m_lexer.get_token_string(), '\'');
+        }
+        else
+        {
+            error_msg += concat("unexpected ", lexer_t::token_type_name(last_token));
+        }
+
+        if (expected != token_type::uninitialized)
+        {
+            error_msg += concat("; expected ", lexer_t::token_type_name(expected));
+        }
+
+        return error_msg;
+    }
+
+  private:
+    /// callback function
+    const parser_callback_t<BasicJsonType> callback = nullptr;
+    /// the type of the last read token
+    token_type last_token = token_type::uninitialized;
+    /// the lexer
+    lexer_t m_lexer;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+    /// whether trailing commas in objects and arrays should be ignored (true) or signaled as errors (false)
+    const bool ignore_trailing_commas = false;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/iterators/internal_iterator.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // ptrdiff_t
+#include <limits>  // numeric_limits
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*
+@brief an iterator for primitive JSON types
+
+This class models an iterator for primitive JSON types (boolean, number,
+string). Its only purpose is to allow the iterator/const_iterator classes
+to "iterate" over primitive values. Internally, the iterator is modeled by
+a `difference_type` variable. Value begin_value (`0`) models the begin and
+end_value (`1`) models past the end.
+*/
+class primitive_iterator_t
+{
+  private:
+    using difference_type = std::ptrdiff_t;
+    static constexpr difference_type begin_value = 0;
+    static constexpr difference_type end_value = begin_value + 1;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /// iterator as signed integer type
+    difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
+
+  public:
+    constexpr difference_type get_value() const noexcept
+    {
+        return m_it;
+    }
+
+    /// set iterator to a defined beginning
+    void set_begin() noexcept
+    {
+        m_it = begin_value;
+    }
+
+    /// set iterator to a defined past the end
+    void set_end() noexcept
+    {
+        m_it = end_value;
+    }
+
+    /// return whether the iterator can be dereferenced
+    constexpr bool is_begin() const noexcept
+    {
+        return m_it == begin_value;
+    }
+
+    /// return whether the iterator is at end
+    constexpr bool is_end() const noexcept
+    {
+        return m_it == end_value;
+    }
+
+    friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it == rhs.m_it;
+    }
+
+    friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it < rhs.m_it;
+    }
+
+    primitive_iterator_t operator+(difference_type n) noexcept
+    {
+        auto result = *this;
+        result += n;
+        return result;
+    }
+
+    friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it - rhs.m_it;
+    }
+
+    primitive_iterator_t& operator++() noexcept
+    {
+        ++m_it;
+        return *this;
+    }
+
+    primitive_iterator_t operator++(int)& noexcept // NOLINT(cert-dcl21-cpp)
+    {
+        auto result = *this;
+        ++m_it;
+        return result;
+    }
+
+    primitive_iterator_t& operator--() noexcept
+    {
+        --m_it;
+        return *this;
+    }
+
+    primitive_iterator_t operator--(int)& noexcept // NOLINT(cert-dcl21-cpp)
+    {
+        auto result = *this;
+        --m_it;
+        return result;
+    }
+
+    primitive_iterator_t& operator+=(difference_type n) noexcept
+    {
+        m_it += n;
+        return *this;
+    }
+
+    primitive_iterator_t& operator-=(difference_type n) noexcept
+    {
+        m_it -= n;
+        return *this;
+    }
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief an iterator value
+
+@note This structure could easily be a union, but MSVC currently does not allow
+unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.
+*/
+template<typename BasicJsonType> struct internal_iterator
+{
+    /// iterator for JSON objects
+    typename BasicJsonType::object_t::iterator object_iterator {};
+    /// iterator for JSON arrays
+    typename BasicJsonType::array_t::iterator array_iterator {};
+    /// generic iterator for all other types
+    primitive_iterator_t primitive_iterator {};
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/iterators/iter_impl.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
+#include <type_traits> // conditional, is_const, remove_const
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/iterators/internal_iterator.hpp>
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+// forward declare to be able to friend it later on
+template<typename IteratorType> class iteration_proxy;
+template<typename IteratorType> class iteration_proxy_value;
+
+/*!
+@brief a template for a bidirectional iterator for the @ref basic_json class
+This class implements a both iterators (iterator and const_iterator) for the
+@ref basic_json class.
+@note An iterator is called *initialized* when a pointer to a JSON value has
+      been set (e.g., by a constructor or a copy assignment). If the iterator is
+      default-constructed, it is *uninitialized* and most methods are undefined.
+      **The library uses assertions to detect calls on uninitialized iterators.**
+@requirement The class satisfies the following concept requirements:
+-
+[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
+  The iterator that can be moved can be moved in both directions (i.e.
+  incremented and decremented).
+@since version 1.0.0, simplified in version 2.0.9, change to bidirectional
+       iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)
+*/
+template<typename BasicJsonType>
+class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
+{
+    /// the iterator with BasicJsonType of different const-ness
+    using other_iter_impl = iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
+    /// allow basic_json to access private members
+    friend other_iter_impl;
+    friend BasicJsonType;
+    friend iteration_proxy<iter_impl>;
+    friend iteration_proxy_value<iter_impl>;
+
+    using object_t = typename BasicJsonType::object_t;
+    using array_t = typename BasicJsonType::array_t;
+    // make sure BasicJsonType is basic_json or const basic_json
+    static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
+                  "iter_impl only accepts (const) basic_json");
+    // superficial check for the LegacyBidirectionalIterator named requirement
+    static_assert(std::is_base_of<std::bidirectional_iterator_tag, std::bidirectional_iterator_tag>::value
+                  &&  std::is_base_of<std::bidirectional_iterator_tag, typename std::iterator_traits<typename array_t::iterator>::iterator_category>::value,
+                  "basic_json iterator assumes array and object type iterators satisfy the LegacyBidirectionalIterator named requirement.");
+
+  public:
+    /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
+    /// The C++ Standard has never required user-defined iterators to derive from std::iterator.
+    /// A user-defined iterator should provide publicly accessible typedefs named
+    /// iterator_category, value_type, difference_type, pointer, and reference.
+    /// Note that value_type is required to be non-const, even for constant iterators.
+    using iterator_category = std::bidirectional_iterator_tag;
+
+    /// the type of the values when the iterator is dereferenced
+    using value_type = typename BasicJsonType::value_type;
+    /// a type to represent differences between iterators
+    using difference_type = typename BasicJsonType::difference_type;
+    /// defines a pointer to the type iterated over (value_type)
+    using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
+          typename BasicJsonType::const_pointer,
+          typename BasicJsonType::pointer>::type;
+    /// defines a reference to the type iterated over (value_type)
+    using reference =
+        typename std::conditional<std::is_const<BasicJsonType>::value,
+        typename BasicJsonType::const_reference,
+        typename BasicJsonType::reference>::type;
+
+    iter_impl() = default;
+    ~iter_impl() = default;
+    iter_impl(iter_impl&&) noexcept = default;
+    iter_impl& operator=(iter_impl&&) noexcept = default;
+
+    /*!
+    @brief constructor for a given JSON instance
+    @param[in] object  pointer to a JSON object for this iterator
+    @pre object != nullptr
+    @post The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    explicit iter_impl(pointer object) noexcept : m_object(object)
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = typename object_t::iterator();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = typename array_t::iterator();
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator = primitive_iterator_t();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @note The conventional copy constructor and copy assignment are implicitly
+          defined. Combined with the following converting constructor and
+          assignment, they support: (1) copy from iterator to iterator, (2)
+          copy from const iterator to const iterator, and (3) conversion from
+          iterator to const iterator. However conversion from const iterator
+          to iterator is not defined.
+    */
+
+    /*!
+    @brief const copy constructor
+    @param[in] other const iterator to copy from
+    @note This copy constructor had to be defined explicitly to circumvent a bug
+          occurring on msvc v19.0 compiler (VS 2015) debug build. For more
+          information refer to: https://github.com/nlohmann/json/issues/1608
+    */
+    iter_impl(const iter_impl<const BasicJsonType>& other) noexcept
+        : m_object(other.m_object), m_it(other.m_it)
+    {}
+
+    /*!
+    @brief converting assignment
+    @param[in] other const iterator to copy from
+    @return const/non-const iterator
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(const iter_impl<const BasicJsonType>& other) noexcept
+    {
+        if (&other != this)
+        {
+            m_object = other.m_object;
+            m_it = other.m_it;
+        }
+        return *this;
+    }
+
+    /*!
+    @brief converting constructor
+    @param[in] other  non-const iterator to copy from
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
+        : m_object(other.m_object), m_it(other.m_it)
+    {}
+
+    /*!
+    @brief converting assignment
+    @param[in] other  non-const iterator to copy from
+    @return const/non-const iterator
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept // NOLINT(cert-oop54-cpp)
+    {
+        m_object = other.m_object;
+        m_it = other.m_it;
+        return *this;
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief set the iterator to the first value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_begin() noexcept
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = m_object->m_data.m_value.object->begin();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = m_object->m_data.m_value.array->begin();
+                break;
+            }
+
+            case value_t::null:
+            {
+                // set to end so begin()==end() is true: null is empty
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator.set_begin();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @brief set the iterator past the last value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_end() noexcept
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = m_object->m_data.m_value.object->end();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = m_object->m_data.m_value.array->end();
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+        }
+    }
+
+  public:
+    /*!
+    @brief return a reference to the value pointed to by the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator*() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
+                return m_it.object_iterator->second;
+            }
+
+            case value_t::array:
+            {
+                JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
+                return *m_it.array_iterator;
+            }
+
+            case value_t::null:
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
+                {
+                    return *m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+            }
+        }
+    }
+
+    /*!
+    @brief dereference the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    pointer operator->() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
+                return &(m_it.object_iterator->second);
+            }
+
+            case value_t::array:
+            {
+                JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
+                return &*m_it.array_iterator;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
+                {
+                    return m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+            }
+        }
+    }
+
+    /*!
+    @brief post-increment (it++)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator++(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        auto result = *this;
+        ++(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-increment (++it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator++()
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                std::advance(m_it.object_iterator, 1);
+                break;
+            }
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, 1);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                ++m_it.primitive_iterator;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief post-decrement (it--)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator--(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        auto result = *this;
+        --(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-decrement (--it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator--()
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                std::advance(m_it.object_iterator, -1);
+                break;
+            }
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, -1);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                --m_it.primitive_iterator;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief comparison: equal
+    @pre (1) Both iterators are initialized to point to the same object, or (2) both iterators are value-initialized.
+    */
+    template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
+    bool operator==(const IterImpl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
+        }
+
+        // value-initialized forward iterators can be compared, and must compare equal to other value-initialized iterators of the same type #4493
+        if (m_object == nullptr)
+        {
+            return true;
+        }
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                return (m_it.object_iterator == other.m_it.object_iterator);
+
+            case value_t::array:
+                return (m_it.array_iterator == other.m_it.array_iterator);
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return (m_it.primitive_iterator == other.m_it.primitive_iterator);
+        }
+    }
+
+    /*!
+    @brief comparison: not equal
+    @pre (1) Both iterators are initialized to point to the same object, or (2) both iterators are value-initialized.
+    */
+    template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
+    bool operator!=(const IterImpl& other) const
+    {
+        return !operator==(other);
+    }
+
+    /*!
+    @brief comparison: smaller
+    @pre (1) Both iterators are initialized to point to the same object, or (2) both iterators are value-initialized.
+    */
+    bool operator<(const iter_impl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
+        }
+
+        // value-initialized forward iterators can be compared, and must compare equal to other value-initialized iterators of the same type #4493
+        if (m_object == nullptr)
+        {
+            // the iterators are both value-initialized and are to be considered equal, but this function checks for smaller, so we return false
+            return false;
+        }
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators", m_object));
+
+            case value_t::array:
+                return (m_it.array_iterator < other.m_it.array_iterator);
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return (m_it.primitive_iterator < other.m_it.primitive_iterator);
+        }
+    }
+
+    /*!
+    @brief comparison: less than or equal
+    @pre (1) Both iterators are initialized to point to the same object, or (2) both iterators are value-initialized.
+    */
+    bool operator<=(const iter_impl& other) const
+    {
+        return !other.operator < (*this);
+    }
+
+    /*!
+    @brief comparison: greater than
+    @pre (1) Both iterators are initialized to point to the same object, or (2) both iterators are value-initialized.
+    */
+    bool operator>(const iter_impl& other) const
+    {
+        return !operator<=(other);
+    }
+
+    /*!
+    @brief comparison: greater than or equal
+    @pre (1) The iterator is initialized; i.e. `m_object != nullptr`, or (2) both iterators are value-initialized.
+    */
+    bool operator>=(const iter_impl& other) const
+    {
+        return !operator<(other);
+    }
+
+    /*!
+    @brief add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator+=(difference_type i)
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object));
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, i);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator += i;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator-=(difference_type i)
+    {
+        return operator+=(-i);
+    }
+
+    /*!
+    @brief add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator+(difference_type i) const
+    {
+        auto result = *this;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief addition of distance and iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    friend iter_impl operator+(difference_type i, const iter_impl& it)
+    {
+        auto result = it;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator-(difference_type i) const
+    {
+        auto result = *this;
+        result -= i;
+        return result;
+    }
+
+    /*!
+    @brief return difference
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    difference_type operator-(const iter_impl& other) const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object));
+
+            case value_t::array:
+                return m_it.array_iterator - other.m_it.array_iterator;
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return m_it.primitive_iterator - other.m_it.primitive_iterator;
+        }
+    }
+
+    /*!
+    @brief access to successor
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator[](difference_type n) const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators", m_object));
+
+            case value_t::array:
+                return *std::next(m_it.array_iterator, n);
+
+            case value_t::null:
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
+                {
+                    return *m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+            }
+        }
+    }
+
+    /*!
+    @brief return the key of an object iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    const typename object_t::key_type& key() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        if (JSON_HEDLEY_LIKELY(m_object->is_object()))
+        {
+            return m_it.object_iterator->first;
+        }
+
+        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_object));
+    }
+
+    /*!
+    @brief return the value of an iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference value() const
+    {
+        return operator*();
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /// associated JSON instance
+    pointer m_object = nullptr;
+    /// the actual iterator of the associated instance
+    internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
+
+// #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // ptrdiff_t
+#include <iterator> // reverse_iterator
+#include <utility> // declval
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+//////////////////////
+// reverse_iterator //
+//////////////////////
+
+/*!
+@brief a template for a reverse iterator class
+
+@tparam Base the base iterator type to reverse. Valid types are @ref
+iterator (to create @ref reverse_iterator) and @ref const_iterator (to
+create @ref const_reverse_iterator).
+
+@requirement The class satisfies the following concept requirements:
+-
+[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
+  The iterator that can be moved can be moved in both directions (i.e.
+  incremented and decremented).
+- [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):
+  It is possible to write to the pointed-to element (only if @a Base is
+  @ref iterator).
+
+@since version 1.0.0
+*/
+template<typename Base>
+class json_reverse_iterator : public std::reverse_iterator<Base>
+{
+  public:
+    using difference_type = std::ptrdiff_t;
+    /// shortcut to the reverse iterator adapter
+    using base_iterator = std::reverse_iterator<Base>;
+    /// the reference type for the pointed-to element
+    using reference = typename Base::reference;
+
+    /// create reverse iterator from iterator
+    explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
+        : base_iterator(it) {}
+
+    /// create reverse iterator from base class
+    explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
+
+    /// post-increment (it++)
+    json_reverse_iterator operator++(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
+    }
+
+    /// pre-increment (++it)
+    json_reverse_iterator& operator++()
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator++());
+    }
+
+    /// post-decrement (it--)
+    json_reverse_iterator operator--(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
+    }
+
+    /// pre-decrement (--it)
+    json_reverse_iterator& operator--()
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator--());
+    }
+
+    /// add to iterator
+    json_reverse_iterator& operator+=(difference_type i)
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
+    }
+
+    /// add to iterator
+    json_reverse_iterator operator+(difference_type i) const
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
+    }
+
+    /// subtract from iterator
+    json_reverse_iterator operator-(difference_type i) const
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
+    }
+
+    /// return difference
+    difference_type operator-(const json_reverse_iterator& other) const
+    {
+        return base_iterator(*this) - base_iterator(other);
+    }
+
+    /// access to successor
+    reference operator[](difference_type n) const
+    {
+        return *(this->operator+(n));
+    }
+
+    /// return the key of an object iterator
+    auto key() const -> decltype(std::declval<Base>().key())
+    {
+        auto it = --this->base();
+        return it.key();
+    }
+
+    /// return the value of an iterator
+    reference value() const
+    {
+        auto it = --this->base();
+        return it.operator * ();
+    }
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+// #include <nlohmann/detail/json_custom_base_class.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <type_traits> // conditional, is_same
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief Default base class of the @ref basic_json class.
+
+So that the correct implementations of the copy / move ctors / assign operators
+of @ref basic_json do not require complex case distinctions
+(no base class / custom base class used as customization point),
+@ref basic_json always has a base class.
+By default, this class is used because it is empty and thus has no effect
+on the behavior of @ref basic_json.
+*/
+struct json_default_base {};
+
+template<class T>
+using json_base_class = typename std::conditional <
+                        std::is_same<T, void>::value,
+                        json_default_base,
+                        T
+                        >::type;
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/json_pointer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // all_of
+#include <cctype> // isdigit
+#include <cerrno> // errno, ERANGE
+#include <cstdlib> // strtoull
+#ifndef JSON_NO_IO
+    #include <iosfwd> // ostream
+#endif  // JSON_NO_IO
+#include <limits> // max
+#include <numeric> // accumulate
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/string_escape.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
+/// @sa https://json.nlohmann.me/api/json_pointer/
+template<typename RefStringType>
+class json_pointer
+{
+    // allow basic_json to access private members
+    NLOHMANN_BASIC_JSON_TPL_DECLARATION
+    friend class basic_json;
+
+    template<typename>
+    friend class json_pointer;
+
+    template<typename T>
+    struct string_t_helper
+    {
+        using type = T;
+    };
+
+    NLOHMANN_BASIC_JSON_TPL_DECLARATION
+    struct string_t_helper<NLOHMANN_BASIC_JSON_TPL>
+    {
+        using type = StringType;
+    };
+
+  public:
+    // for backwards compatibility accept BasicJsonType
+    using string_t = typename string_t_helper<RefStringType>::type;
+
+    /// @brief create JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/json_pointer/
+    explicit json_pointer(const string_t& s = "")
+        : reference_tokens(split(s))
+    {}
+
+    /// @brief return a string representation of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/to_string/
+    string_t to_string() const
+    {
+        return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
+                               string_t{},
+                               [](const string_t& a, const string_t& b)
+        {
+            return detail::concat(a, '/', detail::escape(b));
+        });
+    }
+
+    /// @brief return a string representation of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_string/
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string())
+    operator string_t() const
+    {
+        return to_string();
+    }
+
+#ifndef JSON_NO_IO
+    /// @brief write string representation of the JSON pointer to stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
+    friend std::ostream& operator<<(std::ostream& o, const json_pointer& ptr)
+    {
+        o << ptr.to_string();
+        return o;
+    }
+#endif
+
+    /// @brief append another JSON pointer at the end of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
+    json_pointer& operator/=(const json_pointer& ptr)
+    {
+        reference_tokens.insert(reference_tokens.end(),
+                                ptr.reference_tokens.begin(),
+                                ptr.reference_tokens.end());
+        return *this;
+    }
+
+    /// @brief append an unescaped reference token at the end of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
+    json_pointer& operator/=(string_t token)
+    {
+        push_back(std::move(token));
+        return *this;
+    }
+
+    /// @brief append an array index at the end of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
+    json_pointer& operator/=(std::size_t array_idx)
+    {
+        return *this /= std::to_string(array_idx);
+    }
+
+    /// @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
+    friend json_pointer operator/(const json_pointer& lhs,
+                                  const json_pointer& rhs)
+    {
+        return json_pointer(lhs) /= rhs;
+    }
+
+    /// @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
+    friend json_pointer operator/(const json_pointer& lhs, string_t token) // NOLINT(performance-unnecessary-value-param)
+    {
+        return json_pointer(lhs) /= std::move(token);
+    }
+
+    /// @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
+    friend json_pointer operator/(const json_pointer& lhs, std::size_t array_idx)
+    {
+        return json_pointer(lhs) /= array_idx;
+    }
+
+    /// @brief returns the parent of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/parent_pointer/
+    json_pointer parent_pointer() const
+    {
+        if (empty())
+        {
+            return *this;
+        }
+
+        json_pointer res = *this;
+        res.pop_back();
+        return res;
+    }
+
+    /// @brief remove last reference token
+    /// @sa https://json.nlohmann.me/api/json_pointer/pop_back/
+    void pop_back()
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
+        }
+
+        reference_tokens.pop_back();
+    }
+
+    /// @brief return last reference token
+    /// @sa https://json.nlohmann.me/api/json_pointer/back/
+    const string_t& back() const
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
+        }
+
+        return reference_tokens.back();
+    }
+
+    /// @brief append an unescaped token at the end of the reference pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
+    void push_back(const string_t& token)
+    {
+        reference_tokens.push_back(token);
+    }
+
+    /// @brief append an unescaped token at the end of the reference pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
+    void push_back(string_t&& token)
+    {
+        reference_tokens.push_back(std::move(token));
+    }
+
+    /// @brief return whether pointer points to the root document
+    /// @sa https://json.nlohmann.me/api/json_pointer/empty/
+    bool empty() const noexcept
+    {
+        return reference_tokens.empty();
+    }
+
+  private:
+    /*!
+    @param[in] s  reference token to be converted into an array index
+
+    @return integer representation of @a s
+
+    @throw parse_error.106  if an array index begins with '0'
+    @throw parse_error.109  if an array index begins not with a digit
+    @throw out_of_range.404 if string @a s could not be converted to an integer
+    @throw out_of_range.410 if an array index exceeds size_type
+    */
+    template<typename BasicJsonType>
+    static typename BasicJsonType::size_type array_index(const string_t& s)
+    {
+        using size_type = typename BasicJsonType::size_type;
+
+        // error condition (cf. RFC 6901, Sect. 4)
+        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
+        {
+            JSON_THROW(detail::parse_error::create(106, 0, detail::concat("array index '", s, "' must not begin with '0'"), nullptr));
+        }
+
+        // error condition (cf. RFC 6901, Sect. 4)
+        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
+        {
+            JSON_THROW(detail::parse_error::create(109, 0, detail::concat("array index '", s, "' is not a number"), nullptr));
+        }
+
+        const char* p = s.c_str();
+        char* p_end = nullptr; // NOLINT(misc-const-correctness)
+        errno = 0; // strtoull doesn't reset errno
+        const unsigned long long res = std::strtoull(p, &p_end, 10); // NOLINT(runtime/int)
+        if (p == p_end // invalid input or empty string
+                || errno == ERANGE // out of range
+                || JSON_HEDLEY_UNLIKELY(static_cast<std::size_t>(p_end - p) != s.size())) // incomplete read
+        {
+            JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", s, "'"), nullptr));
+        }
+
+        // only triggered on special platforms (like 32bit), see also
+        // https://github.com/nlohmann/json/pull/2203
+        if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))  // NOLINT(runtime/int)
+        {
+            JSON_THROW(detail::out_of_range::create(410, detail::concat("array index ", s, " exceeds size_type"), nullptr));   // LCOV_EXCL_LINE
+        }
+
+        return static_cast<size_type>(res);
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    json_pointer top() const
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
+        }
+
+        json_pointer result = *this;
+        result.reference_tokens = {reference_tokens[0]};
+        return result;
+    }
+
+  private:
+    /*!
+    @brief create and return a reference to the pointed to value
+
+    @complexity Linear in the number of reference tokens.
+
+    @throw parse_error.109 if array index is not a number
+    @throw type_error.313 if value cannot be unflattened
+    */
+    template<typename BasicJsonType>
+    BasicJsonType& get_and_create(BasicJsonType& j) const
+    {
+        auto* result = &j;
+
+        // in case no reference tokens exist, return a reference to the JSON value
+        // j which will be overwritten by a primitive value
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (result->type())
+            {
+                case detail::value_t::null:
+                {
+                    if (reference_token == "0")
+                    {
+                        // start a new array if the reference token is 0
+                        result = &result->operator[](0);
+                    }
+                    else
+                    {
+                        // start a new object otherwise
+                        result = &result->operator[](reference_token);
+                    }
+                    break;
+                }
+
+                case detail::value_t::object:
+                {
+                    // create an entry in the object
+                    result = &result->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    // create an entry in the array
+                    result = &result->operator[](array_index<BasicJsonType>(reference_token));
+                    break;
+                }
+
+                /*
+                The following code is only reached if there exists a reference
+                token _and_ the current value is primitive. In this case, we have
+                an error situation, because primitive values may only occur as
+                a single value; that is, with an empty list of reference tokens.
+                */
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", &j));
+            }
+        }
+
+        return *result;
+    }
+
+    /*!
+    @brief return a reference to the pointed to value
+
+    @note This version does not throw if a value is not present, but tries to
+          create nested values instead. For instance, calling this function
+          with pointer `"/this/that"` on a null value is equivalent to calling
+          `operator[]("this").operator[]("that")` on that value, effectively
+          changing the null value to an object.
+
+    @param[in] ptr  a JSON value
+
+    @return reference to the JSON value pointed to by the JSON pointer
+
+    @complexity Linear in the length of the JSON pointer.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    template<typename BasicJsonType>
+    BasicJsonType& get_unchecked(BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            // convert null values to arrays or objects before continuing
+            if (ptr->is_null())
+            {
+                // check if the reference token is a number
+                const bool nums =
+                    std::all_of(reference_token.begin(), reference_token.end(),
+                                [](const unsigned char x)
+                {
+                    return std::isdigit(x);
+                });
+
+                // change value to an array for numbers or "-" or to object otherwise
+                *ptr = (nums || reference_token == "-")
+                       ? detail::value_t::array
+                       : detail::value_t::object;
+            }
+
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (reference_token == "-")
+                    {
+                        // explicitly treat "-" as index beyond the end
+                        ptr = &ptr->operator[](ptr->m_data.m_value.array->size());
+                    }
+                    else
+                    {
+                        // convert array index to number; unchecked access
+                        ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
+                    }
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    template<typename BasicJsonType>
+    BasicJsonType& get_checked(BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        JSON_THROW(detail::out_of_range::create(402, detail::concat(
+                                "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()),
+                                ") is out of range"), ptr));
+                    }
+
+                    // note: at performs range check
+                    ptr = &ptr->at(array_index<BasicJsonType>(reference_token));
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @brief return a const reference to the pointed to value
+
+    @param[in] ptr  a JSON value
+
+    @return const reference to the JSON value pointed to by the JSON
+    pointer
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    template<typename BasicJsonType>
+    const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" cannot be used for const access
+                        JSON_THROW(detail::out_of_range::create(402, detail::concat("array index '-' (", std::to_string(ptr->m_data.m_value.array->size()), ") is out of range"), ptr));
+                    }
+
+                    // use unchecked array access
+                    ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    template<typename BasicJsonType>
+    const BasicJsonType& get_checked(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        JSON_THROW(detail::out_of_range::create(402, detail::concat(
+                                "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()),
+                                ") is out of range"), ptr));
+                    }
+
+                    // note: at performs range check
+                    ptr = &ptr->at(array_index<BasicJsonType>(reference_token));
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    */
+    template<typename BasicJsonType>
+    bool contains(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    if (!ptr->contains(reference_token))
+                    {
+                        // we did not find the key in the object
+                        return false;
+                    }
+
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
+                    {
+                        // invalid char
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
+                        {
+                            // the first char should be between '1' and '9'
+                            return false;
+                        }
+                        for (std::size_t i = 1; i < reference_token.size(); i++)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
+                            {
+                                // other char should be between '0' and '9'
+                                return false;
+                            }
+                        }
+                    }
+
+                    const auto idx = array_index<BasicJsonType>(reference_token);
+                    if (idx >= ptr->size())
+                    {
+                        // index out of range
+                        return false;
+                    }
+
+                    ptr = &ptr->operator[](idx);
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                {
+                    // we do not expect primitive values if there is still a
+                    // reference token to process
+                    return false;
+                }
+            }
+        }
+
+        // no reference token left means we found a primitive value
+        return true;
+    }
+
+    /*!
+    @brief split the string input to reference tokens
+
+    @note This function is only called by the json_pointer constructor.
+          All exceptions below are documented there.
+
+    @throw parse_error.107  if the pointer is not empty or begins with '/'
+    @throw parse_error.108  if character '~' is not followed by '0' or '1'
+    */
+    static std::vector<string_t> split(const string_t& reference_string)
+    {
+        std::vector<string_t> result;
+
+        // special case: empty reference string -> no reference tokens
+        if (reference_string.empty())
+        {
+            return result;
+        }
+
+        // check if a nonempty reference string begins with slash
+        if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
+        {
+            JSON_THROW(detail::parse_error::create(107, 1, detail::concat("JSON pointer must be empty or begin with '/' - was: '", reference_string, "'"), nullptr));
+        }
+
+        // extract the reference tokens:
+        // - slash: position of the last read slash (or end of string)
+        // - start: position after the previous slash
+        for (
+            // search for the first slash after the first character
+            std::size_t slash = reference_string.find_first_of('/', 1),
+            // set the beginning of the first reference token
+            start = 1;
+            // we can stop if start == 0 (if slash == string_t::npos)
+            start != 0;
+            // set the beginning of the next reference token
+            // (will eventually be 0 if slash == string_t::npos)
+            start = (slash == string_t::npos) ? 0 : slash + 1,
+            // find next slash
+            slash = reference_string.find_first_of('/', start))
+        {
+            // use the text between the beginning of the reference token
+            // (start) and the last slash (slash).
+            auto reference_token = reference_string.substr(start, slash - start);
+
+            // check reference tokens are properly escaped
+            for (std::size_t pos = reference_token.find_first_of('~');
+                    pos != string_t::npos;
+                    pos = reference_token.find_first_of('~', pos + 1))
+            {
+                JSON_ASSERT(reference_token[pos] == '~');
+
+                // ~ must be followed by 0 or 1
+                if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
+                                         (reference_token[pos + 1] != '0' &&
+                                          reference_token[pos + 1] != '1')))
+                {
+                    JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'", nullptr));
+                }
+            }
+
+            // finally, store the reference token
+            detail::unescape(reference_token);
+            result.push_back(reference_token);
+        }
+
+        return result;
+    }
+
+  private:
+    /*!
+    @param[in] reference_string  the reference string to the current value
+    @param[in] value             the value to consider
+    @param[in,out] result        the result object to insert values to
+
+    @note Empty objects or arrays are flattened to `null`.
+    */
+    template<typename BasicJsonType>
+    static void flatten(const string_t& reference_string,
+                        const BasicJsonType& value,
+                        BasicJsonType& result)
+    {
+        switch (value.type())
+        {
+            case detail::value_t::array:
+            {
+                if (value.m_data.m_value.array->empty())
+                {
+                    // flatten empty array as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate array and use index as a reference string
+                    for (std::size_t i = 0; i < value.m_data.m_value.array->size(); ++i)
+                    {
+                        flatten(detail::concat<string_t>(reference_string, '/', std::to_string(i)),
+                                value.m_data.m_value.array->operator[](i), result);
+                    }
+                }
+                break;
+            }
+
+            case detail::value_t::object:
+            {
+                if (value.m_data.m_value.object->empty())
+                {
+                    // flatten empty object as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate object and use keys as reference string
+                    for (const auto& element : *value.m_data.m_value.object)
+                    {
+                        flatten(detail::concat<string_t>(reference_string, '/', detail::escape(element.first)), element.second, result);
+                    }
+                }
+                break;
+            }
+
+            case detail::value_t::null:
+            case detail::value_t::string:
+            case detail::value_t::boolean:
+            case detail::value_t::number_integer:
+            case detail::value_t::number_unsigned:
+            case detail::value_t::number_float:
+            case detail::value_t::binary:
+            case detail::value_t::discarded:
+            default:
+            {
+                // add a primitive value with its reference string
+                result[reference_string] = value;
+                break;
+            }
+        }
+    }
+
+    /*!
+    @param[in] value  flattened JSON
+
+    @return unflattened JSON
+
+    @throw parse_error.109 if array index is not a number
+    @throw type_error.314  if value is not an object
+    @throw type_error.315  if object values are not primitive
+    @throw type_error.313  if value cannot be unflattened
+    */
+    template<typename BasicJsonType>
+    static BasicJsonType
+    unflatten(const BasicJsonType& value)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
+        {
+            JSON_THROW(detail::type_error::create(314, "only objects can be unflattened", &value));
+        }
+
+        BasicJsonType result;
+
+        // iterate the JSON object values
+        for (const auto& element : *value.m_data.m_value.object)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
+            {
+                JSON_THROW(detail::type_error::create(315, "values in object must be primitive", &element.second));
+            }
+
+            // Assign the value to the reference pointed to by JSON pointer. Note
+            // that if the JSON pointer is "" (i.e., points to the whole value),
+            // function get_and_create returns a reference to the result itself.
+            // An assignment will then create a primitive value.
+            json_pointer(element.first).get_and_create(result) = element.second;
+        }
+
+        return result;
+    }
+
+    // can't use the conversion operator because of ambiguity
+    json_pointer<string_t> convert() const&
+    {
+        json_pointer<string_t> result;
+        result.reference_tokens = reference_tokens;
+        return result;
+    }
+
+    json_pointer<string_t> convert()&&
+    {
+        json_pointer<string_t> result;
+        result.reference_tokens = std::move(reference_tokens);
+        return result;
+    }
+
+  public:
+#if JSON_HAS_THREE_WAY_COMPARISON
+    /// @brief compares two JSON pointers for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    template<typename RefStringTypeRhs>
+    bool operator==(const json_pointer<RefStringTypeRhs>& rhs) const noexcept
+    {
+        return reference_tokens == rhs.reference_tokens;
+    }
+
+    /// @brief compares JSON pointer and string for equality
+    /// @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
+    {
+        return *this == json_pointer(rhs);
+    }
+
+    /// @brief 3-way compares two JSON pointers
+    template<typename RefStringTypeRhs>
+    std::strong_ordering operator<=>(const json_pointer<RefStringTypeRhs>& rhs) const noexcept // *NOPAD*
+    {
+        return  reference_tokens <=> rhs.reference_tokens; // *NOPAD*
+    }
+#else
+    /// @brief compares two JSON pointers for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
+                           const json_pointer<RefStringTypeRhs>& rhs) noexcept;
+
+    /// @brief compares JSON pointer and string for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    template<typename RefStringTypeLhs, typename StringType>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
+                           const StringType& rhs);
+
+    /// @brief compares string and JSON pointer for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    template<typename RefStringTypeRhs, typename StringType>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator==(const StringType& lhs,
+                           const json_pointer<RefStringTypeRhs>& rhs);
+
+    /// @brief compares two JSON pointers for inequality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
+    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
+                           const json_pointer<RefStringTypeRhs>& rhs) noexcept;
+
+    /// @brief compares JSON pointer and string for inequality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
+    template<typename RefStringTypeLhs, typename StringType>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
+                           const StringType& rhs);
+
+    /// @brief compares string and JSON pointer for inequality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
+    template<typename RefStringTypeRhs, typename StringType>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator!=(const StringType& lhs,
+                           const json_pointer<RefStringTypeRhs>& rhs);
+
+    /// @brief compares two JSON pointer for less-than
+    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
+                          const json_pointer<RefStringTypeRhs>& rhs) noexcept;
+#endif
+
+  private:
+    /// the reference tokens
+    std::vector<string_t> reference_tokens;
+};
+
+#if !JSON_HAS_THREE_WAY_COMPARISON
+// functions cannot be defined inside the class due to ODR violations
+template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
+                       const json_pointer<RefStringTypeRhs>& rhs) noexcept
+{
+    return lhs.reference_tokens == rhs.reference_tokens;
+}
+
+template<typename RefStringTypeLhs,
+         typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>
+JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
+inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
+                       const StringType& rhs)
+{
+    return lhs == json_pointer<RefStringTypeLhs>(rhs);
+}
+
+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)
+{
+    return json_pointer<RefStringTypeRhs>(lhs) == rhs;
+}
+
+template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
+                       const json_pointer<RefStringTypeRhs>& rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+template<typename RefStringTypeLhs,
+         typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>
+JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
+inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
+                       const StringType& rhs)
+{
+    return !(lhs == rhs);
+}
+
+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)
+{
+    return !(lhs == rhs);
+}
+
+template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+inline bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
+                      const json_pointer<RefStringTypeRhs>& rhs) noexcept
+{
+    return lhs.reference_tokens < rhs.reference_tokens;
+}
+#endif
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/json_ref.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <initializer_list>
+#include <utility>
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename BasicJsonType>
+class json_ref
+{
+  public:
+    using value_type = BasicJsonType;
+
+    json_ref(value_type&& value)
+        : owned_value(std::move(value))
+    {}
+
+    json_ref(const value_type& value)
+        : value_ref(&value)
+    {}
+
+    json_ref(std::initializer_list<json_ref> init)
+        : owned_value(init)
+    {}
+
+    template <
+        class... Args,
+        enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
+    json_ref(Args && ... args)
+        : owned_value(std::forward<Args>(args)...)
+    {}
+
+    // class should be movable only
+    json_ref(json_ref&&) noexcept = default;
+    json_ref(const json_ref&) = delete;
+    json_ref& operator=(const json_ref&) = delete;
+    json_ref& operator=(json_ref&&) = delete;
+    ~json_ref() = default;
+
+    value_type moved_or_copied() const
+    {
+        if (value_ref == nullptr)
+        {
+            return std::move(owned_value);
+        }
+        return *value_ref;
+    }
+
+    value_type const& operator*() const
+    {
+        return value_ref ? *value_ref : owned_value;
+    }
+
+    value_type const* operator->() const
+    {
+        return &** this;
+    }
+
+  private:
+    mutable value_type owned_value = nullptr;
+    value_type const* value_ref = nullptr;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/string_escape.hpp>
+
+// #include <nlohmann/detail/string_utils.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/output/binary_writer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // reverse
+#include <array> // array
+#include <map> // map
+#include <cmath> // isnan, isinf
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstring> // memcpy
+#include <limits> // numeric_limits
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/input/binary_reader.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // copy
+#include <cstddef> // size_t
+#include <iterator> // back_inserter
+#include <memory> // shared_ptr, make_shared
+#include <string> // basic_string
+#include <vector> // vector
+
+#ifndef JSON_NO_IO
+    #include <ios>      // streamsize
+    #include <ostream>  // basic_ostream
+#endif  // JSON_NO_IO
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// abstract output adapter interface
+template<typename CharType> struct output_adapter_protocol
+{
+    virtual void write_character(CharType c) = 0;
+    virtual void write_characters(const CharType* s, std::size_t length) = 0;
+    virtual ~output_adapter_protocol() = default;
+
+    output_adapter_protocol() = default;
+    output_adapter_protocol(const output_adapter_protocol&) = default;
+    output_adapter_protocol(output_adapter_protocol&&) noexcept = default;
+    output_adapter_protocol& operator=(const output_adapter_protocol&) = default;
+    output_adapter_protocol& operator=(output_adapter_protocol&&) noexcept = default;
+};
+
+/// a type to simplify interfaces
+template<typename CharType>
+using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
+
+/// output adapter for byte vectors
+template<typename CharType, typename AllocatorType = std::allocator<CharType>>
+class output_vector_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
+        : v(vec)
+    {}
+
+    void write_character(CharType c) override
+    {
+        v.push_back(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        v.insert(v.end(), s, s + length);
+    }
+
+  private:
+    std::vector<CharType, AllocatorType>& v;
+};
+
+#ifndef JSON_NO_IO
+/// output adapter for output streams
+template<typename CharType>
+class output_stream_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
+        : stream(s)
+    {}
+
+    void write_character(CharType c) override
+    {
+        stream.put(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        stream.write(s, static_cast<std::streamsize>(length));
+    }
+
+  private:
+    std::basic_ostream<CharType>& stream;
+};
+#endif  // JSON_NO_IO
+
+/// output adapter for basic_string
+template<typename CharType, typename StringType = std::basic_string<CharType>>
+class output_string_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_string_adapter(StringType& s) noexcept
+        : str(s)
+    {}
+
+    void write_character(CharType c) override
+    {
+        str.push_back(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        str.append(s, length);
+    }
+
+  private:
+    StringType& str;
+};
+
+template<typename CharType, typename StringType = std::basic_string<CharType>>
+class output_adapter
+{
+  public:
+    template<typename AllocatorType = std::allocator<CharType>>
+    output_adapter(std::vector<CharType, AllocatorType>& vec)
+        : oa(std::make_shared<output_vector_adapter<CharType, AllocatorType>>(vec)) {}
+
+#ifndef JSON_NO_IO
+    output_adapter(std::basic_ostream<CharType>& s)
+        : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
+#endif  // JSON_NO_IO
+
+    output_adapter(StringType& s)
+        : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
+
+    operator output_adapter_t<CharType>()
+    {
+        return oa;
+    }
+
+  private:
+    output_adapter_t<CharType> oa = nullptr;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// how to encode BJData
+enum class bjdata_version_t
+{
+    draft2,
+    draft3,
+};
+
+///////////////////
+// binary writer //
+///////////////////
+
+/*!
+@brief serialization to CBOR and MessagePack values
+*/
+template<typename BasicJsonType, typename CharType>
+class binary_writer
+{
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+
+  public:
+    /*!
+    @brief create a binary writer
+
+    @param[in] adapter  output adapter to write to
+    */
+    explicit binary_writer(output_adapter_t<CharType> adapter) : oa(std::move(adapter))
+    {
+        JSON_ASSERT(oa);
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @pre       j.type() == value_t::object
+    */
+    void write_bson(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::object:
+            {
+                write_bson_object(*j.m_data.m_value.object);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::array:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                JSON_THROW(type_error::create(317, concat("to serialize to BSON, top-level type must be object, but is ", j.type_name()), &j));
+            }
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    */
+    void write_cbor(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+            {
+                oa->write_character(to_char_type(0xF6));
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                oa->write_character(j.m_data.m_value.boolean
+                                    ? to_char_type(0xF5)
+                                    : to_char_type(0xF4));
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                if (j.m_data.m_value.number_integer >= 0)
+                {
+                    // CBOR does not differentiate between positive signed
+                    // integers and unsigned integers. Therefore, we used the
+                    // code from the value_t::number_unsigned case here.
+                    if (j.m_data.m_value.number_integer <= 0x17)
+                    {
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x18));
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x19));
+                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x1A));
+                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
+                    }
+                    else
+                    {
+                        oa->write_character(to_char_type(0x1B));
+                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                    }
+                }
+                else
+                {
+                    // The conversions below encode the sign in the first
+                    // byte, and the value is converted to a positive number.
+                    const auto positive_number = -1 - j.m_data.m_value.number_integer;
+                    if (j.m_data.m_value.number_integer >= -24)
+                    {
+                        write_number(static_cast<std::uint8_t>(0x20 + positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x38));
+                        write_number(static_cast<std::uint8_t>(positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x39));
+                        write_number(static_cast<std::uint16_t>(positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x3A));
+                        write_number(static_cast<std::uint32_t>(positive_number));
+                    }
+                    else
+                    {
+                        oa->write_character(to_char_type(0x3B));
+                        write_number(static_cast<std::uint64_t>(positive_number));
+                    }
+                }
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_data.m_value.number_unsigned <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_unsigned));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x18));
+                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_unsigned));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x19));
+                    write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_unsigned));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x1A));
+                    write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_unsigned));
+                }
+                else
+                {
+                    oa->write_character(to_char_type(0x1B));
+                    write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
+                }
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                if (std::isnan(j.m_data.m_value.number_float))
+                {
+                    // NaN is 0xf97e00 in CBOR
+                    oa->write_character(to_char_type(0xF9));
+                    oa->write_character(to_char_type(0x7E));
+                    oa->write_character(to_char_type(0x00));
+                }
+                else if (std::isinf(j.m_data.m_value.number_float))
+                {
+                    // Infinity is 0xf97c00, -Infinity is 0xf9fc00
+                    oa->write_character(to_char_type(0xf9));
+                    oa->write_character(j.m_data.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
+                    oa->write_character(to_char_type(0x00));
+                }
+                else
+                {
+                    write_compact_float(j.m_data.m_value.number_float, detail::input_format_t::cbor);
+                }
+                break;
+            }
+
+            case value_t::string:
+            {
+                // step 1: write control byte and the string length
+                const auto N = j.m_data.m_value.string->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x60 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x78));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x79));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x7A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x7B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write the string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
+                    j.m_data.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                // step 1: write control byte and the array size
+                const auto N = j.m_data.m_value.array->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x80 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x98));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x99));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x9A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x9B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_cbor(el);
+                }
+                break;
+            }
+
+            case value_t::binary:
+            {
+                if (j.m_data.m_value.binary->has_subtype())
+                {
+                    if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xd8));
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.binary->subtype()));
+                    }
+                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xd9));
+                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.binary->subtype()));
+                    }
+                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xda));
+                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.binary->subtype()));
+                    }
+                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint64_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xdb));
+                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.binary->subtype()));
+                    }
+                }
+
+                // step 1: write control byte and the binary array size
+                const auto N = j.m_data.m_value.binary->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x40 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x58));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x59));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x5A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x5B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
+                    N);
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // step 1: write control byte and the object size
+                const auto N = j.m_data.m_value.object->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0xA0 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xB8));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xB9));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xBA));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xBB));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                for (const auto& el : *j.m_data.m_value.object)
+                {
+                    write_cbor(el.first);
+                    write_cbor(el.second);
+                }
+                break;
+            }
+
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    */
+    void write_msgpack(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::null: // nil
+            {
+                oa->write_character(to_char_type(0xC0));
+                break;
+            }
+
+            case value_t::boolean: // true and false
+            {
+                oa->write_character(j.m_data.m_value.boolean
+                                    ? to_char_type(0xC3)
+                                    : to_char_type(0xC2));
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                if (j.m_data.m_value.number_integer >= 0)
+                {
+                    // MessagePack does not differentiate between positive
+                    // signed integers and unsigned integers. Therefore, we used
+                    // the code from the value_t::number_unsigned case here.
+                    if (j.m_data.m_value.number_unsigned < 128)
+                    {
+                        // positive fixnum
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        // uint 8
+                        oa->write_character(to_char_type(0xCC));
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        // uint 16
+                        oa->write_character(to_char_type(0xCD));
+                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        // uint 32
+                        oa->write_character(to_char_type(0xCE));
+                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                    {
+                        // uint 64
+                        oa->write_character(to_char_type(0xCF));
+                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                    }
+                }
+                else
+                {
+                    if (j.m_data.m_value.number_integer >= -32)
+                    {
+                        // negative fixnum
+                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                    {
+                        // int 8
+                        oa->write_character(to_char_type(0xD0));
+                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                    {
+                        // int 16
+                        oa->write_character(to_char_type(0xD1));
+                        write_number(static_cast<std::int16_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                    {
+                        // int 32
+                        oa->write_character(to_char_type(0xD2));
+                        write_number(static_cast<std::int32_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
+                    {
+                        // int 64
+                        oa->write_character(to_char_type(0xD3));
+                        write_number(static_cast<std::int64_t>(j.m_data.m_value.number_integer));
+                    }
+                }
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_data.m_value.number_unsigned < 128)
+                {
+                    // positive fixnum
+                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    // uint 8
+                    oa->write_character(to_char_type(0xCC));
+                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // uint 16
+                    oa->write_character(to_char_type(0xCD));
+                    write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // uint 32
+                    oa->write_character(to_char_type(0xCE));
+                    write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    // uint 64
+                    oa->write_character(to_char_type(0xCF));
+                    write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                }
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                write_compact_float(j.m_data.m_value.number_float, detail::input_format_t::msgpack);
+                break;
+            }
+
+            case value_t::string:
+            {
+                // step 1: write control byte and the string length
+                const auto N = j.m_data.m_value.string->size();
+                if (N <= 31)
+                {
+                    // fixstr
+                    write_number(static_cast<std::uint8_t>(0xA0 | N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    // str 8
+                    oa->write_character(to_char_type(0xD9));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // str 16
+                    oa->write_character(to_char_type(0xDA));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // str 32
+                    oa->write_character(to_char_type(0xDB));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write the string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
+                    j.m_data.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                // step 1: write control byte and the array size
+                const auto N = j.m_data.m_value.array->size();
+                if (N <= 15)
+                {
+                    // fixarray
+                    write_number(static_cast<std::uint8_t>(0x90 | N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // array 16
+                    oa->write_character(to_char_type(0xDC));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // array 32
+                    oa->write_character(to_char_type(0xDD));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write each element
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_msgpack(el);
+                }
+                break;
+            }
+
+            case value_t::binary:
+            {
+                // step 0: determine if the binary type has a set subtype to
+                // determine whether to use the ext or fixext types
+                const bool use_ext = j.m_data.m_value.binary->has_subtype();
+
+                // step 1: write control byte and the byte string length
+                const auto N = j.m_data.m_value.binary->size();
+                if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    std::uint8_t output_type{};
+                    bool fixed = true;
+                    if (use_ext)
+                    {
+                        switch (N)
+                        {
+                            case 1:
+                                output_type = 0xD4; // fixext 1
+                                break;
+                            case 2:
+                                output_type = 0xD5; // fixext 2
+                                break;
+                            case 4:
+                                output_type = 0xD6; // fixext 4
+                                break;
+                            case 8:
+                                output_type = 0xD7; // fixext 8
+                                break;
+                            case 16:
+                                output_type = 0xD8; // fixext 16
+                                break;
+                            default:
+                                output_type = 0xC7; // ext 8
+                                fixed = false;
+                                break;
+                        }
+
+                    }
+                    else
+                    {
+                        output_type = 0xC4; // bin 8
+                        fixed = false;
+                    }
+
+                    oa->write_character(to_char_type(output_type));
+                    if (!fixed)
+                    {
+                        write_number(static_cast<std::uint8_t>(N));
+                    }
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    const std::uint8_t output_type = use_ext
+                                                     ? 0xC8 // ext 16
+                                                     : 0xC5; // bin 16
+
+                    oa->write_character(to_char_type(output_type));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    const std::uint8_t output_type = use_ext
+                                                     ? 0xC9 // ext 32
+                                                     : 0xC6; // bin 32
+
+                    oa->write_character(to_char_type(output_type));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 1.5: if this is an ext type, write the subtype
+                if (use_ext)
+                {
+                    write_number(static_cast<std::int8_t>(j.m_data.m_value.binary->subtype()));
+                }
+
+                // step 2: write the byte string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
+                    N);
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // step 1: write control byte and the object size
+                const auto N = j.m_data.m_value.object->size();
+                if (N <= 15)
+                {
+                    // fixmap
+                    write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // map 16
+                    oa->write_character(to_char_type(0xDE));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // map 32
+                    oa->write_character(to_char_type(0xDF));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write each element
+                for (const auto& el : *j.m_data.m_value.object)
+                {
+                    write_msgpack(el.first);
+                    write_msgpack(el.second);
+                }
+                break;
+            }
+
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @param[in] use_count   whether to use '#' prefixes (optimized format)
+    @param[in] use_type    whether to use '$' prefixes (optimized format)
+    @param[in] add_prefix  whether prefixes need to be used for this value
+    @param[in] use_bjdata  whether write in BJData format, default is false
+    @param[in] bjdata_version  which BJData version to use, default is draft2
+    */
+    void write_ubjson(const BasicJsonType& j, const bool use_count,
+                      const bool use_type, const bool add_prefix = true,
+                      const bool use_bjdata = false, const bjdata_version_t bjdata_version = bjdata_version_t::draft2)
+    {
+        const bool bjdata_draft3 = use_bjdata && bjdata_version == bjdata_version_t::draft3;
+
+        switch (j.type())
+        {
+            case value_t::null:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('Z'));
+                }
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(j.m_data.m_value.boolean
+                                        ? to_char_type('T')
+                                        : to_char_type('F'));
+                }
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                write_number_with_ubjson_prefix(j.m_data.m_value.number_integer, add_prefix, use_bjdata);
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                write_number_with_ubjson_prefix(j.m_data.m_value.number_unsigned, add_prefix, use_bjdata);
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                write_number_with_ubjson_prefix(j.m_data.m_value.number_float, add_prefix, use_bjdata);
+                break;
+            }
+
+            case value_t::string:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('S'));
+                }
+                write_number_with_ubjson_prefix(j.m_data.m_value.string->size(), true, use_bjdata);
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
+                    j.m_data.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('['));
+                }
+
+                bool prefix_required = true;
+                if (use_type && !j.m_data.m_value.array->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
+                    const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
+                                                         [this, first_prefix, use_bjdata](const BasicJsonType & v)
+                    {
+                        return ubjson_prefix(v, use_bjdata) == first_prefix;
+                    });
+
+                    std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type
+
+                    if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
+                    {
+                        prefix_required = false;
+                        oa->write_character(to_char_type('$'));
+                        oa->write_character(first_prefix);
+                    }
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_data.m_value.array->size(), true, use_bjdata);
+                }
+
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_ubjson(el, use_count, use_type, prefix_required, use_bjdata, bjdata_version);
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type(']'));
+                }
+
+                break;
+            }
+
+            case value_t::binary:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('['));
+                }
+
+                if (use_type && (bjdata_draft3 || !j.m_data.m_value.binary->empty()))
+                {
+                    JSON_ASSERT(use_count);
+                    oa->write_character(to_char_type('$'));
+                    oa->write_character(bjdata_draft3 ? 'B' : 'U');
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_data.m_value.binary->size(), true, use_bjdata);
+                }
+
+                if (use_type)
+                {
+                    oa->write_characters(
+                        reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
+                        j.m_data.m_value.binary->size());
+                }
+                else
+                {
+                    for (size_t i = 0; i < j.m_data.m_value.binary->size(); ++i)
+                    {
+                        oa->write_character(to_char_type(bjdata_draft3 ? 'B' : 'U'));
+                        oa->write_character(j.m_data.m_value.binary->data()[i]);
+                    }
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type(']'));
+                }
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                if (use_bjdata && j.m_data.m_value.object->size() == 3 && j.m_data.m_value.object->find("_ArrayType_") != j.m_data.m_value.object->end() && j.m_data.m_value.object->find("_ArraySize_") != j.m_data.m_value.object->end() && j.m_data.m_value.object->find("_ArrayData_") != j.m_data.m_value.object->end())
+                {
+                    if (!write_bjdata_ndarray(*j.m_data.m_value.object, use_count, use_type, bjdata_version))  // decode bjdata ndarray in the JData format (https://github.com/NeuroJSON/jdata)
+                    {
+                        break;
+                    }
+                }
+
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('{'));
+                }
+
+                bool prefix_required = true;
+                if (use_type && !j.m_data.m_value.object->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
+                    const bool same_prefix = std::all_of(j.begin(), j.end(),
+                                                         [this, first_prefix, use_bjdata](const BasicJsonType & v)
+                    {
+                        return ubjson_prefix(v, use_bjdata) == first_prefix;
+                    });
+
+                    std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type
+
+                    if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
+                    {
+                        prefix_required = false;
+                        oa->write_character(to_char_type('$'));
+                        oa->write_character(first_prefix);
+                    }
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_data.m_value.object->size(), true, use_bjdata);
+                }
+
+                for (const auto& el : *j.m_data.m_value.object)
+                {
+                    write_number_with_ubjson_prefix(el.first.size(), true, use_bjdata);
+                    oa->write_characters(
+                        reinterpret_cast<const CharType*>(el.first.c_str()),
+                        el.first.size());
+                    write_ubjson(el.second, use_count, use_type, prefix_required, use_bjdata, bjdata_version);
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type('}'));
+                }
+
+                break;
+            }
+
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+  private:
+    //////////
+    // BSON //
+    //////////
+
+    /*!
+    @return The size of a BSON document entry header, including the id marker
+            and the entry name size (and its null-terminator).
+    */
+    static std::size_t calc_bson_entry_header_size(const string_t& name, const BasicJsonType& j)
+    {
+        const auto it = name.find(static_cast<typename string_t::value_type>(0));
+        if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
+        {
+            JSON_THROW(out_of_range::create(409, concat("BSON key cannot contain code point U+0000 (at byte ", std::to_string(it), ")"), &j));
+        }
+
+        static_cast<void>(j);
+        return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
+    }
+
+    /*!
+    @brief Writes the given @a element_type and @a name to the output adapter
+    */
+    void write_bson_entry_header(const string_t& name,
+                                 const std::uint8_t element_type)
+    {
+        oa->write_character(to_char_type(element_type)); // boolean
+        oa->write_characters(
+            reinterpret_cast<const CharType*>(name.c_str()),
+            name.size() + 1u);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and boolean value @a value
+    */
+    void write_bson_boolean(const string_t& name,
+                            const bool value)
+    {
+        write_bson_entry_header(name, 0x08);
+        oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and double value @a value
+    */
+    void write_bson_double(const string_t& name,
+                           const double value)
+    {
+        write_bson_entry_header(name, 0x01);
+        write_number<double>(value, true);
+    }
+
+    /*!
+    @return The size of the BSON-encoded string in @a value
+    */
+    static std::size_t calc_bson_string_size(const string_t& value)
+    {
+        return sizeof(std::int32_t) + value.size() + 1ul;
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and string value @a value
+    */
+    void write_bson_string(const string_t& name,
+                           const string_t& value)
+    {
+        write_bson_entry_header(name, 0x02);
+
+        write_number<std::int32_t>(static_cast<std::int32_t>(value.size() + 1ul), true);
+        oa->write_characters(
+            reinterpret_cast<const CharType*>(value.c_str()),
+            value.size() + 1);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and null value
+    */
+    void write_bson_null(const string_t& name)
+    {
+        write_bson_entry_header(name, 0x0A);
+    }
+
+    /*!
+    @return The size of the BSON-encoded integer @a value
+    */
+    static std::size_t calc_bson_integer_size(const std::int64_t value)
+    {
+        return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
+               ? sizeof(std::int32_t)
+               : sizeof(std::int64_t);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and integer @a value
+    */
+    void write_bson_integer(const string_t& name,
+                            const std::int64_t value)
+    {
+        if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
+        {
+            write_bson_entry_header(name, 0x10); // int32
+            write_number<std::int32_t>(static_cast<std::int32_t>(value), true);
+        }
+        else
+        {
+            write_bson_entry_header(name, 0x12); // int64
+            write_number<std::int64_t>(static_cast<std::int64_t>(value), true);
+        }
+    }
+
+    /*!
+    @return The size of the BSON-encoded unsigned integer in @a j
+    */
+    static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
+    {
+        return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+               ? sizeof(std::int32_t)
+               : sizeof(std::int64_t);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and unsigned @a value
+    */
+    void write_bson_unsigned(const string_t& name,
+                             const BasicJsonType& j)
+    {
+        if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+        {
+            write_bson_entry_header(name, 0x10 /* int32 */);
+            write_number<std::int32_t>(static_cast<std::int32_t>(j.m_data.m_value.number_unsigned), true);
+        }
+        else if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+        {
+            write_bson_entry_header(name, 0x12 /* int64 */);
+            write_number<std::int64_t>(static_cast<std::int64_t>(j.m_data.m_value.number_unsigned), true);
+        }
+        else
+        {
+            write_bson_entry_header(name, 0x11 /* uint64 */);
+            write_number<std::uint64_t>(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned), true);
+        }
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and object @a value
+    */
+    void write_bson_object_entry(const string_t& name,
+                                 const typename BasicJsonType::object_t& value)
+    {
+        write_bson_entry_header(name, 0x03); // object
+        write_bson_object(value);
+    }
+
+    /*!
+    @return The size of the BSON-encoded array @a value
+    */
+    static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
+    {
+        std::size_t array_index = 0ul;
+
+        const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), static_cast<std::size_t>(0), [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type & el)
+        {
+            return result + calc_bson_element_size(std::to_string(array_index++), el);
+        });
+
+        return sizeof(std::int32_t) + embedded_document_size + 1ul;
+    }
+
+    /*!
+    @return The size of the BSON-encoded binary array @a value
+    */
+    static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
+    {
+        return sizeof(std::int32_t) + value.size() + 1ul;
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and array @a value
+    */
+    void write_bson_array(const string_t& name,
+                          const typename BasicJsonType::array_t& value)
+    {
+        write_bson_entry_header(name, 0x04); // array
+        write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_array_size(value)), true);
+
+        std::size_t array_index = 0ul;
+
+        for (const auto& el : value)
+        {
+            write_bson_element(std::to_string(array_index++), el);
+        }
+
+        oa->write_character(to_char_type(0x00));
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and binary value @a value
+    */
+    void write_bson_binary(const string_t& name,
+                           const binary_t& value)
+    {
+        write_bson_entry_header(name, 0x05);
+
+        write_number<std::int32_t>(static_cast<std::int32_t>(value.size()), true);
+        write_number(value.has_subtype() ? static_cast<std::uint8_t>(value.subtype()) : static_cast<std::uint8_t>(0x00));
+
+        oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
+    }
+
+    /*!
+    @brief Calculates the size necessary to serialize the JSON value @a j with its @a name
+    @return The calculated size for the BSON document entry for @a j with the given @a name.
+    */
+    static std::size_t calc_bson_element_size(const string_t& name,
+            const BasicJsonType& j)
+    {
+        const auto header_size = calc_bson_entry_header_size(name, j);
+        switch (j.type())
+        {
+            case value_t::object:
+                return header_size + calc_bson_object_size(*j.m_data.m_value.object);
+
+            case value_t::array:
+                return header_size + calc_bson_array_size(*j.m_data.m_value.array);
+
+            case value_t::binary:
+                return header_size + calc_bson_binary_size(*j.m_data.m_value.binary);
+
+            case value_t::boolean:
+                return header_size + 1ul;
+
+            case value_t::number_float:
+                return header_size + 8ul;
+
+            case value_t::number_integer:
+                return header_size + calc_bson_integer_size(j.m_data.m_value.number_integer);
+
+            case value_t::number_unsigned:
+                return header_size + calc_bson_unsigned_size(j.m_data.m_value.number_unsigned);
+
+            case value_t::string:
+                return header_size + calc_bson_string_size(*j.m_data.m_value.string);
+
+            case value_t::null:
+                return header_size + 0ul;
+
+            // LCOV_EXCL_START
+            case value_t::discarded:
+            default:
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
+                return 0ul;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    /*!
+    @brief Serializes the JSON value @a j to BSON and associates it with the
+           key @a name.
+    @param name The name to associate with the JSON entity @a j within the
+                current BSON document
+    */
+    void write_bson_element(const string_t& name,
+                            const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::object:
+                return write_bson_object_entry(name, *j.m_data.m_value.object);
+
+            case value_t::array:
+                return write_bson_array(name, *j.m_data.m_value.array);
+
+            case value_t::binary:
+                return write_bson_binary(name, *j.m_data.m_value.binary);
+
+            case value_t::boolean:
+                return write_bson_boolean(name, j.m_data.m_value.boolean);
+
+            case value_t::number_float:
+                return write_bson_double(name, j.m_data.m_value.number_float);
+
+            case value_t::number_integer:
+                return write_bson_integer(name, j.m_data.m_value.number_integer);
+
+            case value_t::number_unsigned:
+                return write_bson_unsigned(name, j);
+
+            case value_t::string:
+                return write_bson_string(name, *j.m_data.m_value.string);
+
+            case value_t::null:
+                return write_bson_null(name);
+
+            // LCOV_EXCL_START
+            case value_t::discarded:
+            default:
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
+                return;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    /*!
+    @brief Calculates the size of the BSON serialization of the given
+           JSON-object @a j.
+    @param[in] value  JSON value to serialize
+    @pre       value.type() == value_t::object
+    */
+    static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
+    {
+        const std::size_t document_size = std::accumulate(value.begin(), value.end(), static_cast<std::size_t>(0),
+                                          [](size_t result, const typename BasicJsonType::object_t::value_type & el)
+        {
+            return result += calc_bson_element_size(el.first, el.second);
+        });
+
+        return sizeof(std::int32_t) + document_size + 1ul;
+    }
+
+    /*!
+    @param[in] value  JSON value to serialize
+    @pre       value.type() == value_t::object
+    */
+    void write_bson_object(const typename BasicJsonType::object_t& value)
+    {
+        write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_object_size(value)), true);
+
+        for (const auto& el : value)
+        {
+            write_bson_element(el.first, el.second);
+        }
+
+        oa->write_character(to_char_type(0x00));
+    }
+
+    //////////
+    // CBOR //
+    //////////
+
+    static constexpr CharType get_cbor_float_prefix(float /*unused*/)
+    {
+        return to_char_type(0xFA);  // Single-Precision Float
+    }
+
+    static constexpr CharType get_cbor_float_prefix(double /*unused*/)
+    {
+        return to_char_type(0xFB);  // Double-Precision Float
+    }
+
+    /////////////
+    // MsgPack //
+    /////////////
+
+    static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
+    {
+        return to_char_type(0xCA);  // float 32
+    }
+
+    static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
+    {
+        return to_char_type(0xCB);  // float 64
+    }
+
+    ////////////
+    // UBJSON //
+    ////////////
+
+    // UBJSON: write number (floating point)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_floating_point<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix,
+                                         const bool use_bjdata)
+    {
+        if (add_prefix)
+        {
+            oa->write_character(get_ubjson_float_prefix(n));
+        }
+        write_number(n, use_bjdata);
+    }
+
+    // UBJSON: write number (unsigned integer)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_unsigned<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix,
+                                         const bool use_bjdata)
+    {
+        if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('i'));  // int8
+            }
+            write_number(static_cast<std::uint8_t>(n), use_bjdata);
+        }
+        else if (n <= (std::numeric_limits<std::uint8_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('U'));  // uint8
+            }
+            write_number(static_cast<std::uint8_t>(n), use_bjdata);
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('I'));  // int16
+            }
+            write_number(static_cast<std::int16_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint16_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('u'));  // uint16 - bjdata only
+            }
+            write_number(static_cast<std::uint16_t>(n), use_bjdata);
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('l'));  // int32
+            }
+            write_number(static_cast<std::int32_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint32_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('m'));  // uint32 - bjdata only
+            }
+            write_number(static_cast<std::uint32_t>(n), use_bjdata);
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('L'));  // int64
+            }
+            write_number(static_cast<std::int64_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && n <= (std::numeric_limits<uint64_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('M'));  // uint64 - bjdata only
+            }
+            write_number(static_cast<std::uint64_t>(n), use_bjdata);
+        }
+        else
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('H'));  // high-precision number
+            }
+
+            const auto number = BasicJsonType(n).dump();
+            write_number_with_ubjson_prefix(number.size(), true, use_bjdata);
+            for (std::size_t i = 0; i < number.size(); ++i)
+            {
+                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
+            }
+        }
+    }
+
+    // UBJSON: write number (signed integer)
+    template < typename NumberType, typename std::enable_if <
+                   std::is_signed<NumberType>::value&&
+                   !std::is_floating_point<NumberType>::value, int >::type = 0 >
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix,
+                                         const bool use_bjdata)
+    {
+        if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('i'));  // int8
+            }
+            write_number(static_cast<std::int8_t>(n), use_bjdata);
+        }
+        else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('U'));  // uint8
+            }
+            write_number(static_cast<std::uint8_t>(n), use_bjdata);
+        }
+        else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('I'));  // int16
+            }
+            write_number(static_cast<std::int16_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && (static_cast<std::int64_t>((std::numeric_limits<std::uint16_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint16_t>::max)())))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('u'));  // uint16 - bjdata only
+            }
+            write_number(static_cast<uint16_t>(n), use_bjdata);
+        }
+        else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('l'));  // int32
+            }
+            write_number(static_cast<std::int32_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && (static_cast<std::int64_t>((std::numeric_limits<std::uint32_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint32_t>::max)())))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('m'));  // uint32 - bjdata only
+            }
+            write_number(static_cast<uint32_t>(n), use_bjdata);
+        }
+        else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('L'));  // int64
+            }
+            write_number(static_cast<std::int64_t>(n), use_bjdata);
+        }
+        // LCOV_EXCL_START
+        else
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('H'));  // high-precision number
+            }
+
+            const auto number = BasicJsonType(n).dump();
+            write_number_with_ubjson_prefix(number.size(), true, use_bjdata);
+            for (std::size_t i = 0; i < number.size(); ++i)
+            {
+                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
+            }
+        }
+        // LCOV_EXCL_STOP
+    }
+
+    /*!
+    @brief determine the type prefix of container values
+    */
+    CharType ubjson_prefix(const BasicJsonType& j, const bool use_bjdata) const noexcept
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+                return 'Z';
+
+            case value_t::boolean:
+                return j.m_data.m_value.boolean ? 'T' : 'F';
+
+            case value_t::number_integer:
+            {
+                if ((std::numeric_limits<std::int8_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                {
+                    return 'i';
+                }
+                if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    return 'U';
+                }
+                if ((std::numeric_limits<std::int16_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                {
+                    return 'I';
+                }
+                if (use_bjdata && ((std::numeric_limits<std::uint16_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)()))
+                {
+                    return 'u';
+                }
+                if ((std::numeric_limits<std::int32_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                {
+                    return 'l';
+                }
+                if (use_bjdata && ((std::numeric_limits<std::uint32_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)()))
+                {
+                    return 'm';
+                }
+                if ((std::numeric_limits<std::int64_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
+                {
+                    return 'L';
+                }
+                // anything else is treated as a high-precision number
+                return 'H'; // LCOV_EXCL_LINE
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
+                {
+                    return 'i';
+                }
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
+                {
+                    return 'U';
+                }
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
+                {
+                    return 'I';
+                }
+                if (use_bjdata && j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint16_t>::max)()))
+                {
+                    return 'u';
+                }
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+                {
+                    return 'l';
+                }
+                if (use_bjdata && j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint32_t>::max)()))
+                {
+                    return 'm';
+                }
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+                {
+                    return 'L';
+                }
+                if (use_bjdata && j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    return 'M';
+                }
+                // anything else is treated as a high-precision number
+                return 'H'; // LCOV_EXCL_LINE
+            }
+
+            case value_t::number_float:
+                return get_ubjson_float_prefix(j.m_data.m_value.number_float);
+
+            case value_t::string:
+                return 'S';
+
+            case value_t::array: // fallthrough
+            case value_t::binary:
+                return '[';
+
+            case value_t::object:
+                return '{';
+
+            case value_t::discarded:
+            default:  // discarded values
+                return 'N';
+        }
+    }
+
+    static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
+    {
+        return 'd';  // float 32
+    }
+
+    static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
+    {
+        return 'D';  // float 64
+    }
+
+    /*!
+    @return false if the object is successfully converted to a bjdata ndarray, true if the type or size is invalid
+    */
+    bool write_bjdata_ndarray(const typename BasicJsonType::object_t& value, const bool use_count, const bool use_type, const bjdata_version_t bjdata_version)
+    {
+        std::map<string_t, CharType> bjdtype = {{"uint8", 'U'},  {"int8", 'i'},  {"uint16", 'u'}, {"int16", 'I'},
+            {"uint32", 'm'}, {"int32", 'l'}, {"uint64", 'M'}, {"int64", 'L'}, {"single", 'd'}, {"double", 'D'},
+            {"char", 'C'}, {"byte", 'B'}
+        };
+
+        string_t key = "_ArrayType_";
+        auto it = bjdtype.find(static_cast<string_t>(value.at(key)));
+        if (it == bjdtype.end())
+        {
+            return true;
+        }
+        CharType dtype = it->second;
+
+        key = "_ArraySize_";
+        std::size_t len = (value.at(key).empty() ? 0 : 1);
+        for (const auto& el : value.at(key))
+        {
+            len *= static_cast<std::size_t>(el.m_data.m_value.number_unsigned);
+        }
+
+        key = "_ArrayData_";
+        if (value.at(key).size() != len)
+        {
+            return true;
+        }
+
+        oa->write_character('[');
+        oa->write_character('$');
+        oa->write_character(dtype);
+        oa->write_character('#');
+
+        key = "_ArraySize_";
+        write_ubjson(value.at(key), use_count, use_type, true,  true, bjdata_version);
+
+        key = "_ArrayData_";
+        if (dtype == 'U' || dtype == 'C' || dtype == 'B')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::uint8_t>(el.m_data.m_value.number_unsigned), true);
+            }
+        }
+        else if (dtype == 'i')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::int8_t>(el.m_data.m_value.number_integer), true);
+            }
+        }
+        else if (dtype == 'u')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::uint16_t>(el.m_data.m_value.number_unsigned), true);
+            }
+        }
+        else if (dtype == 'I')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::int16_t>(el.m_data.m_value.number_integer), true);
+            }
+        }
+        else if (dtype == 'm')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::uint32_t>(el.m_data.m_value.number_unsigned), true);
+            }
+        }
+        else if (dtype == 'l')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::int32_t>(el.m_data.m_value.number_integer), true);
+            }
+        }
+        else if (dtype == 'M')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::uint64_t>(el.m_data.m_value.number_unsigned), true);
+            }
+        }
+        else if (dtype == 'L')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::int64_t>(el.m_data.m_value.number_integer), true);
+            }
+        }
+        else if (dtype == 'd')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<float>(el.m_data.m_value.number_float), true);
+            }
+        }
+        else if (dtype == 'D')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<double>(el.m_data.m_value.number_float), true);
+            }
+        }
+        return false;
+    }
+
+    ///////////////////////
+    // Utility functions //
+    ///////////////////////
+
+    /*
+    @brief write a number to output input
+    @param[in] n number of type @a NumberType
+    @param[in] OutputIsLittleEndian Set to true if output data is
+                                 required to be little endian
+    @tparam NumberType the type of the number
+
+    @note This function needs to respect the system's endianness, because bytes
+          in CBOR, MessagePack, and UBJSON are stored in network order (big
+          endian) and therefore need reordering on little endian systems.
+          On the other hand, BSON and BJData use little endian and should reorder
+          on big endian systems.
+    */
+    template<typename NumberType>
+    void write_number(const NumberType n, const bool OutputIsLittleEndian = false)
+    {
+        // step 1: write the number to an array of length NumberType
+        std::array<CharType, sizeof(NumberType)> vec{};
+        std::memcpy(vec.data(), &n, sizeof(NumberType));
+
+        // step 2: write the array to output (with possible reordering)
+        if (is_little_endian != OutputIsLittleEndian)
+        {
+            // reverse byte order prior to conversion if necessary
+            std::reverse(vec.begin(), vec.end());
+        }
+
+        oa->write_characters(vec.data(), sizeof(NumberType));
+    }
+
+    void write_compact_float(const number_float_t n, detail::input_format_t format)
+    {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+        if (!std::isfinite(n) || ((static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
+                                   static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
+                                   static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))))
+        {
+            oa->write_character(format == detail::input_format_t::cbor
+                                ? get_cbor_float_prefix(static_cast<float>(n))
+                                : get_msgpack_float_prefix(static_cast<float>(n)));
+            write_number(static_cast<float>(n));
+        }
+        else
+        {
+            oa->write_character(format == detail::input_format_t::cbor
+                                ? get_cbor_float_prefix(n)
+                                : get_msgpack_float_prefix(n));
+            write_number(n);
+        }
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    }
+
+  public:
+    // The following to_char_type functions are implement the conversion
+    // between uint8_t and CharType. In case CharType is not unsigned,
+    // such a conversion is required to allow values greater than 128.
+    // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
+    template < typename C = CharType,
+               enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr >
+    static constexpr CharType to_char_type(std::uint8_t x) noexcept
+    {
+        return *reinterpret_cast<char*>(&x);
+    }
+
+    template < typename C = CharType,
+               enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr >
+    static CharType to_char_type(std::uint8_t x) noexcept
+    {
+        // The std::is_trivial trait is deprecated in C++26. The replacement is to use
+        // std::is_trivially_copyable and std::is_trivially_default_constructible.
+        // However, some older library implementations support std::is_trivial
+        // but not all the std::is_trivially_* traits.
+        // Since detecting full support across all libraries is difficult,
+        // we use std::is_trivial unless we are using a standard where it has been deprecated.
+        // For more details, see: https://github.com/nlohmann/json/pull/4775#issuecomment-2884361627
+#ifdef JSON_HAS_CPP_26
+        static_assert(std::is_trivially_copyable<CharType>::value, "CharType must be trivially copyable");
+        static_assert(std::is_trivially_default_constructible<CharType>::value, "CharType must be trivially default constructible");
+#else
+        static_assert(std::is_trivial<CharType>::value, "CharType must be trivial");
+#endif
+
+        static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
+        CharType result;
+        std::memcpy(&result, &x, sizeof(x));
+        return result;
+    }
+
+    template<typename C = CharType,
+             enable_if_t<std::is_unsigned<C>::value>* = nullptr>
+    static constexpr CharType to_char_type(std::uint8_t x) noexcept
+    {
+        return x;
+    }
+
+    template < typename InputCharType, typename C = CharType,
+               enable_if_t <
+                   std::is_signed<C>::value &&
+                   std::is_signed<char>::value &&
+                   std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
+                   > * = nullptr >
+    static constexpr CharType to_char_type(InputCharType x) noexcept
+    {
+        return x;
+    }
+
+  private:
+    /// whether we can assume little endianness
+    const bool is_little_endian = little_endianness();
+
+    /// the output
+    output_adapter_t<CharType> oa = nullptr;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+// #include <nlohmann/detail/output/serializer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2008, 2009 Björn Hoehrmann <bjoern@hoehrmann.de>
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // reverse, remove, fill, find, none_of
+#include <array> // array
+#include <clocale> // localeconv, lconv
+#include <cmath> // labs, isfinite, isnan, signbit
+#include <cstddef> // size_t, ptrdiff_t
+#include <cstdint> // uint8_t
+#include <cstdio> // snprintf
+#include <limits> // numeric_limits
+#include <string> // string, char_traits
+#include <iomanip> // setfill, setw
+#include <type_traits> // is_same
+#include <utility> // move
+
+// #include <nlohmann/detail/conversions/to_chars.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2009 Florian Loitsch <https://florian.loitsch.com/>
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <cmath>   // signbit, isfinite
+#include <cstdint> // intN_t, uintN_t
+#include <cstring> // memcpy, memmove
+#include <limits> // numeric_limits
+#include <type_traits> // conditional
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief implements the Grisu2 algorithm for binary to decimal floating-point
+conversion.
+
+This implementation is a slightly modified version of the reference
+implementation which may be obtained from
+http://florian.loitsch.com/publications (bench.tar.gz).
+
+The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.
+
+For a detailed description of the algorithm see:
+
+[1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with
+    Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming
+    Language Design and Implementation, PLDI 2010
+[2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",
+    Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language
+    Design and Implementation, PLDI 1996
+*/
+namespace dtoa_impl
+{
+
+template<typename Target, typename Source>
+Target reinterpret_bits(const Source source)
+{
+    static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
+
+    Target target;
+    std::memcpy(&target, &source, sizeof(Source));
+    return target;
+}
+
+struct diyfp // f * 2^e
+{
+    static constexpr int kPrecision = 64; // = q
+
+    std::uint64_t f = 0;
+    int e = 0;
+
+    constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
+
+    /*!
+    @brief returns x - y
+    @pre x.e == y.e and x.f >= y.f
+    */
+    static diyfp sub(const diyfp& x, const diyfp& y) noexcept
+    {
+        JSON_ASSERT(x.e == y.e);
+        JSON_ASSERT(x.f >= y.f);
+
+        return {x.f - y.f, x.e};
+    }
+
+    /*!
+    @brief returns x * y
+    @note The result is rounded. (Only the upper q bits are returned.)
+    */
+    static diyfp mul(const diyfp& x, const diyfp& y) noexcept
+    {
+        static_assert(kPrecision == 64, "internal error");
+
+        // Computes:
+        //  f = round((x.f * y.f) / 2^q)
+        //  e = x.e + y.e + q
+
+        // Emulate the 64-bit * 64-bit multiplication:
+        //
+        // p = u * v
+        //   = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
+        //   = (u_lo v_lo         ) + 2^32 ((u_lo v_hi         ) + (u_hi v_lo         )) + 2^64 (u_hi v_hi         )
+        //   = (p0                ) + 2^32 ((p1                ) + (p2                )) + 2^64 (p3                )
+        //   = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3                )
+        //   = (p0_lo             ) + 2^32 (p0_hi + p1_lo + p2_lo                      ) + 2^64 (p1_hi + p2_hi + p3)
+        //   = (p0_lo             ) + 2^32 (Q                                          ) + 2^64 (H                 )
+        //   = (p0_lo             ) + 2^32 (Q_lo + 2^32 Q_hi                           ) + 2^64 (H                 )
+        //
+        // (Since Q might be larger than 2^32 - 1)
+        //
+        //   = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
+        //
+        // (Q_hi + H does not overflow a 64-bit int)
+        //
+        //   = p_lo + 2^64 p_hi
+
+        const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
+        const std::uint64_t u_hi = x.f >> 32u;
+        const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
+        const std::uint64_t v_hi = y.f >> 32u;
+
+        const std::uint64_t p0 = u_lo * v_lo;
+        const std::uint64_t p1 = u_lo * v_hi;
+        const std::uint64_t p2 = u_hi * v_lo;
+        const std::uint64_t p3 = u_hi * v_hi;
+
+        const std::uint64_t p0_hi = p0 >> 32u;
+        const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
+        const std::uint64_t p1_hi = p1 >> 32u;
+        const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
+        const std::uint64_t p2_hi = p2 >> 32u;
+
+        std::uint64_t Q = p0_hi + p1_lo + p2_lo;
+
+        // The full product might now be computed as
+        //
+        // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
+        // p_lo = p0_lo + (Q << 32)
+        //
+        // But in this particular case here, the full p_lo is not required.
+        // Effectively, we only need to add the highest bit in p_lo to p_hi (and
+        // Q_hi + 1 does not overflow).
+
+        Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
+
+        const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
+
+        return {h, x.e + y.e + 64};
+    }
+
+    /*!
+    @brief normalize x such that the significand is >= 2^(q-1)
+    @pre x.f != 0
+    */
+    static diyfp normalize(diyfp x) noexcept
+    {
+        JSON_ASSERT(x.f != 0);
+
+        while ((x.f >> 63u) == 0)
+        {
+            x.f <<= 1u;
+            x.e--;
+        }
+
+        return x;
+    }
+
+    /*!
+    @brief normalize x such that the result has the exponent E
+    @pre e >= x.e and the upper e - x.e bits of x.f must be zero.
+    */
+    static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
+    {
+        const int delta = x.e - target_exponent;
+
+        JSON_ASSERT(delta >= 0);
+        JSON_ASSERT(((x.f << delta) >> delta) == x.f);
+
+        return {x.f << delta, target_exponent};
+    }
+};
+
+struct boundaries
+{
+    diyfp w;
+    diyfp minus;
+    diyfp plus;
+};
+
+/*!
+Compute the (normalized) diyfp representing the input number 'value' and its
+boundaries.
+
+@pre value must be finite and positive
+*/
+template<typename FloatType>
+boundaries compute_boundaries(FloatType value)
+{
+    JSON_ASSERT(std::isfinite(value));
+    JSON_ASSERT(value > 0);
+
+    // Convert the IEEE representation into a diyfp.
+    //
+    // If v is denormal:
+    //      value = 0.F * 2^(1 - bias) = (          F) * 2^(1 - bias - (p-1))
+    // If v is normalized:
+    //      value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
+
+    static_assert(std::numeric_limits<FloatType>::is_iec559,
+                  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
+
+    constexpr int      kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
+    constexpr int      kBias      = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
+    constexpr int      kMinExp    = 1 - kBias;
+    constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
+
+    using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
+
+    const auto bits = static_cast<std::uint64_t>(reinterpret_bits<bits_type>(value));
+    const std::uint64_t E = bits >> (kPrecision - 1);
+    const std::uint64_t F = bits & (kHiddenBit - 1);
+
+    const bool is_denormal = E == 0;
+    const diyfp v = is_denormal
+                    ? diyfp(F, kMinExp)
+                    : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
+
+    // Compute the boundaries m- and m+ of the floating-point value
+    // v = f * 2^e.
+    //
+    // Determine v- and v+, the floating-point predecessor and successor of v,
+    // respectively.
+    //
+    //      v- = v - 2^e        if f != 2^(p-1) or e == e_min                (A)
+    //         = v - 2^(e-1)    if f == 2^(p-1) and e > e_min                (B)
+    //
+    //      v+ = v + 2^e
+    //
+    // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
+    // between m- and m+ round to v, regardless of how the input rounding
+    // algorithm breaks ties.
+    //
+    //      ---+-------------+-------------+-------------+-------------+---  (A)
+    //         v-            m-            v             m+            v+
+    //
+    //      -----------------+------+------+-------------+-------------+---  (B)
+    //                       v-     m-     v             m+            v+
+
+    const bool lower_boundary_is_closer = F == 0 && E > 1;
+    const diyfp m_plus = diyfp((2 * v.f) + 1, v.e - 1);
+    const diyfp m_minus = lower_boundary_is_closer
+                          ? diyfp((4 * v.f) - 1, v.e - 2)  // (B)
+                          : diyfp((2 * v.f) - 1, v.e - 1); // (A)
+
+    // Determine the normalized w+ = m+.
+    const diyfp w_plus = diyfp::normalize(m_plus);
+
+    // Determine w- = m- such that e_(w-) = e_(w+).
+    const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
+
+    return {diyfp::normalize(v), w_minus, w_plus};
+}
+
+// Given normalized diyfp w, Grisu needs to find a (normalized) cached
+// power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
+// within a certain range [alpha, gamma] (Definition 3.2 from [1])
+//
+//      alpha <= e = e_c + e_w + q <= gamma
+//
+// or
+//
+//      f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
+//                          <= f_c * f_w * 2^gamma
+//
+// Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
+//
+//      2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
+//
+// or
+//
+//      2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
+//
+// The choice of (alpha,gamma) determines the size of the table and the form of
+// the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
+// in practice:
+//
+// The idea is to cut the number c * w = f * 2^e into two parts, which can be
+// processed independently: An integral part p1, and a fractional part p2:
+//
+//      f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
+//              = (f div 2^-e) + (f mod 2^-e) * 2^e
+//              = p1 + p2 * 2^e
+//
+// The conversion of p1 into decimal form requires a series of divisions and
+// modulos by (a power of) 10. These operations are faster for 32-bit than for
+// 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
+// achieved by choosing
+//
+//      -e >= 32   or   e <= -32 := gamma
+//
+// In order to convert the fractional part
+//
+//      p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
+//
+// into decimal form, the fraction is repeatedly multiplied by 10 and the digits
+// d[-i] are extracted in order:
+//
+//      (10 * p2) div 2^-e = d[-1]
+//      (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
+//
+// The multiplication by 10 must not overflow. It is sufficient to choose
+//
+//      10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
+//
+// Since p2 = f mod 2^-e < 2^-e,
+//
+//      -e <= 60   or   e >= -60 := alpha
+
+constexpr int kAlpha = -60;
+constexpr int kGamma = -32;
+
+struct cached_power // c = f * 2^e ~= 10^k
+{
+    std::uint64_t f;
+    int e;
+    int k;
+};
+
+/*!
+For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached
+power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c
+satisfies (Definition 3.2 from [1])
+
+     alpha <= e_c + e + q <= gamma.
+*/
+inline cached_power get_cached_power_for_binary_exponent(int e)
+{
+    // Now
+    //
+    //      alpha <= e_c + e + q <= gamma                                    (1)
+    //      ==> f_c * 2^alpha <= c * 2^e * 2^q
+    //
+    // and since the c's are normalized, 2^(q-1) <= f_c,
+    //
+    //      ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
+    //      ==> 2^(alpha - e - 1) <= c
+    //
+    // If c were an exact power of ten, i.e. c = 10^k, one may determine k as
+    //
+    //      k = ceil( log_10( 2^(alpha - e - 1) ) )
+    //        = ceil( (alpha - e - 1) * log_10(2) )
+    //
+    // From the paper:
+    // "In theory the result of the procedure could be wrong since c is rounded,
+    //  and the computation itself is approximated [...]. In practice, however,
+    //  this simple function is sufficient."
+    //
+    // For IEEE double precision floating-point numbers converted into
+    // normalized diyfp's w = f * 2^e, with q = 64,
+    //
+    //      e >= -1022      (min IEEE exponent)
+    //           -52        (p - 1)
+    //           -52        (p - 1, possibly normalize denormal IEEE numbers)
+    //           -11        (normalize the diyfp)
+    //         = -1137
+    //
+    // and
+    //
+    //      e <= +1023      (max IEEE exponent)
+    //           -52        (p - 1)
+    //           -11        (normalize the diyfp)
+    //         = 960
+    //
+    // This binary exponent range [-1137,960] results in a decimal exponent
+    // range [-307,324]. One does not need to store a cached power for each
+    // k in this range. For each such k it suffices to find a cached power
+    // such that the exponent of the product lies in [alpha,gamma].
+    // This implies that the difference of the decimal exponents of adjacent
+    // table entries must be less than or equal to
+    //
+    //      floor( (gamma - alpha) * log_10(2) ) = 8.
+    //
+    // (A smaller distance gamma-alpha would require a larger table.)
+
+    // NB:
+    // Actually, this function returns c, such that -60 <= e_c + e + 64 <= -34.
+
+    constexpr int kCachedPowersMinDecExp = -300;
+    constexpr int kCachedPowersDecStep = 8;
+
+    static constexpr std::array<cached_power, 79> kCachedPowers =
+    {
+        {
+            { 0xAB70FE17C79AC6CA, -1060, -300 },
+            { 0xFF77B1FCBEBCDC4F, -1034, -292 },
+            { 0xBE5691EF416BD60C, -1007, -284 },
+            { 0x8DD01FAD907FFC3C,  -980, -276 },
+            { 0xD3515C2831559A83,  -954, -268 },
+            { 0x9D71AC8FADA6C9B5,  -927, -260 },
+            { 0xEA9C227723EE8BCB,  -901, -252 },
+            { 0xAECC49914078536D,  -874, -244 },
+            { 0x823C12795DB6CE57,  -847, -236 },
+            { 0xC21094364DFB5637,  -821, -228 },
+            { 0x9096EA6F3848984F,  -794, -220 },
+            { 0xD77485CB25823AC7,  -768, -212 },
+            { 0xA086CFCD97BF97F4,  -741, -204 },
+            { 0xEF340A98172AACE5,  -715, -196 },
+            { 0xB23867FB2A35B28E,  -688, -188 },
+            { 0x84C8D4DFD2C63F3B,  -661, -180 },
+            { 0xC5DD44271AD3CDBA,  -635, -172 },
+            { 0x936B9FCEBB25C996,  -608, -164 },
+            { 0xDBAC6C247D62A584,  -582, -156 },
+            { 0xA3AB66580D5FDAF6,  -555, -148 },
+            { 0xF3E2F893DEC3F126,  -529, -140 },
+            { 0xB5B5ADA8AAFF80B8,  -502, -132 },
+            { 0x87625F056C7C4A8B,  -475, -124 },
+            { 0xC9BCFF6034C13053,  -449, -116 },
+            { 0x964E858C91BA2655,  -422, -108 },
+            { 0xDFF9772470297EBD,  -396, -100 },
+            { 0xA6DFBD9FB8E5B88F,  -369,  -92 },
+            { 0xF8A95FCF88747D94,  -343,  -84 },
+            { 0xB94470938FA89BCF,  -316,  -76 },
+            { 0x8A08F0F8BF0F156B,  -289,  -68 },
+            { 0xCDB02555653131B6,  -263,  -60 },
+            { 0x993FE2C6D07B7FAC,  -236,  -52 },
+            { 0xE45C10C42A2B3B06,  -210,  -44 },
+            { 0xAA242499697392D3,  -183,  -36 },
+            { 0xFD87B5F28300CA0E,  -157,  -28 },
+            { 0xBCE5086492111AEB,  -130,  -20 },
+            { 0x8CBCCC096F5088CC,  -103,  -12 },
+            { 0xD1B71758E219652C,   -77,   -4 },
+            { 0x9C40000000000000,   -50,    4 },
+            { 0xE8D4A51000000000,   -24,   12 },
+            { 0xAD78EBC5AC620000,     3,   20 },
+            { 0x813F3978F8940984,    30,   28 },
+            { 0xC097CE7BC90715B3,    56,   36 },
+            { 0x8F7E32CE7BEA5C70,    83,   44 },
+            { 0xD5D238A4ABE98068,   109,   52 },
+            { 0x9F4F2726179A2245,   136,   60 },
+            { 0xED63A231D4C4FB27,   162,   68 },
+            { 0xB0DE65388CC8ADA8,   189,   76 },
+            { 0x83C7088E1AAB65DB,   216,   84 },
+            { 0xC45D1DF942711D9A,   242,   92 },
+            { 0x924D692CA61BE758,   269,  100 },
+            { 0xDA01EE641A708DEA,   295,  108 },
+            { 0xA26DA3999AEF774A,   322,  116 },
+            { 0xF209787BB47D6B85,   348,  124 },
+            { 0xB454E4A179DD1877,   375,  132 },
+            { 0x865B86925B9BC5C2,   402,  140 },
+            { 0xC83553C5C8965D3D,   428,  148 },
+            { 0x952AB45CFA97A0B3,   455,  156 },
+            { 0xDE469FBD99A05FE3,   481,  164 },
+            { 0xA59BC234DB398C25,   508,  172 },
+            { 0xF6C69A72A3989F5C,   534,  180 },
+            { 0xB7DCBF5354E9BECE,   561,  188 },
+            { 0x88FCF317F22241E2,   588,  196 },
+            { 0xCC20CE9BD35C78A5,   614,  204 },
+            { 0x98165AF37B2153DF,   641,  212 },
+            { 0xE2A0B5DC971F303A,   667,  220 },
+            { 0xA8D9D1535CE3B396,   694,  228 },
+            { 0xFB9B7CD9A4A7443C,   720,  236 },
+            { 0xBB764C4CA7A44410,   747,  244 },
+            { 0x8BAB8EEFB6409C1A,   774,  252 },
+            { 0xD01FEF10A657842C,   800,  260 },
+            { 0x9B10A4E5E9913129,   827,  268 },
+            { 0xE7109BFBA19C0C9D,   853,  276 },
+            { 0xAC2820D9623BF429,   880,  284 },
+            { 0x80444B5E7AA7CF85,   907,  292 },
+            { 0xBF21E44003ACDD2D,   933,  300 },
+            { 0x8E679C2F5E44FF8F,   960,  308 },
+            { 0xD433179D9C8CB841,   986,  316 },
+            { 0x9E19DB92B4E31BA9,  1013,  324 },
+        }
+    };
+
+    // This computation gives exactly the same results for k as
+    //      k = ceil((kAlpha - e - 1) * 0.30102999566398114)
+    // for |e| <= 1500, but doesn't require floating-point operations.
+    // NB: log_10(2) ~= 78913 / 2^18
+    JSON_ASSERT(e >= -1500);
+    JSON_ASSERT(e <=  1500);
+    const int f = kAlpha - e - 1;
+    const int k = ((f * 78913) / (1 << 18)) + static_cast<int>(f > 0);
+
+    const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
+    JSON_ASSERT(index >= 0);
+    JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());
+
+    const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
+    JSON_ASSERT(kAlpha <= cached.e + e + 64);
+    JSON_ASSERT(kGamma >= cached.e + e + 64);
+
+    return cached;
+}
+
+/*!
+For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
+For n == 0, returns 1 and sets pow10 := 1.
+*/
+inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
+{
+    // LCOV_EXCL_START
+    if (n >= 1000000000)
+    {
+        pow10 = 1000000000;
+        return 10;
+    }
+    // LCOV_EXCL_STOP
+    if (n >= 100000000)
+    {
+        pow10 = 100000000;
+        return  9;
+    }
+    if (n >= 10000000)
+    {
+        pow10 = 10000000;
+        return  8;
+    }
+    if (n >= 1000000)
+    {
+        pow10 = 1000000;
+        return  7;
+    }
+    if (n >= 100000)
+    {
+        pow10 = 100000;
+        return  6;
+    }
+    if (n >= 10000)
+    {
+        pow10 = 10000;
+        return  5;
+    }
+    if (n >= 1000)
+    {
+        pow10 = 1000;
+        return  4;
+    }
+    if (n >= 100)
+    {
+        pow10 = 100;
+        return  3;
+    }
+    if (n >= 10)
+    {
+        pow10 = 10;
+        return  2;
+    }
+
+    pow10 = 1;
+    return 1;
+}
+
+inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
+                         std::uint64_t rest, std::uint64_t ten_k)
+{
+    JSON_ASSERT(len >= 1);
+    JSON_ASSERT(dist <= delta);
+    JSON_ASSERT(rest <= delta);
+    JSON_ASSERT(ten_k > 0);
+
+    //               <--------------------------- delta ---->
+    //                                  <---- dist --------->
+    // --------------[------------------+-------------------]--------------
+    //               M-                 w                   M+
+    //
+    //                                  ten_k
+    //                                <------>
+    //                                       <---- rest ---->
+    // --------------[------------------+----+--------------]--------------
+    //                                  w    V
+    //                                       = buf * 10^k
+    //
+    // ten_k represents a unit-in-the-last-place in the decimal representation
+    // stored in buf.
+    // Decrement buf by ten_k while this takes buf closer to w.
+
+    // The tests are written in this order to avoid overflow in unsigned
+    // integer arithmetic.
+
+    while (rest < dist
+            && delta - rest >= ten_k
+            && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
+    {
+        JSON_ASSERT(buf[len - 1] != '0');
+        buf[len - 1]--;
+        rest += ten_k;
+    }
+}
+
+/*!
+Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.
+M- and M+ must be normalized and share the same exponent -60 <= e <= -32.
+*/
+inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
+                             diyfp M_minus, diyfp w, diyfp M_plus)
+{
+    static_assert(kAlpha >= -60, "internal error");
+    static_assert(kGamma <= -32, "internal error");
+
+    // Generates the digits (and the exponent) of a decimal floating-point
+    // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
+    // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
+    //
+    //               <--------------------------- delta ---->
+    //                                  <---- dist --------->
+    // --------------[------------------+-------------------]--------------
+    //               M-                 w                   M+
+    //
+    // Grisu2 generates the digits of M+ from left to right and stops as soon as
+    // V is in [M-,M+].
+
+    JSON_ASSERT(M_plus.e >= kAlpha);
+    JSON_ASSERT(M_plus.e <= kGamma);
+
+    std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
+    std::uint64_t dist  = diyfp::sub(M_plus, w      ).f; // (significand of (M+ - w ), implicit exponent is e)
+
+    // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
+    //
+    //      M+ = f * 2^e
+    //         = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
+    //         = ((p1        ) * 2^-e + (p2        )) * 2^e
+    //         = p1 + p2 * 2^e
+
+    const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
+
+    auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
+    std::uint64_t p2 = M_plus.f & (one.f - 1);                    // p2 = f mod 2^-e
+
+    // 1)
+    //
+    // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
+
+    JSON_ASSERT(p1 > 0);
+
+    std::uint32_t pow10{};
+    const int k = find_largest_pow10(p1, pow10);
+
+    //      10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
+    //
+    //      p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
+    //         = (d[k-1]         ) * 10^(k-1) + (p1 mod 10^(k-1))
+    //
+    //      M+ = p1                                             + p2 * 2^e
+    //         = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1))          + p2 * 2^e
+    //         = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
+    //         = d[k-1] * 10^(k-1) + (                         rest) * 2^e
+    //
+    // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
+    //
+    //      p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
+    //
+    // but stop as soon as
+    //
+    //      rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
+
+    int n = k;
+    while (n > 0)
+    {
+        // Invariants:
+        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)    (buffer = 0 for n = k)
+        //      pow10 = 10^(n-1) <= p1 < 10^n
+        //
+        const std::uint32_t d = p1 / pow10;  // d = p1 div 10^(n-1)
+        const std::uint32_t r = p1 % pow10;  // r = p1 mod 10^(n-1)
+        //
+        //      M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
+        //         = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
+        //
+        JSON_ASSERT(d <= 9);
+        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
+        //
+        //      M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
+        //
+        p1 = r;
+        n--;
+        //
+        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)
+        //      pow10 = 10^n
+        //
+
+        // Now check if enough digits have been generated.
+        // Compute
+        //
+        //      p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
+        //
+        // Note:
+        // Since rest and delta share the same exponent e, it suffices to
+        // compare the significands.
+        const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
+        if (rest <= delta)
+        {
+            // V = buffer * 10^n, with M- <= V <= M+.
+
+            decimal_exponent += n;
+
+            // We may now just stop. But instead, it looks as if the buffer
+            // could be decremented to bring V closer to w.
+            //
+            // pow10 = 10^n is now 1 ulp in the decimal representation V.
+            // The rounding procedure works with diyfp's with an implicit
+            // exponent of e.
+            //
+            //      10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
+            //
+            const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
+            grisu2_round(buffer, length, dist, delta, rest, ten_n);
+
+            return;
+        }
+
+        pow10 /= 10;
+        //
+        //      pow10 = 10^(n-1) <= p1 < 10^n
+        // Invariants restored.
+    }
+
+    // 2)
+    //
+    // The digits of the integral part have been generated:
+    //
+    //      M+ = d[k-1]...d[1]d[0] + p2 * 2^e
+    //         = buffer            + p2 * 2^e
+    //
+    // Now generate the digits of the fractional part p2 * 2^e.
+    //
+    // Note:
+    // No decimal point is generated: the exponent is adjusted instead.
+    //
+    // p2 actually represents the fraction
+    //
+    //      p2 * 2^e
+    //          = p2 / 2^-e
+    //          = d[-1] / 10^1 + d[-2] / 10^2 + ...
+    //
+    // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
+    //
+    //      p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
+    //                      + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
+    //
+    // using
+    //
+    //      10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
+    //                = (                   d) * 2^-e + (                   r)
+    //
+    // or
+    //      10^m * p2 * 2^e = d + r * 2^e
+    //
+    // i.e.
+    //
+    //      M+ = buffer + p2 * 2^e
+    //         = buffer + 10^-m * (d + r * 2^e)
+    //         = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
+    //
+    // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
+
+    JSON_ASSERT(p2 > delta);
+
+    int m = 0;
+    for (;;)
+    {
+        // Invariant:
+        //      M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
+        //         = buffer * 10^-m + 10^-m * (p2                                 ) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * (10 * p2)                   ) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
+        //
+        JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
+        p2 *= 10;
+        const std::uint64_t d = p2 >> -one.e;     // d = (10 * p2) div 2^-e
+        const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
+        //
+        //      M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
+        //         = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
+        //
+        JSON_ASSERT(d <= 9);
+        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
+        //
+        //      M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
+        //
+        p2 = r;
+        m++;
+        //
+        //      M+ = buffer * 10^-m + 10^-m * p2 * 2^e
+        // Invariant restored.
+
+        // Check if enough digits have been generated.
+        //
+        //      10^-m * p2 * 2^e <= delta * 2^e
+        //              p2 * 2^e <= 10^m * delta * 2^e
+        //                    p2 <= 10^m * delta
+        delta *= 10;
+        dist  *= 10;
+        if (p2 <= delta)
+        {
+            break;
+        }
+    }
+
+    // V = buffer * 10^-m, with M- <= V <= M+.
+
+    decimal_exponent -= m;
+
+    // 1 ulp in the decimal representation is now 10^-m.
+    // Since delta and dist are now scaled by 10^m, we need to do the
+    // same with ulp in order to keep the units in sync.
+    //
+    //      10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
+    //
+    const std::uint64_t ten_m = one.f;
+    grisu2_round(buffer, length, dist, delta, p2, ten_m);
+
+    // By construction this algorithm generates the shortest possible decimal
+    // number (Loitsch, Theorem 6.2) which rounds back to w.
+    // For an input number of precision p, at least
+    //
+    //      N = 1 + ceil(p * log_10(2))
+    //
+    // decimal digits are sufficient to identify all binary floating-point
+    // numbers (Matula, "In-and-Out conversions").
+    // This implies that the algorithm does not produce more than N decimal
+    // digits.
+    //
+    //      N = 17 for p = 53 (IEEE double precision)
+    //      N = 9  for p = 24 (IEEE single precision)
+}
+
+/*!
+v = buf * 10^decimal_exponent
+len is the length of the buffer (number of decimal digits)
+The buffer must be large enough, i.e. >= max_digits10.
+*/
+JSON_HEDLEY_NON_NULL(1)
+inline void grisu2(char* buf, int& len, int& decimal_exponent,
+                   diyfp m_minus, diyfp v, diyfp m_plus)
+{
+    JSON_ASSERT(m_plus.e == m_minus.e);
+    JSON_ASSERT(m_plus.e == v.e);
+
+    //  --------(-----------------------+-----------------------)--------    (A)
+    //          m-                      v                       m+
+    //
+    //  --------------------(-----------+-----------------------)--------    (B)
+    //                      m-          v                       m+
+    //
+    // First scale v (and m- and m+) such that the exponent is in the range
+    // [alpha, gamma].
+
+    const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
+
+    const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
+
+    // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
+    const diyfp w       = diyfp::mul(v,       c_minus_k);
+    const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
+    const diyfp w_plus  = diyfp::mul(m_plus,  c_minus_k);
+
+    //  ----(---+---)---------------(---+---)---------------(---+---)----
+    //          w-                      w                       w+
+    //          = c*m-                  = c*v                   = c*m+
+    //
+    // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
+    // w+ are now off by a small amount.
+    // In fact:
+    //
+    //      w - v * 10^k < 1 ulp
+    //
+    // To account for this inaccuracy, add resp. subtract 1 ulp.
+    //
+    //  --------+---[---------------(---+---)---------------]---+--------
+    //          w-  M-                  w                   M+  w+
+    //
+    // Now any number in [M-, M+] (bounds included) will round to w when input,
+    // regardless of how the input rounding algorithm breaks ties.
+    //
+    // And digit_gen generates the shortest possible such number in [M-, M+].
+    // Note that this does not mean that Grisu2 always generates the shortest
+    // possible number in the interval (m-, m+).
+    const diyfp M_minus(w_minus.f + 1, w_minus.e);
+    const diyfp M_plus (w_plus.f  - 1, w_plus.e );
+
+    decimal_exponent = -cached.k; // = -(-k) = k
+
+    grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
+}
+
+/*!
+v = buf * 10^decimal_exponent
+len is the length of the buffer (number of decimal digits)
+The buffer must be large enough, i.e. >= max_digits10.
+*/
+template<typename FloatType>
+JSON_HEDLEY_NON_NULL(1)
+void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
+{
+    static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
+                  "internal error: not enough precision");
+
+    JSON_ASSERT(std::isfinite(value));
+    JSON_ASSERT(value > 0);
+
+    // If the neighbors (and boundaries) of 'value' are always computed for double-precision
+    // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
+    // decimal representations are not exactly "short".
+    //
+    // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
+    // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
+    // and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars'
+    // does.
+    // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
+    // representation using the corresponding std::from_chars function recovers value exactly". That
+    // indicates that single precision floating-point numbers should be recovered using
+    // 'std::strtof'.
+    //
+    // NB: If the neighbors are computed for single-precision numbers, there is a single float
+    //     (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
+    //     value is off by 1 ulp.
+#if 0 // NOLINT(readability-avoid-unconditional-preprocessor-if)
+    const boundaries w = compute_boundaries(static_cast<double>(value));
+#else
+    const boundaries w = compute_boundaries(value);
+#endif
+
+    grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
+}
+
+/*!
+@brief appends a decimal representation of e to buf
+@return a pointer to the element following the exponent.
+@pre -1000 < e < 1000
+*/
+JSON_HEDLEY_NON_NULL(1)
+JSON_HEDLEY_RETURNS_NON_NULL
+inline char* append_exponent(char* buf, int e)
+{
+    JSON_ASSERT(e > -1000);
+    JSON_ASSERT(e <  1000);
+
+    if (e < 0)
+    {
+        e = -e;
+        *buf++ = '-';
+    }
+    else
+    {
+        *buf++ = '+';
+    }
+
+    auto k = static_cast<std::uint32_t>(e);
+    if (k < 10)
+    {
+        // Always print at least two digits in the exponent.
+        // This is for compatibility with printf("%g").
+        *buf++ = '0';
+        *buf++ = static_cast<char>('0' + k);
+    }
+    else if (k < 100)
+    {
+        *buf++ = static_cast<char>('0' + (k / 10));
+        k %= 10;
+        *buf++ = static_cast<char>('0' + k);
+    }
+    else
+    {
+        *buf++ = static_cast<char>('0' + (k / 100));
+        k %= 100;
+        *buf++ = static_cast<char>('0' + (k / 10));
+        k %= 10;
+        *buf++ = static_cast<char>('0' + k);
+    }
+
+    return buf;
+}
+
+/*!
+@brief prettify v = buf * 10^decimal_exponent
+
+If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point
+notation. Otherwise it will be printed in exponential notation.
+
+@pre min_exp < 0
+@pre max_exp > 0
+*/
+JSON_HEDLEY_NON_NULL(1)
+JSON_HEDLEY_RETURNS_NON_NULL
+inline char* format_buffer(char* buf, int len, int decimal_exponent,
+                           int min_exp, int max_exp)
+{
+    JSON_ASSERT(min_exp < 0);
+    JSON_ASSERT(max_exp > 0);
+
+    const int k = len;
+    const int n = len + decimal_exponent;
+
+    // v = buf * 10^(n-k)
+    // k is the length of the buffer (number of decimal digits)
+    // n is the position of the decimal point relative to the start of the buffer.
+
+    if (k <= n && n <= max_exp)
+    {
+        // digits[000]
+        // len <= max_exp + 2
+
+        std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
+        // Make it look like a floating-point number (#362, #378)
+        buf[n + 0] = '.';
+        buf[n + 1] = '0';
+        return buf + (static_cast<size_t>(n) + 2);
+    }
+
+    if (0 < n && n <= max_exp)
+    {
+        // dig.its
+        // len <= max_digits10 + 1
+
+        JSON_ASSERT(k > n);
+
+        std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
+        buf[n] = '.';
+        return buf + (static_cast<size_t>(k) + 1U);
+    }
+
+    if (min_exp < n && n <= 0)
+    {
+        // 0.[000]digits
+        // len <= 2 + (-min_exp - 1) + max_digits10
+
+        std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
+        buf[0] = '0';
+        buf[1] = '.';
+        std::memset(buf + 2, '0', static_cast<size_t>(-n));
+        return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));
+    }
+
+    if (k == 1)
+    {
+        // dE+123
+        // len <= 1 + 5
+
+        buf += 1;
+    }
+    else
+    {
+        // d.igitsE+123
+        // len <= max_digits10 + 1 + 5
+
+        std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
+        buf[1] = '.';
+        buf += 1 + static_cast<size_t>(k);
+    }
+
+    *buf++ = 'e';
+    return append_exponent(buf, n - 1);
+}
+
+}  // namespace dtoa_impl
+
+/*!
+@brief generates a decimal representation of the floating-point number value in [first, last).
+
+The format of the resulting decimal representation is similar to printf's %g
+format. Returns an iterator pointing past-the-end of the decimal representation.
+
+@note The input number must be finite, i.e. NaN's and Inf's are not supported.
+@note The buffer must be large enough.
+@note The result is NOT null-terminated.
+*/
+template<typename FloatType>
+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.
+    if (std::signbit(value))
+    {
+        value = -value;
+        *first++ = '-';
+    }
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+    if (value == 0) // +-0
+    {
+        *first++ = '0';
+        // Make it look like a floating-point number (#362, #378)
+        *first++ = '.';
+        *first++ = '0';
+        return first;
+    }
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+    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
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/output/binary_writer.hpp>
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+///////////////////
+// serialization //
+///////////////////
+
+/// how to treat decoding errors
+enum class error_handler_t
+{
+    strict,  ///< throw a type_error exception in case of invalid UTF-8
+    replace, ///< replace invalid UTF-8 sequences with U+FFFD
+    ignore   ///< ignore invalid UTF-8 sequences
+};
+
+template<typename BasicJsonType>
+class serializer
+{
+    using string_t = typename BasicJsonType::string_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using binary_char_t = typename BasicJsonType::binary_t::value_type;
+    static constexpr std::uint8_t UTF8_ACCEPT = 0;
+    static constexpr std::uint8_t UTF8_REJECT = 1;
+
+  public:
+    /*!
+    @param[in] s  output stream to serialize to
+    @param[in] ichar  indentation character to use
+    @param[in] error_handler_  how to react on decoding errors
+    */
+    serializer(output_adapter_t<char> s, const char ichar,
+               error_handler_t error_handler_ = error_handler_t::strict)
+        : o(std::move(s))
+        , loc(std::localeconv())
+        , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
+        , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
+        , indent_char(ichar)
+        , indent_string(512, indent_char)
+        , error_handler(error_handler_)
+    {}
+
+    // deleted because of pointer members
+    serializer(const serializer&) = delete;
+    serializer& operator=(const serializer&) = delete;
+    serializer(serializer&&) = delete;
+    serializer& operator=(serializer&&) = delete;
+    ~serializer() = default;
+
+    /*!
+    @brief internal implementation of the serialization function
+
+    This function is called by the public member function dump and organizes
+    the serialization internally. The indentation level is propagated as
+    additional parameter. In case of arrays and objects, the function is
+    called recursively.
+
+    - strings and object keys are escaped using `escape_string()`
+    - integer numbers are converted implicitly via `operator<<`
+    - floating-point numbers are converted to a string using `"%g"` format
+    - binary values are serialized as objects containing the subtype and the
+      byte array
+
+    @param[in] val               value to serialize
+    @param[in] pretty_print      whether the output shall be pretty-printed
+    @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
+    in the output are escaped with `\uXXXX` sequences, and the result consists
+    of ASCII characters only.
+    @param[in] indent_step       the indent level
+    @param[in] current_indent    the current indent level (only used internally)
+    */
+    void dump(const BasicJsonType& val,
+              const bool pretty_print,
+              const bool ensure_ascii,
+              const unsigned int indent_step,
+              const unsigned int current_indent = 0)
+    {
+        switch (val.m_data.m_type)
+        {
+            case value_t::object:
+            {
+                if (val.m_data.m_value.object->empty())
+                {
+                    o->write_characters("{}", 2);
+                    return;
+                }
+
+                if (pretty_print)
+                {
+                    o->write_characters("{\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    // first n-1 elements
+                    auto i = val.m_data.m_value.object->cbegin();
+                    for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i)
+                    {
+                        o->write_characters(indent_string.c_str(), new_indent);
+                        o->write_character('\"');
+                        dump_escaped(i->first, ensure_ascii);
+                        o->write_characters("\": ", 3);
+                        dump(i->second, true, ensure_ascii, indent_step, new_indent);
+                        o->write_characters(",\n", 2);
+                    }
+
+                    // last element
+                    JSON_ASSERT(i != val.m_data.m_value.object->cend());
+                    JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend());
+                    o->write_characters(indent_string.c_str(), new_indent);
+                    o->write_character('\"');
+                    dump_escaped(i->first, ensure_ascii);
+                    o->write_characters("\": ", 3);
+                    dump(i->second, true, ensure_ascii, indent_step, new_indent);
+
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character('}');
+                }
+                else
+                {
+                    o->write_character('{');
+
+                    // first n-1 elements
+                    auto i = val.m_data.m_value.object->cbegin();
+                    for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i)
+                    {
+                        o->write_character('\"');
+                        dump_escaped(i->first, ensure_ascii);
+                        o->write_characters("\":", 2);
+                        dump(i->second, false, ensure_ascii, indent_step, current_indent);
+                        o->write_character(',');
+                    }
+
+                    // last element
+                    JSON_ASSERT(i != val.m_data.m_value.object->cend());
+                    JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend());
+                    o->write_character('\"');
+                    dump_escaped(i->first, ensure_ascii);
+                    o->write_characters("\":", 2);
+                    dump(i->second, false, ensure_ascii, indent_step, current_indent);
+
+                    o->write_character('}');
+                }
+
+                return;
+            }
+
+            case value_t::array:
+            {
+                if (val.m_data.m_value.array->empty())
+                {
+                    o->write_characters("[]", 2);
+                    return;
+                }
+
+                if (pretty_print)
+                {
+                    o->write_characters("[\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    // first n-1 elements
+                    for (auto i = val.m_data.m_value.array->cbegin();
+                            i != val.m_data.m_value.array->cend() - 1; ++i)
+                    {
+                        o->write_characters(indent_string.c_str(), new_indent);
+                        dump(*i, true, ensure_ascii, indent_step, new_indent);
+                        o->write_characters(",\n", 2);
+                    }
+
+                    // last element
+                    JSON_ASSERT(!val.m_data.m_value.array->empty());
+                    o->write_characters(indent_string.c_str(), new_indent);
+                    dump(val.m_data.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
+
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character(']');
+                }
+                else
+                {
+                    o->write_character('[');
+
+                    // first n-1 elements
+                    for (auto i = val.m_data.m_value.array->cbegin();
+                            i != val.m_data.m_value.array->cend() - 1; ++i)
+                    {
+                        dump(*i, false, ensure_ascii, indent_step, current_indent);
+                        o->write_character(',');
+                    }
+
+                    // last element
+                    JSON_ASSERT(!val.m_data.m_value.array->empty());
+                    dump(val.m_data.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
+
+                    o->write_character(']');
+                }
+
+                return;
+            }
+
+            case value_t::string:
+            {
+                o->write_character('\"');
+                dump_escaped(*val.m_data.m_value.string, ensure_ascii);
+                o->write_character('\"');
+                return;
+            }
+
+            case value_t::binary:
+            {
+                if (pretty_print)
+                {
+                    o->write_characters("{\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    o->write_characters(indent_string.c_str(), new_indent);
+
+                    o->write_characters("\"bytes\": [", 10);
+
+                    if (!val.m_data.m_value.binary->empty())
+                    {
+                        for (auto i = val.m_data.m_value.binary->cbegin();
+                                i != val.m_data.m_value.binary->cend() - 1; ++i)
+                        {
+                            dump_integer(*i);
+                            o->write_characters(", ", 2);
+                        }
+                        dump_integer(val.m_data.m_value.binary->back());
+                    }
+
+                    o->write_characters("],\n", 3);
+                    o->write_characters(indent_string.c_str(), new_indent);
+
+                    o->write_characters("\"subtype\": ", 11);
+                    if (val.m_data.m_value.binary->has_subtype())
+                    {
+                        dump_integer(val.m_data.m_value.binary->subtype());
+                    }
+                    else
+                    {
+                        o->write_characters("null", 4);
+                    }
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character('}');
+                }
+                else
+                {
+                    o->write_characters("{\"bytes\":[", 10);
+
+                    if (!val.m_data.m_value.binary->empty())
+                    {
+                        for (auto i = val.m_data.m_value.binary->cbegin();
+                                i != val.m_data.m_value.binary->cend() - 1; ++i)
+                        {
+                            dump_integer(*i);
+                            o->write_character(',');
+                        }
+                        dump_integer(val.m_data.m_value.binary->back());
+                    }
+
+                    o->write_characters("],\"subtype\":", 12);
+                    if (val.m_data.m_value.binary->has_subtype())
+                    {
+                        dump_integer(val.m_data.m_value.binary->subtype());
+                        o->write_character('}');
+                    }
+                    else
+                    {
+                        o->write_characters("null}", 5);
+                    }
+                }
+                return;
+            }
+
+            case value_t::boolean:
+            {
+                if (val.m_data.m_value.boolean)
+                {
+                    o->write_characters("true", 4);
+                }
+                else
+                {
+                    o->write_characters("false", 5);
+                }
+                return;
+            }
+
+            case value_t::number_integer:
+            {
+                dump_integer(val.m_data.m_value.number_integer);
+                return;
+            }
+
+            case value_t::number_unsigned:
+            {
+                dump_integer(val.m_data.m_value.number_unsigned);
+                return;
+            }
+
+            case value_t::number_float:
+            {
+                dump_float(val.m_data.m_value.number_float);
+                return;
+            }
+
+            case value_t::discarded:
+            {
+                o->write_characters("<discarded>", 11);
+                return;
+            }
+
+            case value_t::null:
+            {
+                o->write_characters("null", 4);
+                return;
+            }
+
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief dump escaped string
+
+    Escape a string by replacing certain special characters by a sequence of an
+    escape character (backslash) and another character and other control
+    characters by a sequence of "\u" followed by a four-digit hex
+    representation. The escaped string is written to output stream @a o.
+
+    @param[in] s  the string to escape
+    @param[in] ensure_ascii  whether to escape non-ASCII characters with
+                             \uXXXX sequences
+
+    @complexity Linear in the length of string @a s.
+    */
+    void dump_escaped(const string_t& s, const bool ensure_ascii)
+    {
+        std::uint32_t codepoint{};
+        std::uint8_t state = UTF8_ACCEPT;
+        std::size_t bytes = 0;  // number of bytes written to string_buffer
+
+        // number of bytes written at the point of the last valid byte
+        std::size_t bytes_after_last_accept = 0;
+        std::size_t undumped_chars = 0;
+
+        for (std::size_t i = 0; i < s.size(); ++i)
+        {
+            const auto byte = static_cast<std::uint8_t>(s[i]);
+
+            switch (decode(state, codepoint, byte))
+            {
+                case UTF8_ACCEPT:  // decode found a new code point
+                {
+                    switch (codepoint)
+                    {
+                        case 0x08: // backspace
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'b';
+                            break;
+                        }
+
+                        case 0x09: // horizontal tab
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 't';
+                            break;
+                        }
+
+                        case 0x0A: // newline
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'n';
+                            break;
+                        }
+
+                        case 0x0C: // formfeed
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'f';
+                            break;
+                        }
+
+                        case 0x0D: // carriage return
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'r';
+                            break;
+                        }
+
+                        case 0x22: // quotation mark
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = '\"';
+                            break;
+                        }
+
+                        case 0x5C: // reverse solidus
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = '\\';
+                            break;
+                        }
+
+                        default:
+                        {
+                            // escape control characters (0x00..0x1F) or, if
+                            // ensure_ascii parameter is used, non-ASCII characters
+                            if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
+                            {
+                                if (codepoint <= 0xFFFF)
+                                {
+                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
+                                                                      static_cast<std::uint16_t>(codepoint)));
+                                    bytes += 6;
+                                }
+                                else
+                                {
+                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
+                                                                      static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
+                                                                      static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu))));
+                                    bytes += 12;
+                                }
+                            }
+                            else
+                            {
+                                // copy byte to buffer (all previous bytes
+                                // been copied have in default case above)
+                                string_buffer[bytes++] = s[i];
+                            }
+                            break;
+                        }
+                    }
+
+                    // write buffer and reset index; there must be 13 bytes
+                    // left, as this is the maximal number of bytes to be
+                    // written ("\uxxxx\uxxxx\0") for one code point
+                    if (string_buffer.size() - bytes < 13)
+                    {
+                        o->write_characters(string_buffer.data(), bytes);
+                        bytes = 0;
+                    }
+
+                    // remember the byte position of this accept
+                    bytes_after_last_accept = bytes;
+                    undumped_chars = 0;
+                    break;
+                }
+
+                case UTF8_REJECT:  // decode found invalid UTF-8 byte
+                {
+                    switch (error_handler)
+                    {
+                        case error_handler_t::strict:
+                        {
+                            JSON_THROW(type_error::create(316, concat("invalid UTF-8 byte at index ", std::to_string(i), ": 0x", hex_bytes(byte | 0)), nullptr));
+                        }
+
+                        case error_handler_t::ignore:
+                        case error_handler_t::replace:
+                        {
+                            // in case we saw this character the first time, we
+                            // would like to read it again, because the byte
+                            // may be OK for itself, but just not OK for the
+                            // previous sequence
+                            if (undumped_chars > 0)
+                            {
+                                --i;
+                            }
+
+                            // reset length buffer to the last accepted index;
+                            // thus removing/ignoring the invalid characters
+                            bytes = bytes_after_last_accept;
+
+                            if (error_handler == error_handler_t::replace)
+                            {
+                                // add a replacement character
+                                if (ensure_ascii)
+                                {
+                                    string_buffer[bytes++] = '\\';
+                                    string_buffer[bytes++] = 'u';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'd';
+                                }
+                                else
+                                {
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF');
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF');
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD');
+                                }
+
+                                // write buffer and reset index; there must be 13 bytes
+                                // left, as this is the maximal number of bytes to be
+                                // written ("\uxxxx\uxxxx\0") for one code point
+                                if (string_buffer.size() - bytes < 13)
+                                {
+                                    o->write_characters(string_buffer.data(), bytes);
+                                    bytes = 0;
+                                }
+
+                                bytes_after_last_accept = bytes;
+                            }
+
+                            undumped_chars = 0;
+
+                            // continue processing the string
+                            state = UTF8_ACCEPT;
+                            break;
+                        }
+
+                        default:            // LCOV_EXCL_LINE
+                            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+                    }
+                    break;
+                }
+
+                default:  // decode found yet incomplete multibyte code point
+                {
+                    if (!ensure_ascii)
+                    {
+                        // code point will not be escaped - copy byte to buffer
+                        string_buffer[bytes++] = s[i];
+                    }
+                    ++undumped_chars;
+                    break;
+                }
+            }
+        }
+
+        // we finished processing the string
+        if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
+        {
+            // write buffer
+            if (bytes > 0)
+            {
+                o->write_characters(string_buffer.data(), bytes);
+            }
+        }
+        else
+        {
+            // we finish reading, but do not accept: string was incomplete
+            switch (error_handler)
+            {
+                case error_handler_t::strict:
+                {
+                    JSON_THROW(type_error::create(316, concat("incomplete UTF-8 string; last byte: 0x", hex_bytes(static_cast<std::uint8_t>(s.back() | 0))), nullptr));
+                }
+
+                case error_handler_t::ignore:
+                {
+                    // write all accepted bytes
+                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
+                    break;
+                }
+
+                case error_handler_t::replace:
+                {
+                    // write all accepted bytes
+                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
+                    // add a replacement character
+                    if (ensure_ascii)
+                    {
+                        o->write_characters("\\ufffd", 6);
+                    }
+                    else
+                    {
+                        o->write_characters("\xEF\xBF\xBD", 3);
+                    }
+                    break;
+                }
+
+                default:            // LCOV_EXCL_LINE
+                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+            }
+        }
+    }
+
+  private:
+    /*!
+    @brief count digits
+
+    Count the number of decimal (base 10) digits for an input unsigned integer.
+
+    @param[in] x  unsigned integer number to count its digits
+    @return    number of decimal digits
+    */
+    unsigned int count_digits(number_unsigned_t x) noexcept
+    {
+        unsigned int n_digits = 1;
+        for (;;)
+        {
+            if (x < 10)
+            {
+                return n_digits;
+            }
+            if (x < 100)
+            {
+                return n_digits + 1;
+            }
+            if (x < 1000)
+            {
+                return n_digits + 2;
+            }
+            if (x < 10000)
+            {
+                return n_digits + 3;
+            }
+            x = x / 10000u;
+            n_digits += 4;
+        }
+    }
+
+    /*!
+     * @brief convert a byte to a uppercase hex representation
+     * @param[in] byte byte to represent
+     * @return representation ("00".."FF")
+     */
+    static std::string hex_bytes(std::uint8_t byte)
+    {
+        std::string result = "FF";
+        constexpr const char* nibble_to_hex = "0123456789ABCDEF";
+        result[0] = nibble_to_hex[byte / 16];
+        result[1] = nibble_to_hex[byte % 16];
+        return result;
+    }
+
+    // templates to avoid warnings about useless casts
+    template <typename NumberType, enable_if_t<std::is_signed<NumberType>::value, int> = 0>
+    bool is_negative_number(NumberType x)
+    {
+        return x < 0;
+    }
+
+    template < typename NumberType, enable_if_t <std::is_unsigned<NumberType>::value, int > = 0 >
+    bool is_negative_number(NumberType /*unused*/)
+    {
+        return false;
+    }
+
+    /*!
+    @brief dump an integer
+
+    Dump a given integer to output stream @a o. 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
+    */
+    template < typename NumberType, detail::enable_if_t <
+                   std::is_integral<NumberType>::value ||
+                   std::is_same<NumberType, number_unsigned_t>::value ||
+                   std::is_same<NumberType, number_integer_t>::value ||
+                   std::is_same<NumberType, binary_char_t>::value,
+                   int > = 0 >
+    void dump_integer(NumberType x)
+    {
+        static constexpr std::array<std::array<char, 2>, 100> digits_to_99
+        {
+            {
+                {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
+                {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
+                {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
+                {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
+                {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
+                {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
+                {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
+                {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
+                {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
+                {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
+            }
+        };
+
+        // special case for "0"
+        if (x == 0)
+        {
+            o->write_character('0');
+            return;
+        }
+
+        // use a pointer to fill the buffer
+        auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+
+        number_unsigned_t abs_value;
+
+        unsigned int n_chars{};
+
+        if (is_negative_number(x))
+        {
+            *buffer_ptr = '-';
+            abs_value = remove_sign(static_cast<number_integer_t>(x));
+
+            // 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);
+        }
+
+        // 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 += 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
+        while (abs_value >= 100)
+        {
+            const auto digits_index = static_cast<unsigned>((abs_value % 100));
+            abs_value /= 100;
+            *(--buffer_ptr) = digits_to_99[digits_index][1];
+            *(--buffer_ptr) = digits_to_99[digits_index][0];
+        }
+
+        if (abs_value >= 10)
+        {
+            const auto digits_index = static_cast<unsigned>(abs_value);
+            *(--buffer_ptr) = digits_to_99[digits_index][1];
+            *(--buffer_ptr) = digits_to_99[digits_index][0];
+        }
+        else
+        {
+            *(--buffer_ptr) = static_cast<char>('0' + abs_value);
+        }
+
+        o->write_characters(number_buffer.data(), n_chars);
+    }
+
+    /*!
+    @brief dump a floating-point number
+
+    Dump a given floating-point number to output stream @a o. Works internally
+    with @a number_buffer.
+
+    @param[in] x  floating-point number to dump
+    */
+    void dump_float(number_float_t x)
+    {
+        // NaN / inf
+        if (!std::isfinite(x))
+        {
+            o->write_characters("null", 4);
+            return;
+        }
+
+        // If number_float_t is an IEEE-754 single or double precision number,
+        // use the Grisu2 algorithm to produce short numbers which are
+        // guaranteed to round-trip, using strtof and strtod, resp.
+        //
+        // NB: The test below works if <long double> == <double>.
+        static constexpr bool is_ieee_single_or_double
+            = (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
+              (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
+
+        dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
+    }
+
+    void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
+    {
+        auto* begin = number_buffer.data();
+        auto* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
+
+        o->write_characters(begin, static_cast<size_t>(end - begin));
+    }
+
+    void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
+    {
+        // get the number of digits for a float -> text -> float round-trip
+        static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
+
+        // the actual conversion
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
+
+        // negative value indicates an error
+        JSON_ASSERT(len > 0);
+        // check if the buffer was large enough
+        JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
+
+        // erase thousands separators
+        if (thousands_sep != '\0')
+        {
+            // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::remove returns an iterator, see https://github.com/nlohmann/json/issues/3081
+            const auto end = std::remove(number_buffer.begin(), number_buffer.begin() + len, thousands_sep);
+            std::fill(end, number_buffer.end(), '\0');
+            JSON_ASSERT((end - number_buffer.begin()) <= len);
+            len = (end - number_buffer.begin());
+        }
+
+        // convert decimal point to '.'
+        if (decimal_point != '\0' && decimal_point != '.')
+        {
+            // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::find returns an iterator, see https://github.com/nlohmann/json/issues/3081
+            const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
+            if (dec_pos != number_buffer.end())
+            {
+                *dec_pos = '.';
+            }
+        }
+
+        o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
+
+        // determine if we need to append ".0"
+        const bool value_is_int_like =
+            std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
+                         [](char c)
+        {
+            return c == '.' || c == 'e';
+        });
+
+        if (value_is_int_like)
+        {
+            o->write_characters(".0", 2);
+        }
+    }
+
+    /*!
+    @brief check whether a string is UTF-8 encoded
+
+    The function checks each byte of a string whether it is UTF-8 encoded. The
+    result of the check is stored in the @a state parameter. The function must
+    be called initially with state 0 (accept). State 1 means the string must
+    be rejected, because the current byte is not allowed. If the string is
+    completely processed, but the state is non-zero, the string ended
+    prematurely; that is, the last byte indicated more bytes should have
+    followed.
+
+    @param[in,out] state  the state of the decoding
+    @param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)
+    @param[in] byte       next byte to decode
+    @return               new state
+
+    @note The function has been edited: a std::array is used.
+
+    @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
+    @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+    */
+    static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
+    {
+        static const std::array<std::uint8_t, 400> utf8d =
+        {
+            {
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
+                7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
+                8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
+                0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
+                0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
+                0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
+                1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
+                1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
+                1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
+            }
+        };
+
+        JSON_ASSERT(byte < utf8d.size());
+        const std::uint8_t type = utf8d[byte];
+
+        codep = (state != UTF8_ACCEPT)
+                ? (byte & 0x3fu) | (codep << 6u)
+                : (0xFFu >> type) & (byte);
+
+        const std::size_t index = 256u + (static_cast<size_t>(state) * 16u) + static_cast<size_t>(type);
+        JSON_ASSERT(index < utf8d.size());
+        state = utf8d[index];
+        return state;
+    }
+
+    /*
+     * Overload to make the compiler happy while it is instantiating
+     * dump_integer for number_unsigned_t.
+     * Must never be called.
+     */
+    number_unsigned_t remove_sign(number_unsigned_t x)
+    {
+        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        return x; // LCOV_EXCL_LINE
+    }
+
+    /*
+     * Helper function for dump_integer
+     *
+     * This function takes a negative signed integer and returns its absolute
+     * value as an unsigned integer. The plus/minus shuffling is necessary as we
+     * cannot directly remove the sign of an arbitrary signed integer as the
+     * absolute values of INT_MIN and INT_MAX are usually not the same. See
+     * #1708 for details.
+     */
+    number_unsigned_t remove_sign(number_integer_t x) noexcept
+    {
+        JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)()); // NOLINT(misc-redundant-expression)
+        return static_cast<number_unsigned_t>(-(x + 1)) + 1;
+    }
+
+  private:
+    /// the output of the serializer
+    output_adapter_t<char> o = nullptr;
+
+    /// a (hopefully) large enough character buffer
+    std::array<char, 64> number_buffer{{}};
+
+    /// the locale
+    const std::lconv* loc = nullptr;
+    /// the locale's thousand separator character
+    const char thousands_sep = '\0';
+    /// the locale's decimal point character
+    const char decimal_point = '\0';
+
+    /// string buffer
+    std::array<char, 512> string_buffer{{}};
+
+    /// the indentation character
+    const char indent_char;
+    /// the indentation string
+    string_t indent_string;
+
+    /// error_handler how to react on decoding errors
+    const error_handler_t error_handler;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/value_t.hpp>
+
+// #include <nlohmann/json_fwd.hpp>
+
+// #include <nlohmann/ordered_map.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <functional> // equal_to, less
+#include <initializer_list> // initializer_list
+#include <iterator> // input_iterator_tag, iterator_traits
+#include <memory> // allocator
+#include <stdexcept> // for out_of_range
+#include <type_traits> // enable_if, is_convertible
+#include <utility> // pair
+#include <vector> // vector
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// ordered_map: a minimal map-like container that preserves insertion order
+/// for use within nlohmann::basic_json<ordered_map>
+template <class Key, class T, class IgnoredLess = std::less<Key>,
+          class Allocator = std::allocator<std::pair<const Key, T>>>
+              struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
+{
+    using key_type = Key;
+    using mapped_type = T;
+    using Container = std::vector<std::pair<const Key, T>, Allocator>;
+    using iterator = typename Container::iterator;
+    using const_iterator = typename Container::const_iterator;
+    using size_type = typename Container::size_type;
+    using value_type = typename Container::value_type;
+#ifdef JSON_HAS_CPP_14
+    using key_compare = std::equal_to<>;
+#else
+    using key_compare = std::equal_to<Key>;
+#endif
+
+    // Explicit constructors instead of `using Container::Container`
+    // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)
+    ordered_map() noexcept(noexcept(Container())) : Container{} {}
+    explicit ordered_map(const Allocator& alloc) noexcept(noexcept(Container(alloc))) : Container{alloc} {}
+    template <class It>
+    ordered_map(It first, It last, const Allocator& alloc = Allocator())
+        : Container{first, last, alloc} {}
+    ordered_map(std::initializer_list<value_type> init, const Allocator& alloc = Allocator() )
+        : Container{init, alloc} {}
+
+    std::pair<iterator, bool> emplace(const key_type& key, T&& t)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return {it, false};
+            }
+        }
+        Container::emplace_back(key, std::forward<T>(t));
+        return {std::prev(this->end()), true};
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    std::pair<iterator, bool> emplace(KeyType && key, T && t)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return {it, false};
+            }
+        }
+        Container::emplace_back(std::forward<KeyType>(key), std::forward<T>(t));
+        return {std::prev(this->end()), true};
+    }
+
+    T& operator[](const key_type& key)
+    {
+        return emplace(key, T{}).first->second;
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    T & operator[](KeyType && key)
+    {
+        return emplace(std::forward<KeyType>(key), T{}).first->second;
+    }
+
+    const T& operator[](const key_type& key) const
+    {
+        return at(key);
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    const T & operator[](KeyType && key) const
+    {
+        return at(std::forward<KeyType>(key));
+    }
+
+    T& at(const key_type& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    T & at(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    const T& at(const key_type& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    const T & at(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    size_type erase(const key_type& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                // Since we cannot move const Keys, re-construct them in place
+                for (auto next = it; ++next != this->end(); ++it)
+                {
+                    it->~value_type(); // Destroy but keep allocation
+                    new (&*it) value_type{std::move(*next)};
+                }
+                Container::pop_back();
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    size_type erase(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                // Since we cannot move const Keys, re-construct them in place
+                for (auto next = it; ++next != this->end(); ++it)
+                {
+                    it->~value_type(); // Destroy but keep allocation
+                    new (&*it) value_type{std::move(*next)};
+                }
+                Container::pop_back();
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    iterator erase(iterator pos)
+    {
+        return erase(pos, std::next(pos));
+    }
+
+    iterator erase(iterator first, iterator last)
+    {
+        if (first == last)
+        {
+            return first;
+        }
+
+        const auto elements_affected = std::distance(first, last);
+        const auto offset = std::distance(Container::begin(), first);
+
+        // This is the start situation. We need to delete elements_affected
+        // elements (3 in this example: e, f, g), and need to return an
+        // iterator past the last deleted element (h in this example).
+        // Note that offset is the distance from the start of the vector
+        // to first. We will need this later.
+
+        // [ a, b, c, d, e, f, g, h, i, j ]
+        //               ^        ^
+        //             first    last
+
+        // Since we cannot move const Keys, we re-construct them in place.
+        // We start at first and re-construct (viz. copy) the elements from
+        // the back of the vector. Example for the first iteration:
+
+        //               ,--------.
+        //               v        |   destroy e and re-construct with h
+        // [ a, b, c, d, e, f, g, h, i, j ]
+        //               ^        ^
+        //               it       it + elements_affected
+
+        for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
+        {
+            it->~value_type(); // destroy but keep allocation
+            new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it
+        }
+
+        // [ a, b, c, d, h, i, j, h, i, j ]
+        //               ^        ^
+        //             first    last
+
+        // remove the unneeded elements at the end of the vector
+        Container::resize(this->size() - static_cast<size_type>(elements_affected));
+
+        // [ a, b, c, d, h, i, j ]
+        //               ^        ^
+        //             first    last
+
+        // first is now pointing past the last deleted element, but we cannot
+        // use this iterator, because it may have been invalidated by the
+        // resize call. Instead, we can return begin() + offset.
+        return Container::begin() + offset;
+    }
+
+    size_type count(const key_type& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    size_type count(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    iterator find(const key_type& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    iterator find(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    const_iterator find(const key_type& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    std::pair<iterator, bool> insert( value_type&& value )
+    {
+        return emplace(value.first, std::move(value.second));
+    }
+
+    std::pair<iterator, bool> insert( const value_type& value )
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, value.first))
+            {
+                return {it, false};
+            }
+        }
+        Container::push_back(value);
+        return {--this->end(), true};
+    }
+
+    template<typename InputIt>
+    using require_input_iter = typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category,
+        std::input_iterator_tag>::value>::type;
+
+    template<typename InputIt, typename = require_input_iter<InputIt>>
+    void insert(InputIt first, InputIt last)
+    {
+        for (auto it = first; it != last; ++it)
+        {
+            insert(*it);
+        }
+    }
+
+private:
+    JSON_NO_UNIQUE_ADDRESS key_compare m_compare = key_compare();
+};
+
+NLOHMANN_JSON_NAMESPACE_END
+
+
+#if defined(JSON_HAS_CPP_17)
+    #if JSON_HAS_STATIC_RTTI
+        #include <any>
+    #endif
+    #include <string_view>
+#endif
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+@since version 1.0.0
+*/
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/*!
+@brief a class to store JSON values
+
+@internal
+@invariant The member variables @a m_value and @a m_type have the following
+relationship:
+- If `m_type == value_t::object`, then `m_value.object != nullptr`.
+- If `m_type == value_t::array`, then `m_value.array != nullptr`.
+- If `m_type == value_t::string`, then `m_value.string != nullptr`.
+The invariants are checked by member function assert_invariant().
+
+@note ObjectType trick from https://stackoverflow.com/a/9860911
+@endinternal
+
+@since version 1.0.0
+
+@nosubgrouping
+*/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
+    : public ::nlohmann::detail::json_base_class<CustomBaseClass>
+{
+  private:
+    template<detail::value_t> friend struct detail::external_constructor;
+
+    template<typename>
+    friend class ::nlohmann::json_pointer;
+    // can be restored when json_pointer backwards compatibility is removed
+    // friend ::nlohmann::json_pointer<StringType>;
+
+    template<typename BasicJsonType, typename InputType>
+    friend class ::nlohmann::detail::parser;
+    friend ::nlohmann::detail::serializer<basic_json>;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::iter_impl;
+    template<typename BasicJsonType, typename CharType>
+    friend class ::nlohmann::detail::binary_writer;
+    template<typename BasicJsonType, typename InputType, typename SAX>
+    friend class ::nlohmann::detail::binary_reader;
+    template<typename BasicJsonType, typename InputAdapterType>
+    friend class ::nlohmann::detail::json_sax_dom_parser;
+    template<typename BasicJsonType, typename InputAdapterType>
+    friend class ::nlohmann::detail::json_sax_dom_callback_parser;
+    friend class ::nlohmann::detail::exception;
+
+    /// workaround type for MSVC
+    using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
+    using json_base_class_t = ::nlohmann::detail::json_base_class<CustomBaseClass>;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    // convenience aliases for types residing in namespace detail;
+    using lexer = ::nlohmann::detail::lexer_base<basic_json>;
+
+    template<typename InputAdapterType>
+    static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
+        InputAdapterType adapter,
+        detail::parser_callback_t<basic_json>cb = nullptr,
+        const bool allow_exceptions = true,
+        const bool ignore_comments = false,
+        const bool ignore_trailing_commas = false
+                                 )
+    {
+        return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
+            std::move(cb), allow_exceptions, ignore_comments, ignore_trailing_commas);
+    }
+
+  private:
+    using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
+    template<typename BasicJsonType>
+    using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
+    template<typename BasicJsonType>
+    using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
+    template<typename Iterator>
+    using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
+    template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
+
+    template<typename CharType>
+    using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
+
+    template<typename InputType>
+    using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
+    template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    using serializer = ::nlohmann::detail::serializer<basic_json>;
+
+  public:
+    using value_t = detail::value_t;
+    /// JSON Pointer, see @ref nlohmann::json_pointer
+    using json_pointer = ::nlohmann::json_pointer<StringType>;
+    template<typename T, typename SFINAE>
+    using json_serializer = JSONSerializer<T, SFINAE>;
+    /// how to treat decoding errors
+    using error_handler_t = detail::error_handler_t;
+    /// how to treat CBOR tags
+    using cbor_tag_handler_t = detail::cbor_tag_handler_t;
+    /// how to encode BJData
+    using bjdata_version_t = detail::bjdata_version_t;
+    /// helper type for initializer lists of basic_json values
+    using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
+
+    using input_format_t = detail::input_format_t;
+    /// SAX interface type, see @ref nlohmann::json_sax
+    using json_sax_t = json_sax<basic_json>;
+
+    ////////////////
+    // exceptions //
+    ////////////////
+
+    /// @name exceptions
+    /// Classes to implement user-defined exceptions.
+    /// @{
+
+    using exception = detail::exception;
+    using parse_error = detail::parse_error;
+    using invalid_iterator = detail::invalid_iterator;
+    using type_error = detail::type_error;
+    using out_of_range = detail::out_of_range;
+    using other_error = detail::other_error;
+
+    /// @}
+
+    /////////////////////
+    // container types //
+    /////////////////////
+
+    /// @name container types
+    /// The canonic container types to use @ref basic_json like any other STL
+    /// container.
+    /// @{
+
+    /// the type of elements in a basic_json container
+    using value_type = basic_json;
+
+    /// the type of an element reference
+    using reference = value_type&;
+    /// the type of an element const reference
+    using const_reference = const value_type&;
+
+    /// a type to represent differences between iterators
+    using difference_type = std::ptrdiff_t;
+    /// a type to represent container sizes
+    using size_type = std::size_t;
+
+    /// the allocator type
+    using allocator_type = AllocatorType<basic_json>;
+
+    /// the type of an element pointer
+    using pointer = typename std::allocator_traits<allocator_type>::pointer;
+    /// the type of an element const pointer
+    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
+
+    /// an iterator for a basic_json container
+    using iterator = iter_impl<basic_json>;
+    /// a const iterator for a basic_json container
+    using const_iterator = iter_impl<const basic_json>;
+    /// a reverse iterator for a basic_json container
+    using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
+    /// a const reverse iterator for a basic_json container
+    using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
+
+    /// @}
+
+    /// @brief returns the allocator associated with the container
+    /// @sa https://json.nlohmann.me/api/basic_json/get_allocator/
+    static allocator_type get_allocator()
+    {
+        return allocator_type();
+    }
+
+    /// @brief returns version information on the library
+    /// @sa https://json.nlohmann.me/api/basic_json/meta/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json meta()
+    {
+        basic_json result;
+
+        result["copyright"] = "(C) 2013-2025 Niels Lohmann";
+        result["name"] = "JSON for Modern C++";
+        result["url"] = "https://github.com/nlohmann/json";
+        result["version"]["string"] =
+            detail::concat(std::to_string(NLOHMANN_JSON_VERSION_MAJOR), '.',
+                           std::to_string(NLOHMANN_JSON_VERSION_MINOR), '.',
+                           std::to_string(NLOHMANN_JSON_VERSION_PATCH));
+        result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
+        result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
+        result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
+
+#ifdef _WIN32
+        result["platform"] = "win32";
+#elif defined __linux__
+        result["platform"] = "linux";
+#elif defined __APPLE__
+        result["platform"] = "apple";
+#elif defined __unix__
+        result["platform"] = "unix";
+#else
+        result["platform"] = "unknown";
+#endif
+
+#if defined(__ICC) || defined(__INTEL_COMPILER)
+        result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
+#elif defined(__clang__)
+        result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
+#elif defined(__GNUC__) || defined(__GNUG__)
+        result["compiler"] = {{"family", "gcc"}, {"version", detail::concat(
+                    std::to_string(__GNUC__), '.',
+                    std::to_string(__GNUC_MINOR__), '.',
+                    std::to_string(__GNUC_PATCHLEVEL__))
+            }
+        };
+#elif defined(__HP_cc) || defined(__HP_aCC)
+        result["compiler"] = "hp"
+#elif defined(__IBMCPP__)
+        result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
+#elif defined(_MSC_VER)
+        result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
+#elif defined(__PGI)
+        result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
+#elif defined(__SUNPRO_CC)
+        result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
+#else
+        result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
+#endif
+
+#if defined(_MSVC_LANG)
+        result["compiler"]["c++"] = std::to_string(_MSVC_LANG);
+#elif defined(__cplusplus)
+        result["compiler"]["c++"] = std::to_string(__cplusplus);
+#else
+        result["compiler"]["c++"] = "unknown";
+#endif
+        return result;
+    }
+
+    ///////////////////////////
+    // JSON value data types //
+    ///////////////////////////
+
+    /// @name JSON value data types
+    /// The data types to store a JSON value. These types are derived from
+    /// the template arguments passed to class @ref basic_json.
+    /// @{
+
+    /// @brief default object key comparator type
+    /// The actual object key comparator type (@ref object_comparator_t) may be
+    /// different.
+    /// @sa https://json.nlohmann.me/api/basic_json/default_object_comparator_t/
+#if defined(JSON_HAS_CPP_14)
+    // use of transparent comparator avoids unnecessary repeated construction of temporaries
+    // in functions involving lookup by key with types other than object_t::key_type (aka. StringType)
+    using default_object_comparator_t = std::less<>;
+#else
+    using default_object_comparator_t = std::less<StringType>;
+#endif
+
+    /// @brief a type for an object
+    /// @sa https://json.nlohmann.me/api/basic_json/object_t/
+    using object_t = ObjectType<StringType,
+          basic_json,
+          default_object_comparator_t,
+          AllocatorType<std::pair<const StringType,
+          basic_json>>>;
+
+    /// @brief a type for an array
+    /// @sa https://json.nlohmann.me/api/basic_json/array_t/
+    using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
+
+    /// @brief a type for a string
+    /// @sa https://json.nlohmann.me/api/basic_json/string_t/
+    using string_t = StringType;
+
+    /// @brief a type for a boolean
+    /// @sa https://json.nlohmann.me/api/basic_json/boolean_t/
+    using boolean_t = BooleanType;
+
+    /// @brief a type for a number (integer)
+    /// @sa https://json.nlohmann.me/api/basic_json/number_integer_t/
+    using number_integer_t = NumberIntegerType;
+
+    /// @brief a type for a number (unsigned)
+    /// @sa https://json.nlohmann.me/api/basic_json/number_unsigned_t/
+    using number_unsigned_t = NumberUnsignedType;
+
+    /// @brief a type for a number (floating-point)
+    /// @sa https://json.nlohmann.me/api/basic_json/number_float_t/
+    using number_float_t = NumberFloatType;
+
+    /// @brief a type for a packed binary type
+    /// @sa https://json.nlohmann.me/api/basic_json/binary_t/
+    using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;
+
+    /// @brief object key comparator type
+    /// @sa https://json.nlohmann.me/api/basic_json/object_comparator_t/
+    using object_comparator_t = detail::actual_object_comparator_t<basic_json>;
+
+    /// @}
+
+  private:
+
+    /// helper for exception-safe object creation
+    template<typename T, typename... Args>
+    JSON_HEDLEY_RETURNS_NON_NULL
+    static T* create(Args&& ... args)
+    {
+        AllocatorType<T> alloc;
+        using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
+
+        auto deleter = [&](T * obj)
+        {
+            AllocatorTraits::deallocate(alloc, obj, 1);
+        };
+        std::unique_ptr<T, decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter);
+        AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
+        JSON_ASSERT(obj != nullptr);
+        return obj.release();
+    }
+
+    ////////////////////////
+    // JSON value storage //
+    ////////////////////////
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief a JSON value
+
+    The actual storage for a JSON value of the @ref basic_json class. This
+    union combines the different storage types for the JSON value types
+    defined in @ref value_t.
+
+    JSON type | value_t type    | used type
+    --------- | --------------- | ------------------------
+    object    | object          | pointer to @ref object_t
+    array     | array           | pointer to @ref array_t
+    string    | string          | pointer to @ref string_t
+    boolean   | boolean         | @ref boolean_t
+    number    | number_integer  | @ref number_integer_t
+    number    | number_unsigned | @ref number_unsigned_t
+    number    | number_float    | @ref number_float_t
+    binary    | binary          | pointer to @ref binary_t
+    null      | null            | *no value is stored*
+
+    @note Variable-length types (objects, arrays, and strings) are stored as
+    pointers. The size of the union should not exceed 64 bits if the default
+    value types are used.
+
+    @since version 1.0.0
+    */
+    union json_value
+    {
+        /// object (stored with pointer to save storage)
+        object_t* object;
+        /// array (stored with pointer to save storage)
+        array_t* array;
+        /// string (stored with pointer to save storage)
+        string_t* string;
+        /// binary (stored with pointer to save storage)
+        binary_t* binary;
+        /// boolean
+        boolean_t boolean;
+        /// number (integer)
+        number_integer_t number_integer;
+        /// number (unsigned integer)
+        number_unsigned_t number_unsigned;
+        /// number (floating-point)
+        number_float_t number_float;
+
+        /// default constructor (for null values)
+        json_value() = default;
+        /// constructor for booleans
+        json_value(boolean_t v) noexcept : boolean(v) {}
+        /// constructor for numbers (integer)
+        json_value(number_integer_t v) noexcept : number_integer(v) {}
+        /// constructor for numbers (unsigned)
+        json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
+        /// constructor for numbers (floating-point)
+        json_value(number_float_t v) noexcept : number_float(v) {}
+        /// constructor for empty values of a given type
+        json_value(value_t t)
+        {
+            switch (t)
+            {
+                case value_t::object:
+                {
+                    object = create<object_t>();
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    array = create<array_t>();
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    string = create<string_t>("");
+                    break;
+                }
+
+                case value_t::binary:
+                {
+                    binary = create<binary_t>();
+                    break;
+                }
+
+                case value_t::boolean:
+                {
+                    boolean = static_cast<boolean_t>(false);
+                    break;
+                }
+
+                case value_t::number_integer:
+                {
+                    number_integer = static_cast<number_integer_t>(0);
+                    break;
+                }
+
+                case value_t::number_unsigned:
+                {
+                    number_unsigned = static_cast<number_unsigned_t>(0);
+                    break;
+                }
+
+                case value_t::number_float:
+                {
+                    number_float = static_cast<number_float_t>(0.0);
+                    break;
+                }
+
+                case value_t::null:
+                {
+                    object = nullptr;  // silence warning, see #821
+                    break;
+                }
+
+                case value_t::discarded:
+                default:
+                {
+                    object = nullptr;  // silence warning, see #821
+                    if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
+                    {
+                        JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.12.0", nullptr)); // LCOV_EXCL_LINE
+                    }
+                    break;
+                }
+            }
+        }
+
+        /// constructor for strings
+        json_value(const string_t& value) : string(create<string_t>(value)) {}
+
+        /// constructor for rvalue strings
+        json_value(string_t&& value) : string(create<string_t>(std::move(value))) {}
+
+        /// constructor for objects
+        json_value(const object_t& value) : object(create<object_t>(value)) {}
+
+        /// constructor for rvalue objects
+        json_value(object_t&& value) : object(create<object_t>(std::move(value))) {}
+
+        /// constructor for arrays
+        json_value(const array_t& value) : array(create<array_t>(value)) {}
+
+        /// constructor for rvalue arrays
+        json_value(array_t&& value) : array(create<array_t>(std::move(value))) {}
+
+        /// constructor for binary arrays
+        json_value(const typename binary_t::container_type& value) : binary(create<binary_t>(value)) {}
+
+        /// constructor for rvalue binary arrays
+        json_value(typename binary_t::container_type&& value) : binary(create<binary_t>(std::move(value))) {}
+
+        /// constructor for binary arrays (internal type)
+        json_value(const binary_t& value) : binary(create<binary_t>(value)) {}
+
+        /// constructor for rvalue binary arrays (internal type)
+        json_value(binary_t&& value) : binary(create<binary_t>(std::move(value))) {}
+
+        void destroy(value_t t)
+        {
+            if (
+                (t == value_t::object && object == 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;
+            }
+            if (t == value_t::array || t == value_t::object)
+            {
+                // 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)
+                {
+                    stack.reserve(array->size());
+                    std::move(array->begin(), array->end(), std::back_inserter(stack));
+                }
+                else
+                {
+                    stack.reserve(object->size());
+                    for (auto&& it : *object)
+                    {
+                        stack.push_back(std::move(it.second));
+                    }
+                }
+
+                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::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:
+                {
+                    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:
+                case value_t::number_integer:
+                case value_t::number_unsigned:
+                case value_t::number_float:
+                case value_t::discarded:
+                default:
+                {
+                    break;
+                }
+            }
+        }
+    };
+
+  private:
+    /*!
+    @brief checks the class invariants
+
+    This function asserts the class invariants. It needs to be called at the
+    end of every constructor to make sure that created objects respect the
+    invariant. Furthermore, it has to be called each time the type of a JSON
+    value is changed, because the invariant expresses a relationship between
+    @a m_type and @a m_value.
+
+    Furthermore, the parent relation is checked for arrays and objects: If
+    @a check_parents true and the value is an array or object, then the
+    container's elements must have the current value as parent.
+
+    @param[in] check_parents  whether the parent relation should be checked.
+               The value is true by default and should only be set to false
+               during destruction of objects when the invariant does not
+               need to hold.
+    */
+    void assert_invariant(bool check_parents = true) const noexcept
+    {
+        JSON_ASSERT(m_data.m_type != value_t::object || m_data.m_value.object != nullptr);
+        JSON_ASSERT(m_data.m_type != value_t::array || m_data.m_value.array != nullptr);
+        JSON_ASSERT(m_data.m_type != value_t::string || m_data.m_value.string != nullptr);
+        JSON_ASSERT(m_data.m_type != value_t::binary || m_data.m_value.binary != nullptr);
+
+#if JSON_DIAGNOSTICS
+        JSON_TRY
+        {
+            // cppcheck-suppress assertWithSideEffect
+            JSON_ASSERT(!check_parents || !is_structured() || std::all_of(begin(), end(), [this](const basic_json & j)
+            {
+                return j.m_parent == this;
+            }));
+        }
+        JSON_CATCH(...) {} // LCOV_EXCL_LINE
+#endif
+        static_cast<void>(check_parents);
+    }
+
+    void set_parents()
+    {
+#if JSON_DIAGNOSTICS
+        switch (m_data.m_type)
+        {
+            case value_t::array:
+            {
+                for (auto& element : *m_data.m_value.array)
+                {
+                    element.m_parent = this;
+                }
+                break;
+            }
+
+            case value_t::object:
+            {
+                for (auto& element : *m_data.m_value.object)
+                {
+                    element.second.m_parent = this;
+                }
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                break;
+        }
+#endif
+    }
+
+    iterator set_parents(iterator it, typename iterator::difference_type count_set_parents)
+    {
+#if JSON_DIAGNOSTICS
+        for (typename iterator::difference_type i = 0; i < count_set_parents; ++i)
+        {
+            (it + i)->m_parent = this;
+        }
+#else
+        static_cast<void>(count_set_parents);
+#endif
+        return it;
+    }
+
+    reference set_parent(reference j, std::size_t old_capacity = detail::unknown_size())
+    {
+#if JSON_DIAGNOSTICS
+        if (old_capacity != detail::unknown_size())
+        {
+            // see https://github.com/nlohmann/json/issues/2838
+            JSON_ASSERT(type() == value_t::array);
+            if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
+            {
+                // capacity has changed: update all parents
+                set_parents();
+                return j;
+            }
+        }
+
+        // ordered_json uses a vector internally, so pointers could have
+        // been invalidated; see https://github.com/nlohmann/json/issues/2962
+#ifdef JSON_HEDLEY_MSVC_VERSION
+#pragma warning(push )
+#pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
+#endif
+        if (detail::is_ordered_map<object_t>::value)
+        {
+            set_parents();
+            return j;
+        }
+#ifdef JSON_HEDLEY_MSVC_VERSION
+#pragma warning( pop )
+#endif
+
+        j.m_parent = this;
+#else
+        static_cast<void>(j);
+        static_cast<void>(old_capacity);
+#endif
+        return j;
+    }
+
+  public:
+    //////////////////////////
+    // JSON parser callback //
+    //////////////////////////
+
+    /// @brief parser event types
+    /// @sa https://json.nlohmann.me/api/basic_json/parse_event_t/
+    using parse_event_t = detail::parse_event_t;
+
+    /// @brief per-element parser callback type
+    /// @sa https://json.nlohmann.me/api/basic_json/parser_callback_t/
+    using parser_callback_t = detail::parser_callback_t<basic_json>;
+
+    //////////////////
+    // constructors //
+    //////////////////
+
+    /// @name constructors and destructors
+    /// Constructors of class @ref basic_json, copy/move constructor, copy
+    /// assignment, static functions creating objects, and the destructor.
+    /// @{
+
+    /// @brief create an empty value with a given type
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(const value_t v)
+        : m_data(v)
+    {
+        assert_invariant();
+    }
+
+    /// @brief create a null object
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(std::nullptr_t = nullptr) noexcept // NOLINT(bugprone-exception-escape)
+        : basic_json(value_t::null)
+    {
+        assert_invariant();
+    }
+
+    /// @brief create a JSON value from compatible types
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    template < typename CompatibleType,
+               typename U = detail::uncvref_t<CompatibleType>,
+               detail::enable_if_t <
+                   !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
+    basic_json(CompatibleType && val) noexcept(noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)
+            JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
+                                       std::forward<CompatibleType>(val))))
+    {
+        JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief create a JSON value from an existing one
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    template < typename BasicJsonType,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
+    basic_json(const BasicJsonType& val)
+#if JSON_DIAGNOSTIC_POSITIONS
+        : start_position(val.start_pos()),
+          end_position(val.end_pos())
+#endif
+    {
+        using other_boolean_t = typename BasicJsonType::boolean_t;
+        using other_number_float_t = typename BasicJsonType::number_float_t;
+        using other_number_integer_t = typename BasicJsonType::number_integer_t;
+        using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+        using other_string_t = typename BasicJsonType::string_t;
+        using other_object_t = typename BasicJsonType::object_t;
+        using other_array_t = typename BasicJsonType::array_t;
+        using other_binary_t = typename BasicJsonType::binary_t;
+
+        switch (val.type())
+        {
+            case value_t::boolean:
+                JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
+                break;
+            case value_t::number_float:
+                JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
+                break;
+            case value_t::number_integer:
+                JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
+                break;
+            case value_t::number_unsigned:
+                JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
+                break;
+            case value_t::string:
+                JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
+                break;
+            case value_t::object:
+                JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
+                break;
+            case value_t::array:
+                JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
+                break;
+            case value_t::binary:
+                JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());
+                break;
+            case value_t::null:
+                *this = nullptr;
+                break;
+            case value_t::discarded:
+                m_data.m_type = value_t::discarded;
+                break;
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+        JSON_ASSERT(m_data.m_type == val.type());
+
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief create a container (array or object) from an initializer list
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(initializer_list_t init,
+               bool type_deduction = true,
+               value_t manual_type = value_t::array)
+    {
+        // check if each element is an array with two elements whose first
+        // element is a string
+        bool is_an_object = std::all_of(init.begin(), init.end(),
+                                        [](const detail::json_ref<basic_json>& element_ref)
+        {
+            // The cast is to ensure op[size_type] is called, bearing in mind size_type may not be int;
+            // (many string types can be constructed from 0 via its null-pointer guise, so we get a
+            // broken call to op[key_type], the wrong semantics, and a 4804 warning on Windows)
+            return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[static_cast<size_type>(0)].is_string();
+        });
+
+        // adjust type if type deduction is not wanted
+        if (!type_deduction)
+        {
+            // if an array is wanted, do not create an object though possible
+            if (manual_type == value_t::array)
+            {
+                is_an_object = false;
+            }
+
+            // if an object is wanted but impossible, throw an exception
+            if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
+            {
+                JSON_THROW(type_error::create(301, "cannot create object from initializer list", nullptr));
+            }
+        }
+
+        if (is_an_object)
+        {
+            // the initializer list is a list of pairs -> create an object
+            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;
+
+            for (auto& element_ref : init)
+            {
+                auto element = element_ref.moved_or_copied();
+                m_data.m_value.object->emplace(
+                    std::move(*((*element.m_data.m_value.array)[0].m_data.m_value.string)),
+                    std::move((*element.m_data.m_value.array)[1]));
+            }
+        }
+        else
+        {
+            // the initializer list describes an array -> create an array
+            m_data.m_type = value_t::array;
+            m_data.m_value.array = create<array_t>(init.begin(), init.end());
+        }
+
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief explicitly create a binary array (without subtype)
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(const typename binary_t::container_type& init)
+    {
+        auto res = basic_json();
+        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = init;
+        return res;
+    }
+
+    /// @brief explicitly create a binary array (with subtype)
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype)
+    {
+        auto res = basic_json();
+        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = binary_t(init, subtype);
+        return res;
+    }
+
+    /// @brief explicitly create a binary array
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(typename binary_t::container_type&& init)
+    {
+        auto res = basic_json();
+        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = std::move(init);
+        return res;
+    }
+
+    /// @brief explicitly create a binary array (with subtype)
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(typename binary_t::container_type&& init, typename binary_t::subtype_type subtype)
+    {
+        auto res = basic_json();
+        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = binary_t(std::move(init), subtype);
+        return res;
+    }
+
+    /// @brief explicitly create an array from an initializer list
+    /// @sa https://json.nlohmann.me/api/basic_json/array/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json array(initializer_list_t init = {})
+    {
+        return basic_json(init, false, value_t::array);
+    }
+
+    /// @brief explicitly create an object from an initializer list
+    /// @sa https://json.nlohmann.me/api/basic_json/object/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json object(initializer_list_t init = {})
+    {
+        return basic_json(init, false, value_t::object);
+    }
+
+    /// @brief construct an array with count copies of given value
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(size_type cnt, const basic_json& val):
+        m_data{cnt, val}
+    {
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief construct a JSON container given an iterator range
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    template < class InputIT, typename std::enable_if <
+                   std::is_same<InputIT, typename basic_json_t::iterator>::value ||
+                   std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
+    basic_json(InputIT first, InputIT last) // NOLINT(performance-unnecessary-value-param)
+    {
+        JSON_ASSERT(first.m_object != nullptr);
+        JSON_ASSERT(last.m_object != nullptr);
+
+        // make sure the iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(201, "iterators are not compatible", nullptr));
+        }
+
+        // copy type from the first iterator
+        m_data.m_type = first.m_object->m_data.m_type;
+
+        // check if the iterator range is complete for primitive values
+        switch (m_data.m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            {
+                if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
+                                         || !last.m_it.primitive_iterator.is_end()))
+                {
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", first.m_object));
+                }
+                break;
+            }
+
+            case value_t::null:
+            case value_t::object:
+            case value_t::array:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                break;
+        }
+
+        switch (m_data.m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_data.m_value.number_integer = first.m_object->m_data.m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_data.m_value.number_unsigned = first.m_object->m_data.m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_data.m_value.number_float = first.m_object->m_data.m_value.number_float;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_data.m_value.boolean = first.m_object->m_data.m_value.boolean;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_data.m_value = *first.m_object->m_data.m_value.string;
+                break;
+            }
+
+            case value_t::object:
+            {
+                m_data.m_value.object = create<object_t>(first.m_it.object_iterator,
+                                        last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_data.m_value.array = create<array_t>(first.m_it.array_iterator,
+                                                       last.m_it.array_iterator);
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_data.m_value = *first.m_object->m_data.m_value.binary;
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                JSON_THROW(invalid_iterator::create(206, detail::concat("cannot construct with iterators from ", first.m_object->type_name()), first.m_object));
+        }
+
+        set_parents();
+        assert_invariant();
+    }
+
+    ///////////////////////////////////////
+    // other constructors and destructor //
+    ///////////////////////////////////////
+
+    template<typename JsonRef,
+             detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
+                                 std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
+    basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
+
+    /// @brief copy constructor
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(const basic_json& other)
+        : json_base_class_t(other)
+#if JSON_DIAGNOSTIC_POSITIONS
+        , start_position(other.start_position)
+        , end_position(other.end_position)
+#endif
+    {
+        m_data.m_type = other.m_data.m_type;
+        // check of passed value is valid
+        other.assert_invariant();
+
+        switch (m_data.m_type)
+        {
+            case value_t::object:
+            {
+                m_data.m_value = *other.m_data.m_value.object;
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_data.m_value = *other.m_data.m_value.array;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_data.m_value = *other.m_data.m_value.string;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_data.m_value = other.m_data.m_value.boolean;
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                m_data.m_value = other.m_data.m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_data.m_value = other.m_data.m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_data.m_value = other.m_data.m_value.number_float;
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_data.m_value = *other.m_data.m_value.binary;
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                break;
+        }
+
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief move constructor
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(basic_json&& other) noexcept
+        : json_base_class_t(std::forward<json_base_class_t>(other)),
+          m_data(std::move(other.m_data)) // cppcheck-suppress[accessForwarded] TODO check
+#if JSON_DIAGNOSTIC_POSITIONS
+        , start_position(other.start_position) // cppcheck-suppress[accessForwarded] TODO check
+        , end_position(other.end_position) // cppcheck-suppress[accessForwarded] TODO check
+#endif
+    {
+        // check that the passed value is valid
+        other.assert_invariant(false); // cppcheck-suppress[accessForwarded]
+
+        // invalidate payload
+        other.m_data.m_type = value_t::null;
+        other.m_data.m_value = {};
+
+#if JSON_DIAGNOSTIC_POSITIONS
+        other.start_position = std::string::npos;
+        other.end_position = std::string::npos;
+#endif
+
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief copy assignment
+    /// @sa https://json.nlohmann.me/api/basic_json/operator=/
+    basic_json& operator=(basic_json other) noexcept ( // NOLINT(cppcoreguidelines-c-copy-assignment-signature,misc-unconventional-assign-operator)
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&&
+        std::is_nothrow_move_assignable<json_value>::value&&
+        std::is_nothrow_move_assignable<json_base_class_t>::value
+    )
+    {
+        // check that the passed value is valid
+        other.assert_invariant();
+
+        using std::swap;
+        swap(m_data.m_type, other.m_data.m_type);
+        swap(m_data.m_value, other.m_data.m_value);
+
+#if JSON_DIAGNOSTIC_POSITIONS
+        swap(start_position, other.start_position);
+        swap(end_position, other.end_position);
+#endif
+
+        json_base_class_t::operator=(std::move(other));
+
+        set_parents();
+        assert_invariant();
+        return *this;
+    }
+
+    /// @brief destructor
+    /// @sa https://json.nlohmann.me/api/basic_json/~basic_json/
+    ~basic_json() noexcept
+    {
+        assert_invariant(false);
+    }
+
+    /// @}
+
+  public:
+    ///////////////////////
+    // object inspection //
+    ///////////////////////
+
+    /// @name object inspection
+    /// Functions to inspect the type of a JSON value.
+    /// @{
+
+    /// @brief serialization
+    /// @sa https://json.nlohmann.me/api/basic_json/dump/
+    string_t dump(const int indent = -1,
+                  const char indent_char = ' ',
+                  const bool ensure_ascii = false,
+                  const error_handler_t error_handler = error_handler_t::strict) const
+    {
+        string_t result;
+        serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
+
+        if (indent >= 0)
+        {
+            s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
+        }
+        else
+        {
+            s.dump(*this, false, ensure_ascii, 0);
+        }
+
+        return result;
+    }
+
+    /// @brief return the type of the JSON value (explicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/type/
+    constexpr value_t type() const noexcept
+    {
+        return m_data.m_type;
+    }
+
+    /// @brief return whether type is primitive
+    /// @sa https://json.nlohmann.me/api/basic_json/is_primitive/
+    constexpr bool is_primitive() const noexcept
+    {
+        return is_null() || is_string() || is_boolean() || is_number() || is_binary();
+    }
+
+    /// @brief return whether type is structured
+    /// @sa https://json.nlohmann.me/api/basic_json/is_structured/
+    constexpr bool is_structured() const noexcept
+    {
+        return is_array() || is_object();
+    }
+
+    /// @brief return whether value is null
+    /// @sa https://json.nlohmann.me/api/basic_json/is_null/
+    constexpr bool is_null() const noexcept
+    {
+        return m_data.m_type == value_t::null;
+    }
+
+    /// @brief return whether value is a boolean
+    /// @sa https://json.nlohmann.me/api/basic_json/is_boolean/
+    constexpr bool is_boolean() const noexcept
+    {
+        return m_data.m_type == value_t::boolean;
+    }
+
+    /// @brief return whether value is a number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number/
+    constexpr bool is_number() const noexcept
+    {
+        return is_number_integer() || is_number_float();
+    }
+
+    /// @brief return whether value is an integer number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/
+    constexpr bool is_number_integer() const noexcept
+    {
+        return m_data.m_type == value_t::number_integer || m_data.m_type == value_t::number_unsigned;
+    }
+
+    /// @brief return whether value is an unsigned integer number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/
+    constexpr bool is_number_unsigned() const noexcept
+    {
+        return m_data.m_type == value_t::number_unsigned;
+    }
+
+    /// @brief return whether value is a floating-point number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number_float/
+    constexpr bool is_number_float() const noexcept
+    {
+        return m_data.m_type == value_t::number_float;
+    }
+
+    /// @brief return whether value is an object
+    /// @sa https://json.nlohmann.me/api/basic_json/is_object/
+    constexpr bool is_object() const noexcept
+    {
+        return m_data.m_type == value_t::object;
+    }
+
+    /// @brief return whether value is an array
+    /// @sa https://json.nlohmann.me/api/basic_json/is_array/
+    constexpr bool is_array() const noexcept
+    {
+        return m_data.m_type == value_t::array;
+    }
+
+    /// @brief return whether value is a string
+    /// @sa https://json.nlohmann.me/api/basic_json/is_string/
+    constexpr bool is_string() const noexcept
+    {
+        return m_data.m_type == value_t::string;
+    }
+
+    /// @brief return whether value is a binary array
+    /// @sa https://json.nlohmann.me/api/basic_json/is_binary/
+    constexpr bool is_binary() const noexcept
+    {
+        return m_data.m_type == value_t::binary;
+    }
+
+    /// @brief return whether value is discarded
+    /// @sa https://json.nlohmann.me/api/basic_json/is_discarded/
+    constexpr bool is_discarded() const noexcept
+    {
+        return m_data.m_type == value_t::discarded;
+    }
+
+    /// @brief return the type of the JSON value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_value_t/
+    constexpr operator value_t() const noexcept
+    {
+        return m_data.m_type;
+    }
+
+    /// @}
+
+  private:
+    //////////////////
+    // value access //
+    //////////////////
+
+    /// get a boolean (explicit)
+    boolean_t get_impl(boolean_t* /*unused*/) const
+    {
+        if (JSON_HEDLEY_LIKELY(is_boolean()))
+        {
+            return m_data.m_value.boolean;
+        }
+
+        JSON_THROW(type_error::create(302, detail::concat("type must be boolean, but is ", type_name()), this));
+    }
+
+    /// get a pointer to the value (object)
+    object_t* get_impl_ptr(object_t* /*unused*/) noexcept
+    {
+        return is_object() ? m_data.m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (object)
+    constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
+    {
+        return is_object() ? m_data.m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    array_t* get_impl_ptr(array_t* /*unused*/) noexcept
+    {
+        return is_array() ? m_data.m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
+    {
+        return is_array() ? m_data.m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    string_t* get_impl_ptr(string_t* /*unused*/) noexcept
+    {
+        return is_string() ? m_data.m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
+    {
+        return is_string() ? m_data.m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
+    {
+        return is_boolean() ? &m_data.m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
+    {
+        return is_boolean() ? &m_data.m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
+    {
+        return m_data.m_type == value_t::number_integer ? &m_data.m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
+    {
+        return m_data.m_type == value_t::number_integer ? &m_data.m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (unsigned number)
+    number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
+    {
+        return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr;
+    }
+
+    /// get a pointer to the value (unsigned number)
+    constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
+    {
+        return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
+    {
+        return is_number_float() ? &m_data.m_value.number_float : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
+    {
+        return is_number_float() ? &m_data.m_value.number_float : nullptr;
+    }
+
+    /// get a pointer to the value (binary)
+    binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept
+    {
+        return is_binary() ? m_data.m_value.binary : nullptr;
+    }
+
+    /// get a pointer to the value (binary)
+    constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept
+    {
+        return is_binary() ? m_data.m_value.binary : nullptr;
+    }
+
+    /*!
+    @brief helper function to implement get_ref()
+
+    This function helps to implement get_ref() without code duplication for
+    const and non-const overloads
+
+    @tparam ThisType will be deduced as `basic_json` or `const basic_json`
+
+    @throw type_error.303 if ReferenceType does not match underlying value
+    type of the current JSON
+    */
+    template<typename ReferenceType, typename ThisType>
+    static ReferenceType get_ref_impl(ThisType& obj)
+    {
+        // delegate the call to get_ptr<>()
+        auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
+
+        if (JSON_HEDLEY_LIKELY(ptr != nullptr))
+        {
+            return *ptr;
+        }
+
+        JSON_THROW(type_error::create(303, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj));
+    }
+
+  public:
+    /// @name value access
+    /// Direct access to the stored value of a JSON value.
+    /// @{
+
+    /// @brief get a pointer value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
+    {
+        // delegate the call to get_impl_ptr<>()
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+    /// @brief get a pointer value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
+    template < typename PointerType, typename std::enable_if <
+                   std::is_pointer<PointerType>::value&&
+                   std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
+    constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
+    {
+        // delegate the call to get_impl_ptr<>() const
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+  private:
+    /*!
+    @brief get a value (explicit)
+
+    Explicit type conversion between the JSON value and a compatible value
+    which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
+    and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
+    The value is converted by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    ValueType ret;
+    JSONSerializer<ValueType>::from_json(*this, ret);
+    return ret;
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json,
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `void from_json(const basic_json&, ValueType&)`, and
+    - @ref json_serializer<ValueType> does not have a `from_json()` method of
+      the form `ValueType from_json(const basic_json&)`
+
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @a ValueType
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,get__ValueType_const}
+
+    @since version 2.1.0
+    */
+    template < typename ValueType,
+               detail::enable_if_t <
+                   detail::is_default_constructible<ValueType>::value&&
+                   detail::has_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType get_impl(detail::priority_tag<0> /*unused*/) const noexcept(noexcept(
+            JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
+    {
+        auto ret = ValueType();
+        JSONSerializer<ValueType>::from_json(*this, ret);
+        return ret;
+    }
+
+    /*!
+    @brief get a value (explicit); special case
+
+    Explicit type conversion between the JSON value and a compatible value
+    which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
+    and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
+    The value is converted by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    return JSONSerializer<ValueType>::from_json(*this);
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json and
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `ValueType from_json(const basic_json&)`
+
+    @note If @ref json_serializer<ValueType> has both overloads of
+    `from_json()`, this one is chosen.
+
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @a ValueType
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @since version 2.1.0
+    */
+    template < typename ValueType,
+               detail::enable_if_t <
+                   detail::has_non_default_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType get_impl(detail::priority_tag<1> /*unused*/) const noexcept(noexcept(
+            JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
+    {
+        return JSONSerializer<ValueType>::from_json(*this);
+    }
+
+    /*!
+    @brief get special-case overload
+
+    This overloads converts the current @ref basic_json in a different
+    @ref basic_json type
+
+    @tparam BasicJsonType == @ref basic_json
+
+    @return a copy of *this, converted into @a BasicJsonType
+
+    @complexity Depending on the implementation of the called `from_json()`
+                method.
+
+    @since version 3.2.0
+    */
+    template < typename BasicJsonType,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value,
+                   int > = 0 >
+    BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const
+    {
+        return *this;
+    }
+
+    /*!
+    @brief get special-case overload
+
+    This overloads avoids a lot of template boilerplate, it can be seen as the
+    identity method
+
+    @tparam BasicJsonType == @ref basic_json
+
+    @return a copy of *this
+
+    @complexity Constant.
+
+    @since version 2.1.0
+    */
+    template<typename BasicJsonType,
+             detail::enable_if_t<
+                 std::is_same<BasicJsonType, basic_json_t>::value,
+                 int> = 0>
+    basic_json get_impl(detail::priority_tag<3> /*unused*/) const
+    {
+        return *this;
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+    @copydoc get()
+    */
+    template<typename PointerType,
+             detail::enable_if_t<
+                 std::is_pointer<PointerType>::value,
+                 int> = 0>
+    constexpr auto get_impl(detail::priority_tag<4> /*unused*/) const noexcept
+    -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+  public:
+    /*!
+    @brief get a (pointer) value (explicit)
+
+    Performs explicit type conversion between the JSON value and a compatible value if required.
+
+    - If the requested type is a pointer to the internally stored JSON value that pointer is returned.
+    No copies are made.
+
+    - If the requested type is the current @ref basic_json, or a different @ref basic_json convertible
+    from the current @ref basic_json.
+
+    - Otherwise the value is converted by calling the @ref json_serializer<ValueType> `from_json()`
+    method.
+
+    @tparam ValueTypeCV the provided value type
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @tparam ValueType if necessary
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws if conversion is required
+
+    @since version 2.1.0
+    */
+    template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>>
+#if defined(JSON_HAS_CPP_14)
+    constexpr
+#endif
+    auto get() const noexcept(
+    noexcept(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {})))
+    -> decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {}))
+    {
+        // we cannot static_assert on ValueTypeCV being non-const, because
+        // there is support for get<const basic_json_t>(), which is why we
+        // still need the uncvref
+        static_assert(!std::is_reference<ValueTypeCV>::value,
+                      "get() cannot be used with reference types, you might want to use get_ref()");
+        return get_impl<ValueType>(detail::priority_tag<4> {});
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+
+    Explicit pointer access to the internally stored JSON value. No copies are
+    made.
+
+    @warning The pointer becomes invalid if the underlying JSON object
+    changes.
+
+    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
+    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
+    @ref number_unsigned_t, or @ref number_float_t.
+
+    @return pointer to the internally stored JSON value if the requested
+    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how pointers to internal values of a
+    JSON value can be requested. Note that no type conversions are made and a
+    `nullptr` is returned if the value and the requested pointer type does not
+    match.,get__PointerType}
+
+    @sa see @ref get_ptr() for explicit pointer-member access
+
+    @since version 1.0.0
+    */
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+    /// @brief get a value (explicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_to/
+    template < typename ValueType,
+               detail::enable_if_t <
+                   !detail::is_basic_json<ValueType>::value&&
+                   detail::has_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType & get_to(ValueType& v) const noexcept(noexcept(
+            JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
+    {
+        JSONSerializer<ValueType>::from_json(*this, v);
+        return v;
+    }
+
+    // specialization to allow calling get_to with a basic_json value
+    // see https://github.com/nlohmann/json/issues/2175
+    template<typename ValueType,
+             detail::enable_if_t <
+                 detail::is_basic_json<ValueType>::value,
+                 int> = 0>
+    ValueType & get_to(ValueType& v) const
+    {
+        v = *this;
+        return v;
+    }
+
+    template <
+        typename T, std::size_t N,
+        typename Array = T (&)[N], // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+        detail::enable_if_t <
+            detail::has_from_json<basic_json_t, Array>::value, int > = 0 >
+    Array get_to(T (&v)[N]) const // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+    noexcept(noexcept(JSONSerializer<Array>::from_json(
+                          std::declval<const basic_json_t&>(), v)))
+    {
+        JSONSerializer<Array>::from_json(*this, v);
+        return v;
+    }
+
+    /// @brief get a reference value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
+    template<typename ReferenceType, typename std::enable_if<
+                 std::is_reference<ReferenceType>::value, int>::type = 0>
+    ReferenceType get_ref()
+    {
+        // delegate call to get_ref_impl
+        return get_ref_impl<ReferenceType>(*this);
+    }
+
+    /// @brief get a reference value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
+    template < typename ReferenceType, typename std::enable_if <
+                   std::is_reference<ReferenceType>::value&&
+                   std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
+    ReferenceType get_ref() const
+    {
+        // delegate call to get_ref_impl
+        return get_ref_impl<ReferenceType>(*this);
+    }
+
+    /*!
+    @brief get a value (implicit)
+
+    Implicit type conversion between the JSON value and a compatible value.
+    The call is realized by calling @ref get() const.
+
+    @tparam ValueType non-pointer type compatible to the JSON value, for
+    instance `int` for JSON integer numbers, `bool` for JSON booleans, or
+    `std::vector` types for JSON arrays. The character type of @ref string_t
+    as well as an initializer list of this type is excluded to avoid
+    ambiguities as these types implicitly convert to `std::string`.
+
+    @return copy of the JSON value, converted to type @a ValueType
+
+    @throw type_error.302 in case passed type @a ValueType is incompatible
+    to the JSON value type (e.g., the JSON value is of type boolean, but a
+    string is requested); see example below
+
+    @complexity Linear in the size of the JSON value.
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,operator__ValueType}
+
+    @since version 1.0.0
+    */
+    template < typename ValueType, typename std::enable_if <
+                   detail::conjunction <
+                       detail::negation<std::is_pointer<ValueType>>,
+                       detail::negation<std::is_same<ValueType, std::nullptr_t>>,
+                       detail::negation<std::is_same<ValueType, detail::json_ref<basic_json>>>,
+                                        detail::negation<std::is_same<ValueType, typename string_t::value_type>>,
+                                        detail::negation<detail::is_basic_json<ValueType>>,
+                                        detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>,
+#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
+                                                detail::negation<std::is_same<ValueType, std::string_view>>,
+#endif
+#if defined(JSON_HAS_CPP_17) && JSON_HAS_STATIC_RTTI
+                                                detail::negation<std::is_same<ValueType, std::any>>,
+#endif
+                                                detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
+                                                >::value, int >::type = 0 >
+                                        JSON_EXPLICIT operator ValueType() const
+    {
+        // delegate the call to get<>() const
+        return get<ValueType>();
+    }
+
+    /// @brief get a binary value
+    /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
+    binary_t& get_binary()
+    {
+        if (!is_binary())
+        {
+            JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
+        }
+
+        return *get_ptr<binary_t*>();
+    }
+
+    /// @brief get a binary value
+    /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
+    const binary_t& get_binary() const
+    {
+        if (!is_binary())
+        {
+            JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
+        }
+
+        return *get_ptr<const binary_t*>();
+    }
+
+    /// @}
+
+    ////////////////////
+    // element access //
+    ////////////////////
+
+    /// @name element access
+    /// Access to the JSON value.
+    /// @{
+
+    /// @brief access specified array element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    reference at(size_type idx)
+    {
+        // at only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return set_parent(m_data.m_value.array->at(idx));
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create a better exception explanation
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+            } // cppcheck-suppress[missingReturn]
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+    }
+
+    /// @brief access specified array element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    const_reference at(size_type idx) const
+    {
+        // at only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return m_data.m_value.array->at(idx);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create a better exception explanation
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+            } // cppcheck-suppress[missingReturn]
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    reference at(const typename object_t::key_type& key)
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+
+        auto it = m_data.m_value.object->find(key);
+        if (it == m_data.m_value.object->end())
+        {
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", key, "' not found"), this));
+        }
+        return set_parent(it->second);
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    reference at(KeyType && key)
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+
+        auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
+        if (it == m_data.m_value.object->end())
+        {
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
+        }
+        return set_parent(it->second);
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    const_reference at(const typename object_t::key_type& key) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+
+        auto it = m_data.m_value.object->find(key);
+        if (it == m_data.m_value.object->end())
+        {
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", key, "' not found"), this));
+        }
+        return it->second;
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    const_reference at(KeyType && key) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+
+        auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
+        if (it == m_data.m_value.object->end())
+        {
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
+        }
+        return it->second;
+    }
+
+    /// @brief access specified array element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    reference operator[](size_type idx)
+    {
+        // implicitly convert a null value to an empty array
+        if (is_null())
+        {
+            m_data.m_type = value_t::array;
+            m_data.m_value.array = create<array_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // fill up the array with null values if given idx is outside the range
+            if (idx >= m_data.m_value.array->size())
+            {
+#if JSON_DIAGNOSTICS
+                // remember array size & capacity before resizing
+                const auto old_size = m_data.m_value.array->size();
+                const auto old_capacity = m_data.m_value.array->capacity();
+#endif
+                m_data.m_value.array->resize(idx + 1);
+
+#if JSON_DIAGNOSTICS
+                if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
+                {
+                    // capacity has changed: update all parents
+                    set_parents();
+                }
+                else
+                {
+                    // set parent for values added above
+                    set_parents(begin() + static_cast<typename iterator::difference_type>(old_size), static_cast<typename iterator::difference_type>(idx + 1 - old_size));
+                }
+#endif
+                assert_invariant();
+            }
+
+            return m_data.m_value.array->operator[](idx);
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
+    }
+
+    /// @brief access specified array element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    const_reference operator[](size_type idx) const
+    {
+        // const operator[] only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            return m_data.m_value.array->operator[](idx);
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    reference operator[](typename object_t::key_type key) // NOLINT(performance-unnecessary-value-param)
+    {
+        // implicitly convert a null value to an empty object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            auto result = m_data.m_value.object->emplace(std::move(key), nullptr);
+            return set_parent(result.first->second);
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    const_reference operator[](const typename object_t::key_type& key) const
+    {
+        // const operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            auto it = m_data.m_value.object->find(key);
+            JSON_ASSERT(it != m_data.m_value.object->end());
+            return it->second;
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
+    }
+
+    // these two functions resolve a (const) char * ambiguity affecting Clang and MSVC
+    // (they seemingly cannot be constrained to resolve the ambiguity)
+    template<typename T>
+    reference operator[](T* key)
+    {
+        return operator[](typename object_t::key_type(key));
+    }
+
+    template<typename T>
+    const_reference operator[](T* key) const
+    {
+        return operator[](typename object_t::key_type(key));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = 0 >
+    reference operator[](KeyType && key)
+    {
+        // implicitly convert a null value to an empty object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            auto result = m_data.m_value.object->emplace(std::forward<KeyType>(key), nullptr);
+            return set_parent(result.first->second);
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = 0 >
+    const_reference operator[](KeyType && key) const
+    {
+        // const operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
+            JSON_ASSERT(it != m_data.m_value.object->end());
+            return it->second;
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
+    }
+
+  private:
+    template<typename KeyType>
+    using is_comparable_with_object_key = detail::is_comparable <
+        object_comparator_t, const typename object_t::key_type&, KeyType >;
+
+    template<typename ValueType>
+    using value_return_type = std::conditional <
+        detail::is_c_string_uncvref<ValueType>::value,
+        string_t, typename std::decay<ValueType>::type >;
+
+  public:
+    /// @brief access specified object element with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, detail::enable_if_t <
+                   !detail::is_transparent<object_comparator_t>::value
+                   && detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // If 'key' is found, return its value. Otherwise, return `default_value'.
+            const auto it = find(key);
+            if (it != end())
+            {
+                return it->template get<ValueType>();
+            }
+
+            return default_value;
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type,
+               detail::enable_if_t <
+                   !detail::is_transparent<object_comparator_t>::value
+                   && detail::is_getable<basic_json_t, ReturnType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ReturnType value(const typename object_t::key_type& key, ValueType && default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // If 'key' is found, return its value. Otherwise, return `default_value'.
+            const auto it = find(key);
+            if (it != end())
+            {
+                return it->template get<ReturnType>();
+            }
+
+            return std::forward<ValueType>(default_value);
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, class KeyType, detail::enable_if_t <
+                   detail::is_transparent<object_comparator_t>::value
+                   && !detail::is_json_pointer<KeyType>::value
+                   && is_comparable_with_object_key<KeyType>::value
+                   && detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ValueType value(KeyType && key, const ValueType& default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // If 'key' is found, return its value. Otherwise, return `default_value'.
+            const auto it = find(std::forward<KeyType>(key));
+            if (it != end())
+            {
+                return it->template get<ValueType>();
+            }
+
+            return default_value;
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element via JSON Pointer with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, class KeyType, class ReturnType = typename value_return_type<ValueType>::type,
+               detail::enable_if_t <
+                   detail::is_transparent<object_comparator_t>::value
+                   && !detail::is_json_pointer<KeyType>::value
+                   && is_comparable_with_object_key<KeyType>::value
+                   && detail::is_getable<basic_json_t, ReturnType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ReturnType value(KeyType && key, ValueType && default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // If 'key' is found, return its value. Otherwise, return `default_value'.
+            const auto it = find(std::forward<KeyType>(key));
+            if (it != end())
+            {
+                return it->template get<ReturnType>();
+            }
+
+            return std::forward<ValueType>(default_value);
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element via JSON Pointer with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, detail::enable_if_t <
+                   detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ValueType value(const json_pointer& ptr, const ValueType& default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // If the pointer resolves to a value, return it. Otherwise, return
+            // 'default_value'.
+            JSON_TRY
+            {
+                return ptr.get_checked(this).template get<ValueType>();
+            }
+            JSON_INTERNAL_CATCH (out_of_range&)
+            {
+                return default_value;
+            }
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element via JSON Pointer with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type,
+               detail::enable_if_t <
+                   detail::is_getable<basic_json_t, ReturnType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ReturnType value(const json_pointer& ptr, ValueType && default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // If the pointer resolves to a value, return it. Otherwise, return
+            // 'default_value'.
+            JSON_TRY
+            {
+                return ptr.get_checked(this).template get<ReturnType>();
+            }
+            JSON_INTERNAL_CATCH (out_of_range&)
+            {
+                return std::forward<ValueType>(default_value);
+            }
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    template < class ValueType, class BasicJsonType, detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value
+                   && detail::is_getable<basic_json_t, ValueType>::value
+                   && !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
+    {
+        return value(ptr.convert(), default_value);
+    }
+
+    template < class ValueType, class BasicJsonType, class ReturnType = typename value_return_type<ValueType>::type,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value
+                   && detail::is_getable<basic_json_t, ReturnType>::value
+                   && !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
+    {
+        return value(ptr.convert(), std::forward<ValueType>(default_value));
+    }
+
+    /// @brief access the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/front/
+    reference front()
+    {
+        return *begin();
+    }
+
+    /// @brief access the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/front/
+    const_reference front() const
+    {
+        return *cbegin();
+    }
+
+    /// @brief access the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/back/
+    reference back()
+    {
+        auto tmp = end();
+        --tmp;
+        return *tmp;
+    }
+
+    /// @brief access the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/back/
+    const_reference back() const
+    {
+        auto tmp = cend();
+        --tmp;
+        return *tmp;
+    }
+
+    /// @brief remove element given an iterator
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    template < class IteratorType, detail::enable_if_t <
+                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
+                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 >
+    IteratorType erase(IteratorType pos) // NOLINT(performance-unnecessary-value-param)
+    {
+        // make sure the iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+        }
+
+        IteratorType result = end();
+
+        switch (m_data.m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            case value_t::binary:
+            {
+                if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
+                {
+                    JSON_THROW(invalid_iterator::create(205, "iterator out of range", this));
+                }
+
+                if (is_string())
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
+                    m_data.m_value.string = nullptr;
+                }
+                else if (is_binary())
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
+                    m_data.m_value.binary = nullptr;
+                }
+
+                m_data.m_type = value_t::null;
+                assert_invariant();
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_data.m_value.object->erase(pos.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_data.m_value.array->erase(pos.m_it.array_iterator);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+
+        return result;
+    }
+
+    /// @brief remove elements given an iterator range
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    template < class IteratorType, detail::enable_if_t <
+                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
+                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 >
+    IteratorType erase(IteratorType first, IteratorType last) // NOLINT(performance-unnecessary-value-param)
+    {
+        // make sure the iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value", this));
+        }
+
+        IteratorType result = end();
+
+        switch (m_data.m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            case value_t::binary:
+            {
+                if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
+                                       || !last.m_it.primitive_iterator.is_end()))
+                {
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", this));
+                }
+
+                if (is_string())
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
+                    m_data.m_value.string = nullptr;
+                }
+                else if (is_binary())
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
+                    m_data.m_value.binary = nullptr;
+                }
+
+                m_data.m_type = value_t::null;
+                assert_invariant();
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_data.m_value.object->erase(first.m_it.object_iterator,
+                                              last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_data.m_value.array->erase(first.m_it.array_iterator,
+                                             last.m_it.array_iterator);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+
+        return result;
+    }
+
+  private:
+    template < typename KeyType, detail::enable_if_t <
+                   detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = 0 >
+    size_type erase_internal(KeyType && key)
+    {
+        // this erase only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+
+        return m_data.m_value.object->erase(std::forward<KeyType>(key));
+    }
+
+    template < typename KeyType, detail::enable_if_t <
+                   !detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = 0 >
+    size_type erase_internal(KeyType && key)
+    {
+        // this erase only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+
+        const auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
+        if (it != m_data.m_value.object->end())
+        {
+            m_data.m_value.object->erase(it);
+            return 1;
+        }
+        return 0;
+    }
+
+  public:
+
+    /// @brief remove element from a JSON object given a key
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    size_type erase(const typename object_t::key_type& key)
+    {
+        // the indirection via erase_internal() is added to avoid making this
+        // function a template and thus de-rank it during overload resolution
+        return erase_internal(key);
+    }
+
+    /// @brief remove element from a JSON object given a key
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    size_type erase(KeyType && key)
+    {
+        return erase_internal(std::forward<KeyType>(key));
+    }
+
+    /// @brief remove element from a JSON array given an index
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    void erase(const size_type idx)
+    {
+        // this erase only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            if (JSON_HEDLEY_UNLIKELY(idx >= size()))
+            {
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+            }
+
+            m_data.m_value.array->erase(m_data.m_value.array->begin() + static_cast<difference_type>(idx));
+        }
+        else
+        {
+            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+    }
+
+    /// @}
+
+    ////////////
+    // lookup //
+    ////////////
+
+    /// @name lookup
+    /// @{
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    iterator find(const typename object_t::key_type& key)
+    {
+        auto result = end();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_data.m_value.object->find(key);
+        }
+
+        return result;
+    }
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    const_iterator find(const typename object_t::key_type& key) const
+    {
+        auto result = cend();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_data.m_value.object->find(key);
+        }
+
+        return result;
+    }
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    iterator find(KeyType && key)
+    {
+        auto result = end();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_data.m_value.object->find(std::forward<KeyType>(key));
+        }
+
+        return result;
+    }
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    const_iterator find(KeyType && key) const
+    {
+        auto result = cend();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_data.m_value.object->find(std::forward<KeyType>(key));
+        }
+
+        return result;
+    }
+
+    /// @brief returns the number of occurrences of a key in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/count/
+    size_type count(const typename object_t::key_type& key) const
+    {
+        // return 0 for all nonobject types
+        return is_object() ? m_data.m_value.object->count(key) : 0;
+    }
+
+    /// @brief returns the number of occurrences of a key in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/count/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    size_type count(KeyType && key) const
+    {
+        // return 0 for all nonobject types
+        return is_object() ? m_data.m_value.object->count(std::forward<KeyType>(key)) : 0;
+    }
+
+    /// @brief check the existence of an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    bool contains(const typename object_t::key_type& key) const
+    {
+        return is_object() && m_data.m_value.object->find(key) != m_data.m_value.object->end();
+    }
+
+    /// @brief check the existence of an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    bool contains(KeyType && key) const
+    {
+        return is_object() && m_data.m_value.object->find(std::forward<KeyType>(key)) != m_data.m_value.object->end();
+    }
+
+    /// @brief check the existence of an element in a JSON object given a JSON pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    bool contains(const json_pointer& ptr) const
+    {
+        return ptr.contains(this);
+    }
+
+    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)
+    bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const
+    {
+        return ptr.contains(this);
+    }
+
+    /// @}
+
+    ///////////////
+    // iterators //
+    ///////////////
+
+    /// @name iterators
+    /// @{
+
+    /// @brief returns an iterator to the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/begin/
+    iterator begin() noexcept
+    {
+        iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /// @brief returns an iterator to the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/begin/
+    const_iterator begin() const noexcept
+    {
+        return cbegin();
+    }
+
+    /// @brief returns a const iterator to the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/cbegin/
+    const_iterator cbegin() const noexcept
+    {
+        const_iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /// @brief returns an iterator to one past the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/end/
+    iterator end() noexcept
+    {
+        iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /// @brief returns an iterator to one past the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/end/
+    const_iterator end() const noexcept
+    {
+        return cend();
+    }
+
+    /// @brief returns an iterator to one past the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/cend/
+    const_iterator cend() const noexcept
+    {
+        const_iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /// @brief returns an iterator to the reverse-beginning
+    /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
+    reverse_iterator rbegin() noexcept
+    {
+        return reverse_iterator(end());
+    }
+
+    /// @brief returns an iterator to the reverse-beginning
+    /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
+    const_reverse_iterator rbegin() const noexcept
+    {
+        return crbegin();
+    }
+
+    /// @brief returns an iterator to the reverse-end
+    /// @sa https://json.nlohmann.me/api/basic_json/rend/
+    reverse_iterator rend() noexcept
+    {
+        return reverse_iterator(begin());
+    }
+
+    /// @brief returns an iterator to the reverse-end
+    /// @sa https://json.nlohmann.me/api/basic_json/rend/
+    const_reverse_iterator rend() const noexcept
+    {
+        return crend();
+    }
+
+    /// @brief returns a const reverse iterator to the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/crbegin/
+    const_reverse_iterator crbegin() const noexcept
+    {
+        return const_reverse_iterator(cend());
+    }
+
+    /// @brief returns a const reverse iterator to one before the first
+    /// @sa https://json.nlohmann.me/api/basic_json/crend/
+    const_reverse_iterator crend() const noexcept
+    {
+        return const_reverse_iterator(cbegin());
+    }
+
+  public:
+    /// @brief wrapper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    /// @deprecated This function is deprecated since 3.1.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use @ref items() instead;
+    ///             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
+    {
+        return ref.items();
+    }
+
+    /// @brief wrapper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    /// @deprecated This function is deprecated since 3.1.0 and will be removed in
+    ///         version 4.0.0 of the library. Please use @ref items() instead;
+    ///         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
+    {
+        return ref.items();
+    }
+
+    /// @brief helper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    iteration_proxy<iterator> items() noexcept
+    {
+        return iteration_proxy<iterator>(*this);
+    }
+
+    /// @brief helper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    iteration_proxy<const_iterator> items() const noexcept
+    {
+        return iteration_proxy<const_iterator>(*this);
+    }
+
+    /// @}
+
+    //////////////
+    // capacity //
+    //////////////
+
+    /// @name capacity
+    /// @{
+
+    /// @brief checks whether the container is empty.
+    /// @sa https://json.nlohmann.me/api/basic_json/empty/
+    bool empty() const noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::null:
+            {
+                // null values are empty
+                return true;
+            }
+
+            case value_t::array:
+            {
+                // delegate call to array_t::empty()
+                return m_data.m_value.array->empty();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::empty()
+                return m_data.m_value.object->empty();
+            }
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // all other types are nonempty
+                return false;
+            }
+        }
+    }
+
+    /// @brief returns the number of elements
+    /// @sa https://json.nlohmann.me/api/basic_json/size/
+    size_type size() const noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::null:
+            {
+                // null values are empty
+                return 0;
+            }
+
+            case value_t::array:
+            {
+                // delegate call to array_t::size()
+                return m_data.m_value.array->size();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::size()
+                return m_data.m_value.object->size();
+            }
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // all other types have size 1
+                return 1;
+            }
+        }
+    }
+
+    /// @brief returns the maximum possible number of elements
+    /// @sa https://json.nlohmann.me/api/basic_json/max_size/
+    size_type max_size() const noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::array:
+            {
+                // delegate call to array_t::max_size()
+                return m_data.m_value.array->max_size();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::max_size()
+                return m_data.m_value.object->max_size();
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // all other types have max_size() == size()
+                return size();
+            }
+        }
+    }
+
+    /// @}
+
+    ///////////////
+    // modifiers //
+    ///////////////
+
+    /// @name modifiers
+    /// @{
+
+    /// @brief clears the contents
+    /// @sa https://json.nlohmann.me/api/basic_json/clear/
+    void clear() noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_data.m_value.number_integer = 0;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_data.m_value.number_unsigned = 0;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_data.m_value.number_float = 0.0;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_data.m_value.boolean = false;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_data.m_value.string->clear();
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_data.m_value.binary->clear();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_data.m_value.array->clear();
+                break;
+            }
+
+            case value_t::object:
+            {
+                m_data.m_value.object->clear();
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(basic_json&& val)
+    {
+        // push_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
+        }
+
+        // transform a null object into an array
+        if (is_null())
+        {
+            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add the element to the array (move semantics)
+        const auto old_capacity = m_data.m_value.array->capacity();
+        m_data.m_value.array->push_back(std::move(val));
+        set_parent(m_data.m_value.array->back(), old_capacity);
+        // if val is moved from, basic_json move constructor marks it null, so we do not call the destructor
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(basic_json&& val)
+    {
+        push_back(std::move(val));
+        return *this;
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(const basic_json& val)
+    {
+        // push_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
+        }
+
+        // transform a null object into an array
+        if (is_null())
+        {
+            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add the element to the array
+        const auto old_capacity = m_data.m_value.array->capacity();
+        m_data.m_value.array->push_back(val);
+        set_parent(m_data.m_value.array->back(), old_capacity);
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(const basic_json& val)
+    {
+        push_back(val);
+        return *this;
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(const typename object_t::value_type& val)
+    {
+        // push_back only works for null objects or objects
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
+        {
+            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
+        }
+
+        // transform a null object into an object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // add the element to the object
+        auto res = m_data.m_value.object->insert(val);
+        set_parent(res.first->second);
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(const typename object_t::value_type& val)
+    {
+        push_back(val);
+        return *this;
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(initializer_list_t init)
+    {
+        if (is_object() && init.size() == 2 && (*init.begin())->is_string())
+        {
+            basic_json&& key = init.begin()->moved_or_copied();
+            push_back(typename object_t::value_type(
+                          std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
+        }
+        else
+        {
+            push_back(basic_json(init));
+        }
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(initializer_list_t init)
+    {
+        push_back(init);
+        return *this;
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/emplace_back/
+    template<class... Args>
+    reference emplace_back(Args&& ... args)
+    {
+        // emplace_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(311, detail::concat("cannot use emplace_back() with ", type_name()), this));
+        }
+
+        // transform a null object into an array
+        if (is_null())
+        {
+            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add the element to the array (perfect forwarding)
+        const auto old_capacity = m_data.m_value.array->capacity();
+        m_data.m_value.array->emplace_back(std::forward<Args>(args)...);
+        return set_parent(m_data.m_value.array->back(), old_capacity);
+    }
+
+    /// @brief add an object to an object if key does not exist
+    /// @sa https://json.nlohmann.me/api/basic_json/emplace/
+    template<class... Args>
+    std::pair<iterator, bool> emplace(Args&& ... args)
+    {
+        // emplace only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
+        {
+            JSON_THROW(type_error::create(311, detail::concat("cannot use emplace() with ", type_name()), this));
+        }
+
+        // transform a null object into an object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // add the element to the array (perfect forwarding)
+        auto res = m_data.m_value.object->emplace(std::forward<Args>(args)...);
+        set_parent(res.first->second);
+
+        // create a result iterator and set iterator to the result of emplace
+        auto it = begin();
+        it.m_it.object_iterator = res.first;
+
+        // return pair of iterator and boolean
+        return {it, res.second};
+    }
+
+    /// Helper for insertion of an iterator
+    /// @note: This uses std::distance to support GCC 4.8,
+    ///        see https://github.com/nlohmann/json/pull/1257
+    template<typename... Args>
+    iterator insert_iterator(const_iterator pos, Args&& ... args) // NOLINT(performance-unnecessary-value-param)
+    {
+        iterator result(this);
+        JSON_ASSERT(m_data.m_value.array != nullptr);
+
+        auto insert_pos = std::distance(m_data.m_value.array->begin(), pos.m_it.array_iterator);
+        m_data.m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
+        result.m_it.array_iterator = m_data.m_value.array->begin() + insert_pos;
+
+        // This could have been written as:
+        // result.m_it.array_iterator = m_data.m_value.array->insert(pos.m_it.array_iterator, cnt, val);
+        // but the return value of insert is missing in GCC 4.8, so it is written this way instead.
+
+        set_parents();
+        return result;
+    }
+
+    /// @brief inserts element into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, const basic_json& val) // NOLINT(performance-unnecessary-value-param)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // check if iterator pos fits to this JSON value
+            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+            {
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+            }
+
+            // insert to array and return iterator
+            return insert_iterator(pos, val);
+        }
+
+        JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+    }
+
+    /// @brief inserts element into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, basic_json&& val) // NOLINT(performance-unnecessary-value-param)
+    {
+        return insert(pos, val);
+    }
+
+    /// @brief inserts copies of element into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, size_type cnt, const basic_json& val) // NOLINT(performance-unnecessary-value-param)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // check if iterator pos fits to this JSON value
+            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+            {
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+            }
+
+            // insert to array and return iterator
+            return insert_iterator(pos, cnt, val);
+        }
+
+        JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+    }
+
+    /// @brief inserts range of elements into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, const_iterator first, const_iterator last) // NOLINT(performance-unnecessary-value-param)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_UNLIKELY(!is_array()))
+        {
+            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
+        {
+            JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container", this));
+        }
+
+        // insert to array and return iterator
+        return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
+    }
+
+    /// @brief inserts elements from initializer list into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, initializer_list_t ilist) // NOLINT(performance-unnecessary-value-param)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_UNLIKELY(!is_array()))
+        {
+            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+        }
+
+        // insert to array and return iterator
+        return insert_iterator(pos, ilist.begin(), ilist.end());
+    }
+
+    /// @brief inserts range of elements into object
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    void insert(const_iterator first, const_iterator last) // NOLINT(performance-unnecessary-value-param)
+    {
+        // insert only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
+        }
+
+        // passed iterators must belong to objects
+        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects", this));
+        }
+
+        m_data.m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
+        set_parents();
+    }
+
+    /// @brief updates a JSON object from another object, overwriting existing keys
+    /// @sa https://json.nlohmann.me/api/basic_json/update/
+    void update(const_reference j, bool merge_objects = false)
+    {
+        update(j.begin(), j.end(), merge_objects);
+    }
+
+    /// @brief updates a JSON object from another object, overwriting existing keys
+    /// @sa https://json.nlohmann.me/api/basic_json/update/
+    void update(const_iterator first, const_iterator last, bool merge_objects = false) // NOLINT(performance-unnecessary-value-param)
+    {
+        // implicitly convert a null value to an empty object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", type_name()), this));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
+        }
+
+        // passed iterators must belong to objects
+        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
+        {
+            JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", first.m_object->type_name()), first.m_object));
+        }
+
+        for (auto it = first; it != last; ++it)
+        {
+            if (merge_objects && it.value().is_object())
+            {
+                auto it2 = m_data.m_value.object->find(it.key());
+                if (it2 != m_data.m_value.object->end())
+                {
+                    it2->second.update(it.value(), true);
+                    continue;
+                }
+            }
+            m_data.m_value.object->operator[](it.key()) = it.value();
+#if JSON_DIAGNOSTICS
+            m_data.m_value.object->operator[](it.key()).m_parent = this;
+#endif
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(reference other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        std::swap(m_data.m_type, other.m_data.m_type);
+        std::swap(m_data.m_value, other.m_data.m_value);
+
+        set_parents();
+        other.set_parents();
+        assert_invariant();
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    friend void swap(reference left, reference right) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        left.swap(right);
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(array_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    {
+        // swap only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.array), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(array_t&) with ", type_name()), this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(object_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    {
+        // swap only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.object), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(object_t&) with ", type_name()), this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(string_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_string()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.string), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(string_t&) with ", type_name()), this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(binary_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_binary()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.binary), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t&) with ", type_name()), this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(typename binary_t::container_type& other) // NOLINT(bugprone-exception-escape)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_binary()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.binary), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t::container_type&) with ", type_name()), this));
+        }
+    }
+
+    /// @}
+
+    //////////////////////////////////////////
+    // lexicographical comparison operators //
+    //////////////////////////////////////////
+
+    /// @name lexicographical comparison operators
+    /// @{
+
+    // note parentheses around operands are necessary; see
+    // https://github.com/nlohmann/json/issues/1530
+#define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result)                       \
+    const auto lhs_type = lhs.type();                                                                    \
+    const auto rhs_type = rhs.type();                                                                    \
+    \
+    if (lhs_type == rhs_type) /* NOLINT(readability/braces) */                                           \
+    {                                                                                                    \
+        switch (lhs_type)                                                                                \
+        {                                                                                                \
+            case value_t::array:                                                                         \
+                return (*lhs.m_data.m_value.array) op (*rhs.m_data.m_value.array);                                     \
+                \
+            case value_t::object:                                                                        \
+                return (*lhs.m_data.m_value.object) op (*rhs.m_data.m_value.object);                                   \
+                \
+            case value_t::null:                                                                          \
+                return (null_result);                                                                    \
+                \
+            case value_t::string:                                                                        \
+                return (*lhs.m_data.m_value.string) op (*rhs.m_data.m_value.string);                                   \
+                \
+            case value_t::boolean:                                                                       \
+                return (lhs.m_data.m_value.boolean) op (rhs.m_data.m_value.boolean);                                   \
+                \
+            case value_t::number_integer:                                                                \
+                return (lhs.m_data.m_value.number_integer) op (rhs.m_data.m_value.number_integer);                     \
+                \
+            case value_t::number_unsigned:                                                               \
+                return (lhs.m_data.m_value.number_unsigned) op (rhs.m_data.m_value.number_unsigned);                   \
+                \
+            case value_t::number_float:                                                                  \
+                return (lhs.m_data.m_value.number_float) op (rhs.m_data.m_value.number_float);                         \
+                \
+            case value_t::binary:                                                                        \
+                return (*lhs.m_data.m_value.binary) op (*rhs.m_data.m_value.binary);                                   \
+                \
+            case value_t::discarded:                                                                     \
+            default:                                                                                     \
+                return (unordered_result);                                                               \
+        }                                                                                                \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)                   \
+    {                                                                                                    \
+        return static_cast<number_float_t>(lhs.m_data.m_value.number_integer) op rhs.m_data.m_value.number_float;      \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)                   \
+    {                                                                                                    \
+        return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_integer);      \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)                  \
+    {                                                                                                    \
+        return static_cast<number_float_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_float;     \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)                  \
+    {                                                                                                    \
+        return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_unsigned);     \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)                \
+    {                                                                                                    \
+        return static_cast<number_integer_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_integer; \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)                \
+    {                                                                                                    \
+        return lhs.m_data.m_value.number_integer op static_cast<number_integer_t>(rhs.m_data.m_value.number_unsigned); \
+    }                                                                                                    \
+    else if(compares_unordered(lhs, rhs))\
+    {\
+        return (unordered_result);\
+    }\
+    \
+    return (default_result);
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    // returns true if:
+    // - any operand is NaN and the other operand is of number type
+    // - any operand is discarded
+    // in legacy mode, discarded values are considered ordered if
+    // an operation is computed as an odd number of inverses of others
+    static bool compares_unordered(const_reference lhs, const_reference rhs, bool inverse = false) noexcept
+    {
+        if ((lhs.is_number_float() && std::isnan(lhs.m_data.m_value.number_float) && rhs.is_number())
+                || (rhs.is_number_float() && std::isnan(rhs.m_data.m_value.number_float) && lhs.is_number()))
+        {
+            return true;
+        }
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+        return (lhs.is_discarded() || rhs.is_discarded()) && !inverse;
+#else
+        static_cast<void>(inverse);
+        return lhs.is_discarded() || rhs.is_discarded();
+#endif
+    }
+
+  private:
+    bool compares_unordered(const_reference rhs, bool inverse = false) const noexcept
+    {
+        return compares_unordered(*this, rhs, inverse);
+    }
+
+  public:
+#if JSON_HAS_THREE_WAY_COMPARISON
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    bool operator==(const_reference rhs) const noexcept
+    {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+        const_reference lhs = *this;
+        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    }
+
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    template<typename ScalarType>
+    requires std::is_scalar_v<ScalarType>
+    bool operator==(ScalarType rhs) const noexcept
+    {
+        return *this == basic_json(rhs);
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    bool operator!=(const_reference rhs) const noexcept
+    {
+        if (compares_unordered(rhs, true))
+        {
+            return false;
+        }
+        return !operator==(rhs);
+    }
+
+    /// @brief comparison: 3-way
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/
+    std::partial_ordering operator<=>(const_reference rhs) const noexcept // *NOPAD*
+    {
+        const_reference lhs = *this;
+        // default_result is used if we cannot compare values. In that case,
+        // we compare types.
+        JSON_IMPLEMENT_OPERATOR(<=>, // *NOPAD*
+                                std::partial_ordering::equivalent,
+                                std::partial_ordering::unordered,
+                                lhs_type <=> rhs_type) // *NOPAD*
+    }
+
+    /// @brief comparison: 3-way
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/
+    template<typename ScalarType>
+    requires std::is_scalar_v<ScalarType>
+    std::partial_ordering operator<=>(ScalarType rhs) const noexcept // *NOPAD*
+    {
+        return *this <=> basic_json(rhs); // *NOPAD*
+    }
+
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    // all operators that are computed as an odd number of inverses of others
+    // need to be overloaded to emulate the legacy comparison behavior
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
+    bool operator<=(const_reference rhs) const noexcept
+    {
+        if (compares_unordered(rhs, true))
+        {
+            return false;
+        }
+        return !(rhs < *this);
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    template<typename ScalarType>
+    requires std::is_scalar_v<ScalarType>
+    bool operator<=(ScalarType rhs) const noexcept
+    {
+        return *this <= basic_json(rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
+    bool operator>=(const_reference rhs) const noexcept
+    {
+        if (compares_unordered(rhs, true))
+        {
+            return false;
+        }
+        return !(*this < rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    template<typename ScalarType>
+    requires std::is_scalar_v<ScalarType>
+    bool operator>=(ScalarType rhs) const noexcept
+    {
+        return *this >= basic_json(rhs);
+    }
+#endif
+#else
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    friend bool operator==(const_reference lhs, const_reference rhs) noexcept
+    {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    }
+
+    /// @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
+    {
+        return lhs == basic_json(rhs);
+    }
+
+    /// @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==(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) == rhs;
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
+    {
+        if (compares_unordered(lhs, rhs, true))
+        {
+            return false;
+        }
+        return !(lhs == rhs);
+    }
+
+    /// @brief comparison: not equal
+    /// @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
+    {
+        return lhs != basic_json(rhs);
+    }
+
+    /// @brief comparison: not equal
+    /// @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
+    {
+        return basic_json(lhs) != rhs;
+    }
+
+    /// @brief comparison: less than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
+    friend bool operator<(const_reference lhs, const_reference rhs) noexcept
+    {
+        // default_result is used if we cannot compare values. In that case,
+        // we compare types. Note we have to call the operator explicitly,
+        // because MSVC has problems otherwise.
+        JSON_IMPLEMENT_OPERATOR( <, false, false, operator<(lhs_type, rhs_type))
+    }
+
+    /// @brief comparison: less than
+    /// @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
+    {
+        return lhs < basic_json(rhs);
+    }
+
+    /// @brief comparison: less than
+    /// @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
+    {
+        return basic_json(lhs) < rhs;
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
+    {
+        if (compares_unordered(lhs, rhs, true))
+        {
+            return false;
+        }
+        return !(rhs < lhs);
+    }
+
+    /// @brief comparison: less than or equal
+    /// @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
+    {
+        return lhs <= basic_json(rhs);
+    }
+
+    /// @brief comparison: less than or equal
+    /// @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
+    {
+        return basic_json(lhs) <= rhs;
+    }
+
+    /// @brief comparison: greater than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
+    friend bool operator>(const_reference lhs, const_reference rhs) noexcept
+    {
+        // double inverse
+        if (compares_unordered(lhs, rhs))
+        {
+            return false;
+        }
+        return !(lhs <= rhs);
+    }
+
+    /// @brief comparison: greater than
+    /// @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
+    {
+        return lhs > basic_json(rhs);
+    }
+
+    /// @brief comparison: greater than
+    /// @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
+    {
+        return basic_json(lhs) > rhs;
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
+    {
+        if (compares_unordered(lhs, rhs, true))
+        {
+            return false;
+        }
+        return !(lhs < rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @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
+    {
+        return lhs >= basic_json(rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @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
+    {
+        return basic_json(lhs) >= rhs;
+    }
+#endif
+
+#undef JSON_IMPLEMENT_OPERATOR
+
+    /// @}
+
+    ///////////////////
+    // serialization //
+    ///////////////////
+
+    /// @name serialization
+    /// @{
+#ifndef JSON_NO_IO
+    /// @brief serialize to stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
+    friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
+    {
+        // read width member and use it as the indentation parameter if nonzero
+        const bool pretty_print = o.width() > 0;
+        const auto indentation = pretty_print ? o.width() : 0;
+
+        // reset width to 0 for subsequent calls to this stream
+        o.width(0);
+
+        // do the actual serialization
+        serializer s(detail::output_adapter<char>(o), o.fill());
+        s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
+        return o;
+    }
+
+    /// @brief serialize to stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
+    /// @deprecated This function is deprecated since 3.0.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use
+    ///             operator<<(std::ostream&, const basic_json&) instead; that is,
+    ///             replace calls like `j >> o;` with `o << j;`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&))
+    friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
+    {
+        return o << j;
+    }
+#endif  // JSON_NO_IO
+    /// @}
+
+    /////////////////////
+    // deserialization //
+    /////////////////////
+
+    /// @name deserialization
+    /// @{
+
+    /// @brief deserialize from a compatible input
+    /// @sa https://json.nlohmann.me/api/basic_json/parse/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json parse(InputType&& i,
+                            parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false,
+                            const bool ignore_trailing_commas = false)
+    {
+        basic_json result;
+        parser(detail::input_adapter(std::forward<InputType>(i)), std::move(cb), allow_exceptions, ignore_comments, ignore_trailing_commas).parse(true, result); // cppcheck-suppress[accessMoved,accessForwarded]
+        return result;
+    }
+
+    /// @brief deserialize from a pair of character iterators
+    /// @sa https://json.nlohmann.me/api/basic_json/parse/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json parse(IteratorType first,
+                            IteratorType last,
+                            parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false,
+                            const bool ignore_trailing_commas = false)
+    {
+        basic_json result;
+        parser(detail::input_adapter(std::move(first), std::move(last)), std::move(cb), allow_exceptions, ignore_comments, ignore_trailing_commas).parse(true, result); // cppcheck-suppress[accessMoved]
+        return result;
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))
+    static basic_json parse(detail::span_input_adapter&& i,
+                            parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false,
+                            const bool ignore_trailing_commas = false)
+    {
+        basic_json result;
+        parser(i.get(), std::move(cb), allow_exceptions, ignore_comments, ignore_trailing_commas).parse(true, result); // cppcheck-suppress[accessMoved]
+        return result;
+    }
+
+    /// @brief check if the input is valid JSON
+    /// @sa https://json.nlohmann.me/api/basic_json/accept/
+    template<typename InputType>
+    static bool accept(InputType&& i,
+                       const bool ignore_comments = false,
+                       const bool ignore_trailing_commas = false)
+    {
+        return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments, ignore_trailing_commas).accept(true);
+    }
+
+    /// @brief check if the input is valid JSON
+    /// @sa https://json.nlohmann.me/api/basic_json/accept/
+    template<typename IteratorType>
+    static bool accept(IteratorType first, IteratorType last,
+                       const bool ignore_comments = false,
+                       const bool ignore_trailing_commas = false)
+    {
+        return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments, ignore_trailing_commas).accept(true);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))
+    static bool accept(detail::span_input_adapter&& i,
+                       const bool ignore_comments = false,
+                       const bool ignore_trailing_commas = false)
+    {
+        return parser(i.get(), nullptr, false, ignore_comments, ignore_trailing_commas).accept(true);
+    }
+
+    /// @brief generate SAX events
+    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
+    template <typename InputType, typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    static bool sax_parse(InputType&& i, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false,
+                          const bool ignore_trailing_commas = false)
+    {
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wtautological-pointer-compare"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnonnull-compare"
+#endif
+        if (sax == nullptr)
+        {
+            JSON_THROW(other_error::create(502, "SAX handler must not be null", nullptr));
+        }
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        return format == input_format_t::json
+               ? parser(std::move(ia), nullptr, true, ignore_comments, ignore_trailing_commas).sax_parse(sax, strict)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
+    }
+
+    /// @brief generate SAX events
+    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
+    template<class IteratorType, class SAX>
+    JSON_HEDLEY_NON_NULL(3)
+    static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false,
+                          const bool ignore_trailing_commas = false)
+    {
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wtautological-pointer-compare"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnonnull-compare"
+#endif
+        if (sax == nullptr)
+        {
+            JSON_THROW(other_error::create(502, "SAX handler must not be null", nullptr));
+        }
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        return format == input_format_t::json
+               ? parser(std::move(ia), nullptr, true, ignore_comments, ignore_trailing_commas).sax_parse(sax, strict)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
+    }
+
+    /// @brief generate SAX events
+    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
+    /// @deprecated This function is deprecated since 3.8.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use
+    ///             sax_parse(ptr, ptr + len) instead.
+    template <typename SAX>
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))
+    JSON_HEDLEY_NON_NULL(2)
+    static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false,
+                          const bool ignore_trailing_commas = false)
+    {
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wtautological-pointer-compare"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnonnull-compare"
+#endif
+        if (sax == nullptr)
+        {
+            JSON_THROW(other_error::create(502, "SAX handler must not be null", nullptr));
+        }
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+        auto ia = i.get();
+        return format == input_format_t::json
+               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+               ? parser(std::move(ia), nullptr, true, ignore_comments, ignore_trailing_commas).sax_parse(sax, strict)
+               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
+    }
+#ifndef JSON_NO_IO
+    /// @brief deserialize from stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
+    /// @deprecated This stream operator is deprecated since 3.0.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use
+    ///             operator>>(std::istream&, basic_json&) instead; that is,
+    ///             replace calls like `j << i;` with `i >> j;`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&))
+    friend std::istream& operator<<(basic_json& j, std::istream& i)
+    {
+        return operator>>(i, j);
+    }
+
+    /// @brief deserialize from stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
+    friend std::istream& operator>>(std::istream& i, basic_json& j)
+    {
+        parser(detail::input_adapter(i)).parse(false, j);
+        return i;
+    }
+#endif  // JSON_NO_IO
+    /// @}
+
+    ///////////////////////////
+    // convenience functions //
+    ///////////////////////////
+
+    /// @brief return the type as string
+    /// @sa https://json.nlohmann.me/api/basic_json/type_name/
+    JSON_HEDLEY_RETURNS_NON_NULL
+    const char* type_name() const noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::null:
+                return "null";
+            case value_t::object:
+                return "object";
+            case value_t::array:
+                return "array";
+            case value_t::string:
+                return "string";
+            case value_t::boolean:
+                return "boolean";
+            case value_t::binary:
+                return "binary";
+            case value_t::discarded:
+                return "discarded";
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+                return "number";
+            default:
+                return "invalid";
+        }
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    //////////////////////
+    // member variables //
+    //////////////////////
+
+    struct data
+    {
+        /// the type of the current element
+        value_t m_type = value_t::null;
+
+        /// the value of the current element
+        json_value m_value = {};
+
+        data(const value_t v)
+            : m_type(v), m_value(v)
+        {
+        }
+
+        data(size_type cnt, const basic_json& val)
+            : m_type(value_t::array)
+        {
+            m_value.array = create<array_t>(cnt, val);
+        }
+
+        data() noexcept = default;
+        data(data&&) noexcept = default;
+        data(const data&) noexcept = delete;
+        data& operator=(data&&) noexcept = delete;
+        data& operator=(const data&) noexcept = delete;
+
+        ~data() noexcept
+        {
+            m_value.destroy(m_type);
+        }
+    };
+
+    data m_data = {};
+
+#if JSON_DIAGNOSTICS
+    /// a pointer to a parent value (for debugging purposes)
+    basic_json* m_parent = nullptr;
+#endif
+
+#if JSON_DIAGNOSTIC_POSITIONS
+    /// the start position of the value
+    std::size_t start_position = std::string::npos;
+    /// the end position of the value
+    std::size_t end_position = std::string::npos;
+  public:
+    constexpr std::size_t start_pos() const noexcept
+    {
+        return start_position;
+    }
+
+    constexpr std::size_t end_pos() const noexcept
+    {
+        return end_position;
+    }
+#endif
+
+    //////////////////////////////////////////
+    // binary serialization/deserialization //
+    //////////////////////////////////////////
+
+    /// @name binary serialization/deserialization support
+    /// @{
+
+  public:
+    /// @brief create a CBOR serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
+    static std::vector<std::uint8_t> to_cbor(const basic_json& j)
+    {
+        std::vector<std::uint8_t> result;
+        to_cbor(j, result);
+        return result;
+    }
+
+    /// @brief create a CBOR serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
+    static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o)
+    {
+        binary_writer<std::uint8_t>(o).write_cbor(j);
+    }
+
+    /// @brief create a CBOR serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
+    static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_cbor(j);
+    }
+
+    /// @brief create a MessagePack serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
+    static std::vector<std::uint8_t> to_msgpack(const basic_json& j)
+    {
+        std::vector<std::uint8_t> result;
+        to_msgpack(j, result);
+        return result;
+    }
+
+    /// @brief create a MessagePack serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
+    static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o)
+    {
+        binary_writer<std::uint8_t>(o).write_msgpack(j);
+    }
+
+    /// @brief create a MessagePack serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
+    static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_msgpack(j);
+    }
+
+    /// @brief create a UBJSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
+    static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
+            const bool use_size = false,
+            const bool use_type = false)
+    {
+        std::vector<std::uint8_t> result;
+        to_ubjson(j, result, use_size, use_type);
+        return result;
+    }
+
+    /// @brief create a UBJSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
+    static void to_ubjson(const basic_json& j, detail::output_adapter<std::uint8_t> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type);
+    }
+
+    /// @brief create a UBJSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
+    static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<char>(o).write_ubjson(j, use_size, use_type);
+    }
+
+    /// @brief create a BJData serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
+    static std::vector<std::uint8_t> to_bjdata(const basic_json& j,
+            const bool use_size = false,
+            const bool use_type = false,
+            const bjdata_version_t version = bjdata_version_t::draft2)
+    {
+        std::vector<std::uint8_t> result;
+        to_bjdata(j, result, use_size, use_type, version);
+        return result;
+    }
+
+    /// @brief create a BJData serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
+    static void to_bjdata(const basic_json& j, detail::output_adapter<std::uint8_t> o,
+                          const bool use_size = false, const bool use_type = false,
+                          const bjdata_version_t version = bjdata_version_t::draft2)
+    {
+        binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type, true, true, version);
+    }
+
+    /// @brief create a BJData serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
+    static void to_bjdata(const basic_json& j, detail::output_adapter<char> o,
+                          const bool use_size = false, const bool use_type = false,
+                          const bjdata_version_t version = bjdata_version_t::draft2)
+    {
+        binary_writer<char>(o).write_ubjson(j, use_size, use_type, true, true, version);
+    }
+
+    /// @brief create a BSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
+    static std::vector<std::uint8_t> to_bson(const basic_json& j)
+    {
+        std::vector<std::uint8_t> result;
+        to_bson(j, result);
+        return result;
+    }
+
+    /// @brief create a BSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
+    static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o)
+    {
+        binary_writer<std::uint8_t>(o).write_bson(j);
+    }
+
+    /// @brief create a BSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
+    static void to_bson(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_bson(j);
+    }
+
+    /// @brief create a JSON value from an input in CBOR format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_cbor(InputType&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in CBOR format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_cbor(IteratorType first, IteratorType last,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
+    static basic_json from_cbor(const T* ptr, std::size_t len,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
+    static basic_json from_cbor(detail::span_input_adapter&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        auto ia = i.get();
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in MessagePack format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_msgpack(InputType&& i,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in MessagePack format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_msgpack(IteratorType first, IteratorType last,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
+    static basic_json from_msgpack(const T* ptr, std::size_t len,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    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)
+    {
+        basic_json result;
+        auto ia = i.get();
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in UBJSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_ubjson(InputType&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in UBJSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_ubjson(IteratorType first, IteratorType last,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
+    static basic_json from_ubjson(const T* ptr, std::size_t len,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    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)
+    {
+        basic_json result;
+        auto ia = i.get();
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BJData format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bjdata(InputType&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BJData format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bjdata(IteratorType first, IteratorType last,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bson(InputType&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bson(IteratorType first, IteratorType last,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
+    static basic_json from_bson(const T* ptr, std::size_t len,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        return from_bson(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    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)
+    {
+        basic_json result;
+        auto ia = i.get();
+        detail::json_sax_dom_parser<basic_json, decltype(ia)> sdp(result, allow_exceptions);
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict); // cppcheck-suppress[accessMoved]
+        return res ? result : basic_json(value_t::discarded);
+    }
+    /// @}
+
+    //////////////////////////
+    // JSON Pointer support //
+    //////////////////////////
+
+    /// @name JSON Pointer functions
+    /// @{
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    reference operator[](const json_pointer& ptr)
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    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)
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    const_reference operator[](const json_pointer& ptr) const
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    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
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    reference at(const json_pointer& ptr)
+    {
+        return ptr.get_checked(this);
+    }
+
+    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)
+    {
+        return ptr.get_checked(this);
+    }
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    const_reference at(const json_pointer& ptr) const
+    {
+        return ptr.get_checked(this);
+    }
+
+    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
+    {
+        return ptr.get_checked(this);
+    }
+
+    /// @brief return flattened JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/flatten/
+    basic_json flatten() const
+    {
+        basic_json result(value_t::object);
+        json_pointer::flatten("", *this, result);
+        return result;
+    }
+
+    /// @brief unflatten a previously flattened JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/unflatten/
+    basic_json unflatten() const
+    {
+        return json_pointer::unflatten(*this);
+    }
+
+    /// @}
+
+    //////////////////////////
+    // JSON Patch functions //
+    //////////////////////////
+
+    /// @name JSON Patch functions
+    /// @{
+
+    /// @brief applies a JSON patch in-place without copying the object
+    /// @sa https://json.nlohmann.me/api/basic_json/patch/
+    void patch_inplace(const basic_json& json_patch)
+    {
+        basic_json& result = *this;
+        // the valid JSON Patch operations
+        enum class patch_operations {add, remove, replace, move, copy, test, invalid};
+
+        const auto get_op = [](const string_t& op)
+        {
+            if (op == "add")
+            {
+                return patch_operations::add;
+            }
+            if (op == "remove")
+            {
+                return patch_operations::remove;
+            }
+            if (op == "replace")
+            {
+                return patch_operations::replace;
+            }
+            if (op == "move")
+            {
+                return patch_operations::move;
+            }
+            if (op == "copy")
+            {
+                return patch_operations::copy;
+            }
+            if (op == "test")
+            {
+                return patch_operations::test;
+            }
+
+            return patch_operations::invalid;
+        };
+
+        // wrapper for "add" operation; add value at ptr
+        const auto operation_add = [&result](json_pointer & ptr, const basic_json & val)
+        {
+            // adding to the root of the target document means replacing it
+            if (ptr.empty())
+            {
+                result = val;
+                return;
+            }
+
+            // make sure the top element of the pointer exists
+            json_pointer const top_pointer = ptr.top();
+            if (top_pointer != ptr)
+            {
+                result.at(top_pointer);
+            }
+
+            // get reference to the parent of the JSON pointer ptr
+            const auto last_path = ptr.back();
+            ptr.pop_back();
+            // parent must exist when performing patch add per RFC6902 specs
+            basic_json& parent = result.at(ptr);
+
+            switch (parent.m_data.m_type)
+            {
+                case value_t::null:
+                case value_t::object:
+                {
+                    // use operator[] to add value
+                    parent[last_path] = val;
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    if (last_path == "-")
+                    {
+                        // special case: append to back
+                        parent.push_back(val);
+                    }
+                    else
+                    {
+                        const auto idx = json_pointer::template array_index<basic_json_t>(last_path);
+                        if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
+                        {
+                            // avoid undefined behavior
+                            JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), &parent));
+                        }
+
+                        // default case: insert add offset
+                        parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
+                    }
+                    break;
+                }
+
+                // if there exists a parent, it cannot be primitive
+                case value_t::string: // LCOV_EXCL_LINE
+                case value_t::boolean: // LCOV_EXCL_LINE
+                case value_t::number_integer: // LCOV_EXCL_LINE
+                case value_t::number_unsigned: // LCOV_EXCL_LINE
+                case value_t::number_float: // LCOV_EXCL_LINE
+                case value_t::binary: // LCOV_EXCL_LINE
+                case value_t::discarded: // LCOV_EXCL_LINE
+                default:            // LCOV_EXCL_LINE
+                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+            }
+        };
+
+        // wrapper for "remove" operation; remove value at ptr
+        const auto operation_remove = [this, & result](json_pointer & ptr)
+        {
+            // get reference to the parent of the JSON pointer ptr
+            const auto last_path = ptr.back();
+            ptr.pop_back();
+            basic_json& parent = result.at(ptr);
+
+            // remove child
+            if (parent.is_object())
+            {
+                // perform range check
+                auto it = parent.find(last_path);
+                if (JSON_HEDLEY_LIKELY(it != parent.end()))
+                {
+                    parent.erase(it);
+                }
+                else
+                {
+                    JSON_THROW(out_of_range::create(403, detail::concat("key '", last_path, "' not found"), this));
+                }
+            }
+            else if (parent.is_array())
+            {
+                // note erase performs range check
+                parent.erase(json_pointer::template array_index<basic_json_t>(last_path));
+            }
+        };
+
+        // type check: top level value must be an array
+        if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
+        {
+            JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &json_patch));
+        }
+
+        // iterate and apply the operations
+        for (const auto& val : json_patch)
+        {
+            // wrapper to get a value for an operation
+            const auto get_value = [&val](const string_t& op,
+                                          const string_t& member,
+                                          bool string_type) -> basic_json &
+            {
+                // find value
+                auto it = val.m_data.m_value.object->find(member);
+
+                // context-sensitive error message
+                const auto error_msg = (op == "op") ? "operation" : detail::concat("operation '", op, '\''); // NOLINT(bugprone-unused-local-non-trivial-variable)
+
+                // check if the desired value is present
+                if (JSON_HEDLEY_UNLIKELY(it == val.m_data.m_value.object->end()))
+                {
+                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
+                    JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have member '", member, "'"), &val));
+                }
+
+                // check if the result is of type string
+                if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
+                {
+                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
+                    JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have string member '", member, "'"), &val));
+                }
+
+                // no error: return value
+                return it->second;
+            };
+
+            // type check: every element of the array must be an object
+            if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
+            {
+                JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &val));
+            }
+
+            // collect mandatory members
+            const auto op = get_value("op", "op", true).template get<string_t>();
+            const auto path = get_value(op, "path", true).template get<string_t>();
+            json_pointer ptr(path);
+
+            switch (get_op(op))
+            {
+                case patch_operations::add:
+                {
+                    operation_add(ptr, get_value("add", "value", false));
+                    break;
+                }
+
+                case patch_operations::remove:
+                {
+                    operation_remove(ptr);
+                    break;
+                }
+
+                case patch_operations::replace:
+                {
+                    // the "path" location must exist - use at()
+                    result.at(ptr) = get_value("replace", "value", false);
+                    break;
+                }
+
+                case patch_operations::move:
+                {
+                    const auto from_path = get_value("move", "from", true).template get<string_t>();
+                    json_pointer from_ptr(from_path);
+
+                    // the "from" location must exist - use at()
+                    basic_json const v = result.at(from_ptr);
+
+                    // The move operation is functionally identical to a
+                    // "remove" operation on the "from" location, followed
+                    // immediately by an "add" operation at the target
+                    // location with the value that was just removed.
+                    operation_remove(from_ptr);
+                    operation_add(ptr, v);
+                    break;
+                }
+
+                case patch_operations::copy:
+                {
+                    const auto from_path = get_value("copy", "from", true).template get<string_t>();
+                    const json_pointer from_ptr(from_path);
+
+                    // the "from" location must exist - use at()
+                    basic_json const v = result.at(from_ptr);
+
+                    // The copy is functionally identical to an "add"
+                    // operation at the target location using the value
+                    // specified in the "from" member.
+                    operation_add(ptr, v);
+                    break;
+                }
+
+                case patch_operations::test:
+                {
+                    bool success = false;
+                    JSON_TRY
+                    {
+                        // check if "value" matches the one at "path"
+                        // the "path" location must exist - use at()
+                        success = (result.at(ptr) == get_value("test", "value", false));
+                    }
+                    JSON_INTERNAL_CATCH (out_of_range&)
+                    {
+                        // ignore out of range errors: success remains false
+                    }
+
+                    // throw an exception if the test fails
+                    if (JSON_HEDLEY_UNLIKELY(!success))
+                    {
+                        JSON_THROW(other_error::create(501, detail::concat("unsuccessful: ", val.dump()), &val));
+                    }
+
+                    break;
+                }
+
+                case patch_operations::invalid:
+                default:
+                {
+                    // op must be "add", "remove", "replace", "move", "copy", or
+                    // "test"
+                    JSON_THROW(parse_error::create(105, 0, detail::concat("operation value '", op, "' is invalid"), &val));
+                }
+            }
+        }
+    }
+
+    /// @brief applies a JSON patch to a copy of the current object
+    /// @sa https://json.nlohmann.me/api/basic_json/patch/
+    basic_json patch(const basic_json& json_patch) const
+    {
+        basic_json result = *this;
+        result.patch_inplace(json_patch);
+        return result;
+    }
+
+    /// @brief creates a diff as a JSON patch
+    /// @sa https://json.nlohmann.me/api/basic_json/diff/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json diff(const basic_json& source, const basic_json& target,
+                           const string_t& path = "")
+    {
+        // the patch
+        basic_json result(value_t::array);
+
+        // if the values are the same, return an empty patch
+        if (source == target)
+        {
+            return result;
+        }
+
+        if (source.type() != target.type())
+        {
+            // different types: replace value
+            result.push_back(
+            {
+                {"op", "replace"}, {"path", path}, {"value", target}
+            });
+            return result;
+        }
+
+        switch (source.type())
+        {
+            case value_t::array:
+            {
+                // first pass: traverse common elements
+                std::size_t i = 0;
+                while (i < source.size() && i < target.size())
+                {
+                    // recursive call to compare array values at index i
+                    auto temp_diff = diff(source[i], target[i], detail::concat<string_t>(path, '/', detail::to_string<string_t>(i)));
+                    result.insert(result.end(), temp_diff.begin(), temp_diff.end());
+                    ++i;
+                }
+
+                // We now reached the end of at least one array
+                // in a second pass, traverse the remaining elements
+
+                // remove my remaining elements
+                const auto end_index = static_cast<difference_type>(result.size());
+                while (i < source.size())
+                {
+                    // add operations in reverse order to avoid invalid
+                    // indices
+                    result.insert(result.begin() + end_index, object(
+                    {
+                        {"op", "remove"},
+                        {"path", detail::concat<string_t>(path, '/', detail::to_string<string_t>(i))}
+                    }));
+                    ++i;
+                }
+
+                // add other remaining elements
+                while (i < target.size())
+                {
+                    result.push_back(
+                    {
+                        {"op", "add"},
+                        {"path", detail::concat<string_t>(path, "/-")},
+                        {"value", target[i]}
+                    });
+                    ++i;
+                }
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // first pass: traverse this object's elements
+                for (auto it = source.cbegin(); it != source.cend(); ++it)
+                {
+                    // escape the key name to be used in a JSON patch
+                    const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
+
+                    if (target.find(it.key()) != target.end())
+                    {
+                        // recursive call to compare object values at key it
+                        auto temp_diff = diff(it.value(), target[it.key()], path_key);
+                        result.insert(result.end(), temp_diff.begin(), temp_diff.end());
+                    }
+                    else
+                    {
+                        // found a key that is not in o -> remove it
+                        result.push_back(object(
+                        {
+                            {"op", "remove"}, {"path", path_key}
+                        }));
+                    }
+                }
+
+                // second pass: traverse other object's elements
+                for (auto it = target.cbegin(); it != target.cend(); ++it)
+                {
+                    if (source.find(it.key()) == source.end())
+                    {
+                        // found a key that is not in this -> add it
+                        const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
+                        result.push_back(
+                        {
+                            {"op", "add"}, {"path", path_key},
+                            {"value", it.value()}
+                        });
+                    }
+                }
+
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // both primitive types: replace value
+                result.push_back(
+                {
+                    {"op", "replace"}, {"path", path}, {"value", target}
+                });
+                break;
+            }
+        }
+
+        return result;
+    }
+    /// @}
+
+    ////////////////////////////////
+    // JSON Merge Patch functions //
+    ////////////////////////////////
+
+    /// @name JSON Merge Patch functions
+    /// @{
+
+    /// @brief applies a JSON Merge Patch
+    /// @sa https://json.nlohmann.me/api/basic_json/merge_patch/
+    void merge_patch(const basic_json& apply_patch)
+    {
+        if (apply_patch.is_object())
+        {
+            if (!is_object())
+            {
+                *this = object();
+            }
+            for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
+            {
+                if (it.value().is_null())
+                {
+                    erase(it.key());
+                }
+                else
+                {
+                    operator[](it.key()).merge_patch(it.value());
+                }
+            }
+        }
+        else
+        {
+            *this = apply_patch;
+        }
+    }
+
+    /// @}
+};
+
+/// @brief user-defined to_string function for JSON values
+/// @sa https://json.nlohmann.me/api/basic_json/to_string/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
+{
+    return j.dump();
+}
+
+inline namespace literals
+{
+inline namespace json_literals
+{
+
+/// @brief user-defined string literal for JSON values
+/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json/
+JSON_HEDLEY_NON_NULL(1)
+#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+    inline nlohmann::json operator""_json(const char* s, std::size_t n)
+#else
+    // GCC 4.8 requires a space between "" and suffix
+    inline nlohmann::json operator"" _json(const char* s, std::size_t n)
+#endif
+{
+    return nlohmann::json::parse(s, s + n);
+}
+
+#if defined(__cpp_char8_t)
+JSON_HEDLEY_NON_NULL(1)
+inline nlohmann::json operator""_json(const char8_t* s, std::size_t n)
+{
+    return nlohmann::json::parse(reinterpret_cast<const char*>(s),
+                                 reinterpret_cast<const char*>(s) + n);
+}
+#endif
+
+/// @brief user-defined string literal for JSON pointer
+/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json_pointer/
+JSON_HEDLEY_NON_NULL(1)
+#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+    inline nlohmann::json::json_pointer operator""_json_pointer(const char* s, std::size_t n)
+#else
+    // GCC 4.8 requires a space between "" and suffix
+    inline nlohmann::json::json_pointer operator"" _json_pointer(const char* s, std::size_t n)
+#endif
+{
+    return nlohmann::json::json_pointer(std::string(s, n));
+}
+
+#if defined(__cpp_char8_t)
+inline nlohmann::json::json_pointer operator""_json_pointer(const char8_t* s, std::size_t n)
+{
+    return nlohmann::json::json_pointer(std::string(reinterpret_cast<const char*>(s), n));
+}
+#endif
+
+}  // namespace json_literals
+}  // namespace literals
+NLOHMANN_JSON_NAMESPACE_END
+
+///////////////////////
+// nonmember support //
+///////////////////////
+
+namespace std // NOLINT(cert-dcl58-cpp)
+{
+
+/// @brief hash value for JSON objects
+/// @sa https://json.nlohmann.me/api/basic_json/std_hash/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+struct hash<nlohmann::NLOHMANN_BASIC_JSON_TPL> // NOLINT(cert-dcl58-cpp)
+{
+    std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL& j) const
+    {
+        return nlohmann::detail::hash(j);
+    }
+};
+
+// specialization for std::less<value_t>
+template<>
+struct less< ::nlohmann::detail::value_t> // do not remove the space after '<', see https://github.com/nlohmann/json/pull/679
+{
+    /*!
+    @brief compare two value_t enum values
+    @since version 3.0.0
+    */
+    bool operator()(::nlohmann::detail::value_t lhs,
+                    ::nlohmann::detail::value_t rhs) const noexcept
+    {
+#if JSON_HAS_THREE_WAY_COMPARISON
+        return std::is_lt(lhs <=> rhs); // *NOPAD*
+#else
+        return ::nlohmann::detail::operator<(lhs, rhs);
+#endif
+    }
+};
+
+// C++20 prohibit function specialization in the std namespace.
+#ifndef JSON_HAS_CPP_20
+
+/// @brief exchanges the values of two JSON objects
+/// @sa https://json.nlohmann.me/api/basic_json/std_swap/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC_JSON_TPL& j2) noexcept(  // NOLINT(readability-inconsistent-declaration-parameter-name, cert-dcl58-cpp)
+    is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&&                          // NOLINT(misc-redundant-expression,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value)
+{
+    j1.swap(j2);
+}
+
+#endif
+
+}  // namespace std
+
+#if JSON_USE_GLOBAL_UDLS
+    #if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+        using nlohmann::literals::json_literals::operator""_json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+        using nlohmann::literals::json_literals::operator""_json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+    #else
+        // GCC 4.8 requires a space between "" and suffix
+        using nlohmann::literals::json_literals::operator"" _json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+        using nlohmann::literals::json_literals::operator"" _json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+    #endif
+#endif
+
+// #include <nlohmann/detail/macro_unscope.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// restore clang diagnostic settings
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
+
+// clean up
+#undef JSON_ASSERT
+#undef JSON_INTERNAL_CATCH
+#undef JSON_THROW
+#undef JSON_PRIVATE_UNLESS_TESTED
+#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
+#undef NLOHMANN_BASIC_JSON_TPL
+#undef JSON_EXPLICIT
+#undef NLOHMANN_CAN_CALL_STD_FUNC_IMPL
+#undef JSON_INLINE_VARIABLE
+#undef JSON_NO_UNIQUE_ADDRESS
+#undef JSON_DISABLE_ENUM_SERIALIZATION
+#undef JSON_USE_GLOBAL_UDLS
+
+#ifndef JSON_TEST_KEEP_MACROS
+    #undef JSON_CATCH
+    #undef JSON_TRY
+    #undef JSON_HAS_CPP_11
+    #undef JSON_HAS_CPP_14
+    #undef JSON_HAS_CPP_17
+    #undef JSON_HAS_CPP_20
+    #undef JSON_HAS_CPP_23
+    #undef JSON_HAS_CPP_26
+    #undef JSON_HAS_FILESYSTEM
+    #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+    #undef JSON_HAS_THREE_WAY_COMPARISON
+    #undef JSON_HAS_RANGES
+    #undef JSON_HAS_STATIC_RTTI
+    #undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+#endif
+
+// #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2025 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#undef JSON_HEDLEY_ALWAYS_INLINE
+#undef JSON_HEDLEY_ARM_VERSION
+#undef JSON_HEDLEY_ARM_VERSION_CHECK
+#undef JSON_HEDLEY_ARRAY_PARAM
+#undef JSON_HEDLEY_ASSUME
+#undef JSON_HEDLEY_BEGIN_C_DECLS
+#undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_BUILTIN
+#undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_EXTENSION
+#undef JSON_HEDLEY_CLANG_HAS_FEATURE
+#undef JSON_HEDLEY_CLANG_HAS_WARNING
+#undef JSON_HEDLEY_COMPCERT_VERSION
+#undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
+#undef JSON_HEDLEY_CONCAT
+#undef JSON_HEDLEY_CONCAT3
+#undef JSON_HEDLEY_CONCAT3_EX
+#undef JSON_HEDLEY_CONCAT_EX
+#undef JSON_HEDLEY_CONST
+#undef JSON_HEDLEY_CONSTEXPR
+#undef JSON_HEDLEY_CONST_CAST
+#undef JSON_HEDLEY_CPP_CAST
+#undef JSON_HEDLEY_CRAY_VERSION
+#undef JSON_HEDLEY_CRAY_VERSION_CHECK
+#undef JSON_HEDLEY_C_DECL
+#undef JSON_HEDLEY_DEPRECATED
+#undef JSON_HEDLEY_DEPRECATED_FOR
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
+#undef JSON_HEDLEY_DIAGNOSTIC_POP
+#undef JSON_HEDLEY_DIAGNOSTIC_PUSH
+#undef JSON_HEDLEY_DMC_VERSION
+#undef JSON_HEDLEY_DMC_VERSION_CHECK
+#undef JSON_HEDLEY_EMPTY_BASES
+#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
+#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
+#undef JSON_HEDLEY_END_C_DECLS
+#undef JSON_HEDLEY_FLAGS
+#undef JSON_HEDLEY_FLAGS_CAST
+#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_BUILTIN
+#undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_EXTENSION
+#undef JSON_HEDLEY_GCC_HAS_FEATURE
+#undef JSON_HEDLEY_GCC_HAS_WARNING
+#undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
+#undef JSON_HEDLEY_GCC_VERSION
+#undef JSON_HEDLEY_GCC_VERSION_CHECK
+#undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_BUILTIN
+#undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_EXTENSION
+#undef JSON_HEDLEY_GNUC_HAS_FEATURE
+#undef JSON_HEDLEY_GNUC_HAS_WARNING
+#undef JSON_HEDLEY_GNUC_VERSION
+#undef JSON_HEDLEY_GNUC_VERSION_CHECK
+#undef JSON_HEDLEY_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_BUILTIN
+#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
+#undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_EXTENSION
+#undef JSON_HEDLEY_HAS_FEATURE
+#undef JSON_HEDLEY_HAS_WARNING
+#undef JSON_HEDLEY_IAR_VERSION
+#undef JSON_HEDLEY_IAR_VERSION_CHECK
+#undef JSON_HEDLEY_IBM_VERSION
+#undef JSON_HEDLEY_IBM_VERSION_CHECK
+#undef JSON_HEDLEY_IMPORT
+#undef JSON_HEDLEY_INLINE
+#undef JSON_HEDLEY_INTEL_CL_VERSION
+#undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
+#undef JSON_HEDLEY_INTEL_VERSION
+#undef JSON_HEDLEY_INTEL_VERSION_CHECK
+#undef JSON_HEDLEY_IS_CONSTANT
+#undef JSON_HEDLEY_IS_CONSTEXPR_
+#undef JSON_HEDLEY_LIKELY
+#undef JSON_HEDLEY_MALLOC
+#undef JSON_HEDLEY_MCST_LCC_VERSION
+#undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
+#undef JSON_HEDLEY_MESSAGE
+#undef JSON_HEDLEY_MSVC_VERSION
+#undef JSON_HEDLEY_MSVC_VERSION_CHECK
+#undef JSON_HEDLEY_NEVER_INLINE
+#undef JSON_HEDLEY_NON_NULL
+#undef JSON_HEDLEY_NO_ESCAPE
+#undef JSON_HEDLEY_NO_RETURN
+#undef JSON_HEDLEY_NO_THROW
+#undef JSON_HEDLEY_NULL
+#undef JSON_HEDLEY_PELLES_VERSION
+#undef JSON_HEDLEY_PELLES_VERSION_CHECK
+#undef JSON_HEDLEY_PGI_VERSION
+#undef JSON_HEDLEY_PGI_VERSION_CHECK
+#undef JSON_HEDLEY_PREDICT
+#undef JSON_HEDLEY_PRINTF_FORMAT
+#undef JSON_HEDLEY_PRIVATE
+#undef JSON_HEDLEY_PUBLIC
+#undef JSON_HEDLEY_PURE
+#undef JSON_HEDLEY_REINTERPRET_CAST
+#undef JSON_HEDLEY_REQUIRE
+#undef JSON_HEDLEY_REQUIRE_CONSTEXPR
+#undef JSON_HEDLEY_REQUIRE_MSG
+#undef JSON_HEDLEY_RESTRICT
+#undef JSON_HEDLEY_RETURNS_NON_NULL
+#undef JSON_HEDLEY_SENTINEL
+#undef JSON_HEDLEY_STATIC_ASSERT
+#undef JSON_HEDLEY_STATIC_CAST
+#undef JSON_HEDLEY_STRINGIFY
+#undef JSON_HEDLEY_STRINGIFY_EX
+#undef JSON_HEDLEY_SUNPRO_VERSION
+#undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
+#undef JSON_HEDLEY_TINYC_VERSION
+#undef JSON_HEDLEY_TINYC_VERSION_CHECK
+#undef JSON_HEDLEY_TI_ARMCL_VERSION
+#undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL2000_VERSION
+#undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL430_VERSION
+#undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL6X_VERSION
+#undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL7X_VERSION
+#undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CLPRU_VERSION
+#undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
+#undef JSON_HEDLEY_TI_VERSION
+#undef JSON_HEDLEY_TI_VERSION_CHECK
+#undef JSON_HEDLEY_UNAVAILABLE
+#undef JSON_HEDLEY_UNLIKELY
+#undef JSON_HEDLEY_UNPREDICTABLE
+#undef JSON_HEDLEY_UNREACHABLE
+#undef JSON_HEDLEY_UNREACHABLE_RETURN
+#undef JSON_HEDLEY_VERSION
+#undef JSON_HEDLEY_VERSION_DECODE_MAJOR
+#undef JSON_HEDLEY_VERSION_DECODE_MINOR
+#undef JSON_HEDLEY_VERSION_DECODE_REVISION
+#undef JSON_HEDLEY_VERSION_ENCODE
+#undef JSON_HEDLEY_WARNING
+#undef JSON_HEDLEY_WARN_UNUSED_RESULT
+#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
+#undef JSON_HEDLEY_FALL_THROUGH
+
+
+
+#endif  // INCLUDE_NLOHMANN_JSON_HPP_
\ No newline at end of file
diff --git a/include/luajit/lauxlib.h b/include/luajit/lauxlib.h
new file mode 120000
index 0000000..9b90d8d
--- /dev/null
+++ b/include/luajit/lauxlib.h
@@ -0,0 +1 @@
+../../lib/luajit/inc/lauxlib.h
\ No newline at end of file
diff --git a/include/luajit/lua.h b/include/luajit/lua.h
new file mode 120000
index 0000000..d8a9d9a
--- /dev/null
+++ b/include/luajit/lua.h
@@ -0,0 +1 @@
+../../lib/luajit/inc/lua.h
\ No newline at end of file
diff --git a/include/luajit/lua.hpp b/include/luajit/lua.hpp
new file mode 120000
index 0000000..04539d8
--- /dev/null
+++ b/include/luajit/lua.hpp
@@ -0,0 +1 @@
+../../lib/luajit/inc/lua.hpp
\ No newline at end of file
diff --git a/include/luajit/luaconf.h b/include/luajit/luaconf.h
new file mode 120000
index 0000000..0f62f1a
--- /dev/null
+++ b/include/luajit/luaconf.h
@@ -0,0 +1 @@
+../../lib/luajit/inc/luaconf.h
\ No newline at end of file
diff --git a/include/luajit/lualib.h b/include/luajit/lualib.h
new file mode 120000
index 0000000..c65cbfe
--- /dev/null
+++ b/include/luajit/lualib.h
@@ -0,0 +1 @@
+../../lib/luajit/inc/lualib.h
\ No newline at end of file