From be1d3de49be7cf8453171b9c0bc5149a6404c68d Mon Sep 17 00:00:00 2001
From: Niels Lohmann <niels.lohmann@gmail.com>
Date: Sun, 18 Dec 2016 20:32:09 +0100
Subject: [PATCH] :lipstick: moved changes to re2c file and ran `make pretty`

---
 src/json.hpp                  | 6315 +++++++++++++++++----------------
 src/json.hpp.re2c             | 4716 +++++++++++++-----------
 test/src/unit-class_lexer.cpp |   48 +-
 test/src/unit-udt.cpp         |  623 ++--
 4 files changed, 6100 insertions(+), 5602 deletions(-)

diff --git a/src/json.hpp b/src/json.hpp
index f883d9ed..7325e7c8 100644
--- a/src/json.hpp
+++ b/src/json.hpp
@@ -126,12 +126,12 @@ using conditional_t = typename std::conditional<If, Then, Else>::type;
 template <typename T>
 using is_scoped_enum =
     std::integral_constant<bool, not std::is_convertible<T, int>::value and
-                                     std::is_enum<T>::value>;
+    std::is_enum<T>::value>;
 
 template <typename T>
 using is_unscoped_enum =
     std::integral_constant<bool, std::is_convertible<T, int>::value and
-                                     std::is_enum<T>::value>;
+    std::is_enum<T>::value>;
 
 // TODO update this doc
 /*!
@@ -142,7 +142,10 @@ using is_unscoped_enum =
 namespace detail
 {
 // Very useful construct against boilerplate (more boilerplate needed than in C++17: http://en.cppreference.com/w/cpp/types/void_t)
-template <typename...> struct make_void { using type = void; };
+template <typename...> struct make_void
+{
+    using type = void;
+};
 template <typename... Ts> using void_t = typename make_void<Ts...>::type;
 
 // Implementation of 3 C++17 constructs: conjunction, disjunction, negation.
@@ -160,14 +163,14 @@ template <class...> struct conjunction : std::true_type {};
 template <class B1> struct conjunction<B1> : B1 {};
 template <class B1, class... Bn>
 struct conjunction<B1, Bn...>
-    : conditional_t<bool(B1::value), conjunction<Bn...>, B1> {};
+: conditional_t<bool(B1::value), conjunction<Bn...>, B1> {};
 
-template <class B> struct negation : std::integral_constant<bool, !B::value> {};
+template <class B> struct negation : std::integral_constant < bool, !B::value > {};
 template <class...> struct disjunction : std::false_type {};
 template <class B1> struct disjunction<B1> : B1 {};
 template <class B1, class... Bn>
 struct disjunction<B1, Bn...>
-    : conditional_t<bool(B1::value), B1, disjunction<Bn...>> {};
+: conditional_t<bool(B1::value), B1, disjunction<Bn...>> {};
 
 /*!
 @brief Helper to determine whether there's a key_type for T.
@@ -178,17 +181,17 @@ contains a `mapped_type`, whereas `std::vector` fails the test.
 @since version 1.0.0, overworked in version 2.0.6
 */
 #define NLOHMANN_JSON_HAS_HELPER(type)                                         \
-  template <typename T> struct has_##type {                                    \
-  private:                                                                     \
-    template <typename U, typename = typename U::type>                         \
-    static int detect(U &&);                                                   \
-                                                                               \
-    static void detect(...);                                                   \
-                                                                               \
-  public:                                                                      \
-    static constexpr bool value =                                              \
-        std::is_integral<decltype(detect(std::declval<T>()))>::value;          \
-  };
+    template <typename T> struct has_##type {                                    \
+    private:                                                                     \
+        template <typename U, typename = typename U::type>                         \
+        static int detect(U &&);                                                   \
+        \
+        static void detect(...);                                                   \
+        \
+    public:                                                                      \
+        static constexpr bool value =                                              \
+                std::is_integral<decltype(detect(std::declval<T>()))>::value;          \
+    };
 
 NLOHMANN_JSON_HAS_HELPER(mapped_type)
 NLOHMANN_JSON_HAS_HELPER(key_type)
@@ -198,122 +201,122 @@ NLOHMANN_JSON_HAS_HELPER(iterator)
 #undef NLOHMANN_JSON_HAS_HELPER
 
 template <bool B, class RealType, class CompatibleObjectType>
-struct is_compatible_object_type_impl : std::false_type{};
+struct is_compatible_object_type_impl : std::false_type {};
 
 template <class RealType, class CompatibleObjectType>
 struct is_compatible_object_type_impl<true, RealType, CompatibleObjectType>
 {
-  static constexpr auto value =
-      std::is_constructible<typename RealType::key_type,
-                            typename CompatibleObjectType::key_type>::value and
-      std::is_constructible<typename RealType::mapped_type,
-                            typename CompatibleObjectType::mapped_type>::value;
+    static constexpr auto value =
+        std::is_constructible<typename RealType::key_type,
+        typename CompatibleObjectType::key_type>::value and
+        std::is_constructible<typename RealType::mapped_type,
+        typename CompatibleObjectType::mapped_type>::value;
 };
 
 template<class RealType, class CompatibleObjectType>
 struct is_compatible_object_type
 {
-  // As noted ahead, we need to stop evaluating traits if CompatibleObjectType = void
-  // hence the conjunction
-  static auto constexpr value = is_compatible_object_type_impl<
-      conjunction<negation<std::is_same<void, CompatibleObjectType>>,
-                  has_mapped_type<CompatibleObjectType>,
-                  has_key_type<CompatibleObjectType>>::value,
-      RealType, CompatibleObjectType>::value;
+    // As noted ahead, we need to stop evaluating traits if CompatibleObjectType = void
+    // hence the conjunction
+    static auto constexpr value = is_compatible_object_type_impl <
+                                  conjunction<negation<std::is_same<void, CompatibleObjectType>>,
+                                  has_mapped_type<CompatibleObjectType>,
+                                  has_key_type<CompatibleObjectType>>::value,
+                                  RealType, CompatibleObjectType >::value;
 };
 
 template <bool B, class BasicJson, class CompatibleArrayType>
-struct is_compatible_array_type_impl : std::false_type{};
+struct is_compatible_array_type_impl : std::false_type {};
 
 template <class BasicJson, class CompatibleArrayType>
 struct is_compatible_array_type_impl<true, BasicJson, CompatibleArrayType>
 {
-  static constexpr auto value =
-      not std::is_same<CompatibleArrayType,
-                       typename BasicJson::iterator>::value and
-      not std::is_same<CompatibleArrayType,
-                       typename BasicJson::const_iterator>::value and
-      not std::is_same<CompatibleArrayType,
-                       typename BasicJson::reverse_iterator>::value and
-      not std::is_same<CompatibleArrayType,
-                       typename BasicJson::const_reverse_iterator>::value and
-      not std::is_same<CompatibleArrayType,
-                       typename BasicJson::array_t::iterator>::value and
-      not std::is_same<CompatibleArrayType,
-                       typename BasicJson::array_t::const_iterator>::value;
+    static constexpr auto value =
+        not std::is_same<CompatibleArrayType,
+        typename BasicJson::iterator>::value and
+        not std::is_same<CompatibleArrayType,
+        typename BasicJson::const_iterator>::value and
+        not std::is_same<CompatibleArrayType,
+        typename BasicJson::reverse_iterator>::value and
+        not std::is_same<CompatibleArrayType,
+        typename BasicJson::const_reverse_iterator>::value and
+        not std::is_same<CompatibleArrayType,
+        typename BasicJson::array_t::iterator>::value and
+        not std::is_same<CompatibleArrayType,
+        typename BasicJson::array_t::const_iterator>::value;
 };
 
 template <class BasicJson, class CompatibleArrayType>
 struct is_compatible_array_type
 {
-  // the check for CompatibleArrayType = void is done in is_compatible_object_type
-  // but we need the conjunction here as well
-  static auto constexpr value = is_compatible_array_type_impl<
-      conjunction<negation<is_compatible_object_type<
-                      typename BasicJson::object_t, CompatibleArrayType>>,
-                  has_value_type<CompatibleArrayType>,
-                  has_iterator<CompatibleArrayType>>::value,
-      BasicJson, CompatibleArrayType>::value;
+    // the check for CompatibleArrayType = void is done in is_compatible_object_type
+    // but we need the conjunction here as well
+    static auto constexpr value = is_compatible_array_type_impl <
+                                  conjunction<negation<is_compatible_object_type<
+                                  typename BasicJson::object_t, CompatibleArrayType>>,
+                                  has_value_type<CompatibleArrayType>,
+                                  has_iterator<CompatibleArrayType>>::value,
+                                  BasicJson, CompatibleArrayType >::value;
 };
 
 template <bool, typename, typename>
-struct is_compatible_integer_type_impl : std::false_type{};
+struct is_compatible_integer_type_impl : std::false_type {};
 
 template <typename RealIntegerType, typename CompatibleNumberIntegerType>
 struct is_compatible_integer_type_impl<true, RealIntegerType, CompatibleNumberIntegerType>
 {
-  using RealLimits = std::numeric_limits<RealIntegerType>;
-  using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
+    using RealLimits = std::numeric_limits<RealIntegerType>;
+    using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
 
-  static constexpr auto value =
-      std::is_constructible<RealIntegerType,
-                            CompatibleNumberIntegerType>::value and
-      CompatibleLimits::is_integer and
-      RealLimits::is_signed == CompatibleLimits::is_signed;
+    static constexpr auto value =
+        std::is_constructible<RealIntegerType,
+        CompatibleNumberIntegerType>::value and
+        CompatibleLimits::is_integer and
+        RealLimits::is_signed == CompatibleLimits::is_signed;
 };
 
 template <typename RealIntegerType, typename CompatibleNumberIntegerType>
 struct is_compatible_integer_type
 {
-  static constexpr auto value = is_compatible_integer_type_impl<
-      std::is_arithmetic<CompatibleNumberIntegerType>::value, RealIntegerType,
-      CompatibleNumberIntegerType>::value;
+    static constexpr auto value = is_compatible_integer_type_impl <
+                                  std::is_arithmetic<CompatibleNumberIntegerType>::value, RealIntegerType,
+                                  CompatibleNumberIntegerType >::value;
 };
 
 template <typename RealFloat, typename CompatibleFloat>
 struct is_compatible_float_type
 {
-  static constexpr auto value =
-      std::is_constructible<RealFloat, CompatibleFloat>::value and
-      std::is_floating_point<CompatibleFloat>::value;
+    static constexpr auto value =
+        std::is_constructible<RealFloat, CompatibleFloat>::value and
+        std::is_floating_point<CompatibleFloat>::value;
 };
 
 template <typename T, typename BasicJson>
 struct is_compatible_basic_json_type
 {
-  static auto constexpr value =
-      is_unscoped_enum<T>::value or
-      std::is_same<T, BasicJson>::value or
-      std::is_constructible<typename BasicJson::string_t, T>::value or
-      std::is_same<typename BasicJson::boolean_t, T>::value or
-      is_compatible_array_type<BasicJson, T>::value or
-      is_compatible_object_type<typename BasicJson::object_t, T>::value or
-      is_compatible_float_type<typename BasicJson::number_float_t, T>::value or
-      is_compatible_integer_type<typename BasicJson::number_integer_t,
-                                 T>::value or
-      is_compatible_integer_type<typename BasicJson::number_unsigned_t,
-                                 T>::value;
+    static auto constexpr value =
+        is_unscoped_enum<T>::value or
+        std::is_same<T, BasicJson>::value or
+        std::is_constructible<typename BasicJson::string_t, T>::value or
+        std::is_same<typename BasicJson::boolean_t, T>::value or
+        is_compatible_array_type<BasicJson, T>::value or
+        is_compatible_object_type<typename BasicJson::object_t, T>::value or
+        is_compatible_float_type<typename BasicJson::number_float_t, T>::value or
+        is_compatible_integer_type<typename BasicJson::number_integer_t,
+        T>::value or
+        is_compatible_integer_type<typename BasicJson::number_unsigned_t,
+        T>::value;
 };
 
 template <typename T, typename BasicJson, typename PrimitiveIterator>
 struct is_basic_json_nested_class
 {
-  static auto constexpr value = std::is_same<T, typename BasicJson::iterator>::value or
-                                std::is_same<T, typename BasicJson::const_iterator>::value or
-                                std::is_same<T, typename BasicJson::reverse_iterator>::value or
-                                std::is_same<T, typename BasicJson::const_reverse_iterator>::value or
-                                std::is_same<T, PrimitiveIterator>::value or
-                                std::is_same<T, typename BasicJson::json_pointer>::value;
+    static auto constexpr value = std::is_same<T, typename BasicJson::iterator>::value or
+                                  std::is_same<T, typename BasicJson::const_iterator>::value or
+                                  std::is_same<T, typename BasicJson::reverse_iterator>::value or
+                                  std::is_same<T, typename BasicJson::const_reverse_iterator>::value or
+                                  std::is_same<T, PrimitiveIterator>::value or
+                                  std::is_same<T, typename BasicJson::json_pointer>::value;
 };
 
 // This trait checks if JSONSerializer<T>::from_json(json const&, udt&) exists
@@ -321,17 +324,17 @@ template <template <typename, typename> class JSONSerializer, typename Json,
           typename T>
 struct has_from_json
 {
-private:
-  // also check the return type of from_json
-  template <typename U, typename = enable_if_t<std::is_same<void, decltype(uncvref_t<U>::from_json(
-                            std::declval<Json>(), std::declval<T &>()))>::value>>
-  static int detect(U &&);
+  private:
+    // also check the return type of from_json
+    template <typename U, typename = enable_if_t<std::is_same<void, decltype(uncvref_t<U>::from_json(
+                  std::declval<Json>(), std::declval<T&>()))>::value>>
+    static int detect(U&&);
 
-  static void detect(...);
+    static void detect(...);
 
-public:
-  static constexpr bool value = std::is_integral<decltype(
-      detect(std::declval<JSONSerializer<T, void>>()))>::value;
+  public:
+    static constexpr bool value = std::is_integral<decltype(
+                                      detect(std::declval<JSONSerializer<T, void>>()))>::value;
 };
 
 // This trait checks if JSONSerializer<T>::from_json(json const&) exists
@@ -340,15 +343,15 @@ template <template <typename, typename> class JSONSerializer, typename Json,
           typename T>
 struct has_non_default_from_json
 {
-private:
-  template <typename U, typename = enable_if_t<std::is_same<T, decltype(uncvref_t<U>::from_json(std::declval<Json>()))>::value>>
-  static int detect(U &&);
+  private:
+    template <typename U, typename = enable_if_t<std::is_same<T, decltype(uncvref_t<U>::from_json(std::declval<Json>()))>::value>>
+    static int detect(U&&);
 
-  static void detect(...);
+    static void detect(...);
 
-public:
-  static constexpr bool value = std::is_integral<decltype(
-      detect(std::declval<JSONSerializer<T, void>>()))>::value;
+  public:
+    static constexpr bool value = std::is_integral<decltype(
+                                      detect(std::declval<JSONSerializer<T, void>>()))>::value;
 };
 
 // This trait checks if JSONSerializer<T>::to_json exists
@@ -356,16 +359,16 @@ template <template <typename, typename> class JSONSerializer, typename Json,
           typename T>
 struct has_to_json
 {
-private:
-  template <typename U, typename = decltype(uncvref_t<U>::to_json(
-                            std::declval<Json &>(), std::declval<T>()))>
-  static int detect(U &&);
+  private:
+    template <typename U, typename = decltype(uncvref_t<U>::to_json(
+                  std::declval<Json&>(), std::declval<T>()))>
+    static int detect(U&&);
 
-  static void detect(...);
+    static void detect(...);
 
-public:
-  static constexpr bool value = std::is_integral<decltype(
-      detect(std::declval<JSONSerializer<T, void>>()))>::value;
+  public:
+    static constexpr bool value = std::is_integral<decltype(
+                                      detect(std::declval<JSONSerializer<T, void>>()))>::value;
 };
 
 // those declarations are needed to workaround a MSVC bug related to ADL
@@ -375,26 +378,26 @@ void from_json();
 
 struct to_json_fn
 {
-  // is it really useful to mark those as constexpr?
-  template <typename Json, typename T>
-  constexpr auto operator()(Json &&j, T &&val) const
-      noexcept(noexcept(to_json(std::forward<Json>(j), std::forward<T>(val))))
-          -> decltype(to_json(std::forward<Json>(j), std::forward<T>(val)),
-                      void())
-  {
-    return to_json(std::forward<Json>(j), std::forward<T>(val));
-  }
+    // is it really useful to mark those as constexpr?
+    template <typename Json, typename T>
+    constexpr auto operator()(Json&& j, T&& val) const
+    noexcept(noexcept(to_json(std::forward<Json>(j), std::forward<T>(val))))
+    -> decltype(to_json(std::forward<Json>(j), std::forward<T>(val)),
+                void())
+    {
+        return to_json(std::forward<Json>(j), std::forward<T>(val));
+    }
 };
 
 struct from_json_fn
 {
-  template <typename Json, typename T>
-  constexpr auto operator()(Json &&j, T &val) const
-      noexcept(noexcept(from_json(std::forward<Json>(j), val)))
-          -> decltype(from_json(std::forward<Json>(j), val), void())
-  {
-    return from_json(std::forward<Json>(j), val);
-  }
+    template <typename Json, typename T>
+    constexpr auto operator()(Json&& j, T& val) const
+    noexcept(noexcept(from_json(std::forward<Json>(j), val)))
+    -> decltype(from_json(std::forward<Json>(j), val), void())
+    {
+        return from_json(std::forward<Json>(j), val);
+    }
 };
 
 /*!
@@ -423,7 +426,7 @@ struct DecimalSeparator : std::numpunct<char>
 template <typename T>
 struct static_const
 {
-  static constexpr T value{};
+    static constexpr T value{};
 };
 
 template <typename T>
@@ -431,8 +434,8 @@ constexpr T static_const<T>::value;
 
 inline namespace
 {
-  constexpr auto const& to_json = static_const<detail::to_json_fn>::value;
-  constexpr auto const& from_json = static_const<detail::from_json_fn>::value;
+constexpr auto const& to_json = static_const<detail::to_json_fn>::value;
+constexpr auto const& from_json = static_const<detail::from_json_fn>::value;
 }
 
 // default JSONSerializer template argument, doesn't care about template argument
@@ -440,17 +443,17 @@ inline namespace
 template <typename = void, typename = void>
 struct adl_serializer
 {
-  template <typename Json, typename T>
-  static void from_json(Json&& j, T& val)
-  {
-    ::nlohmann::from_json(std::forward<Json>(j), val);
-  }
+    template <typename Json, typename T>
+    static void from_json(Json&& j, T& val)
+    {
+        ::nlohmann::from_json(std::forward<Json>(j), val);
+    }
 
-  template <typename Json, typename T>
-  static void to_json(Json& j, T&& val)
-  {
-    ::nlohmann::to_json(j, std::forward<T>(val));
-  }
+    template <typename Json, typename T>
+    static void to_json(Json& j, T&& val)
+    {
+        ::nlohmann::to_json(j, std::forward<T>(val));
+    }
 };
 
 /*!
@@ -1535,12 +1538,12 @@ class basic_json
               enable_if_t<detail::is_compatible_object_type<
                               object_t, CompatibleObjectType>::value,
                           int> = 0>
-    basic_json(const CompatibleObjectType &val) : m_type(value_t::object)
+    basic_json(const CompatibleObjectType& val) : m_type(value_t::object)
     {
-      using std::begin;
-      using std::end;
-      m_value.object = create<object_t>(begin(val), end(val));
-      assert_invariant();
+        using std::begin;
+        using std::end;
+        m_value.object = create<object_t>(begin(val), end(val));
+        assert_invariant();
     }
 
     /*!
@@ -1598,12 +1601,12 @@ class basic_json
               enable_if_t<detail::is_compatible_array_type<
                               basic_json_t, CompatibleArrayType>::value,
                           int> = 0>
-    basic_json(const CompatibleArrayType &val) : m_type(value_t::array)
+    basic_json(const CompatibleArrayType& val) : m_type(value_t::array)
     {
-      using std::begin;
-      using std::end;
-      m_value.array = create<array_t>(begin(val), end(val));
-      assert_invariant();
+        using std::begin;
+        using std::end;
+        m_value.array = create<array_t>(begin(val), end(val));
+        assert_invariant();
     }
 
 
@@ -1614,18 +1617,18 @@ class basic_json
     template <
         typename T,
         enable_if_t<not std::is_base_of<std::istream, uncvref_t<T>>::value and
-                        not detail::is_basic_json_nested_class<uncvref_t<T>, basic_json_t, primitive_iterator_t>::value and
-                        not std::is_same<uncvref_t<T>, typename basic_json_t::array_t::iterator>::value and
-                        not std::is_same<uncvref_t<T>, typename basic_json_t::object_t::iterator>::value and
+                    not detail::is_basic_json_nested_class<uncvref_t<T>, basic_json_t, primitive_iterator_t>::value and
+                    not std::is_same<uncvref_t<T>, typename basic_json_t::array_t::iterator>::value and
+                    not std::is_same<uncvref_t<T>, typename basic_json_t::object_t::iterator>::value and
 
-                        detail::conjunction<detail::negation<detail::is_compatible_basic_json_type<
-                            uncvref_t<T>, basic_json_t>>,
-                        detail::has_to_json<JSONSerializer, basic_json,
-                                            uncvref_t<T>>>::value,
-                    int> = 0>
-    basic_json(T &&val)
+                    detail::conjunction<detail::negation<detail::is_compatible_basic_json_type<
+                                            uncvref_t<T>, basic_json_t>>,
+                                        detail::has_to_json<JSONSerializer, basic_json,
+                                                uncvref_t<T>>>::value,
+                                                int> = 0 >
+                    basic_json(T && val)
     {
-      JSONSerializer<uncvref_t<T>>::to_json(*this, std::forward<T>(val));
+        JSONSerializer<uncvref_t<T>>::to_json(*this, std::forward<T>(val));
     }
 
     /*!
@@ -1828,11 +1831,12 @@ class basic_json
         typename CompatibleNumberIntegerType,
         enable_if_t<detail::is_compatible_integer_type<
                         number_integer_t, CompatibleNumberIntegerType>::value,
-                    int> = 0>
+                    int> = 0 >
     basic_json(const CompatibleNumberIntegerType val) noexcept
         : m_type(value_t::number_integer),
-          m_value(static_cast<number_integer_t>(val)) {
-      assert_invariant();
+          m_value(static_cast<number_integer_t>(val))
+    {
+        assert_invariant();
     }
 
     /*!
@@ -1885,11 +1889,12 @@ class basic_json
         typename CompatibleNumberUnsignedType,
         enable_if_t<detail::is_compatible_integer_type<
                         number_unsigned_t, CompatibleNumberUnsignedType>::value,
-                    int> = 0>
+                    int> = 0 >
     basic_json(const CompatibleNumberUnsignedType val) noexcept
         : m_type(value_t::number_unsigned),
-          m_value(static_cast<number_unsigned_t>(val)) {
-      assert_invariant();
+          m_value(static_cast<number_unsigned_t>(val))
+    {
+        assert_invariant();
     }
 
     /*!
@@ -2123,7 +2128,7 @@ class basic_json
     @since version 1.0.0
     */
     static basic_json array(std::initializer_list<basic_json> init =
-                                std::initializer_list<basic_json>())
+                            std::initializer_list<basic_json>())
     {
         return basic_json(init, false, value_t::array);
     }
@@ -2163,7 +2168,7 @@ class basic_json
     @since version 1.0.0
     */
     static basic_json object(std::initializer_list<basic_json> init =
-                                 std::initializer_list<basic_json>())
+                             std::initializer_list<basic_json>())
     {
         return basic_json(init, false, value_t::object);
     }
@@ -2504,7 +2509,7 @@ class basic_json
         std::is_nothrow_move_assignable<value_t>::value and
         std::is_nothrow_move_constructible<json_value>::value and
         std::is_nothrow_move_assignable<json_value>::value
-    )
+                                       )
     {
         // check that passed value is valid
         other.assert_invariant();
@@ -2521,59 +2526,65 @@ class basic_json
     template <typename T, enable_if_t<not detail::is_compatible_basic_json_type<
                                           uncvref_t<T>, basic_json_t>::value and
                                       detail::has_to_json<JSONSerializer, basic_json_t, uncvref_t<T>>::value>>
-    reference &operator=(T &&val) noexcept(std::is_nothrow_constructible<basic_json_t, uncvref_t<T>>::value and
+    reference& operator=(T&& val) noexcept(std::is_nothrow_constructible<basic_json_t, uncvref_t<T>>::value and
                                            std::is_nothrow_move_assignable<uncvref_t<T>>::value)
     {
-      static_assert(sizeof(T) == 0 , "");
-      // I'm not sure this a is good practice...
-      return *this = basic_json_t{std::forward<T>(val)};
+        static_assert(sizeof(T) == 0 , "");
+        // I'm not sure this a is good practice...
+        return *this = basic_json_t{std::forward<T>(val)};
     }
 
-        /*!
-        @brief destructor
+    /*!
+    @brief destructor
 
-        Destroys the JSON value and frees all allocated memory.
+    Destroys the JSON value and frees all allocated memory.
 
-        @complexity Linear.
+    @complexity Linear.
 
-        @requirement This function helps `basic_json` satisfying the
-        [Container](http://en.cppreference.com/w/cpp/concept/Container)
-        requirements:
-        - The complexity is linear.
-        - All stored elements are destroyed and all memory is freed.
+    @requirement This function helps `basic_json` satisfying the
+    [Container](http://en.cppreference.com/w/cpp/concept/Container)
+    requirements:
+    - The complexity is linear.
+    - All stored elements are destroyed and all memory is freed.
 
-        @since version 1.0.0
-        */
-        ~basic_json() {
-      assert_invariant();
+    @since version 1.0.0
+    */
+    ~basic_json()
+    {
+        assert_invariant();
 
-      switch (m_type) {
-      case value_t::object: {
-        AllocatorType<object_t> alloc;
-        alloc.destroy(m_value.object);
-        alloc.deallocate(m_value.object, 1);
-        break;
-      }
+        switch (m_type)
+        {
+            case value_t::object:
+            {
+                AllocatorType<object_t> alloc;
+                alloc.destroy(m_value.object);
+                alloc.deallocate(m_value.object, 1);
+                break;
+            }
 
-      case value_t::array: {
-        AllocatorType<array_t> alloc;
-        alloc.destroy(m_value.array);
-        alloc.deallocate(m_value.array, 1);
-        break;
-      }
+            case value_t::array:
+            {
+                AllocatorType<array_t> alloc;
+                alloc.destroy(m_value.array);
+                alloc.deallocate(m_value.array, 1);
+                break;
+            }
 
-      case value_t::string: {
-        AllocatorType<string_t> alloc;
-        alloc.destroy(m_value.string);
-        alloc.deallocate(m_value.string, 1);
-        break;
-      }
+            case value_t::string:
+            {
+                AllocatorType<string_t> alloc;
+                alloc.destroy(m_value.string);
+                alloc.deallocate(m_value.string, 1);
+                break;
+            }
 
-      default: {
-        // all other types need no specific destructor
-        break;
-      }
-      }
+            default:
+            {
+                // all other types need no specific destructor
+                break;
+            }
+        }
     }
 
     /// @}
@@ -3025,15 +3036,15 @@ class basic_json
     /// get an array (explicit)
     template <
         class T,
-        typename std::enable_if<
+        typename std::enable_if <
             std::is_convertible<basic_json_t, typename T::value_type>::value and
-                not std::is_same<basic_json_t,
-                                 typename T::value_type>::value and
-                not std::is_arithmetic<T>::value and
-                not std::is_convertible<std::string, T>::value and
-                not detail::has_mapped_type<T>::value,
-            int>::type = 0>
-    T get_impl(T *) const
+            not std::is_same<basic_json_t,
+                             typename T::value_type>::value and
+            not std::is_arithmetic<T>::value and
+            not std::is_convertible<std::string, T>::value and
+            not detail::has_mapped_type<T>::value,
+            int >::type = 0 >
+    T get_impl(T*) const
     {
         if (is_array())
         {
@@ -3305,41 +3316,41 @@ class basic_json
     template <typename ValueType,
               enable_if_t<not std::is_pointer<ValueType>::value, int> = 0>
     auto get() const
-        -> decltype(this->get_impl(static_cast<ValueType *>(nullptr)))
+    -> decltype(this->get_impl(static_cast<ValueType*>(nullptr)))
     {
-      return get_impl(static_cast<ValueType *>(nullptr));
+        return get_impl(static_cast<ValueType*>(nullptr));
     }
 
     template <
         typename T,
         enable_if_t<detail::conjunction<detail::negation<detail::is_compatible_basic_json_type<
-                        uncvref_t<T>, basic_json_t>>,
-                        detail::has_from_json<JSONSerializer, basic_json_t,
-                                              uncvref_t<T>>>::value,
-                    int> = 0>
-    auto get() const -> uncvref_t<T>
+                                            uncvref_t<T>, basic_json_t>>,
+                                        detail::has_from_json<JSONSerializer, basic_json_t,
+                                                uncvref_t<T>>>::value,
+                                                int> = 0 >
+                    auto get() const -> uncvref_t<T>
     {
-      using type = uncvref_t<T>;
-      static_assert(std::is_default_constructible<type>::value &&
-                        std::is_copy_constructible<type>::value,
-                    "user-defined types must be DefaultConstructible and "
-                    "CopyConstructible when used with get");
-      type ret;
-      JSONSerializer<type>::from_json(*this, ret);
-      return ret;
+        using type = uncvref_t<T>;
+        static_assert(std::is_default_constructible<type>::value&&
+        std::is_copy_constructible<type>::value,
+        "user-defined types must be DefaultConstructible and "
+        "CopyConstructible when used with get");
+        type ret;
+        JSONSerializer<type>::from_json(*this, ret);
+        return ret;
     }
 
     // This overload is chosen for non-default constructible user-defined-types
     template <
         typename T,
         enable_if_t<detail::conjunction<detail::negation<detail::is_compatible_basic_json_type<
-                        uncvref_t<T>, basic_json_t>>,
-                        detail::has_non_default_from_json<JSONSerializer, basic_json_t,
-                                              uncvref_t<T>>>::value,
-                    short> = 0>
-    T get() const
+                                            uncvref_t<T>, basic_json_t>>,
+                                        detail::has_non_default_from_json<JSONSerializer, basic_json_t,
+                                                uncvref_t<T>>>::value,
+                                                short> = 0 >
+                    T get() const
     {
-      return JSONSerializer<T>::from_json(*this);
+        return JSONSerializer<T>::from_json(*this);
     }
 
     /*!
@@ -3421,8 +3432,8 @@ class basic_json
     {
         // get the type of the PointerType (remove pointer and const)
         using pointee_t = typename std::remove_const<typename
-                          std::remove_pointer<typename
-                          std::remove_const<PointerType>::type>::type>::type;
+                std::remove_pointer<typename
+                                    std::remove_const<PointerType>::type>::type>::type;
         // make sure the type matches the allowed types
         static_assert(
             std::is_same<object_t, pointee_t>::value
@@ -3449,8 +3460,8 @@ class basic_json
     {
         // get the type of the PointerType (remove pointer and const)
         using pointee_t = typename std::remove_const<typename
-                          std::remove_pointer<typename
-                          std::remove_const<PointerType>::type>::type>::type;
+                std::remove_pointer<typename
+                                    std::remove_const<PointerType>::type>::type>::type;
         // make sure the type matches the allowed types
         static_assert(
             std::is_same<object_t, pointee_t>::value
@@ -4503,14 +4514,14 @@ class basic_json
             case value_t::object:
             {
                 result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
-                                              last.m_it.object_iterator);
+                        last.m_it.object_iterator);
                 break;
             }
 
             case value_t::array:
             {
                 result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
-                                             last.m_it.array_iterator);
+                        last.m_it.array_iterator);
                 break;
             }
 
@@ -5727,9 +5738,9 @@ class basic_json
         // insert to array and return iterator
         iterator result(this);
         result.m_it.array_iterator = m_value.array->insert(
-                                         pos.m_it.array_iterator,
-                                         first.m_it.array_iterator,
-                                         last.m_it.array_iterator);
+            pos.m_it.array_iterator,
+            first.m_it.array_iterator,
+            last.m_it.array_iterator);
         return result;
     }
 
@@ -5799,7 +5810,7 @@ class basic_json
         std::is_nothrow_move_assignable<value_t>::value and
         std::is_nothrow_move_constructible<json_value>::value and
         std::is_nothrow_move_assignable<json_value>::value
-    )
+                                       )
     {
         std::swap(m_type, other.m_type);
         std::swap(m_value, other.m_value);
@@ -8399,13 +8410,13 @@ class basic_json
                         o << (pretty_print ? ",\n" : ",");
                     }
                     o << string_t(new_indent, ' ') << "\""
-                      << escape_string(i->first) << "\":"
-                      << (pretty_print ? " " : "");
-                    i->second.dump(o, pretty_print, indent_step, new_indent);
+                                                    << escape_string(i->first) << "\":"
+                                                            << (pretty_print ? " " : "");
+                                                            i->second.dump(o, pretty_print, indent_step, new_indent);
                 }
 
-                // decrease indentation
-                if (pretty_print)
+                                                        // decrease indentation
+                                                        if (pretty_print)
                 {
                     new_indent -= indent_step;
                     o << "\n";
@@ -8450,16 +8461,16 @@ class basic_json
                 }
 
                 o << string_t(new_indent, ' ') << "]";
-                return;
+                   return;
             }
 
-            case value_t::string:
+               case value_t::string:
             {
                 o << string_t("\"") << escape_string(*m_value.string) << "\"";
-                return;
+                                     return;
             }
 
-            case value_t::boolean:
+                                 case value_t::boolean:
             {
                 o << (m_value.boolean ? "true" : "false");
                 return;
@@ -8533,126 +8544,126 @@ class basic_json
     */
     class primitive_iterator_t
     {
-      public:
+        public:
 
         difference_type get_value() const noexcept
-        {
-          return m_it;
-        }
-        /// set iterator to a defined beginning
-        void set_begin() noexcept
-        {
-            m_it = begin_value;
-        }
+    {
+        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;
-        }
+    /// 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 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);
-        }
+    /// 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;
+    }
 
-        friend constexpr bool operator!=(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
-        {
-          return !(lhs == rhs);
-        }
+    friend constexpr bool operator!=(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return !(lhs == rhs);
+    }
 
-        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;
+    }
 
-        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;
+    }
 
-        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;
+    }
 
-        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 i)
-        {
-            auto result = *this;
-            result += i;
-            return result;
-        }
+    primitive_iterator_t operator+(difference_type i)
+    {
+        auto result = *this;
+        result += i;
+        return result;
+    }
 
-        friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
-        {
-          return lhs.m_it - rhs.m_it;
-        }
+    friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it - rhs.m_it;
+    }
 
-        friend std::ostream& operator<<(std::ostream& os, primitive_iterator_t it)
-        {
-          return os << it.m_it;
-        }
+    friend std::ostream& operator<<(std::ostream& os, primitive_iterator_t it)
+    {
+        return os << it.m_it;
+    }
 
-        primitive_iterator_t& operator++()
-        {
-          ++m_it;
-          return *this;
-        }
+    primitive_iterator_t& operator++()
+    {
+        ++m_it;
+        return *this;
+    }
 
-        primitive_iterator_t& operator++(int)
-        {
-          m_it++;
-          return *this;
-        }
+    primitive_iterator_t& operator++(int)
+    {
+        m_it++;
+        return *this;
+    }
 
-        primitive_iterator_t& operator--()
-        {
-          --m_it;
-          return *this;
-        }
+    primitive_iterator_t& operator--()
+    {
+        --m_it;
+        return *this;
+    }
 
-        primitive_iterator_t& operator--(int)
-        {
-          m_it--;
-          return *this;
-        }
+    primitive_iterator_t& operator--(int)
+    {
+        m_it--;
+        return *this;
+    }
 
-        primitive_iterator_t& operator+=(difference_type n)
-        {
-          m_it += n;
-          return *this;
-        }
+    primitive_iterator_t& operator+=(difference_type n)
+    {
+        m_it += n;
+        return *this;
+    }
 
-        primitive_iterator_t& operator-=(difference_type n)
-        {
-          m_it -= n;
-          return *this;
-        }
+    primitive_iterator_t& operator-=(difference_type n)
+    {
+        m_it -= n;
+        return *this;
+    }
 
-      private:
-        static constexpr difference_type begin_value = 0;
-        static constexpr difference_type end_value = begin_value + 1;
+    private:
+    static constexpr difference_type begin_value = 0;
+    static constexpr difference_type end_value = begin_value + 1;
 
-        /// iterator as signed integer type
-        difference_type m_it = std::numeric_limits<std::ptrdiff_t>::denorm_min();
-    };
+    /// iterator as signed integer type
+    difference_type m_it = std::numeric_limits<std::ptrdiff_t>::denorm_min();
+                                              };
 
     /*!
     @brief an iterator value
@@ -8672,104 +8683,104 @@ class basic_json
 
         /// create an uninitialized internal_iterator
         internal_iterator() noexcept
-            : object_iterator(), array_iterator(), primitive_iterator()
-        {}
+        : object_iterator(), array_iterator(), primitive_iterator()
+    {}
     };
 
     /// proxy class for the iterator_wrapper functions
     template<typename IteratorType>
     class iteration_proxy
     {
-      private:
+        private:
         /// helper class for iteration
         class iteration_proxy_internal
         {
-          private:
+            private:
             /// the iterator
             IteratorType anchor;
             /// an index for arrays (used to create key names)
             size_t array_index = 0;
 
-          public:
+            public:
             explicit iteration_proxy_internal(IteratorType it) noexcept
-                : anchor(it)
-            {}
+            : anchor(it)
+    {}
 
-            /// dereference operator (needed for range-based for)
-            iteration_proxy_internal& operator*()
+    /// dereference operator (needed for range-based for)
+    iteration_proxy_internal& operator*()
+    {
+        return *this;
+    }
+
+    /// increment operator (needed for range-based for)
+    iteration_proxy_internal& operator++()
+    {
+        ++anchor;
+        ++array_index;
+
+        return *this;
+    }
+
+    /// inequality operator (needed for range-based for)
+    bool operator!= (const iteration_proxy_internal& o) const
+    {
+        return anchor != o.anchor;
+    }
+
+    /// return key of the iterator
+    typename basic_json::string_t key() const
+    {
+        assert(anchor.m_object != nullptr);
+
+        switch (anchor.m_object->type())
+        {
+            // use integer array index as key
+            case value_t::array:
             {
-                return *this;
+                return std::to_string(array_index);
             }
 
-            /// increment operator (needed for range-based for)
-            iteration_proxy_internal& operator++()
+            // use key from the object
+            case value_t::object:
             {
-                ++anchor;
-                ++array_index;
-
-                return *this;
+                return anchor.key();
             }
 
-            /// inequality operator (needed for range-based for)
-            bool operator!= (const iteration_proxy_internal& o) const
+            // use an empty key for all primitive types
+            default:
             {
-                return anchor != o.anchor;
+                return "";
             }
+        }
+    }
 
-            /// return key of the iterator
-            typename basic_json::string_t key() const
-            {
-                assert(anchor.m_object != nullptr);
-
-                switch (anchor.m_object->type())
-                {
-                    // use integer array index as key
-                    case value_t::array:
-                    {
-                        return std::to_string(array_index);
-                    }
-
-                    // use key from the object
-                    case value_t::object:
-                    {
-                        return anchor.key();
-                    }
-
-                    // use an empty key for all primitive types
-                    default:
-                    {
-                        return "";
-                    }
-                }
-            }
-
-            /// return value of the iterator
-            typename IteratorType::reference value() const
-            {
-                return anchor.value();
-            }
+    /// return value of the iterator
+    typename IteratorType::reference value() const
+    {
+        return anchor.value();
+    }
         };
 
-        /// the container to iterate
-        typename IteratorType::reference container;
+    /// the container to iterate
+    typename IteratorType::reference container;
 
-      public:
-        /// construct iteration proxy from a container
-        explicit iteration_proxy(typename IteratorType::reference cont)
-            : container(cont)
-        {}
+    public:
+    /// construct iteration proxy from a container
+    explicit iteration_proxy(typename IteratorType::reference cont)
+    : container(cont)
+    {}
 
-        /// return iterator begin (needed for range-based for)
-        iteration_proxy_internal begin() noexcept
-        {
-            return iteration_proxy_internal(container.begin());
-        }
+    /// return iterator begin (needed for range-based for)
+    iteration_proxy_internal begin() noexcept
+    {
+        return iteration_proxy_internal(container.begin());
+    }
 
-        /// return iterator end (needed for range-based for)
-        iteration_proxy_internal end() noexcept
-        {
-            return iteration_proxy_internal(container.end());
-        }
+    /// return iterator end (needed for range-based for)
+    iteration_proxy_internal end() noexcept
+    {
+        return iteration_proxy_internal(container.end());
+    }
     };
 
   public:
@@ -8793,7 +8804,7 @@ class basic_json
     @since version 1.0.0, simplified in version 2.0.9
     */
     template<typename U>
-    class iter_impl : public std::iterator<std::random_access_iterator_tag, U>
+  class iter_impl : public std::iterator<std::random_access_iterator_tag, U>
     {
         /// allow basic_json to access private members
         friend class basic_json;
@@ -8803,19 +8814,19 @@ class basic_json
                       or std::is_same<U, const basic_json>::value,
                       "iter_impl only accepts (const) basic_json");
 
-      public:
+        public:
         /// the type of the values when the iterator is dereferenced
         using value_type = typename basic_json::value_type;
         /// a type to represent differences between iterators
         using difference_type = typename basic_json::difference_type;
         /// defines a pointer to the type iterated over (value_type)
         using pointer = typename std::conditional<std::is_const<U>::value,
-              typename basic_json::const_pointer,
-              typename basic_json::pointer>::type;
+                typename basic_json::const_pointer,
+                typename basic_json::pointer>::type;
         /// defines a reference to the type iterated over (value_type)
         using reference = typename std::conditional<std::is_const<U>::value,
-              typename basic_json::const_reference,
-              typename basic_json::reference>::type;
+                typename basic_json::const_reference,
+                typename basic_json::reference>::type;
         /// the category of the iterator
         using iterator_category = std::bidirectional_iterator_tag;
 
@@ -8829,566 +8840,566 @@ class basic_json
         @post The iterator is initialized; i.e. `m_object != nullptr`.
         */
         explicit iter_impl(pointer object) noexcept
-            : m_object(object)
+        : m_object(object)
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
         {
-            assert(m_object != nullptr);
-
-            switch (m_object->m_type)
+            case basic_json::value_t::object:
             {
-                case basic_json::value_t::object:
-                {
-                    m_it.object_iterator = typename object_t::iterator();
-                    break;
-                }
-
-                case basic_json::value_t::array:
-                {
-                    m_it.array_iterator = typename array_t::iterator();
-                    break;
-                }
-
-                default:
-                {
-                    m_it.primitive_iterator = primitive_iterator_t();
-                    break;
-                }
-            }
-        }
-
-        /*
-        Use operator `const_iterator` instead of `const_iterator(const iterator&
-        other) noexcept` to avoid two class definitions for @ref iterator and
-        @ref const_iterator.
-
-        This function is only called if this class is an @ref iterator. If this
-        class is a @ref const_iterator this function is not called.
-        */
-        operator const_iterator() const
-        {
-            const_iterator ret;
-
-            if (m_object)
-            {
-                ret.m_object = m_object;
-                ret.m_it = m_it;
+                m_it.object_iterator = typename object_t::iterator();
+                break;
             }
 
-            return ret;
-        }
-
-        /*!
-        @brief copy constructor
-        @param[in] other  iterator to copy from
-        @note It is not checked whether @a other is initialized.
-        */
-        iter_impl(const iter_impl& other) noexcept
-            : m_object(other.m_object), m_it(other.m_it)
-        {}
-
-        /*!
-        @brief copy assignment
-        @param[in,out] other  iterator to copy from
-        @note It is not checked whether @a other is initialized.
-        */
-        iter_impl& operator=(iter_impl other) noexcept(
-            std::is_nothrow_move_constructible<pointer>::value and
-            std::is_nothrow_move_assignable<pointer>::value and
-            std::is_nothrow_move_constructible<internal_iterator>::value and
-            std::is_nothrow_move_assignable<internal_iterator>::value
-        )
-        {
-            std::swap(m_object, other.m_object);
-            std::swap(m_it, other.m_it);
-            return *this;
-        }
-
-      private:
-        /*!
-        @brief set the iterator to the first value
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        void set_begin() noexcept
-        {
-            assert(m_object != nullptr);
-
-            switch (m_object->m_type)
+            case basic_json::value_t::array:
             {
-                case basic_json::value_t::object:
-                {
-                    m_it.object_iterator = m_object->m_value.object->begin();
-                    break;
-                }
+                m_it.array_iterator = typename array_t::iterator();
+                break;
+            }
 
-                case basic_json::value_t::array:
-                {
-                    m_it.array_iterator = m_object->m_value.array->begin();
-                    break;
-                }
-
-                case basic_json::value_t::null:
-                {
-                    // set to end so begin()==end() is true: null is empty
-                    m_it.primitive_iterator.set_end();
-                    break;
-                }
-
-                default:
-                {
-                    m_it.primitive_iterator.set_begin();
-                    break;
-                }
+            default:
+            {
+                m_it.primitive_iterator = primitive_iterator_t();
+                break;
             }
         }
+    }
 
-        /*!
-        @brief set the iterator past the last value
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        void set_end() noexcept
+    /*
+    Use operator `const_iterator` instead of `const_iterator(const iterator&
+    other) noexcept` to avoid two class definitions for @ref iterator and
+    @ref const_iterator.
+
+    This function is only called if this class is an @ref iterator. If this
+    class is a @ref const_iterator this function is not called.
+    */
+    operator const_iterator() const
+    {
+        const_iterator ret;
+
+        if (m_object)
         {
-            assert(m_object != nullptr);
-
-            switch (m_object->m_type)
-            {
-                case basic_json::value_t::object:
-                {
-                    m_it.object_iterator = m_object->m_value.object->end();
-                    break;
-                }
-
-                case basic_json::value_t::array:
-                {
-                    m_it.array_iterator = m_object->m_value.array->end();
-                    break;
-                }
-
-                default:
-                {
-                    m_it.primitive_iterator.set_end();
-                    break;
-                }
-            }
+            ret.m_object = m_object;
+            ret.m_it = m_it;
         }
 
-      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
+        return ret;
+    }
+
+    /*!
+    @brief copy constructor
+    @param[in] other  iterator to copy from
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl(const iter_impl& other) noexcept
+    : m_object(other.m_object), m_it(other.m_it)
+    {}
+
+    /*!
+    @brief copy assignment
+    @param[in,out] other  iterator to copy from
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(iter_impl other) noexcept(
+        std::is_nothrow_move_constructible<pointer>::value and
+        std::is_nothrow_move_assignable<pointer>::value and
+        std::is_nothrow_move_constructible<internal_iterator>::value and
+        std::is_nothrow_move_assignable<internal_iterator>::value
+                                       )
+    {
+        std::swap(m_object, other.m_object);
+        std::swap(m_it, other.m_it);
+        return *this;
+    }
+
+    private:
+    /*!
+    @brief set the iterator to the first value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_begin() noexcept
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
         {
-            assert(m_object != nullptr);
-
-            switch (m_object->m_type)
+            case basic_json::value_t::object:
             {
-                case basic_json::value_t::object:
-                {
-                    assert(m_it.object_iterator != m_object->m_value.object->end());
-                    return m_it.object_iterator->second;
-                }
+                m_it.object_iterator = m_object->m_value.object->begin();
+                break;
+            }
 
-                case basic_json::value_t::array:
-                {
-                    assert(m_it.array_iterator != m_object->m_value.array->end());
-                    return *m_it.array_iterator;
-                }
+            case basic_json::value_t::array:
+            {
+                m_it.array_iterator = m_object->m_value.array->begin();
+                break;
+            }
 
-                case basic_json::value_t::null:
-                {
+            case basic_json::value_t::null:
+            {
+                // set to end so begin()==end() is true: null is empty
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+
+            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
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case basic_json::value_t::object:
+            {
+                m_it.object_iterator = m_object->m_value.object->end();
+                break;
+            }
+
+            case basic_json::value_t::array:
+            {
+                m_it.array_iterator = m_object->m_value.array->end();
+                break;
+            }
+
+            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
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case basic_json::value_t::object:
+            {
+                assert(m_it.object_iterator != m_object->m_value.object->end());
+                return m_it.object_iterator->second;
+            }
+
+            case basic_json::value_t::array:
+            {
+                assert(m_it.array_iterator != m_object->m_value.array->end());
+                return *m_it.array_iterator;
+            }
+
+            case basic_json::value_t::null:
+            {
                     JSON_THROW(std::out_of_range("cannot get value"));
-                }
+            }
 
-                default:
+            default:
+            {
+                if (m_it.primitive_iterator.is_begin())
                 {
-                    if (m_it.primitive_iterator.is_begin())
-                    {
-                        return *m_object;
-                    }
+                    return *m_object;
+                }
 
                     JSON_THROW(std::out_of_range("cannot get value"));
-                }
             }
         }
+    }
 
-        /*!
-        @brief dereference the iterator
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        pointer operator->() const
+    /*!
+    @brief dereference the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    pointer operator->() const
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
         {
-            assert(m_object != nullptr);
-
-            switch (m_object->m_type)
+            case basic_json::value_t::object:
             {
-                case basic_json::value_t::object:
-                {
-                    assert(m_it.object_iterator != m_object->m_value.object->end());
-                    return &(m_it.object_iterator->second);
-                }
+                assert(m_it.object_iterator != m_object->m_value.object->end());
+                return &(m_it.object_iterator->second);
+            }
 
-                case basic_json::value_t::array:
-                {
-                    assert(m_it.array_iterator != m_object->m_value.array->end());
-                    return &*m_it.array_iterator;
-                }
+            case basic_json::value_t::array:
+            {
+                assert(m_it.array_iterator != m_object->m_value.array->end());
+                return &*m_it.array_iterator;
+            }
 
-                default:
+            default:
+            {
+                if (m_it.primitive_iterator.is_begin())
                 {
-                    if (m_it.primitive_iterator.is_begin())
-                    {
-                        return m_object;
-                    }
+                    return m_object;
+                }
 
                     JSON_THROW(std::out_of_range("cannot get value"));
-                }
+            }
+        }
+    }
+
+    /*!
+    @brief post-increment (it++)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator++(int)
+    {
+        auto result = *this;
+        ++(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-increment (++it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator++()
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case basic_json::value_t::object:
+            {
+                std::advance(m_it.object_iterator, 1);
+                break;
+            }
+
+            case basic_json::value_t::array:
+            {
+                std::advance(m_it.array_iterator, 1);
+                break;
+            }
+
+            default:
+            {
+                ++m_it.primitive_iterator;
+                break;
             }
         }
 
-        /*!
-        @brief post-increment (it++)
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        iter_impl operator++(int)
-        {
-            auto result = *this;
-            ++(*this);
-            return result;
-        }
+        return *this;
+    }
 
-        /*!
-        @brief pre-increment (++it)
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        iter_impl& operator++()
-        {
-            assert(m_object != nullptr);
+    /*!
+    @brief post-decrement (it--)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator--(int)
+    {
+        auto result = *this;
+        --(*this);
+        return result;
+    }
 
-            switch (m_object->m_type)
+    /*!
+    @brief pre-decrement (--it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator--()
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case basic_json::value_t::object:
             {
-                case basic_json::value_t::object:
-                {
-                    std::advance(m_it.object_iterator, 1);
-                    break;
-                }
-
-                case basic_json::value_t::array:
-                {
-                    std::advance(m_it.array_iterator, 1);
-                    break;
-                }
-
-                default:
-                {
-                    ++m_it.primitive_iterator;
-                    break;
-                }
+                std::advance(m_it.object_iterator, -1);
+                break;
             }
 
-            return *this;
-        }
-
-        /*!
-        @brief post-decrement (it--)
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        iter_impl operator--(int)
-        {
-            auto result = *this;
-            --(*this);
-            return result;
-        }
-
-        /*!
-        @brief pre-decrement (--it)
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        iter_impl& operator--()
-        {
-            assert(m_object != nullptr);
-
-            switch (m_object->m_type)
+            case basic_json::value_t::array:
             {
-                case basic_json::value_t::object:
-                {
-                    std::advance(m_it.object_iterator, -1);
-                    break;
-                }
-
-                case basic_json::value_t::array:
-                {
-                    std::advance(m_it.array_iterator, -1);
-                    break;
-                }
-
-                default:
-                {
-                    --m_it.primitive_iterator;
-                    break;
-                }
+                std::advance(m_it.array_iterator, -1);
+                break;
             }
 
-            return *this;
+            default:
+            {
+                --m_it.primitive_iterator;
+                break;
+            }
         }
 
-        /*!
-        @brief  comparison: equal
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        bool operator==(const iter_impl& other) const
+        return *this;
+    }
+
+    /*!
+    @brief  comparison: equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator==(const iter_impl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (m_object != other.m_object)
         {
-            // if objects are not the same, the comparison is undefined
-            if (m_object != other.m_object)
-            {
                 JSON_THROW(std::domain_error("cannot compare iterators of different containers"));
-            }
-
-            assert(m_object != nullptr);
-
-            switch (m_object->m_type)
-            {
-                case basic_json::value_t::object:
-                {
-                    return (m_it.object_iterator == other.m_it.object_iterator);
-                }
-
-                case basic_json::value_t::array:
-                {
-                    return (m_it.array_iterator == other.m_it.array_iterator);
-                }
-
-                default:
-                {
-                    return (m_it.primitive_iterator == other.m_it.primitive_iterator);
-                }
-            }
         }
 
-        /*!
-        @brief  comparison: not equal
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        bool operator!=(const iter_impl& other) const
-        {
-            return not operator==(other);
-        }
+        assert(m_object != nullptr);
 
-        /*!
-        @brief  comparison: smaller
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        bool operator<(const iter_impl& other) const
+        switch (m_object->m_type)
         {
-            // if objects are not the same, the comparison is undefined
-            if (m_object != other.m_object)
+            case basic_json::value_t::object:
             {
+                return (m_it.object_iterator == other.m_it.object_iterator);
+            }
+
+            case basic_json::value_t::array:
+            {
+                return (m_it.array_iterator == other.m_it.array_iterator);
+            }
+
+            default:
+            {
+                return (m_it.primitive_iterator == other.m_it.primitive_iterator);
+            }
+        }
+    }
+
+    /*!
+    @brief  comparison: not equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator!=(const iter_impl& other) const
+    {
+        return not operator==(other);
+    }
+
+    /*!
+    @brief  comparison: smaller
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<(const iter_impl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (m_object != other.m_object)
+        {
                 JSON_THROW(std::domain_error("cannot compare iterators of different containers"));
-            }
+        }
 
-            assert(m_object != nullptr);
+        assert(m_object != nullptr);
 
-            switch (m_object->m_type)
+        switch (m_object->m_type)
+        {
+            case basic_json::value_t::object:
             {
-                case basic_json::value_t::object:
-                {
                     JSON_THROW(std::domain_error("cannot compare order of object iterators"));
-                }
+            }
 
-                case basic_json::value_t::array:
-                {
-                    return (m_it.array_iterator < other.m_it.array_iterator);
-                }
+            case basic_json::value_t::array:
+            {
+                return (m_it.array_iterator < other.m_it.array_iterator);
+            }
 
-                default:
-                {
-                    return (m_it.primitive_iterator < other.m_it.primitive_iterator);
-                }
+            default:
+            {
+                return (m_it.primitive_iterator < other.m_it.primitive_iterator);
             }
         }
+    }
 
-        /*!
-        @brief  comparison: less than or equal
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        bool operator<=(const iter_impl& other) const
+    /*!
+    @brief  comparison: less than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<=(const iter_impl& other) const
+    {
+        return not other.operator < (*this);
+    }
+
+    /*!
+    @brief  comparison: greater than
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>(const iter_impl& other) const
+    {
+        return not operator<=(other);
+    }
+
+    /*!
+    @brief  comparison: greater than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>=(const iter_impl& other) const
+    {
+        return not operator<(other);
+    }
+
+    /*!
+    @brief  add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator+=(difference_type i)
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
         {
-            return not other.operator < (*this);
-        }
-
-        /*!
-        @brief  comparison: greater than
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        bool operator>(const iter_impl& other) const
-        {
-            return not operator<=(other);
-        }
-
-        /*!
-        @brief  comparison: greater than or equal
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        bool operator>=(const iter_impl& other) const
-        {
-            return not operator<(other);
-        }
-
-        /*!
-        @brief  add to iterator
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        iter_impl& operator+=(difference_type i)
-        {
-            assert(m_object != nullptr);
-
-            switch (m_object->m_type)
+            case basic_json::value_t::object:
             {
-                case basic_json::value_t::object:
-                {
                     JSON_THROW(std::domain_error("cannot use offsets with object iterators"));
-                }
-
-                case basic_json::value_t::array:
-                {
-                    std::advance(m_it.array_iterator, i);
-                    break;
-                }
-
-                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)
-        {
-            auto result = *this;
-            result += i;
-            return result;
-        }
-
-        /*!
-        @brief  subtract from iterator
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        iter_impl operator-(difference_type i)
-        {
-            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
-        {
-            assert(m_object != nullptr);
-
-            switch (m_object->m_type)
+            case basic_json::value_t::array:
+            {
+                std::advance(m_it.array_iterator, i);
+                break;
+            }
+
+            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)
+    {
+        auto result = *this;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief  subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator-(difference_type i)
+    {
+        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
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case basic_json::value_t::object:
             {
-                case basic_json::value_t::object:
-                {
                     JSON_THROW(std::domain_error("cannot use offsets with object iterators"));
-                }
+            }
 
-                case basic_json::value_t::array:
-                {
-                    return m_it.array_iterator - other.m_it.array_iterator;
-                }
+            case basic_json::value_t::array:
+            {
+                return m_it.array_iterator - other.m_it.array_iterator;
+            }
 
-                default:
-                {
-                    return m_it.primitive_iterator - other.m_it.primitive_iterator;
-                }
+            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
+    /*!
+    @brief  access to successor
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator[](difference_type n) const
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
         {
-            assert(m_object != nullptr);
-
-            switch (m_object->m_type)
+            case basic_json::value_t::object:
             {
-                case basic_json::value_t::object:
-                {
                     JSON_THROW(std::domain_error("cannot use operator[] for object iterators"));
-                }
+            }
 
-                case basic_json::value_t::array:
-                {
-                    return *std::next(m_it.array_iterator, n);
-                }
+            case basic_json::value_t::array:
+            {
+                return *std::next(m_it.array_iterator, n);
+            }
 
-                case basic_json::value_t::null:
-                {
+            case basic_json::value_t::null:
+            {
                     JSON_THROW(std::out_of_range("cannot get value"));
-                }
+            }
 
-                default:
+            default:
+            {
+                if (m_it.primitive_iterator.get_value() == -n)
                 {
-                    if (m_it.primitive_iterator.get_value() == -n)
-                    {
-                        return *m_object;
-                    }
+                    return *m_object;
+                }
 
                     JSON_THROW(std::out_of_range("cannot get value"));
-                }
             }
         }
+    }
 
-        /*!
-        @brief  return the key of an object iterator
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        typename object_t::key_type key() const
+    /*!
+    @brief  return the key of an object iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    typename object_t::key_type key() const
+    {
+        assert(m_object != nullptr);
+
+        if (m_object->is_object())
         {
-            assert(m_object != nullptr);
-
-            if (m_object->is_object())
-            {
-                return m_it.object_iterator->first;
-            }
+            return m_it.object_iterator->first;
+        }
 
             JSON_THROW(std::domain_error("cannot use key() for non-object iterators"));
-        }
+    }
 
-        /*!
-        @brief  return the value of an iterator
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        reference value() const
-        {
-            return operator*();
-        }
+    /*!
+    @brief  return the value of an iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference value() const
+    {
+        return operator*();
+    }
 
-      private:
-        /// associated JSON instance
-        pointer m_object = nullptr;
-        /// the actual iterator of the associated instance
-        internal_iterator m_it = internal_iterator();
-    };
+    private:
+    /// associated JSON instance
+    pointer m_object = nullptr;
+    /// the actual iterator of the associated instance
+    internal_iterator m_it = internal_iterator();
+                       };
 
     /*!
     @brief a template for a reverse iterator class
@@ -9408,9 +9419,9 @@ class basic_json
     @since version 1.0.0
     */
     template<typename Base>
-    class json_reverse_iterator : public std::reverse_iterator<Base>
+  class json_reverse_iterator : public std::reverse_iterator<Base>
     {
-      public:
+        public:
         /// shortcut to the reverse iterator adaptor
         using base_iterator = std::reverse_iterator<Base>;
         /// the reference type for the pointed-to element
@@ -9418,89 +9429,89 @@ class basic_json
 
         /// create reverse iterator from iterator
         json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
-            : base_iterator(it)
-        {}
+        : base_iterator(it)
+    {}
 
-        /// create reverse iterator from base class
-        json_reverse_iterator(const base_iterator& it) noexcept
-            : base_iterator(it)
-        {}
+    /// create reverse iterator from base class
+    json_reverse_iterator(const base_iterator& it) noexcept
+    : base_iterator(it)
+    {}
 
-        /// post-increment (it++)
-        json_reverse_iterator operator++(int)
-        {
-            return base_iterator::operator++(1);
-        }
+    /// post-increment (it++)
+    json_reverse_iterator operator++(int)
+    {
+        return base_iterator::operator++(1);
+    }
 
-        /// pre-increment (++it)
-        json_reverse_iterator& operator++()
-        {
-            base_iterator::operator++();
-            return *this;
-        }
+    /// pre-increment (++it)
+    json_reverse_iterator& operator++()
+    {
+        base_iterator::operator++();
+        return *this;
+    }
 
-        /// post-decrement (it--)
-        json_reverse_iterator operator--(int)
-        {
-            return base_iterator::operator--(1);
-        }
+    /// post-decrement (it--)
+    json_reverse_iterator operator--(int)
+    {
+        return base_iterator::operator--(1);
+    }
 
-        /// pre-decrement (--it)
-        json_reverse_iterator& operator--()
-        {
-            base_iterator::operator--();
-            return *this;
-        }
+    /// pre-decrement (--it)
+    json_reverse_iterator& operator--()
+    {
+        base_iterator::operator--();
+        return *this;
+    }
 
-        /// add to iterator
-        json_reverse_iterator& operator+=(difference_type i)
-        {
-            base_iterator::operator+=(i);
-            return *this;
-        }
+    /// add to iterator
+    json_reverse_iterator& operator+=(difference_type i)
+    {
+        base_iterator::operator+=(i);
+        return *this;
+    }
 
-        /// add to iterator
-        json_reverse_iterator operator+(difference_type i) const
-        {
-            auto result = *this;
-            result += i;
-            return result;
-        }
+    /// add to iterator
+    json_reverse_iterator operator+(difference_type i) const
+    {
+        auto result = *this;
+        result += i;
+        return result;
+    }
 
-        /// subtract from iterator
-        json_reverse_iterator operator-(difference_type i) const
-        {
-            auto result = *this;
-            result -= i;
-            return result;
-        }
+    /// subtract from iterator
+    json_reverse_iterator operator-(difference_type i) const
+    {
+        auto result = *this;
+        result -= i;
+        return result;
+    }
 
-        /// return difference
-        difference_type operator-(const json_reverse_iterator& other) const
-        {
-            return this->base() - other.base();
-        }
+    /// return difference
+    difference_type operator-(const json_reverse_iterator& other) const
+    {
+        return this->base() - other.base();
+    }
 
-        /// access to successor
-        reference operator[](difference_type n) const
-        {
-            return *(this->operator+(n));
-        }
+    /// access to successor
+    reference operator[](difference_type n) const
+    {
+        return *(this->operator+(n));
+    }
 
-        /// return the key of an object iterator
-        typename object_t::key_type key() const
-        {
-            auto it = --this->base();
-            return it.key();
-        }
+    /// return the key of an object iterator
+    typename object_t::key_type key() const
+    {
+        auto it = --this->base();
+        return it.key();
+    }
 
-        /// return the value of an iterator
-        reference value() const
-        {
-            auto it = --this->base();
-            return it.operator * ();
-        }
-    };
+    /// return the value of an iterator
+    reference value() const
+    {
+        auto it = --this->base();
+        return it.operator * ();
+    }
+                                                   };
 
 
   private:
@@ -9517,656 +9528,666 @@ class basic_json
     */
     class lexer
     {
-      public:
+        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_number,    ///< a number -- use get_number() 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
-        };
+    {
+        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_number,    ///< a number -- use get_number() 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
+    };
 
-        /// the char type to use in the lexer
-        using lexer_char_t = unsigned char;
+    /// the char type to use in the lexer
+    using lexer_char_t = unsigned char;
 
-        /// a lexer from a buffer with given length
-        lexer(const lexer_char_t* buff, const size_t len) noexcept
-            : m_content(buff)
-        {
-            assert(m_content != nullptr);
-            m_start = m_cursor = m_content;
-            m_limit = m_content + len;
-        }
+    /// a lexer from a buffer with given length
+    lexer(const lexer_char_t* buff, const size_t len) noexcept
+    : m_content(buff)
+    {
+        assert(m_content != nullptr);
+        m_start = m_cursor = m_content;
+        m_limit = m_content + len;
+    }
 
-        /// a lexer from an input stream
-        explicit lexer(std::istream& s)
-            : m_stream(&s), m_line_buffer()
+    /// a lexer from an input stream
+    explicit lexer(std::istream& s)
+    : m_stream(&s), m_line_buffer()
+    {
+        // immediately abort if stream is erroneous
+        if (s.fail())
         {
-            // immediately abort if stream is erroneous
-            if (s.fail())
-            {
                 JSON_THROW(std::invalid_argument("stream error"));
-            }
-
-            // fill buffer
-            fill_line_buffer();
-
-            // skip UTF-8 byte-order mark
-            if (m_line_buffer.size() >= 3 and m_line_buffer.substr(0, 3) == "\xEF\xBB\xBF")
-            {
-                m_line_buffer[0] = ' ';
-                m_line_buffer[1] = ' ';
-                m_line_buffer[2] = ' ';
-            }
         }
 
-        // switch off unwanted functions (due to pointer members)
-        lexer() = delete;
-        lexer(const lexer&) = delete;
-        lexer operator=(const lexer&) = delete;
+        // fill buffer
+        fill_line_buffer();
 
-        /*!
-        @brief create a string from one or two Unicode code points
-
-        There are two cases: (1) @a codepoint1 is in the Basic Multilingual
-        Plane (U+0000 through U+FFFF) and @a codepoint2 is 0, or (2)
-        @a codepoint1 and @a codepoint2 are a UTF-16 surrogate pair to
-        represent a code point above U+FFFF.
-
-        @param[in] codepoint1  the code point (can be high surrogate)
-        @param[in] codepoint2  the code point (can be low surrogate or 0)
-
-        @return string representation of the code point; the length of the
-        result string is between 1 and 4 characters.
-
-        @throw std::out_of_range if code point is > 0x10ffff; example: `"code
-        points above 0x10FFFF are invalid"`
-        @throw std::invalid_argument if the low surrogate is invalid; example:
-        `""missing or wrong low surrogate""`
-
-        @complexity Constant.
-
-        @see <http://en.wikipedia.org/wiki/UTF-8#Sample_code>
-        */
-        static string_t to_unicode(const std::size_t codepoint1,
-                                   const std::size_t codepoint2 = 0)
+        // skip UTF-8 byte-order mark
+        if (m_line_buffer.size() >= 3 and m_line_buffer.substr(0, 3) == "\xEF\xBB\xBF")
         {
-            // calculate the code point from the given code points
-            std::size_t codepoint = codepoint1;
+            m_line_buffer[0] = ' ';
+            m_line_buffer[1] = ' ';
+            m_line_buffer[2] = ' ';
+        }
+    }
 
-            // check if codepoint1 is a high surrogate
-            if (codepoint1 >= 0xD800 and codepoint1 <= 0xDBFF)
-            {
-                // check if codepoint2 is a low surrogate
-                if (codepoint2 >= 0xDC00 and codepoint2 <= 0xDFFF)
-                {
-                    codepoint =
-                        // high surrogate occupies the most significant 22 bits
-                        (codepoint1 << 10)
-                        // low surrogate occupies the least significant 15 bits
-                        + codepoint2
-                        // there is still the 0xD800, 0xDC00 and 0x10000 noise
-                        // in the result so we have to subtract with:
-                        // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
-                        - 0x35FDC00;
-                }
-                else
-                {
-                    JSON_THROW(std::invalid_argument("missing or wrong low surrogate"));
-                }
-            }
+    // switch off unwanted functions (due to pointer members)
+    lexer() = delete;
+    lexer(const lexer&) = delete;
+    lexer operator=(const lexer&) = delete;
 
-            string_t result;
+    /*!
+    @brief create a string from one or two Unicode code points
 
-            if (codepoint < 0x80)
+    There are two cases: (1) @a codepoint1 is in the Basic Multilingual
+    Plane (U+0000 through U+FFFF) and @a codepoint2 is 0, or (2)
+    @a codepoint1 and @a codepoint2 are a UTF-16 surrogate pair to
+    represent a code point above U+FFFF.
+
+    @param[in] codepoint1  the code point (can be high surrogate)
+    @param[in] codepoint2  the code point (can be low surrogate or 0)
+
+    @return string representation of the code point; the length of the
+    result string is between 1 and 4 characters.
+
+    @throw std::out_of_range if code point is > 0x10ffff; example: `"code
+    points above 0x10FFFF are invalid"`
+    @throw std::invalid_argument if the low surrogate is invalid; example:
+    `""missing or wrong low surrogate""`
+
+    @complexity Constant.
+
+    @see <http://en.wikipedia.org/wiki/UTF-8#Sample_code>
+    */
+    static string_t to_unicode(const std::size_t codepoint1,
+                               const std::size_t codepoint2 = 0)
+    {
+        // calculate the code point from the given code points
+        std::size_t codepoint = codepoint1;
+
+        // check if codepoint1 is a high surrogate
+        if (codepoint1 >= 0xD800 and codepoint1 <= 0xDBFF)
+        {
+            // check if codepoint2 is a low surrogate
+            if (codepoint2 >= 0xDC00 and codepoint2 <= 0xDFFF)
             {
-                // 1-byte characters: 0xxxxxxx (ASCII)
-                result.append(1, static_cast<typename string_t::value_type>(codepoint));
-            }
-            else if (codepoint <= 0x7ff)
-            {
-                // 2-byte characters: 110xxxxx 10xxxxxx
-                result.append(1, static_cast<typename string_t::value_type>(0xC0 | ((codepoint >> 6) & 0x1F)));
-                result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
-            }
-            else if (codepoint <= 0xffff)
-            {
-                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
-                result.append(1, static_cast<typename string_t::value_type>(0xE0 | ((codepoint >> 12) & 0x0F)));
-                result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
-                result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
-            }
-            else if (codepoint <= 0x10ffff)
-            {
-                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-                result.append(1, static_cast<typename string_t::value_type>(0xF0 | ((codepoint >> 18) & 0x07)));
-                result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 12) & 0x3F)));
-                result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
-                result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
+                codepoint =
+                // high surrogate occupies the most significant 22 bits
+                (codepoint1 << 10)
+                 // low surrogate occupies the least significant 15 bits
+                 + codepoint2
+                 // there is still the 0xD800, 0xDC00 and 0x10000 noise
+                 // in the result so we have to subtract with:
+                 // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
+                 - 0x35FDC00;
             }
             else
             {
+                    JSON_THROW(std::invalid_argument("missing or wrong low surrogate"));
+            }
+        }
+
+        string_t result;
+
+        if (codepoint < 0x80)
+        {
+            // 1-byte characters: 0xxxxxxx (ASCII)
+            result.append(1, static_cast<typename string_t::value_type>(codepoint));
+        }
+        else if (codepoint <= 0x7ff)
+        {
+            // 2-byte characters: 110xxxxx 10xxxxxx
+            result.append(1, static_cast<typename string_t::value_type>(0xC0 | ((codepoint >> 6) & 0x1F)));
+            result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
+        }
+        else if (codepoint <= 0xffff)
+        {
+            // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
+            result.append(1, static_cast<typename string_t::value_type>(0xE0 | ((codepoint >> 12) & 0x0F)));
+            result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
+            result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
+        }
+        else if (codepoint <= 0x10ffff)
+        {
+            // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+            result.append(1, static_cast<typename string_t::value_type>(0xF0 | ((codepoint >> 18) & 0x07)));
+            result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 12) & 0x3F)));
+            result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
+            result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
+        }
+        else
+        {
                 JSON_THROW(std::out_of_range("code points above 0x10FFFF are invalid"));
-            }
-
-            return result;
         }
 
-        /// return name of values of type token_type (only used for errors)
-        static std::string token_type_name(const token_type t)
+        return result;
+    }
+
+    /// return name of values of type token_type (only used for errors)
+    static std::string token_type_name(const token_type t)
+    {
+        switch (t)
         {
-            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_number:
+                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";
+            default:
             {
-                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_number:
-                    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";
-                default:
+                // catch non-enum values
+                return "unknown token"; // LCOV_EXCL_LINE
+            }
+        }
+    }
+
+    /*!
+    This function implements a scanner for JSON. It is specified using
+    regular expressions that try to follow RFC 7159 as close as possible.
+    These regular expressions are then translated into a minimized
+    deterministic finite automaton (DFA) by the tool
+    [re2c](http://re2c.org). As a result, the translated code for this
+    function consists of a large block of code with `goto` jumps.
+
+    @return the class of the next token read from the buffer
+
+    @complexity Linear in the length of the input.\n
+
+    Proposition: The loop below will always terminate for finite input.\n
+
+    Proof (by contradiction): Assume a finite input. To loop forever, the
+    loop must never hit code with a `break` statement. The only code
+    snippets without a `break` statement are the continue statements for
+    whitespace and byte-order-marks. To loop forever, the input must be an
+    infinite sequence of whitespace or byte-order-marks. This contradicts
+    the assumption of finite input, q.e.d.
+    */
+    token_type scan()
+    {
+        while (true)
+        {
+            // pointer for backtracking information
+            m_marker = nullptr;
+
+            // remember the begin of the token
+            m_start = m_cursor;
+            assert(m_start != nullptr);
+
+
+            {
+                lexer_char_t yych;
+                unsigned int yyaccept = 0;
+                static const unsigned char yybm[] =
                 {
-                    // catch non-enum values
-                    return "unknown token"; // LCOV_EXCL_LINE
+                    0,   0,   0,   0,   0,   0,   0,   0,
+                    0,  32,  32,   0,   0,  32,   0,   0,
+                    0,   0,   0,   0,   0,   0,   0,   0,
+                    0,   0,   0,   0,   0,   0,   0,   0,
+                    160, 128,   0, 128, 128, 128, 128, 128,
+                    128, 128, 128, 128, 128, 128, 128, 128,
+                    192, 192, 192, 192, 192, 192, 192, 192,
+                    192, 192, 128, 128, 128, 128, 128, 128,
+                    128, 128, 128, 128, 128, 128, 128, 128,
+                    128, 128, 128, 128, 128, 128, 128, 128,
+                    128, 128, 128, 128, 128, 128, 128, 128,
+                    128, 128, 128, 128,   0, 128, 128, 128,
+                    128, 128, 128, 128, 128, 128, 128, 128,
+                    128, 128, 128, 128, 128, 128, 128, 128,
+                    128, 128, 128, 128, 128, 128, 128, 128,
+                    128, 128, 128, 128, 128, 128, 128, 128,
+                    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,
+                    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,
+                    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,
+                    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,
+                };
+                if ((m_limit - m_cursor) < 5)
+                {
+                    fill_line_buffer(5);    // LCOV_EXCL_LINE
                 }
-            }
-        }
-
-        /*!
-        This function implements a scanner for JSON. It is specified using
-        regular expressions that try to follow RFC 7159 as close as possible.
-        These regular expressions are then translated into a minimized
-        deterministic finite automaton (DFA) by the tool
-        [re2c](http://re2c.org). As a result, the translated code for this
-        function consists of a large block of code with `goto` jumps.
-
-        @return the class of the next token read from the buffer
-
-        @complexity Linear in the length of the input.\n
-
-        Proposition: The loop below will always terminate for finite input.\n
-
-        Proof (by contradiction): Assume a finite input. To loop forever, the
-        loop must never hit code with a `break` statement. The only code
-        snippets without a `break` statement are the continue statements for
-        whitespace and byte-order-marks. To loop forever, the input must be an
-        infinite sequence of whitespace or byte-order-marks. This contradicts
-        the assumption of finite input, q.e.d.
-        */
-        token_type scan()
-        {
-            while (true)
-            {
-                // pointer for backtracking information
-                m_marker = nullptr;
-
-                // remember the begin of the token
-                m_start = m_cursor;
-                assert(m_start != nullptr);
-
-
+                yych = *m_cursor;
+                if (yybm[0 + yych] & 32)
                 {
-                    lexer_char_t yych;
-                    unsigned int yyaccept = 0;
-                    static const unsigned char yybm[] =
+                    goto basic_json_parser_6;
+                }
+                if (yych <= '[')
+                {
+                    if (yych <= '-')
                     {
-                        0,   0,   0,   0,   0,   0,   0,   0,
-                        0,  32,  32,   0,   0,  32,   0,   0,
-                        0,   0,   0,   0,   0,   0,   0,   0,
-                        0,   0,   0,   0,   0,   0,   0,   0,
-                        160, 128,   0, 128, 128, 128, 128, 128,
-                        128, 128, 128, 128, 128, 128, 128, 128,
-                        192, 192, 192, 192, 192, 192, 192, 192,
-                        192, 192, 128, 128, 128, 128, 128, 128,
-                        128, 128, 128, 128, 128, 128, 128, 128,
-                        128, 128, 128, 128, 128, 128, 128, 128,
-                        128, 128, 128, 128, 128, 128, 128, 128,
-                        128, 128, 128, 128,   0, 128, 128, 128,
-                        128, 128, 128, 128, 128, 128, 128, 128,
-                        128, 128, 128, 128, 128, 128, 128, 128,
-                        128, 128, 128, 128, 128, 128, 128, 128,
-                        128, 128, 128, 128, 128, 128, 128, 128,
-                        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,
-                        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,
-                        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,
-                        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,
-                    };
-                    if ((m_limit - m_cursor) < 5)
-                    {
-                        fill_line_buffer(5);    // LCOV_EXCL_LINE
-                    }
-                    yych = *m_cursor;
-                    if (yybm[0 + yych] & 32)
-                    {
-                        goto basic_json_parser_6;
-                    }
-                    if (yych <= '[')
-                    {
-                        if (yych <= '-')
+                        if (yych <= '"')
                         {
-                            if (yych <= '"')
+                            if (yych <= 0x00)
                             {
-                                if (yych <= 0x00)
-                                {
-                                    goto basic_json_parser_2;
-                                }
-                                if (yych <= '!')
-                                {
-                                    goto basic_json_parser_4;
-                                }
-                                goto basic_json_parser_9;
+                                goto basic_json_parser_2;
                             }
-                            else
+                            if (yych <= '!')
                             {
-                                if (yych <= '+')
-                                {
-                                    goto basic_json_parser_4;
-                                }
-                                if (yych <= ',')
-                                {
-                                    goto basic_json_parser_10;
-                                }
-                                goto basic_json_parser_12;
+                                goto basic_json_parser_4;
                             }
+                            goto basic_json_parser_9;
                         }
                         else
                         {
-                            if (yych <= '9')
+                            if (yych <= '+')
                             {
-                                if (yych <= '/')
-                                {
-                                    goto basic_json_parser_4;
-                                }
-                                if (yych <= '0')
-                                {
-                                    goto basic_json_parser_13;
-                                }
-                                goto basic_json_parser_15;
+                                goto basic_json_parser_4;
                             }
-                            else
+                            if (yych <= ',')
                             {
-                                if (yych <= ':')
-                                {
-                                    goto basic_json_parser_17;
-                                }
-                                if (yych <= 'Z')
-                                {
-                                    goto basic_json_parser_4;
-                                }
-                                goto basic_json_parser_19;
+                                goto basic_json_parser_10;
                             }
+                            goto basic_json_parser_12;
                         }
                     }
                     else
                     {
-                        if (yych <= 'n')
+                        if (yych <= '9')
                         {
-                            if (yych <= 'e')
+                            if (yych <= '/')
                             {
-                                if (yych == ']')
-                                {
-                                    goto basic_json_parser_21;
-                                }
                                 goto basic_json_parser_4;
                             }
-                            else
+                            if (yych <= '0')
                             {
-                                if (yych <= 'f')
-                                {
-                                    goto basic_json_parser_23;
-                                }
-                                if (yych <= 'm')
-                                {
-                                    goto basic_json_parser_4;
-                                }
-                                goto basic_json_parser_24;
+                                goto basic_json_parser_13;
                             }
+                            goto basic_json_parser_15;
                         }
                         else
                         {
-                            if (yych <= 'z')
+                            if (yych <= ':')
+                            {
+                                goto basic_json_parser_17;
+                            }
+                            if (yych <= 'Z')
                             {
-                                if (yych == 't')
-                                {
-                                    goto basic_json_parser_25;
-                                }
-                                goto basic_json_parser_4;
-                            }
-                            else
-                            {
-                                if (yych <= '{')
-                                {
-                                    goto basic_json_parser_26;
-                                }
-                                if (yych == '}')
-                                {
-                                    goto basic_json_parser_28;
-                                }
                                 goto basic_json_parser_4;
                             }
+                            goto basic_json_parser_19;
                         }
                     }
+                }
+                else
+                {
+                    if (yych <= 'n')
+                    {
+                        if (yych <= 'e')
+                        {
+                            if (yych == ']')
+                            {
+                                goto basic_json_parser_21;
+                            }
+                            goto basic_json_parser_4;
+                        }
+                        else
+                        {
+                            if (yych <= 'f')
+                            {
+                                goto basic_json_parser_23;
+                            }
+                            if (yych <= 'm')
+                            {
+                                goto basic_json_parser_4;
+                            }
+                            goto basic_json_parser_24;
+                        }
+                    }
+                    else
+                    {
+                        if (yych <= 'z')
+                        {
+                            if (yych == 't')
+                            {
+                                goto basic_json_parser_25;
+                            }
+                            goto basic_json_parser_4;
+                        }
+                        else
+                        {
+                            if (yych <= '{')
+                            {
+                                goto basic_json_parser_26;
+                            }
+                            if (yych == '}')
+                            {
+                                goto basic_json_parser_28;
+                            }
+                            goto basic_json_parser_4;
+                        }
+                    }
+                }
 basic_json_parser_2:
-                    ++m_cursor;
-                    {
-                        last_token_type = token_type::end_of_input;
-                        break;
-                    }
+                ++m_cursor;
+                {
+                    last_token_type = token_type::end_of_input;
+                    break;
+                }
 basic_json_parser_4:
-                    ++m_cursor;
+                ++m_cursor;
 basic_json_parser_5:
-                    {
-                        last_token_type = token_type::parse_error;
-                        break;
-                    }
+                {
+                    last_token_type = token_type::parse_error;
+                    break;
+                }
 basic_json_parser_6:
-                    ++m_cursor;
-                    if (m_limit <= m_cursor)
-                    {
-                        fill_line_buffer(1);    // LCOV_EXCL_LINE
-                    }
-                    yych = *m_cursor;
-                    if (yybm[0 + yych] & 32)
-                    {
-                        goto basic_json_parser_6;
-                    }
-                    {
-                        continue;
-                    }
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    fill_line_buffer(1);    // LCOV_EXCL_LINE
+                }
+                yych = *m_cursor;
+                if (yybm[0 + yych] & 32)
+                {
+                    goto basic_json_parser_6;
+                }
+                {
+                    continue;
+                }
 basic_json_parser_9:
-                    yyaccept = 0;
-                    yych = *(m_marker = ++m_cursor);
-                    if (yych <= 0x1F)
-                    {
-                        goto basic_json_parser_5;
-                    }
-                    if (yych <= 0x7F)
-                    {
-                        goto basic_json_parser_31;
-                    }
-                    if (yych <= 0xC1)
-                    {
-                        goto basic_json_parser_5;
-                    }
-                    if (yych <= 0xF4)
-                    {
-                        goto basic_json_parser_31;
-                    }
+                yyaccept = 0;
+                yych = *(m_marker = ++m_cursor);
+                if (yych <= 0x1F)
+                {
                     goto basic_json_parser_5;
+                }
+                if (yych <= 0x7F)
+                {
+                    goto basic_json_parser_31;
+                }
+                if (yych <= 0xC1)
+                {
+                    goto basic_json_parser_5;
+                }
+                if (yych <= 0xF4)
+                {
+                    goto basic_json_parser_31;
+                }
+                goto basic_json_parser_5;
 basic_json_parser_10:
-                    ++m_cursor;
-                    {
-                        last_token_type = token_type::value_separator;
-                        break;
-                    }
+                ++m_cursor;
+                {
+                    last_token_type = token_type::value_separator;
+                    break;
+                }
 basic_json_parser_12:
-                    yych = *++m_cursor;
+                yych = *++m_cursor;
+                if (yych <= '/')
+                {
+                    goto basic_json_parser_5;
+                }
+                if (yych <= '0')
+                {
+                    goto basic_json_parser_13;
+                }
+                if (yych <= '9')
+                {
+                    goto basic_json_parser_15;
+                }
+                goto basic_json_parser_5;
+basic_json_parser_13:
+                yyaccept = 1;
+                yych = *(m_marker = ++m_cursor);
+                if (yych <= 'D')
+                {
+                    if (yych == '.')
+                    {
+                        goto basic_json_parser_43;
+                    }
+                }
+                else
+                {
+                    if (yych <= 'E')
+                    {
+                        goto basic_json_parser_44;
+                    }
+                    if (yych == 'e')
+                    {
+                        goto basic_json_parser_44;
+                    }
+                }
+basic_json_parser_14:
+                {
+                    last_token_type = token_type::value_number;
+                    break;
+                }
+basic_json_parser_15:
+                yyaccept = 1;
+                m_marker = ++m_cursor;
+                if ((m_limit - m_cursor) < 3)
+                {
+                    fill_line_buffer(3);    // LCOV_EXCL_LINE
+                }
+                yych = *m_cursor;
+                if (yybm[0 + yych] & 64)
+                {
+                    goto basic_json_parser_15;
+                }
+                if (yych <= 'D')
+                {
+                    if (yych == '.')
+                    {
+                        goto basic_json_parser_43;
+                    }
+                    goto basic_json_parser_14;
+                }
+                else
+                {
+                    if (yych <= 'E')
+                    {
+                        goto basic_json_parser_44;
+                    }
+                    if (yych == 'e')
+                    {
+                        goto basic_json_parser_44;
+                    }
+                    goto basic_json_parser_14;
+                }
+basic_json_parser_17:
+                ++m_cursor;
+                {
+                    last_token_type = token_type::name_separator;
+                    break;
+                }
+basic_json_parser_19:
+                ++m_cursor;
+                {
+                    last_token_type = token_type::begin_array;
+                    break;
+                }
+basic_json_parser_21:
+                ++m_cursor;
+                {
+                    last_token_type = token_type::end_array;
+                    break;
+                }
+basic_json_parser_23:
+                yyaccept = 0;
+                yych = *(m_marker = ++m_cursor);
+                if (yych == 'a')
+                {
+                    goto basic_json_parser_45;
+                }
+                goto basic_json_parser_5;
+basic_json_parser_24:
+                yyaccept = 0;
+                yych = *(m_marker = ++m_cursor);
+                if (yych == 'u')
+                {
+                    goto basic_json_parser_46;
+                }
+                goto basic_json_parser_5;
+basic_json_parser_25:
+                yyaccept = 0;
+                yych = *(m_marker = ++m_cursor);
+                if (yych == 'r')
+                {
+                    goto basic_json_parser_47;
+                }
+                goto basic_json_parser_5;
+basic_json_parser_26:
+                ++m_cursor;
+                {
+                    last_token_type = token_type::begin_object;
+                    break;
+                }
+basic_json_parser_28:
+                ++m_cursor;
+                {
+                    last_token_type = token_type::end_object;
+                    break;
+                }
+basic_json_parser_30:
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    fill_line_buffer(1);    // LCOV_EXCL_LINE
+                }
+                yych = *m_cursor;
+basic_json_parser_31:
+                if (yybm[0 + yych] & 128)
+                {
+                    goto basic_json_parser_30;
+                }
+                if (yych <= 0xE0)
+                {
+                    if (yych <= '\\')
+                    {
+                        if (yych <= 0x1F)
+                        {
+                            goto basic_json_parser_32;
+                        }
+                        if (yych <= '"')
+                        {
+                            goto basic_json_parser_33;
+                        }
+                        goto basic_json_parser_35;
+                    }
+                    else
+                    {
+                        if (yych <= 0xC1)
+                        {
+                            goto basic_json_parser_32;
+                        }
+                        if (yych <= 0xDF)
+                        {
+                            goto basic_json_parser_36;
+                        }
+                        goto basic_json_parser_37;
+                    }
+                }
+                else
+                {
+                    if (yych <= 0xEF)
+                    {
+                        if (yych == 0xED)
+                        {
+                            goto basic_json_parser_39;
+                        }
+                        goto basic_json_parser_38;
+                    }
+                    else
+                    {
+                        if (yych <= 0xF0)
+                        {
+                            goto basic_json_parser_40;
+                        }
+                        if (yych <= 0xF3)
+                        {
+                            goto basic_json_parser_41;
+                        }
+                        if (yych <= 0xF4)
+                        {
+                            goto basic_json_parser_42;
+                        }
+                    }
+                }
+basic_json_parser_32:
+                m_cursor = m_marker;
+                if (yyaccept == 0)
+                {
+                    goto basic_json_parser_5;
+                }
+                else
+                {
+                    goto basic_json_parser_14;
+                }
+basic_json_parser_33:
+                ++m_cursor;
+                {
+                    last_token_type = token_type::value_string;
+                    break;
+                }
+basic_json_parser_35:
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    fill_line_buffer(1);    // LCOV_EXCL_LINE
+                }
+                yych = *m_cursor;
+                if (yych <= 'e')
+                {
                     if (yych <= '/')
                     {
-                        goto basic_json_parser_5;
-                    }
-                    if (yych <= '0')
-                    {
-                        goto basic_json_parser_13;
-                    }
-                    if (yych <= '9')
-                    {
-                        goto basic_json_parser_15;
-                    }
-                    goto basic_json_parser_5;
-basic_json_parser_13:
-                    yyaccept = 1;
-                    yych = *(m_marker = ++m_cursor);
-                    if (yych <= 'D')
-                    {
-                        if (yych == '.')
+                        if (yych == '"')
                         {
-                            goto basic_json_parser_43;
+                            goto basic_json_parser_30;
                         }
-                    }
-                    else
-                    {
-                        if (yych <= 'E')
+                        if (yych <= '.')
                         {
-                            goto basic_json_parser_44;
+                            goto basic_json_parser_32;
                         }
-                        if (yych == 'e')
-                        {
-                            goto basic_json_parser_44;
-                        }
-                    }
-basic_json_parser_14:
-                    {
-                        last_token_type = token_type::value_number;
-                        break;
-                    }
-basic_json_parser_15:
-                    yyaccept = 1;
-                    m_marker = ++m_cursor;
-                    if ((m_limit - m_cursor) < 3)
-                    {
-                        fill_line_buffer(3);    // LCOV_EXCL_LINE
-                    }
-                    yych = *m_cursor;
-                    if (yybm[0 + yych] & 64)
-                    {
-                        goto basic_json_parser_15;
-                    }
-                    if (yych <= 'D')
-                    {
-                        if (yych == '.')
-                        {
-                            goto basic_json_parser_43;
-                        }
-                        goto basic_json_parser_14;
-                    }
-                    else
-                    {
-                        if (yych <= 'E')
-                        {
-                            goto basic_json_parser_44;
-                        }
-                        if (yych == 'e')
-                        {
-                            goto basic_json_parser_44;
-                        }
-                        goto basic_json_parser_14;
-                    }
-basic_json_parser_17:
-                    ++m_cursor;
-                    {
-                        last_token_type = token_type::name_separator;
-                        break;
-                    }
-basic_json_parser_19:
-                    ++m_cursor;
-                    {
-                        last_token_type = token_type::begin_array;
-                        break;
-                    }
-basic_json_parser_21:
-                    ++m_cursor;
-                    {
-                        last_token_type = token_type::end_array;
-                        break;
-                    }
-basic_json_parser_23:
-                    yyaccept = 0;
-                    yych = *(m_marker = ++m_cursor);
-                    if (yych == 'a')
-                    {
-                        goto basic_json_parser_45;
-                    }
-                    goto basic_json_parser_5;
-basic_json_parser_24:
-                    yyaccept = 0;
-                    yych = *(m_marker = ++m_cursor);
-                    if (yych == 'u')
-                    {
-                        goto basic_json_parser_46;
-                    }
-                    goto basic_json_parser_5;
-basic_json_parser_25:
-                    yyaccept = 0;
-                    yych = *(m_marker = ++m_cursor);
-                    if (yych == 'r')
-                    {
-                        goto basic_json_parser_47;
-                    }
-                    goto basic_json_parser_5;
-basic_json_parser_26:
-                    ++m_cursor;
-                    {
-                        last_token_type = token_type::begin_object;
-                        break;
-                    }
-basic_json_parser_28:
-                    ++m_cursor;
-                    {
-                        last_token_type = token_type::end_object;
-                        break;
-                    }
-basic_json_parser_30:
-                    ++m_cursor;
-                    if (m_limit <= m_cursor)
-                    {
-                        fill_line_buffer(1);    // LCOV_EXCL_LINE
-                    }
-                    yych = *m_cursor;
-basic_json_parser_31:
-                    if (yybm[0 + yych] & 128)
-                    {
                         goto basic_json_parser_30;
                     }
-                    if (yych <= 0xE0)
+                    else
                     {
                         if (yych <= '\\')
                         {
-                            if (yych <= 0x1F)
-                            {
-                                goto basic_json_parser_32;
-                            }
-                            if (yych <= '"')
-                            {
-                                goto basic_json_parser_33;
-                            }
-                            goto basic_json_parser_35;
-                        }
-                        else
-                        {
-                            if (yych <= 0xC1)
-                            {
-                                goto basic_json_parser_32;
-                            }
-                            if (yych <= 0xDF)
-                            {
-                                goto basic_json_parser_36;
-                            }
-                            goto basic_json_parser_37;
-                        }
-                    }
-                    else
-                    {
-                        if (yych <= 0xEF)
-                        {
-                            if (yych == 0xED)
-                            {
-                                goto basic_json_parser_39;
-                            }
-                            goto basic_json_parser_38;
-                        }
-                        else
-                        {
-                            if (yych <= 0xF0)
-                            {
-                                goto basic_json_parser_40;
-                            }
-                            if (yych <= 0xF3)
-                            {
-                                goto basic_json_parser_41;
-                            }
-                            if (yych <= 0xF4)
-                            {
-                                goto basic_json_parser_42;
-                            }
-                        }
-                    }
-basic_json_parser_32:
-                    m_cursor = m_marker;
-                    if (yyaccept == 0)
-                    {
-                        goto basic_json_parser_5;
-                    }
-                    else
-                    {
-                        goto basic_json_parser_14;
-                    }
-basic_json_parser_33:
-                    ++m_cursor;
-                    {
-                        last_token_type = token_type::value_string;
-                        break;
-                    }
-basic_json_parser_35:
-                    ++m_cursor;
-                    if (m_limit <= m_cursor)
-                    {
-                        fill_line_buffer(1);    // LCOV_EXCL_LINE
-                    }
-                    yych = *m_cursor;
-                    if (yych <= 'e')
-                    {
-                        if (yych <= '/')
-                        {
-                            if (yych == '"')
-                            {
-                                goto basic_json_parser_30;
-                            }
-                            if (yych <= '.')
+                            if (yych <= '[')
                             {
                                 goto basic_json_parser_32;
                             }
@@ -10174,33 +10195,33 @@ basic_json_parser_35:
                         }
                         else
                         {
-                            if (yych <= '\\')
+                            if (yych == 'b')
                             {
-                                if (yych <= '[')
-                                {
-                                    goto basic_json_parser_32;
-                                }
                                 goto basic_json_parser_30;
                             }
-                            else
-                            {
-                                if (yych == 'b')
-                                {
-                                    goto basic_json_parser_30;
-                                }
-                                goto basic_json_parser_32;
-                            }
+                            goto basic_json_parser_32;
                         }
                     }
+                }
+                else
+                {
+                    if (yych <= 'q')
+                    {
+                        if (yych <= 'f')
+                        {
+                            goto basic_json_parser_30;
+                        }
+                        if (yych == 'n')
+                        {
+                            goto basic_json_parser_30;
+                        }
+                        goto basic_json_parser_32;
+                    }
                     else
                     {
-                        if (yych <= 'q')
+                        if (yych <= 's')
                         {
-                            if (yych <= 'f')
-                            {
-                                goto basic_json_parser_30;
-                            }
-                            if (yych == 'n')
+                            if (yych <= 'r')
                             {
                                 goto basic_json_parser_30;
                             }
@@ -10208,920 +10229,910 @@ basic_json_parser_35:
                         }
                         else
                         {
-                            if (yych <= 's')
+                            if (yych <= 't')
                             {
-                                if (yych <= 'r')
-                                {
-                                    goto basic_json_parser_30;
-                                }
-                                goto basic_json_parser_32;
+                                goto basic_json_parser_30;
                             }
-                            else
+                            if (yych <= 'u')
                             {
-                                if (yych <= 't')
-                                {
-                                    goto basic_json_parser_30;
-                                }
-                                if (yych <= 'u')
-                                {
-                                    goto basic_json_parser_48;
-                                }
-                                goto basic_json_parser_32;
+                                goto basic_json_parser_48;
                             }
+                            goto basic_json_parser_32;
                         }
                     }
+                }
 basic_json_parser_36:
-                    ++m_cursor;
-                    if (m_limit <= m_cursor)
-                    {
-                        fill_line_buffer(1);    // LCOV_EXCL_LINE
-                    }
-                    yych = *m_cursor;
-                    if (yych <= 0x7F)
-                    {
-                        goto basic_json_parser_32;
-                    }
-                    if (yych <= 0xBF)
-                    {
-                        goto basic_json_parser_30;
-                    }
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    fill_line_buffer(1);    // LCOV_EXCL_LINE
+                }
+                yych = *m_cursor;
+                if (yych <= 0x7F)
+                {
                     goto basic_json_parser_32;
+                }
+                if (yych <= 0xBF)
+                {
+                    goto basic_json_parser_30;
+                }
+                goto basic_json_parser_32;
 basic_json_parser_37:
-                    ++m_cursor;
-                    if (m_limit <= m_cursor)
-                    {
-                        fill_line_buffer(1);    // LCOV_EXCL_LINE
-                    }
-                    yych = *m_cursor;
-                    if (yych <= 0x9F)
-                    {
-                        goto basic_json_parser_32;
-                    }
-                    if (yych <= 0xBF)
-                    {
-                        goto basic_json_parser_36;
-                    }
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    fill_line_buffer(1);    // LCOV_EXCL_LINE
+                }
+                yych = *m_cursor;
+                if (yych <= 0x9F)
+                {
                     goto basic_json_parser_32;
+                }
+                if (yych <= 0xBF)
+                {
+                    goto basic_json_parser_36;
+                }
+                goto basic_json_parser_32;
 basic_json_parser_38:
-                    ++m_cursor;
-                    if (m_limit <= m_cursor)
-                    {
-                        fill_line_buffer(1);    // LCOV_EXCL_LINE
-                    }
-                    yych = *m_cursor;
-                    if (yych <= 0x7F)
-                    {
-                        goto basic_json_parser_32;
-                    }
-                    if (yych <= 0xBF)
-                    {
-                        goto basic_json_parser_36;
-                    }
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    fill_line_buffer(1);    // LCOV_EXCL_LINE
+                }
+                yych = *m_cursor;
+                if (yych <= 0x7F)
+                {
                     goto basic_json_parser_32;
+                }
+                if (yych <= 0xBF)
+                {
+                    goto basic_json_parser_36;
+                }
+                goto basic_json_parser_32;
 basic_json_parser_39:
-                    ++m_cursor;
-                    if (m_limit <= m_cursor)
-                    {
-                        fill_line_buffer(1);    // LCOV_EXCL_LINE
-                    }
-                    yych = *m_cursor;
-                    if (yych <= 0x7F)
-                    {
-                        goto basic_json_parser_32;
-                    }
-                    if (yych <= 0x9F)
-                    {
-                        goto basic_json_parser_36;
-                    }
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    fill_line_buffer(1);    // LCOV_EXCL_LINE
+                }
+                yych = *m_cursor;
+                if (yych <= 0x7F)
+                {
                     goto basic_json_parser_32;
+                }
+                if (yych <= 0x9F)
+                {
+                    goto basic_json_parser_36;
+                }
+                goto basic_json_parser_32;
 basic_json_parser_40:
-                    ++m_cursor;
-                    if (m_limit <= m_cursor)
-                    {
-                        fill_line_buffer(1);    // LCOV_EXCL_LINE
-                    }
-                    yych = *m_cursor;
-                    if (yych <= 0x8F)
-                    {
-                        goto basic_json_parser_32;
-                    }
-                    if (yych <= 0xBF)
-                    {
-                        goto basic_json_parser_38;
-                    }
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    fill_line_buffer(1);    // LCOV_EXCL_LINE
+                }
+                yych = *m_cursor;
+                if (yych <= 0x8F)
+                {
                     goto basic_json_parser_32;
+                }
+                if (yych <= 0xBF)
+                {
+                    goto basic_json_parser_38;
+                }
+                goto basic_json_parser_32;
 basic_json_parser_41:
-                    ++m_cursor;
-                    if (m_limit <= m_cursor)
-                    {
-                        fill_line_buffer(1);    // LCOV_EXCL_LINE
-                    }
-                    yych = *m_cursor;
-                    if (yych <= 0x7F)
-                    {
-                        goto basic_json_parser_32;
-                    }
-                    if (yych <= 0xBF)
-                    {
-                        goto basic_json_parser_38;
-                    }
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    fill_line_buffer(1);    // LCOV_EXCL_LINE
+                }
+                yych = *m_cursor;
+                if (yych <= 0x7F)
+                {
                     goto basic_json_parser_32;
+                }
+                if (yych <= 0xBF)
+                {
+                    goto basic_json_parser_38;
+                }
+                goto basic_json_parser_32;
 basic_json_parser_42:
-                    ++m_cursor;
-                    if (m_limit <= m_cursor)
-                    {
-                        fill_line_buffer(1);    // LCOV_EXCL_LINE
-                    }
-                    yych = *m_cursor;
-                    if (yych <= 0x7F)
-                    {
-                        goto basic_json_parser_32;
-                    }
-                    if (yych <= 0x8F)
-                    {
-                        goto basic_json_parser_38;
-                    }
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    fill_line_buffer(1);    // LCOV_EXCL_LINE
+                }
+                yych = *m_cursor;
+                if (yych <= 0x7F)
+                {
                     goto basic_json_parser_32;
+                }
+                if (yych <= 0x8F)
+                {
+                    goto basic_json_parser_38;
+                }
+                goto basic_json_parser_32;
 basic_json_parser_43:
-                    yych = *++m_cursor;
-                    if (yych <= '/')
-                    {
-                        goto basic_json_parser_32;
-                    }
-                    if (yych <= '9')
-                    {
-                        goto basic_json_parser_49;
-                    }
+                yych = *++m_cursor;
+                if (yych <= '/')
+                {
                     goto basic_json_parser_32;
+                }
+                if (yych <= '9')
+                {
+                    goto basic_json_parser_49;
+                }
+                goto basic_json_parser_32;
 basic_json_parser_44:
-                    yych = *++m_cursor;
-                    if (yych <= ',')
+                yych = *++m_cursor;
+                if (yych <= ',')
+                {
+                    if (yych == '+')
                     {
-                        if (yych == '+')
-                        {
-                            goto basic_json_parser_51;
-                        }
-                        goto basic_json_parser_32;
-                    }
-                    else
-                    {
-                        if (yych <= '-')
-                        {
-                            goto basic_json_parser_51;
-                        }
-                        if (yych <= '/')
-                        {
-                            goto basic_json_parser_32;
-                        }
-                        if (yych <= '9')
-                        {
-                            goto basic_json_parser_52;
-                        }
-                        goto basic_json_parser_32;
-                    }
-basic_json_parser_45:
-                    yych = *++m_cursor;
-                    if (yych == 'l')
-                    {
-                        goto basic_json_parser_54;
+                        goto basic_json_parser_51;
                     }
                     goto basic_json_parser_32;
-basic_json_parser_46:
-                    yych = *++m_cursor;
-                    if (yych == 'l')
+                }
+                else
+                {
+                    if (yych <= '-')
                     {
-                        goto basic_json_parser_55;
+                        goto basic_json_parser_51;
                     }
-                    goto basic_json_parser_32;
-basic_json_parser_47:
-                    yych = *++m_cursor;
-                    if (yych == 'u')
-                    {
-                        goto basic_json_parser_56;
-                    }
-                    goto basic_json_parser_32;
-basic_json_parser_48:
-                    ++m_cursor;
-                    if (m_limit <= m_cursor)
-                    {
-                        fill_line_buffer(1);    // LCOV_EXCL_LINE
-                    }
-                    yych = *m_cursor;
-                    if (yych <= '@')
-                    {
-                        if (yych <= '/')
-                        {
-                            goto basic_json_parser_32;
-                        }
-                        if (yych <= '9')
-                        {
-                            goto basic_json_parser_57;
-                        }
-                        goto basic_json_parser_32;
-                    }
-                    else
-                    {
-                        if (yych <= 'F')
-                        {
-                            goto basic_json_parser_57;
-                        }
-                        if (yych <= '`')
-                        {
-                            goto basic_json_parser_32;
-                        }
-                        if (yych <= 'f')
-                        {
-                            goto basic_json_parser_57;
-                        }
-                        goto basic_json_parser_32;
-                    }
-basic_json_parser_49:
-                    yyaccept = 1;
-                    m_marker = ++m_cursor;
-                    if ((m_limit - m_cursor) < 3)
-                    {
-                        fill_line_buffer(3);    // LCOV_EXCL_LINE
-                    }
-                    yych = *m_cursor;
-                    if (yych <= 'D')
-                    {
-                        if (yych <= '/')
-                        {
-                            goto basic_json_parser_14;
-                        }
-                        if (yych <= '9')
-                        {
-                            goto basic_json_parser_49;
-                        }
-                        goto basic_json_parser_14;
-                    }
-                    else
-                    {
-                        if (yych <= 'E')
-                        {
-                            goto basic_json_parser_44;
-                        }
-                        if (yych == 'e')
-                        {
-                            goto basic_json_parser_44;
-                        }
-                        goto basic_json_parser_14;
-                    }
-basic_json_parser_51:
-                    yych = *++m_cursor;
                     if (yych <= '/')
                     {
                         goto basic_json_parser_32;
                     }
-                    if (yych >= ':')
-                    {
-                        goto basic_json_parser_32;
-                    }
-basic_json_parser_52:
-                    ++m_cursor;
-                    if (m_limit <= m_cursor)
-                    {
-                        fill_line_buffer(1);    // LCOV_EXCL_LINE
-                    }
-                    yych = *m_cursor;
-                    if (yych <= '/')
-                    {
-                        goto basic_json_parser_14;
-                    }
                     if (yych <= '9')
                     {
                         goto basic_json_parser_52;
                     }
-                    goto basic_json_parser_14;
-basic_json_parser_54:
-                    yych = *++m_cursor;
-                    if (yych == 's')
-                    {
-                        goto basic_json_parser_58;
-                    }
                     goto basic_json_parser_32;
-basic_json_parser_55:
-                    yych = *++m_cursor;
-                    if (yych == 'l')
-                    {
-                        goto basic_json_parser_59;
-                    }
-                    goto basic_json_parser_32;
-basic_json_parser_56:
-                    yych = *++m_cursor;
-                    if (yych == 'e')
-                    {
-                        goto basic_json_parser_61;
-                    }
-                    goto basic_json_parser_32;
-basic_json_parser_57:
-                    ++m_cursor;
-                    if (m_limit <= m_cursor)
-                    {
-                        fill_line_buffer(1);    // LCOV_EXCL_LINE
-                    }
-                    yych = *m_cursor;
-                    if (yych <= '@')
-                    {
-                        if (yych <= '/')
-                        {
-                            goto basic_json_parser_32;
-                        }
-                        if (yych <= '9')
-                        {
-                            goto basic_json_parser_63;
-                        }
-                        goto basic_json_parser_32;
-                    }
-                    else
-                    {
-                        if (yych <= 'F')
-                        {
-                            goto basic_json_parser_63;
-                        }
-                        if (yych <= '`')
-                        {
-                            goto basic_json_parser_32;
-                        }
-                        if (yych <= 'f')
-                        {
-                            goto basic_json_parser_63;
-                        }
-                        goto basic_json_parser_32;
-                    }
-basic_json_parser_58:
-                    yych = *++m_cursor;
-                    if (yych == 'e')
-                    {
-                        goto basic_json_parser_64;
-                    }
-                    goto basic_json_parser_32;
-basic_json_parser_59:
-                    ++m_cursor;
-                    {
-                        last_token_type = token_type::literal_null;
-                        break;
-                    }
-basic_json_parser_61:
-                    ++m_cursor;
-                    {
-                        last_token_type = token_type::literal_true;
-                        break;
-                    }
-basic_json_parser_63:
-                    ++m_cursor;
-                    if (m_limit <= m_cursor)
-                    {
-                        fill_line_buffer(1);    // LCOV_EXCL_LINE
-                    }
-                    yych = *m_cursor;
-                    if (yych <= '@')
-                    {
-                        if (yych <= '/')
-                        {
-                            goto basic_json_parser_32;
-                        }
-                        if (yych <= '9')
-                        {
-                            goto basic_json_parser_66;
-                        }
-                        goto basic_json_parser_32;
-                    }
-                    else
-                    {
-                        if (yych <= 'F')
-                        {
-                            goto basic_json_parser_66;
-                        }
-                        if (yych <= '`')
-                        {
-                            goto basic_json_parser_32;
-                        }
-                        if (yych <= 'f')
-                        {
-                            goto basic_json_parser_66;
-                        }
-                        goto basic_json_parser_32;
-                    }
-basic_json_parser_64:
-                    ++m_cursor;
-                    {
-                        last_token_type = token_type::literal_false;
-                        break;
-                    }
-basic_json_parser_66:
-                    ++m_cursor;
-                    if (m_limit <= m_cursor)
-                    {
-                        fill_line_buffer(1);    // LCOV_EXCL_LINE
-                    }
-                    yych = *m_cursor;
-                    if (yych <= '@')
-                    {
-                        if (yych <= '/')
-                        {
-                            goto basic_json_parser_32;
-                        }
-                        if (yych <= '9')
-                        {
-                            goto basic_json_parser_30;
-                        }
-                        goto basic_json_parser_32;
-                    }
-                    else
-                    {
-                        if (yych <= 'F')
-                        {
-                            goto basic_json_parser_30;
-                        }
-                        if (yych <= '`')
-                        {
-                            goto basic_json_parser_32;
-                        }
-                        if (yych <= 'f')
-                        {
-                            goto basic_json_parser_30;
-                        }
-                        goto basic_json_parser_32;
-                    }
                 }
-
-            }
-
-            return last_token_type;
-        }
-
-        /*!
-        @brief append data from the stream to the line buffer
-
-        This function is called by the scan() function when the end of the
-        buffer (`m_limit`) is reached and the `m_cursor` pointer cannot be
-        incremented without leaving the limits of the line buffer. Note re2c
-        decides when to call this function.
-
-        If the lexer reads from contiguous storage, there is no trailing null
-        byte. Therefore, this function must make sure to add these padding
-        null bytes.
-
-        If the lexer reads from an input stream, this function reads the next
-        line of the input.
-
-        @pre
-            p p p p p p u u u u u x . . . . . .
-            ^           ^       ^   ^
-            m_content   m_start |   m_limit
-                                m_cursor
-
-        @post
-            u u u u u x x x x x x x . . . . . .
-            ^       ^               ^
-            |       m_cursor        m_limit
-            m_start
-            m_content
-        */
-        void fill_line_buffer(size_t n = 0)
-        {
-            // if line buffer is used, m_content points to its data
-            assert(m_line_buffer.empty()
-                   or m_content == reinterpret_cast<const lexer_char_t*>(m_line_buffer.data()));
-
-            // if line buffer is used, m_limit is set past the end of its data
-            assert(m_line_buffer.empty()
-                   or m_limit == m_content + m_line_buffer.size());
-
-            // pointer relationships
-            assert(m_content <= m_start);
-            assert(m_start <= m_cursor);
-            assert(m_cursor <= m_limit);
-            assert(m_marker == nullptr or m_marker  <= m_limit);
-
-            // number of processed characters (p)
-            const auto num_processed_chars = static_cast<size_t>(m_start - m_content);
-            // offset for m_marker wrt. to m_start
-            const auto offset_marker = (m_marker == nullptr) ? 0 : m_marker - m_start;
-            // number of unprocessed characters (u)
-            const auto offset_cursor = m_cursor - m_start;
-
-            // no stream is used or end of file is reached
-            if (m_stream == nullptr or m_stream->eof())
-            {
-                // m_start may or may not be pointing into m_line_buffer at
-                // this point. We trust the standand library to do the right
-                // thing. See http://stackoverflow.com/q/28142011/266378
-                m_line_buffer.assign(m_start, m_limit);
-
-                // append n characters to make sure that there is sufficient
-                // space between m_cursor and m_limit
-                m_line_buffer.append(1, '\x00');
-                if (n > 0)
+basic_json_parser_45:
+                yych = *++m_cursor;
+                if (yych == 'l')
                 {
-                    m_line_buffer.append(n - 1, '\x01');
+                    goto basic_json_parser_54;
                 }
-            }
-            else
-            {
-                // delete processed characters from line buffer
-                m_line_buffer.erase(0, num_processed_chars);
-                // read next line from input stream
-                m_line_buffer_tmp.clear();
-                std::getline(*m_stream, m_line_buffer_tmp, '\n');
-
-                // add line with newline symbol to the line buffer
-                m_line_buffer += m_line_buffer_tmp;
-                m_line_buffer.push_back('\n');
-            }
-
-            // set pointers
-            m_content = reinterpret_cast<const lexer_char_t*>(m_line_buffer.data());
-            assert(m_content != nullptr);
-            m_start  = m_content;
-            m_marker = m_start + offset_marker;
-            m_cursor = m_start + offset_cursor;
-            m_limit  = m_start + m_line_buffer.size();
-        }
-
-        /// return string representation of last read token
-        string_t get_token_string() const
-        {
-            assert(m_start != nullptr);
-            return string_t(reinterpret_cast<typename string_t::const_pointer>(m_start),
-                            static_cast<size_t>(m_cursor - m_start));
-        }
-
-        /*!
-        @brief return string value for string tokens
-
-        The function iterates the characters between the opening and closing
-        quotes of the string value. The complete string is the range
-        [m_start,m_cursor). Consequently, we iterate from m_start+1 to
-        m_cursor-1.
-
-        We differentiate two cases:
-
-        1. Escaped characters. In this case, a new character is constructed
-           according to the nature of the escape. Some escapes create new
-           characters (e.g., `"\\n"` is replaced by `"\n"`), some are copied
-           as is (e.g., `"\\\\"`). Furthermore, Unicode escapes of the shape
-           `"\\uxxxx"` need special care. In this case, to_unicode takes care
-           of the construction of the values.
-        2. Unescaped characters are copied as is.
-
-        @pre `m_cursor - m_start >= 2`, meaning the length of the last token
-        is at least 2 bytes which is trivially true for any string (which
-        consists of at least two quotes).
-
-            " c1 c2 c3 ... "
-            ^                ^
-            m_start          m_cursor
-
-        @complexity Linear in the length of the string.\n
-
-        Lemma: The loop body will always terminate.\n
-
-        Proof (by contradiction): Assume the loop body does not terminate. As
-        the loop body does not contain another loop, one of the called
-        functions must never return. The called functions are `std::strtoul`
-        and to_unicode. Neither function can loop forever, so the loop body
-        will never loop forever which contradicts the assumption that the loop
-        body does not terminate, q.e.d.\n
-
-        Lemma: The loop condition for the for loop is eventually false.\n
-
-        Proof (by contradiction): Assume the loop does not terminate. Due to
-        the above lemma, this can only be due to a tautological loop
-        condition; that is, the loop condition i < m_cursor - 1 must always be
-        true. Let x be the change of i for any loop iteration. Then
-        m_start + 1 + x < m_cursor - 1 must hold to loop indefinitely. This
-        can be rephrased to m_cursor - m_start - 2 > x. With the
-        precondition, we x <= 0, meaning that the loop condition holds
-        indefinitly if i is always decreased. However, observe that the value
-        of i is strictly increasing with each iteration, as it is incremented
-        by 1 in the iteration expression and never decremented inside the loop
-        body. Hence, the loop condition will eventually be false which
-        contradicts the assumption that the loop condition is a tautology,
-        q.e.d.
-
-        @return string value of current token without opening and closing
-        quotes
-        @throw std::out_of_range if to_unicode fails
-        */
-        string_t get_string() const
-        {
-            assert(m_cursor - m_start >= 2);
-
-            string_t result;
-            result.reserve(static_cast<size_t>(m_cursor - m_start - 2));
-
-            // iterate the result between the quotes
-            for (const lexer_char_t* i = m_start + 1; i < m_cursor - 1; ++i)
-            {
-                // find next escape character
-                auto e = std::find(i, m_cursor - 1, '\\');
-                if (e != i)
+                goto basic_json_parser_32;
+basic_json_parser_46:
+                yych = *++m_cursor;
+                if (yych == 'l')
                 {
-                    // see https://github.com/nlohmann/json/issues/365#issuecomment-262874705
-                    for (auto k = i; k < e; k++)
+                    goto basic_json_parser_55;
+                }
+                goto basic_json_parser_32;
+basic_json_parser_47:
+                yych = *++m_cursor;
+                if (yych == 'u')
+                {
+                    goto basic_json_parser_56;
+                }
+                goto basic_json_parser_32;
+basic_json_parser_48:
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    fill_line_buffer(1);    // LCOV_EXCL_LINE
+                }
+                yych = *m_cursor;
+                if (yych <= '@')
+                {
+                    if (yych <= '/')
                     {
-                        result.push_back(static_cast<typename string_t::value_type>(*k));
+                        goto basic_json_parser_32;
                     }
-                    i = e - 1; // -1 because of ++i
+                    if (yych <= '9')
+                    {
+                        goto basic_json_parser_57;
+                    }
+                    goto basic_json_parser_32;
                 }
                 else
                 {
-                    // processing escaped character
-                    // read next character
-                    ++i;
-
-                    switch (*i)
+                    if (yych <= 'F')
                     {
-                        // the default escapes
-                        case 't':
-                        {
-                            result += "\t";
-                            break;
-                        }
-                        case 'b':
-                        {
-                            result += "\b";
-                            break;
-                        }
-                        case 'f':
-                        {
-                            result += "\f";
-                            break;
-                        }
-                        case 'n':
-                        {
-                            result += "\n";
-                            break;
-                        }
-                        case 'r':
-                        {
-                            result += "\r";
-                            break;
-                        }
-                        case '\\':
-                        {
-                            result += "\\";
-                            break;
-                        }
-                        case '/':
-                        {
-                            result += "/";
-                            break;
-                        }
-                        case '"':
-                        {
-                            result += "\"";
-                            break;
-                        }
-
-                        // unicode
-                        case 'u':
-                        {
-                            // get code xxxx from uxxxx
-                            auto codepoint = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>(i + 1),
-                                                          4).c_str(), nullptr, 16);
-
-                            // check if codepoint is a high surrogate
-                            if (codepoint >= 0xD800 and codepoint <= 0xDBFF)
-                            {
-                                // make sure there is a subsequent unicode
-                                if ((i + 6 >= m_limit) or * (i + 5) != '\\' or * (i + 6) != 'u')
-                                {
-                                    JSON_THROW(std::invalid_argument("missing low surrogate"));
-                                }
-
-                                // get code yyyy from uxxxx\uyyyy
-                                auto codepoint2 = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>
-                                                               (i + 7), 4).c_str(), nullptr, 16);
-                                result += to_unicode(codepoint, codepoint2);
-                                // skip the next 10 characters (xxxx\uyyyy)
-                                i += 10;
-                            }
-                            else if (codepoint >= 0xDC00 and codepoint <= 0xDFFF)
-                            {
-                                // we found a lone low surrogate
-                                JSON_THROW(std::invalid_argument("missing high surrogate"));
-                            }
-                            else
-                            {
-                                // add unicode character(s)
-                                result += to_unicode(codepoint);
-                                // skip the next four characters (xxxx)
-                                i += 4;
-                            }
-                            break;
-                        }
+                        goto basic_json_parser_57;
                     }
+                    if (yych <= '`')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                    if (yych <= 'f')
+                    {
+                        goto basic_json_parser_57;
+                    }
+                    goto basic_json_parser_32;
                 }
-            }
-
-            return result;
-        }
-
-        /*!
-        @brief parse floating point number
-
-        This function (and its overloads) serves to select the most approprate
-        standard floating point number parsing function based on the type
-        supplied via the first parameter.  Set this to @a
-        static_cast<number_float_t*>(nullptr).
-
-        @param[in,out] endptr recieves a pointer to the first character after
-        the number
-
-        @return the floating point number
-        */
-        long double str_to_float_t(long double* /* type */, char** endptr) const
-        {
-            return std::strtold(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
-        }
-
-        /*!
-        @brief parse floating point number
-
-        This function (and its overloads) serves to select the most approprate
-        standard floating point number parsing function based on the type
-        supplied via the first parameter.  Set this to @a
-        static_cast<number_float_t*>(nullptr).
-
-        @param[in,out] endptr  recieves a pointer to the first character after
-        the number
-
-        @return the floating point number
-        */
-        double str_to_float_t(double* /* type */, char** endptr) const
-        {
-            return std::strtod(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
-        }
-
-        /*!
-        @brief parse floating point number
-
-        This function (and its overloads) serves to select the most approprate
-        standard floating point number parsing function based on the type
-        supplied via the first parameter.  Set this to @a
-        static_cast<number_float_t*>(nullptr).
-
-        @param[in,out] endptr  recieves a pointer to the first character after
-        the number
-
-        @return the floating point number
-        */
-        float str_to_float_t(float* /* type */, char** endptr) const
-        {
-            return std::strtof(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
-        }
-
-        /*!
-        @brief return number value for number tokens
-
-        This function translates the last token into the most appropriate
-        number type (either integer, unsigned integer or floating point),
-        which is passed back to the caller via the result parameter.
-
-        This function parses the integer component up to the radix point or
-        exponent while collecting information about the 'floating point
-        representation', which it stores in the result parameter. If there is
-        no radix point or exponent, and the number can fit into a @ref
-        number_integer_t or @ref number_unsigned_t then it sets the result
-        parameter accordingly.
-
-        If the number is a floating point number the number is then parsed
-        using @a std:strtod (or @a std:strtof or @a std::strtold).
-
-        @param[out] result  @ref basic_json object to receive the number, or
-        NAN if the conversion read past the current token. The latter case
-        needs to be treated by the caller function.
-        */
-        void get_number(basic_json& result) const
-        {
-            assert(m_start != nullptr);
-
-            const lexer::lexer_char_t* curptr = m_start;
-
-            // accumulate the integer conversion result (unsigned for now)
-            number_unsigned_t value = 0;
-
-            // maximum absolute value of the relevant integer type
-            number_unsigned_t max;
-
-            // temporarily store the type to avoid unecessary bitfield access
-            value_t type;
-
-            // look for sign
-            if (*curptr == '-')
-            {
-                type = value_t::number_integer;
-                max = static_cast<uint64_t>((std::numeric_limits<number_integer_t>::max)()) + 1;
-                curptr++;
-            }
-            else
-            {
-                type = value_t::number_unsigned;
-                max = static_cast<uint64_t>((std::numeric_limits<number_unsigned_t>::max)());
-            }
-
-            // count the significant figures
-            for (; curptr < m_cursor; curptr++)
-            {
-                // quickly skip tests if a digit
-                if (*curptr < '0' || *curptr > '9')
+basic_json_parser_49:
+                yyaccept = 1;
+                m_marker = ++m_cursor;
+                if ((m_limit - m_cursor) < 3)
                 {
-                    if (*curptr == '.')
+                    fill_line_buffer(3);    // LCOV_EXCL_LINE
+                }
+                yych = *m_cursor;
+                if (yych <= 'D')
+                {
+                    if (yych <= '/')
                     {
-                        // don't count '.' but change to float
-                        type = value_t::number_float;
-                        continue;
+                        goto basic_json_parser_14;
                     }
-                    // assume exponent (if not then will fail parse): change to
-                    // float, stop counting and record exponent details
-                    type = value_t::number_float;
+                    if (yych <= '9')
+                    {
+                        goto basic_json_parser_49;
+                    }
+                    goto basic_json_parser_14;
+                }
+                else
+                {
+                    if (yych <= 'E')
+                    {
+                        goto basic_json_parser_44;
+                    }
+                    if (yych == 'e')
+                    {
+                        goto basic_json_parser_44;
+                    }
+                    goto basic_json_parser_14;
+                }
+basic_json_parser_51:
+                yych = *++m_cursor;
+                if (yych <= '/')
+                {
+                    goto basic_json_parser_32;
+                }
+                if (yych >= ':')
+                {
+                    goto basic_json_parser_32;
+                }
+basic_json_parser_52:
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    fill_line_buffer(1);    // LCOV_EXCL_LINE
+                }
+                yych = *m_cursor;
+                if (yych <= '/')
+                {
+                    goto basic_json_parser_14;
+                }
+                if (yych <= '9')
+                {
+                    goto basic_json_parser_52;
+                }
+                goto basic_json_parser_14;
+basic_json_parser_54:
+                yych = *++m_cursor;
+                if (yych == 's')
+                {
+                    goto basic_json_parser_58;
+                }
+                goto basic_json_parser_32;
+basic_json_parser_55:
+                yych = *++m_cursor;
+                if (yych == 'l')
+                {
+                    goto basic_json_parser_59;
+                }
+                goto basic_json_parser_32;
+basic_json_parser_56:
+                yych = *++m_cursor;
+                if (yych == 'e')
+                {
+                    goto basic_json_parser_61;
+                }
+                goto basic_json_parser_32;
+basic_json_parser_57:
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    fill_line_buffer(1);    // LCOV_EXCL_LINE
+                }
+                yych = *m_cursor;
+                if (yych <= '@')
+                {
+                    if (yych <= '/')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                    if (yych <= '9')
+                    {
+                        goto basic_json_parser_63;
+                    }
+                    goto basic_json_parser_32;
+                }
+                else
+                {
+                    if (yych <= 'F')
+                    {
+                        goto basic_json_parser_63;
+                    }
+                    if (yych <= '`')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                    if (yych <= 'f')
+                    {
+                        goto basic_json_parser_63;
+                    }
+                    goto basic_json_parser_32;
+                }
+basic_json_parser_58:
+                yych = *++m_cursor;
+                if (yych == 'e')
+                {
+                    goto basic_json_parser_64;
+                }
+                goto basic_json_parser_32;
+basic_json_parser_59:
+                ++m_cursor;
+                {
+                    last_token_type = token_type::literal_null;
                     break;
                 }
-
-                // skip if definitely not an integer
-                if (type != value_t::number_float)
+basic_json_parser_61:
+                ++m_cursor;
                 {
-                    auto digit = static_cast<number_unsigned_t>(*curptr - '0');
-
-                    // overflow if value * 10 + digit > max, move terms around
-                    // to avoid overflow in intermediate values
-                    if (value > (max - digit) / 10)
-                    {
-                        // overflow
-                        type = value_t::number_float;
-                    }
-                    else
-                    {
-                        // no overflow
-                        value = value * 10 + digit;
-                    }
+                    last_token_type = token_type::literal_true;
+                    break;
                 }
-            }
-
-            // save the value (if not a float)
-            if (type == value_t::number_unsigned)
-            {
-                result.m_value.number_unsigned = value;
-            }
-            else if (type == value_t::number_integer)
-            {
-                // invariant: if we parsed a '-', the absolute value is between
-                // 0 (we allow -0) and max == -INT64_MIN
-                assert(value >= 0);
-                assert(value <= max);
-
-                if (value == max)
+basic_json_parser_63:
+                ++m_cursor;
+                if (m_limit <= m_cursor)
                 {
-                    // we cannot simply negate value (== max == -INT64_MIN),
-                    // see https://github.com/nlohmann/json/issues/389
-                    result.m_value.number_integer = static_cast<number_integer_t>(INT64_MIN);
+                    fill_line_buffer(1);    // LCOV_EXCL_LINE
+                }
+                yych = *m_cursor;
+                if (yych <= '@')
+                {
+                    if (yych <= '/')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                    if (yych <= '9')
+                    {
+                        goto basic_json_parser_66;
+                    }
+                    goto basic_json_parser_32;
                 }
                 else
                 {
-                    // all other values can be negated safely
-                    result.m_value.number_integer = -static_cast<number_integer_t>(value);
+                    if (yych <= 'F')
+                    {
+                        goto basic_json_parser_66;
+                    }
+                    if (yych <= '`')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                    if (yych <= 'f')
+                    {
+                        goto basic_json_parser_66;
+                    }
+                    goto basic_json_parser_32;
                 }
+basic_json_parser_64:
+                ++m_cursor;
+                {
+                    last_token_type = token_type::literal_false;
+                    break;
+                }
+basic_json_parser_66:
+                ++m_cursor;
+                if (m_limit <= m_cursor)
+                {
+                    fill_line_buffer(1);    // LCOV_EXCL_LINE
+                }
+                yych = *m_cursor;
+                if (yych <= '@')
+                {
+                    if (yych <= '/')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                    if (yych <= '9')
+                    {
+                        goto basic_json_parser_30;
+                    }
+                    goto basic_json_parser_32;
+                }
+                else
+                {
+                    if (yych <= 'F')
+                    {
+                        goto basic_json_parser_30;
+                    }
+                    if (yych <= '`')
+                    {
+                        goto basic_json_parser_32;
+                    }
+                    if (yych <= 'f')
+                    {
+                        goto basic_json_parser_30;
+                    }
+                    goto basic_json_parser_32;
+                }
+            }
+
+        }
+
+        return last_token_type;
+    }
+
+    /*!
+    @brief append data from the stream to the line buffer
+
+    This function is called by the scan() function when the end of the
+    buffer (`m_limit`) is reached and the `m_cursor` pointer cannot be
+    incremented without leaving the limits of the line buffer. Note re2c
+    decides when to call this function.
+
+    If the lexer reads from contiguous storage, there is no trailing null
+    byte. Therefore, this function must make sure to add these padding
+    null bytes.
+
+    If the lexer reads from an input stream, this function reads the next
+    line of the input.
+
+    @pre
+        p p p p p p u u u u u x . . . . . .
+        ^           ^       ^   ^
+        m_content   m_start |   m_limit
+                            m_cursor
+
+    @post
+        u u u u u x x x x x x x . . . . . .
+        ^       ^               ^
+        |       m_cursor        m_limit
+        m_start
+        m_content
+    */
+    void fill_line_buffer(size_t n = 0)
+    {
+        // if line buffer is used, m_content points to its data
+        assert(m_line_buffer.empty()
+               or m_content == reinterpret_cast<const lexer_char_t*>(m_line_buffer.data()));
+
+        // if line buffer is used, m_limit is set past the end of its data
+        assert(m_line_buffer.empty()
+               or m_limit == m_content + m_line_buffer.size());
+
+        // pointer relationships
+        assert(m_content <= m_start);
+        assert(m_start <= m_cursor);
+        assert(m_cursor <= m_limit);
+        assert(m_marker == nullptr or m_marker  <= m_limit);
+
+        // number of processed characters (p)
+            const auto num_processed_chars = static_cast<size_t>(m_start - m_content);
+        // offset for m_marker wrt. to m_start
+        const auto offset_marker = (m_marker == nullptr) ? 0 : m_marker - m_start;
+        // number of unprocessed characters (u)
+        const auto offset_cursor = m_cursor - m_start;
+
+        // no stream is used or end of file is reached
+        if (m_stream == nullptr or m_stream->eof())
+        {
+            // m_start may or may not be pointing into m_line_buffer at
+            // this point. We trust the standand library to do the right
+            // thing. See http://stackoverflow.com/q/28142011/266378
+            m_line_buffer.assign(m_start, m_limit);
+
+            // append n characters to make sure that there is sufficient
+            // space between m_cursor and m_limit
+            m_line_buffer.append(1, '\x00');
+            if (n > 0)
+            {
+                m_line_buffer.append(n - 1, '\x01');
+            }
+        }
+        else
+        {
+            // delete processed characters from line buffer
+            m_line_buffer.erase(0, num_processed_chars);
+            // read next line from input stream
+            m_line_buffer_tmp.clear();
+            std::getline(*m_stream, m_line_buffer_tmp, '\n');
+
+            // add line with newline symbol to the line buffer
+            m_line_buffer += m_line_buffer_tmp;
+            m_line_buffer.push_back('\n');
+        }
+
+        // set pointers
+        m_content = reinterpret_cast<const lexer_char_t*>(m_line_buffer.data());
+        assert(m_content != nullptr);
+        m_start  = m_content;
+        m_marker = m_start + offset_marker;
+        m_cursor = m_start + offset_cursor;
+        m_limit  = m_start + m_line_buffer.size();
+    }
+
+    /// return string representation of last read token
+    string_t get_token_string() const
+    {
+        assert(m_start != nullptr);
+        return string_t(reinterpret_cast<typename string_t::const_pointer>(m_start),
+                        static_cast<size_t>(m_cursor - m_start));
+    }
+
+    /*!
+    @brief return string value for string tokens
+
+    The function iterates the characters between the opening and closing
+    quotes of the string value. The complete string is the range
+    [m_start,m_cursor). Consequently, we iterate from m_start+1 to
+    m_cursor-1.
+
+    We differentiate two cases:
+
+    1. Escaped characters. In this case, a new character is constructed
+       according to the nature of the escape. Some escapes create new
+       characters (e.g., `"\\n"` is replaced by `"\n"`), some are copied
+       as is (e.g., `"\\\\"`). Furthermore, Unicode escapes of the shape
+       `"\\uxxxx"` need special care. In this case, to_unicode takes care
+       of the construction of the values.
+    2. Unescaped characters are copied as is.
+
+    @pre `m_cursor - m_start >= 2`, meaning the length of the last token
+    is at least 2 bytes which is trivially true for any string (which
+    consists of at least two quotes).
+
+        " c1 c2 c3 ... "
+        ^                ^
+        m_start          m_cursor
+
+    @complexity Linear in the length of the string.\n
+
+    Lemma: The loop body will always terminate.\n
+
+    Proof (by contradiction): Assume the loop body does not terminate. As
+    the loop body does not contain another loop, one of the called
+    functions must never return. The called functions are `std::strtoul`
+    and to_unicode. Neither function can loop forever, so the loop body
+    will never loop forever which contradicts the assumption that the loop
+    body does not terminate, q.e.d.\n
+
+    Lemma: The loop condition for the for loop is eventually false.\n
+
+    Proof (by contradiction): Assume the loop does not terminate. Due to
+    the above lemma, this can only be due to a tautological loop
+    condition; that is, the loop condition i < m_cursor - 1 must always be
+    true. Let x be the change of i for any loop iteration. Then
+    m_start + 1 + x < m_cursor - 1 must hold to loop indefinitely. This
+    can be rephrased to m_cursor - m_start - 2 > x. With the
+    precondition, we x <= 0, meaning that the loop condition holds
+    indefinitly if i is always decreased. However, observe that the value
+    of i is strictly increasing with each iteration, as it is incremented
+    by 1 in the iteration expression and never decremented inside the loop
+    body. Hence, the loop condition will eventually be false which
+    contradicts the assumption that the loop condition is a tautology,
+    q.e.d.
+
+    @return string value of current token without opening and closing
+    quotes
+    @throw std::out_of_range if to_unicode fails
+    */
+    string_t get_string() const
+    {
+        assert(m_cursor - m_start >= 2);
+
+        string_t result;
+        result.reserve(static_cast<size_t>(m_cursor - m_start - 2));
+
+        // iterate the result between the quotes
+        for (const lexer_char_t* i = m_start + 1; i < m_cursor - 1; ++i)
+        {
+            // find next escape character
+            auto e = std::find(i, m_cursor - 1, '\\');
+            if (e != i)
+            {
+                // see https://github.com/nlohmann/json/issues/365#issuecomment-262874705
+                for (auto k = i; k < e; k++)
+                {
+                    result.push_back(static_cast<typename string_t::value_type>(*k));
+                }
+                i = e - 1; // -1 because of ++i
             }
             else
             {
-                // parse with strtod
-                result.m_value.number_float = str_to_float_t(static_cast<number_float_t*>(nullptr), nullptr);
+                // processing escaped character
+                // read next character
+                ++i;
 
-                // replace infinity and NAN by null
-                if (not std::isfinite(result.m_value.number_float))
+                switch (*i)
                 {
-                    type = value_t::null;
-                    result.m_value = basic_json::json_value();
+                    // the default escapes
+                    case 't':
+                    {
+                        result += "\t";
+                        break;
+                    }
+                    case 'b':
+                    {
+                        result += "\b";
+                        break;
+                    }
+                    case 'f':
+                    {
+                        result += "\f";
+                        break;
+                    }
+                    case 'n':
+                    {
+                        result += "\n";
+                        break;
+                    }
+                    case 'r':
+                    {
+                        result += "\r";
+                        break;
+                    }
+                    case '\\':
+                    {
+                        result += "\\";
+                        break;
+                    }
+                    case '/':
+                    {
+                        result += "/";
+                        break;
+                    }
+                    case '"':
+                    {
+                        result += "\"";
+                        break;
+                    }
+
+                    // unicode
+                    case 'u':
+                    {
+                        // get code xxxx from uxxxx
+                        auto codepoint = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>(i + 1),
+                                                      4).c_str(), nullptr, 16);
+
+                        // check if codepoint is a high surrogate
+                        if (codepoint >= 0xD800 and codepoint <= 0xDBFF)
+                        {
+                            // make sure there is a subsequent unicode
+                            if ((i + 6 >= m_limit) or * (i + 5) != '\\' or * (i + 6) != 'u')
+                            {
+                                    JSON_THROW(std::invalid_argument("missing low surrogate"));
+                            }
+
+                            // get code yyyy from uxxxx\uyyyy
+                            auto codepoint2 = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>
+                                                           (i + 7), 4).c_str(), nullptr, 16);
+                            result += to_unicode(codepoint, codepoint2);
+                            // skip the next 10 characters (xxxx\uyyyy)
+                            i += 10;
+                        }
+                        else if (codepoint >= 0xDC00 and codepoint <= 0xDFFF)
+                        {
+                            // we found a lone low surrogate
+                                JSON_THROW(std::invalid_argument("missing high surrogate"));
+                        }
+                        else
+                        {
+                            // add unicode character(s)
+                            result += to_unicode(codepoint);
+                            // skip the next four characters (xxxx)
+                            i += 4;
+                        }
+                        break;
+                    }
                 }
             }
-
-            // save the type
-            result.m_type = type;
         }
 
-      private:
-        /// optional input stream
-        std::istream* m_stream = nullptr;
-        /// line buffer buffer for m_stream
-        string_t m_line_buffer {};
-        /// used for filling m_line_buffer
-        string_t m_line_buffer_tmp {};
-        /// the buffer pointer
-        const lexer_char_t* m_content = nullptr;
-        /// pointer to the beginning of the current symbol
-        const lexer_char_t* m_start = nullptr;
-        /// pointer for backtracking information
-        const lexer_char_t* m_marker = nullptr;
-        /// pointer to the current symbol
-        const lexer_char_t* m_cursor = nullptr;
-        /// pointer to the end of the buffer
-        const lexer_char_t* m_limit = nullptr;
-        /// the last token type
-        token_type last_token_type = token_type::end_of_input;
-    };
+        return result;
+    }
+
+    /*!
+    @brief parse floating point number
+
+    This function (and its overloads) serves to select the most approprate
+    standard floating point number parsing function based on the type
+    supplied via the first parameter.  Set this to @a
+    static_cast<number_float_t*>(nullptr).
+
+    @param[in,out] endptr recieves a pointer to the first character after
+    the number
+
+    @return the floating point number
+    */
+    long double str_to_float_t(long double* /* type */, char** endptr) const
+    {
+        return std::strtold(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
+    }
+
+    /*!
+    @brief parse floating point number
+
+    This function (and its overloads) serves to select the most approprate
+    standard floating point number parsing function based on the type
+    supplied via the first parameter.  Set this to @a
+    static_cast<number_float_t*>(nullptr).
+
+    @param[in,out] endptr  recieves a pointer to the first character after
+    the number
+
+    @return the floating point number
+    */
+    double str_to_float_t(double* /* type */, char** endptr) const
+    {
+        return std::strtod(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
+    }
+
+    /*!
+    @brief parse floating point number
+
+    This function (and its overloads) serves to select the most approprate
+    standard floating point number parsing function based on the type
+    supplied via the first parameter.  Set this to @a
+    static_cast<number_float_t*>(nullptr).
+
+    @param[in,out] endptr  recieves a pointer to the first character after
+    the number
+
+    @return the floating point number
+    */
+    float str_to_float_t(float* /* type */, char** endptr) const
+    {
+        return std::strtof(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
+    }
+
+    /*!
+    @brief return number value for number tokens
+
+    This function translates the last token into the most appropriate
+    number type (either integer, unsigned integer or floating point),
+    which is passed back to the caller via the result parameter.
+
+    This function parses the integer component up to the radix point or
+    exponent while collecting information about the 'floating point
+    representation', which it stores in the result parameter. If there is
+    no radix point or exponent, and the number can fit into a @ref
+    number_integer_t or @ref number_unsigned_t then it sets the result
+    parameter accordingly.
+
+    If the number is a floating point number the number is then parsed
+    using @a std:strtod (or @a std:strtof or @a std::strtold).
+
+    @param[out] result  @ref basic_json object to receive the number, or
+    NAN if the conversion read past the current token. The latter case
+    needs to be treated by the caller function.
+    */
+    void get_number(basic_json& result) const
+    {
+        assert(m_start != nullptr);
+
+        const lexer::lexer_char_t* curptr = m_start;
+
+        // accumulate the integer conversion result (unsigned for now)
+        number_unsigned_t value = 0;
+
+        // maximum absolute value of the relevant integer type
+        number_unsigned_t max;
+
+        // temporarily store the type to avoid unecessary bitfield access
+        value_t type;
+
+        // look for sign
+        if (*curptr == '-')
+        {
+            type = value_t::number_integer;
+            max = static_cast<uint64_t>((std::numeric_limits<number_integer_t>::max)()) + 1;
+            curptr++;
+        }
+        else
+        {
+            type = value_t::number_unsigned;
+            max = static_cast<uint64_t>((std::numeric_limits<number_unsigned_t>::max)());
+        }
+
+        // count the significant figures
+        for (; curptr < m_cursor; curptr++)
+        {
+            // quickly skip tests if a digit
+            if (*curptr < '0' || *curptr > '9')
+            {
+                if (*curptr == '.')
+                {
+                    // don't count '.' but change to float
+                    type = value_t::number_float;
+                    continue;
+                }
+                // assume exponent (if not then will fail parse): change to
+                // float, stop counting and record exponent details
+                type = value_t::number_float;
+                break;
+            }
+
+            // skip if definitely not an integer
+            if (type != value_t::number_float)
+            {
+                auto digit = static_cast<number_unsigned_t>(*curptr - '0');
+
+                // overflow if value * 10 + digit > max, move terms around
+                // to avoid overflow in intermediate values
+                if (value > (max - digit) / 10)
+                {
+                    // overflow
+                    type = value_t::number_float;
+                }
+                else
+                {
+                    // no overflow
+                    value = value * 10 + digit;
+                }
+            }
+        }
+
+        // save the value (if not a float)
+        if (type == value_t::number_unsigned)
+        {
+            result.m_value.number_unsigned = value;
+        }
+        else if (type == value_t::number_integer)
+        {
+            // invariant: if we parsed a '-', the absolute value is between
+            // 0 (we allow -0) and max == -INT64_MIN
+            assert(value >= 0);
+            assert(value <= max);
+
+            if (value == max)
+            {
+                // we cannot simply negate value (== max == -INT64_MIN),
+                // see https://github.com/nlohmann/json/issues/389
+                result.m_value.number_integer = static_cast<number_integer_t>(INT64_MIN);
+            }
+            else
+            {
+                // all other values can be negated safely
+                result.m_value.number_integer = -static_cast<number_integer_t>(value);
+            }
+        }
+        else
+        {
+            // parse with strtod
+                result.m_value.number_float = str_to_float_t(static_cast<number_float_t*>(nullptr), nullptr);
+
+            // replace infinity and NAN by null
+            if (not std::isfinite(result.m_value.number_float))
+            {
+                type = value_t::null;
+                result.m_value = basic_json::json_value();
+            }
+        }
+
+        // save the type
+        result.m_type = type;
+    }
+
+    private:
+    /// optional input stream
+    std::istream* m_stream = nullptr;
+    /// line buffer buffer for m_stream
+    string_t m_line_buffer {};
+    /// used for filling m_line_buffer
+    string_t m_line_buffer_tmp {};
+    /// the buffer pointer
+    const lexer_char_t* m_content = nullptr;
+    /// pointer to the beginning of the current symbol
+    const lexer_char_t* m_start = nullptr;
+    /// pointer for backtracking information
+    const lexer_char_t* m_marker = nullptr;
+    /// pointer to the current symbol
+    const lexer_char_t* m_cursor = nullptr;
+    /// pointer to the end of the buffer
+    const lexer_char_t* m_limit = nullptr;
+    /// the last token type
+    token_type last_token_type = token_type::end_of_input;
+                                                };
 
     /*!
     @brief syntax analysis
@@ -11130,282 +11141,282 @@ basic_json_parser_66:
     */
     class parser
     {
-      public:
+        public:
         /// a parser reading from a string literal
         parser(const char* buff, const parser_callback_t cb = nullptr)
-            : callback(cb),
-              m_lexer(reinterpret_cast<const typename lexer::lexer_char_t*>(buff), std::strlen(buff))
-        {}
+        : callback(cb),
+        m_lexer(reinterpret_cast<const typename lexer::lexer_char_t*>(buff), std::strlen(buff))
+    {}
 
-        /// a parser reading from an input stream
-        parser(std::istream& is, const parser_callback_t cb = nullptr)
-            : callback(cb), m_lexer(is)
-        {}
+    /// a parser reading from an input stream
+    parser(std::istream& is, const parser_callback_t cb = nullptr)
+    : callback(cb), m_lexer(is)
+    {}
 
-        /// a parser reading from an iterator range with contiguous storage
-        template<class IteratorType, typename std::enable_if<
-                     std::is_same<typename std::iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value
-                     , int>::type
-                 = 0>
-        parser(IteratorType first, IteratorType last, const parser_callback_t cb = nullptr)
-            : callback(cb),
-              m_lexer(reinterpret_cast<const typename lexer::lexer_char_t*>(&(*first)),
-                      static_cast<size_t>(std::distance(first, last)))
-        {}
+    /// a parser reading from an iterator range with contiguous storage
+    template<class IteratorType, typename std::enable_if<
+                 std::is_same<typename std::iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value
+                 , int>::type
+             = 0>
+    parser(IteratorType first, IteratorType last, const parser_callback_t cb = nullptr)
+    : callback(cb),
+    m_lexer(reinterpret_cast<const typename lexer::lexer_char_t*>(&(*first)),
+            static_cast<size_t>(std::distance(first, last)))
+    {}
 
-        /// public parser interface
-        basic_json parse()
+    /// public parser interface
+    basic_json parse()
+    {
+        // read first token
+        get_token();
+
+        basic_json result = parse_internal(true);
+        result.assert_invariant();
+
+        expect(lexer::token_type::end_of_input);
+
+        // return parser result and replace it with null in case the
+        // top-level value was discarded by the callback function
+        return result.is_discarded() ? basic_json() : std::move(result);
+    }
+
+    private:
+    /// the actual parser
+    basic_json parse_internal(bool keep)
+    {
+        auto result = basic_json(value_t::discarded);
+
+        switch (last_token)
         {
-            // read first token
-            get_token();
-
-            basic_json result = parse_internal(true);
-            result.assert_invariant();
-
-            expect(lexer::token_type::end_of_input);
-
-            // return parser result and replace it with null in case the
-            // top-level value was discarded by the callback function
-            return result.is_discarded() ? basic_json() : std::move(result);
-        }
-
-      private:
-        /// the actual parser
-        basic_json parse_internal(bool keep)
-        {
-            auto result = basic_json(value_t::discarded);
-
-            switch (last_token)
+            case lexer::token_type::begin_object:
             {
-                case lexer::token_type::begin_object:
+                if (keep and (not callback
+                              or ((keep = callback(depth++, parse_event_t::object_start, result)) != 0)))
                 {
-                    if (keep and (not callback
-                                  or ((keep = callback(depth++, parse_event_t::object_start, result)) != 0)))
-                    {
-                        // explicitly set result to object to cope with {}
-                        result.m_type = value_t::object;
-                        result.m_value = value_t::object;
-                    }
+                    // explicitly set result to object to cope with {}
+                    result.m_type = value_t::object;
+                    result.m_value = value_t::object;
+                }
 
-                    // read next token
-                    get_token();
+                // read next token
+                get_token();
 
-                    // closing } -> we are done
-                    if (last_token == lexer::token_type::end_object)
-                    {
-                        get_token();
-                        if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
-                        {
-                            result = basic_json(value_t::discarded);
-                        }
-                        return result;
-                    }
-
-                    // no comma is expected here
-                    unexpect(lexer::token_type::value_separator);
-
-                    // otherwise: parse key-value pairs
-                    do
-                    {
-                        // ugly, but could be fixed with loop reorganization
-                        if (last_token == lexer::token_type::value_separator)
-                        {
-                            get_token();
-                        }
-
-                        // store key
-                        expect(lexer::token_type::value_string);
-                        const auto key = m_lexer.get_string();
-
-                        bool keep_tag = false;
-                        if (keep)
-                        {
-                            if (callback)
-                            {
-                                basic_json k(key);
-                                keep_tag = callback(depth, parse_event_t::key, k);
-                            }
-                            else
-                            {
-                                keep_tag = true;
-                            }
-                        }
-
-                        // parse separator (:)
-                        get_token();
-                        expect(lexer::token_type::name_separator);
-
-                        // parse and add value
-                        get_token();
-                        auto value = parse_internal(keep);
-                        if (keep and keep_tag and not value.is_discarded())
-                        {
-                            result[key] = std::move(value);
-                        }
-                    }
-                    while (last_token == lexer::token_type::value_separator);
-
-                    // closing }
-                    expect(lexer::token_type::end_object);
+                // closing } -> we are done
+                if (last_token == lexer::token_type::end_object)
+                {
                     get_token();
                     if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
                     {
                         result = basic_json(value_t::discarded);
                     }
-
                     return result;
                 }
 
-                case lexer::token_type::begin_array:
+                // no comma is expected here
+                unexpect(lexer::token_type::value_separator);
+
+                // otherwise: parse key-value pairs
+                do
                 {
-                    if (keep and (not callback
-                                  or ((keep = callback(depth++, parse_event_t::array_start, result)) != 0)))
-                    {
-                        // explicitly set result to object to cope with []
-                        result.m_type = value_t::array;
-                        result.m_value = value_t::array;
-                    }
-
-                    // read next token
-                    get_token();
-
-                    // closing ] -> we are done
-                    if (last_token == lexer::token_type::end_array)
+                    // ugly, but could be fixed with loop reorganization
+                    if (last_token == lexer::token_type::value_separator)
                     {
                         get_token();
-                        if (callback and not callback(--depth, parse_event_t::array_end, result))
-                        {
-                            result = basic_json(value_t::discarded);
-                        }
-                        return result;
                     }
 
-                    // no comma is expected here
-                    unexpect(lexer::token_type::value_separator);
+                    // store key
+                    expect(lexer::token_type::value_string);
+                    const auto key = m_lexer.get_string();
 
-                    // otherwise: parse values
-                    do
+                    bool keep_tag = false;
+                    if (keep)
                     {
-                        // ugly, but could be fixed with loop reorganization
-                        if (last_token == lexer::token_type::value_separator)
+                        if (callback)
                         {
-                            get_token();
+                            basic_json k(key);
+                            keep_tag = callback(depth, parse_event_t::key, k);
                         }
-
-                        // parse value
-                        auto value = parse_internal(keep);
-                        if (keep and not value.is_discarded())
+                        else
                         {
-                            result.push_back(std::move(value));
+                            keep_tag = true;
                         }
                     }
-                    while (last_token == lexer::token_type::value_separator);
 
-                    // closing ]
-                    expect(lexer::token_type::end_array);
+                    // parse separator (:)
                     get_token();
-                    if (keep and callback and not callback(--depth, parse_event_t::array_end, result))
+                    expect(lexer::token_type::name_separator);
+
+                    // parse and add value
+                    get_token();
+                    auto value = parse_internal(keep);
+                    if (keep and keep_tag and not value.is_discarded())
+                    {
+                        result[key] = std::move(value);
+                    }
+                }
+                while (last_token == lexer::token_type::value_separator);
+
+                // closing }
+                expect(lexer::token_type::end_object);
+                get_token();
+                if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
+                {
+                    result = basic_json(value_t::discarded);
+                }
+
+                return result;
+            }
+
+            case lexer::token_type::begin_array:
+            {
+                if (keep and (not callback
+                              or ((keep = callback(depth++, parse_event_t::array_start, result)) != 0)))
+                {
+                    // explicitly set result to object to cope with []
+                    result.m_type = value_t::array;
+                    result.m_value = value_t::array;
+                }
+
+                // read next token
+                get_token();
+
+                // closing ] -> we are done
+                if (last_token == lexer::token_type::end_array)
+                {
+                    get_token();
+                    if (callback and not callback(--depth, parse_event_t::array_end, result))
                     {
                         result = basic_json(value_t::discarded);
                     }
-
                     return result;
                 }
 
-                case lexer::token_type::literal_null:
+                // no comma is expected here
+                unexpect(lexer::token_type::value_separator);
+
+                // otherwise: parse values
+                do
                 {
-                    get_token();
-                    result.m_type = value_t::null;
-                    break;
+                    // ugly, but could be fixed with loop reorganization
+                    if (last_token == lexer::token_type::value_separator)
+                    {
+                        get_token();
+                    }
+
+                    // parse value
+                    auto value = parse_internal(keep);
+                    if (keep and not value.is_discarded())
+                    {
+                        result.push_back(std::move(value));
+                    }
+                }
+                while (last_token == lexer::token_type::value_separator);
+
+                // closing ]
+                expect(lexer::token_type::end_array);
+                get_token();
+                if (keep and callback and not callback(--depth, parse_event_t::array_end, result))
+                {
+                    result = basic_json(value_t::discarded);
                 }
 
-                case lexer::token_type::value_string:
-                {
-                    const auto s = m_lexer.get_string();
-                    get_token();
-                    result = basic_json(s);
-                    break;
-                }
-
-                case lexer::token_type::literal_true:
-                {
-                    get_token();
-                    result.m_type = value_t::boolean;
-                    result.m_value = true;
-                    break;
-                }
-
-                case lexer::token_type::literal_false:
-                {
-                    get_token();
-                    result.m_type = value_t::boolean;
-                    result.m_value = false;
-                    break;
-                }
-
-                case lexer::token_type::value_number:
-                {
-                    m_lexer.get_number(result);
-                    get_token();
-                    break;
-                }
-
-                default:
-                {
-                    // the last token was unexpected
-                    unexpect(last_token);
-                }
+                return result;
             }
 
-            if (keep and callback and not callback(depth, parse_event_t::value, result))
+            case lexer::token_type::literal_null:
             {
-                result = basic_json(value_t::discarded);
+                get_token();
+                result.m_type = value_t::null;
+                break;
             }
-            return result;
-        }
 
-        /// get next token from lexer
-        typename lexer::token_type get_token()
-        {
-            last_token = m_lexer.scan();
-            return last_token;
-        }
-
-        void expect(typename lexer::token_type t) const
-        {
-            if (t != last_token)
+            case lexer::token_type::value_string:
             {
-                std::string error_msg = "parse error - unexpected ";
-                error_msg += (last_token == lexer::token_type::parse_error ? ("'" +  m_lexer.get_token_string() +
-                              "'") :
-                              lexer::token_type_name(last_token));
-                error_msg += "; expected " + lexer::token_type_name(t);
+                const auto s = m_lexer.get_string();
+                get_token();
+                result = basic_json(s);
+                break;
+            }
+
+            case lexer::token_type::literal_true:
+            {
+                get_token();
+                result.m_type = value_t::boolean;
+                result.m_value = true;
+                break;
+            }
+
+            case lexer::token_type::literal_false:
+            {
+                get_token();
+                result.m_type = value_t::boolean;
+                result.m_value = false;
+                break;
+            }
+
+            case lexer::token_type::value_number:
+            {
+                m_lexer.get_number(result);
+                get_token();
+                break;
+            }
+
+            default:
+            {
+                // the last token was unexpected
+                unexpect(last_token);
+            }
+        }
+
+        if (keep and callback and not callback(depth, parse_event_t::value, result))
+        {
+            result = basic_json(value_t::discarded);
+        }
+        return result;
+    }
+
+    /// get next token from lexer
+    typename lexer::token_type get_token()
+    {
+        last_token = m_lexer.scan();
+        return last_token;
+    }
+
+    void expect(typename lexer::token_type t) const
+    {
+        if (t != last_token)
+        {
+            std::string error_msg = "parse error - unexpected ";
+            error_msg += (last_token == lexer::token_type::parse_error ? ("'" +  m_lexer.get_token_string() +
+                          "'") :
+                          lexer::token_type_name(last_token));
+            error_msg += "; expected " + lexer::token_type_name(t);
                 JSON_THROW(std::invalid_argument(error_msg));
-            }
         }
+    }
 
-        void unexpect(typename lexer::token_type t) const
+    void unexpect(typename lexer::token_type t) const
+    {
+        if (t == last_token)
         {
-            if (t == last_token)
-            {
-                std::string error_msg = "parse error - unexpected ";
-                error_msg += (last_token == lexer::token_type::parse_error ? ("'" +  m_lexer.get_token_string() +
-                              "'") :
-                              lexer::token_type_name(last_token));
+            std::string error_msg = "parse error - unexpected ";
+            error_msg += (last_token == lexer::token_type::parse_error ? ("'" +  m_lexer.get_token_string() +
+                          "'") :
+                          lexer::token_type_name(last_token));
                 JSON_THROW(std::invalid_argument(error_msg));
-            }
         }
+    }
 
-      private:
-        /// current level of recursion
-        int depth = 0;
-        /// callback function
-        const parser_callback_t callback = nullptr;
-        /// the type of the last read token
-        typename lexer::token_type last_token = lexer::token_type::uninitialized;
-        /// the lexer
-        lexer m_lexer;
-    };
+    private:
+    /// current level of recursion
+    int depth = 0;
+    /// callback function
+    const parser_callback_t callback = nullptr;
+    /// the type of the last read token
+    typename lexer::token_type last_token = lexer::token_type::uninitialized;
+    /// the lexer
+    lexer m_lexer;
+                            };
 
   public:
     /*!
@@ -11424,7 +11435,7 @@ basic_json_parser_66:
         /// allow basic_json to access private members
         friend class basic_json;
 
-      public:
+        public:
         /*!
         @brief create JSON pointer
 
@@ -11448,562 +11459,562 @@ basic_json_parser_66:
         @since version 2.0.0
         */
         explicit json_pointer(const std::string& s = "")
-            : reference_tokens(split(s))
-        {}
+        : reference_tokens(split(s))
+    {}
 
-        /*!
-        @brief return a string representation of the JSON pointer
+    /*!
+    @brief return a string representation of the JSON pointer
 
-        @invariant For each JSON pointer `ptr`, it holds:
-        @code {.cpp}
-        ptr == json_pointer(ptr.to_string());
-        @endcode
+    @invariant For each JSON pointer `ptr`, it holds:
+    @code {.cpp}
+    ptr == json_pointer(ptr.to_string());
+    @endcode
 
-        @return a string representation of the JSON pointer
+    @return a string representation of the JSON pointer
 
-        @liveexample{The example shows the result of `to_string`.,
-        json_pointer__to_string}
+    @liveexample{The example shows the result of `to_string`.,
+    json_pointer__to_string}
 
-        @since version 2.0.0
-        */
-        std::string to_string() const noexcept
+    @since version 2.0.0
+    */
+    std::string to_string() const noexcept
+    {
+        return std::accumulate(reference_tokens.begin(),
+                               reference_tokens.end(), std::string{},
+                               [](const std::string & a, const std::string & b)
         {
-            return std::accumulate(reference_tokens.begin(),
-                                   reference_tokens.end(), std::string{},
-                                   [](const std::string & a, const std::string & b)
-            {
-                return a + "/" + escape(b);
-            });
-        }
+            return a + "/" + escape(b);
+        });
+    }
 
-        /// @copydoc to_string()
-        operator std::string() const
-        {
-            return to_string();
-        }
+    /// @copydoc to_string()
+    operator std::string() const
+    {
+        return to_string();
+    }
 
-      private:
-        /// remove and return last reference pointer
-        std::string pop_back()
+    private:
+    /// remove and return last reference pointer
+    std::string pop_back()
+    {
+        if (is_root())
         {
-            if (is_root())
-            {
                 JSON_THROW(std::domain_error("JSON pointer has no parent"));
-            }
-
-            auto last = reference_tokens.back();
-            reference_tokens.pop_back();
-            return last;
         }
 
-        /// return whether pointer points to the root document
-        bool is_root() const
-        {
-            return reference_tokens.empty();
-        }
+        auto last = reference_tokens.back();
+        reference_tokens.pop_back();
+        return last;
+    }
 
-        json_pointer top() const
+    /// return whether pointer points to the root document
+    bool is_root() const
+    {
+        return reference_tokens.empty();
+    }
+
+    json_pointer top() const
+    {
+        if (is_root())
         {
-            if (is_root())
-            {
                 JSON_THROW(std::domain_error("JSON pointer has no parent"));
-            }
-
-            json_pointer result = *this;
-            result.reference_tokens = {reference_tokens[0]};
-            return result;
         }
 
-        /*!
-        @brief create and return a reference to the pointed to value
+        json_pointer result = *this;
+        result.reference_tokens = {reference_tokens[0]};
+        return result;
+    }
 
-        @complexity Linear in the number of reference tokens.
-        */
-        reference get_and_create(reference j) const
+    /*!
+    @brief create and return a reference to the pointed to value
+
+    @complexity Linear in the number of reference tokens.
+    */
+    reference get_and_create(reference j) const
+    {
+        pointer 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)
         {
-            pointer 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->m_type)
             {
-                switch (result->m_type)
+                case value_t::null:
                 {
-                    case value_t::null:
+                    if (reference_token == "0")
                     {
-                        if (reference_token == "0")
-                        {
-                            // start a new array if reference token is 0
-                            result = &result->operator[](0);
-                        }
-                        else
-                        {
-                            // start a new object otherwise
-                            result = &result->operator[](reference_token);
-                        }
-                        break;
+                        // start a new array if reference token is 0
+                        result = &result->operator[](0);
                     }
-
-                    case value_t::object:
+                    else
                     {
-                        // create an entry in the object
+                        // start a new object otherwise
                         result = &result->operator[](reference_token);
-                        break;
-                    }
-
-                    case value_t::array:
-                    {
-                        // create an entry in the array
-                        result = &result->operator[](static_cast<size_type>(std::stoi(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 single value; that is, with an
-                    empty list of reference tokens.
-                    */
-                    default:
-                    {
-                        JSON_THROW(std::domain_error("invalid value to unflatten"));
-                    }
-                }
-            }
-
-            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 std::out_of_range      if the JSON pointer can not be resolved
-        @throw std::domain_error      if an array index begins with '0'
-        @throw std::invalid_argument  if an array index was not a number
-        */
-        reference get_unchecked(pointer ptr) const
-        {
-            for (const auto& reference_token : reference_tokens)
-            {
-                // convert null values to arrays or objects before continuing
-                if (ptr->m_type == value_t::null)
-                {
-                    // check if reference token is a number
-                    const bool nums = std::all_of(reference_token.begin(),
-                                                  reference_token.end(),
-                                                  [](const char x)
-                    {
-                        return std::isdigit(x);
-                    });
-
-                    // change value to array for numbers or "-" or to object
-                    // otherwise
-                    if (nums or reference_token == "-")
-                    {
-                        *ptr = value_t::array;
-                    }
-                    else
-                    {
-                        *ptr = value_t::object;
-                    }
-                }
-
-                switch (ptr->m_type)
-                {
-                    case value_t::object:
-                    {
-                        // use unchecked object access
-                        ptr = &ptr->operator[](reference_token);
-                        break;
-                    }
-
-                    case value_t::array:
-                    {
-                        // error condition (cf. RFC 6901, Sect. 4)
-                        if (reference_token.size() > 1 and reference_token[0] == '0')
-                        {
-                            JSON_THROW(std::domain_error("array index must not begin with '0'"));
-                        }
-
-                        if (reference_token == "-")
-                        {
-                            // explicityly treat "-" as index beyond the end
-                            ptr = &ptr->operator[](ptr->m_value.array->size());
-                        }
-                        else
-                        {
-                            // convert array index to number; unchecked access
-                            ptr = &ptr->operator[](static_cast<size_type>(std::stoi(reference_token)));
-                        }
-                        break;
-                    }
-
-                    default:
-                    {
-                        JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));
-                    }
-                }
-            }
-
-            return *ptr;
-        }
-
-        reference get_checked(pointer ptr) const
-        {
-            for (const auto& reference_token : reference_tokens)
-            {
-                switch (ptr->m_type)
-                {
-                    case value_t::object:
-                    {
-                        // note: at performs range check
-                        ptr = &ptr->at(reference_token);
-                        break;
-                    }
-
-                    case value_t::array:
-                    {
-                        if (reference_token == "-")
-                        {
-                            // "-" always fails the range check
-                            throw std::out_of_range("array index '-' (" +
-                                                    std::to_string(ptr->m_value.array->size()) +
-                                                    ") is out of range");
-                        }
-
-                        // error condition (cf. RFC 6901, Sect. 4)
-                        if (reference_token.size() > 1 and reference_token[0] == '0')
-                        {
-                            JSON_THROW(std::domain_error("array index must not begin with '0'"));
-                        }
-
-                        // note: at performs range check
-                        ptr = &ptr->at(static_cast<size_type>(std::stoi(reference_token)));
-                        break;
-                    }
-
-                    default:
-                    {
-                        JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));
-                    }
-                }
-            }
-
-            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
-        */
-        const_reference get_unchecked(const_pointer ptr) const
-        {
-            for (const auto& reference_token : reference_tokens)
-            {
-                switch (ptr->m_type)
-                {
-                    case value_t::object:
-                    {
-                        // use unchecked object access
-                        ptr = &ptr->operator[](reference_token);
-                        break;
-                    }
-
-                    case value_t::array:
-                    {
-                        if (reference_token == "-")
-                        {
-                            // "-" cannot be used for const access
-                            throw std::out_of_range("array index '-' (" +
-                                                    std::to_string(ptr->m_value.array->size()) +
-                                                    ") is out of range");
-                        }
-
-                        // error condition (cf. RFC 6901, Sect. 4)
-                        if (reference_token.size() > 1 and reference_token[0] == '0')
-                        {
-                            JSON_THROW(std::domain_error("array index must not begin with '0'"));
-                        }
-
-                        // use unchecked array access
-                        ptr = &ptr->operator[](static_cast<size_type>(std::stoi(reference_token)));
-                        break;
-                    }
-
-                    default:
-                    {
-                        JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));
-                    }
-                }
-            }
-
-            return *ptr;
-        }
-
-        const_reference get_checked(const_pointer ptr) const
-        {
-            for (const auto& reference_token : reference_tokens)
-            {
-                switch (ptr->m_type)
-                {
-                    case value_t::object:
-                    {
-                        // note: at performs range check
-                        ptr = &ptr->at(reference_token);
-                        break;
-                    }
-
-                    case value_t::array:
-                    {
-                        if (reference_token == "-")
-                        {
-                            // "-" always fails the range check
-                            throw std::out_of_range("array index '-' (" +
-                                                    std::to_string(ptr->m_value.array->size()) +
-                                                    ") is out of range");
-                        }
-
-                        // error condition (cf. RFC 6901, Sect. 4)
-                        if (reference_token.size() > 1 and reference_token[0] == '0')
-                        {
-                            JSON_THROW(std::domain_error("array index must not begin with '0'"));
-                        }
-
-                        // note: at performs range check
-                        ptr = &ptr->at(static_cast<size_type>(std::stoi(reference_token)));
-                        break;
-                    }
-
-                    default:
-                    {
-                        JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));
-                    }
-                }
-            }
-
-            return *ptr;
-        }
-
-        /// split the string input to reference tokens
-        static std::vector<std::string> split(const std::string& reference_string)
-        {
-            std::vector<std::string> result;
-
-            // special case: empty reference string -> no reference tokens
-            if (reference_string.empty())
-            {
-                return result;
-            }
-
-            // check if nonempty reference string begins with slash
-            if (reference_string[0] != '/')
-            {
-                JSON_THROW(std::domain_error("JSON pointer must be empty or begin with '/'"));
-            }
-
-            // 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
-                size_t slash = reference_string.find_first_of('/', 1),
-                // set the beginning of the first reference token
-                start = 1;
-                // we can stop if start == string::npos+1 = 0
-                start != 0;
-                // set the beginning of the next reference token
-                // (will eventually be 0 if slash == std::string::npos)
-                start = 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 (size_t pos = reference_token.find_first_of('~');
-                        pos != std::string::npos;
-                        pos = reference_token.find_first_of('~', pos + 1))
-                {
-                    assert(reference_token[pos] == '~');
-
-                    // ~ must be followed by 0 or 1
-                    if (pos == reference_token.size() - 1 or
-                            (reference_token[pos + 1] != '0' and
-                             reference_token[pos + 1] != '1'))
-                    {
-                        JSON_THROW(std::domain_error("escape error: '~' must be followed with '0' or '1'"));
-                    }
-                }
-
-                // finally, store the reference token
-                unescape(reference_token);
-                result.push_back(reference_token);
-            }
-
-            return result;
-        }
-
-      private:
-        /*!
-        @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.
-
-        @since version 2.0.0
-        */
-        static void replace_substring(std::string& s,
-                                      const std::string& f,
-                                      const std::string& t)
-        {
-            assert(not f.empty());
-
-            for (
-                size_t pos = s.find(f);         // find first occurrence of f
-                pos != std::string::npos;       // make sure f was found
-                s.replace(pos, f.size(), t),    // replace with t
-                pos = s.find(f, pos + t.size()) // find next occurrence of f
-            );
-        }
-
-        /// escape tilde and slash
-        static std::string escape(std::string s)
-        {
-            // escape "~"" to "~0" and "/" to "~1"
-            replace_substring(s, "~", "~0");
-            replace_substring(s, "/", "~1");
-            return s;
-        }
-
-        /// unescape tilde and slash
-        static void unescape(std::string& s)
-        {
-            // first transform any occurrence of the sequence '~1' to '/'
-            replace_substring(s, "~1", "/");
-            // then transform any occurrence of the sequence '~0' to '~'
-            replace_substring(s, "~0", "~");
-        }
-
-        /*!
-        @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`.
-        */
-        static void flatten(const std::string& reference_string,
-                            const basic_json& value,
-                            basic_json& result)
-        {
-            switch (value.m_type)
-            {
-                case value_t::array:
-                {
-                    if (value.m_value.array->empty())
-                    {
-                        // flatten empty array as null
-                        result[reference_string] = nullptr;
-                    }
-                    else
-                    {
-                        // iterate array and use index as reference string
-                        for (size_t i = 0; i < value.m_value.array->size(); ++i)
-                        {
-                            flatten(reference_string + "/" + std::to_string(i),
-                                    value.m_value.array->operator[](i), result);
-                        }
                     }
                     break;
                 }
 
                 case value_t::object:
                 {
-                    if (value.m_value.object->empty())
+                    // create an entry in the object
+                    result = &result->operator[](reference_token);
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    // create an entry in the array
+                    result = &result->operator[](static_cast<size_type>(std::stoi(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 single value; that is, with an
+                empty list of reference tokens.
+                */
+                default:
+                {
+                        JSON_THROW(std::domain_error("invalid value to unflatten"));
+                }
+            }
+        }
+
+        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 std::out_of_range      if the JSON pointer can not be resolved
+    @throw std::domain_error      if an array index begins with '0'
+    @throw std::invalid_argument  if an array index was not a number
+    */
+    reference get_unchecked(pointer ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            // convert null values to arrays or objects before continuing
+            if (ptr->m_type == value_t::null)
+            {
+                // check if reference token is a number
+                const bool nums = std::all_of(reference_token.begin(),
+                                              reference_token.end(),
+                                              [](const char x)
+                {
+                    return std::isdigit(x);
+                });
+
+                // change value to array for numbers or "-" or to object
+                // otherwise
+                if (nums or reference_token == "-")
+                {
+                    *ptr = value_t::array;
+                }
+                else
+                {
+                    *ptr = value_t::object;
+                }
+            }
+
+            switch (ptr->m_type)
+            {
+                case value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    // error condition (cf. RFC 6901, Sect. 4)
+                    if (reference_token.size() > 1 and reference_token[0] == '0')
                     {
-                        // flatten empty object as null
-                        result[reference_string] = nullptr;
+                            JSON_THROW(std::domain_error("array index must not begin with '0'"));
+                    }
+
+                    if (reference_token == "-")
+                    {
+                        // explicityly treat "-" as index beyond the end
+                        ptr = &ptr->operator[](ptr->m_value.array->size());
                     }
                     else
                     {
-                        // iterate object and use keys as reference string
-                        for (const auto& element : *value.m_value.object)
-                        {
-                            flatten(reference_string + "/" + escape(element.first),
-                                    element.second, result);
-                        }
+                        // convert array index to number; unchecked access
+                        ptr = &ptr->operator[](static_cast<size_type>(std::stoi(reference_token)));
                     }
                     break;
                 }
 
                 default:
                 {
-                    // add primitive value with its reference string
-                    result[reference_string] = value;
-                    break;
+                        JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));
                 }
             }
         }
 
-        /*!
-        @param[in] value  flattened JSON
+        return *ptr;
+    }
 
-        @return unflattened JSON
-        */
-        static basic_json unflatten(const basic_json& value)
+    reference get_checked(pointer ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
         {
-            if (not value.is_object())
+            switch (ptr->m_type)
             {
-                JSON_THROW(std::domain_error("only objects can be unflattened"));
-            }
-
-            basic_json result;
-
-            // iterate the JSON object values
-            for (const auto& element : *value.m_value.object)
-            {
-                if (not element.second.is_primitive())
+                case value_t::object:
                 {
-                    JSON_THROW(std::domain_error("values in object must be primitive"));
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
                 }
 
-                // assign value to 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
-                // result itself. An assignment will then create a primitive
-                // value.
-                json_pointer(element.first).get_and_create(result) = element.second;
-            }
+                case value_t::array:
+                {
+                    if (reference_token == "-")
+                    {
+                        // "-" always fails the range check
+                        throw std::out_of_range("array index '-' (" +
+                                                std::to_string(ptr->m_value.array->size()) +
+                                                ") is out of range");
+                    }
 
+                    // error condition (cf. RFC 6901, Sect. 4)
+                    if (reference_token.size() > 1 and reference_token[0] == '0')
+                    {
+                            JSON_THROW(std::domain_error("array index must not begin with '0'"));
+                    }
+
+                    // note: at performs range check
+                    ptr = &ptr->at(static_cast<size_type>(std::stoi(reference_token)));
+                    break;
+                }
+
+                default:
+                {
+                        JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));
+                }
+            }
+        }
+
+        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
+    */
+    const_reference get_unchecked(const_pointer ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->m_type)
+            {
+                case value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    if (reference_token == "-")
+                    {
+                        // "-" cannot be used for const access
+                        throw std::out_of_range("array index '-' (" +
+                                                std::to_string(ptr->m_value.array->size()) +
+                                                ") is out of range");
+                    }
+
+                    // error condition (cf. RFC 6901, Sect. 4)
+                    if (reference_token.size() > 1 and reference_token[0] == '0')
+                    {
+                            JSON_THROW(std::domain_error("array index must not begin with '0'"));
+                    }
+
+                    // use unchecked array access
+                    ptr = &ptr->operator[](static_cast<size_type>(std::stoi(reference_token)));
+                    break;
+                }
+
+                default:
+                {
+                        JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));
+                }
+            }
+        }
+
+        return *ptr;
+    }
+
+    const_reference get_checked(const_pointer ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->m_type)
+            {
+                case value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    if (reference_token == "-")
+                    {
+                        // "-" always fails the range check
+                        throw std::out_of_range("array index '-' (" +
+                                                std::to_string(ptr->m_value.array->size()) +
+                                                ") is out of range");
+                    }
+
+                    // error condition (cf. RFC 6901, Sect. 4)
+                    if (reference_token.size() > 1 and reference_token[0] == '0')
+                    {
+                            JSON_THROW(std::domain_error("array index must not begin with '0'"));
+                    }
+
+                    // note: at performs range check
+                    ptr = &ptr->at(static_cast<size_type>(std::stoi(reference_token)));
+                    break;
+                }
+
+                default:
+                {
+                        JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));
+                }
+            }
+        }
+
+        return *ptr;
+    }
+
+    /// split the string input to reference tokens
+    static std::vector<std::string> split(const std::string& reference_string)
+    {
+        std::vector<std::string> result;
+
+        // special case: empty reference string -> no reference tokens
+        if (reference_string.empty())
+        {
             return result;
         }
 
-      private:
-        /// the reference tokens
-        std::vector<std::string> reference_tokens {};
-    };
+        // check if nonempty reference string begins with slash
+        if (reference_string[0] != '/')
+        {
+                JSON_THROW(std::domain_error("JSON pointer must be empty or begin with '/'"));
+        }
+
+        // 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
+                size_t slash = reference_string.find_first_of('/', 1),
+            // set the beginning of the first reference token
+            start = 1;
+            // we can stop if start == string::npos+1 = 0
+            start != 0;
+            // set the beginning of the next reference token
+            // (will eventually be 0 if slash == std::string::npos)
+            start = 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 (size_t pos = reference_token.find_first_of('~');
+                    pos != std::string::npos;
+                        pos = reference_token.find_first_of('~', pos + 1))
+            {
+                assert(reference_token[pos] == '~');
+
+                // ~ must be followed by 0 or 1
+                if (pos == reference_token.size() - 1 or
+                        (reference_token[pos + 1] != '0' and
+                         reference_token[pos + 1] != '1'))
+                {
+                        JSON_THROW(std::domain_error("escape error: '~' must be followed with '0' or '1'"));
+                }
+            }
+
+            // finally, store the reference token
+            unescape(reference_token);
+            result.push_back(reference_token);
+        }
+
+        return result;
+    }
+
+    private:
+    /*!
+    @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.
+
+    @since version 2.0.0
+    */
+    static void replace_substring(std::string& s,
+                                  const std::string& f,
+                                  const std::string& t)
+    {
+        assert(not f.empty());
+
+        for (
+            size_t pos = s.find(f);         // find first occurrence of f
+            pos != std::string::npos;       // make sure f was found
+            s.replace(pos, f.size(), t),    // replace with t
+            pos = s.find(f, pos + t.size()) // find next occurrence of f
+        );
+    }
+
+    /// escape tilde and slash
+    static std::string escape(std::string s)
+    {
+        // escape "~"" to "~0" and "/" to "~1"
+        replace_substring(s, "~", "~0");
+        replace_substring(s, "/", "~1");
+        return s;
+    }
+
+    /// unescape tilde and slash
+    static void unescape(std::string& s)
+    {
+        // first transform any occurrence of the sequence '~1' to '/'
+        replace_substring(s, "~1", "/");
+        // then transform any occurrence of the sequence '~0' to '~'
+        replace_substring(s, "~0", "~");
+    }
+
+    /*!
+    @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`.
+    */
+    static void flatten(const std::string& reference_string,
+                        const basic_json& value,
+                        basic_json& result)
+    {
+        switch (value.m_type)
+        {
+            case value_t::array:
+            {
+                if (value.m_value.array->empty())
+                {
+                    // flatten empty array as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate array and use index as reference string
+                    for (size_t i = 0; i < value.m_value.array->size(); ++i)
+                    {
+                        flatten(reference_string + "/" + std::to_string(i),
+                                value.m_value.array->operator[](i), result);
+                    }
+                }
+                break;
+            }
+
+            case value_t::object:
+            {
+                if (value.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_value.object)
+                    {
+                        flatten(reference_string + "/" + escape(element.first),
+                                element.second, result);
+                    }
+                }
+                break;
+            }
+
+            default:
+            {
+                // add primitive value with its reference string
+                result[reference_string] = value;
+                break;
+            }
+        }
+    }
+
+    /*!
+    @param[in] value  flattened JSON
+
+    @return unflattened JSON
+    */
+    static basic_json unflatten(const basic_json& value)
+    {
+        if (not value.is_object())
+        {
+                JSON_THROW(std::domain_error("only objects can be unflattened"));
+        }
+
+        basic_json result;
+
+        // iterate the JSON object values
+        for (const auto& element : *value.m_value.object)
+        {
+            if (not element.second.is_primitive())
+            {
+                    JSON_THROW(std::domain_error("values in object must be primitive"));
+            }
+
+            // assign value to 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
+            // result itself. An assignment will then create a primitive
+            // value.
+            json_pointer(element.first).get_and_create(result) = element.second;
+        }
+
+        return result;
+    }
+
+    private:
+    /// the reference tokens
+    std::vector<std::string> reference_tokens {};
+               };
 
     //////////////////////////
     // JSON Pointer support //
@@ -12684,38 +12695,38 @@ using json = basic_json<>;
 
 // specialization of std::swap, and std::hash
 namespace std
-{
-/*!
-@brief exchanges the values of two JSON objects
-
-@since version 1.0.0
-*/
-template<>
-inline void swap(nlohmann::json& j1,
-                 nlohmann::json& j2) noexcept(
-                     is_nothrow_move_constructible<nlohmann::json>::value and
-                     is_nothrow_move_assignable<nlohmann::json>::value
-                 )
-{
-    j1.swap(j2);
-}
-
-/// hash value for JSON objects
-template<>
-struct hash<nlohmann::json>
 {
     /*!
-    @brief return a hash value for a JSON object
+    @brief exchanges the values of two JSON objects
 
     @since version 1.0.0
     */
-    std::size_t operator()(const nlohmann::json& j) const
+    template<>
+    inline void swap(nlohmann::json& j1,
+                     nlohmann::json& j2) noexcept(
+                         is_nothrow_move_constructible<nlohmann::json>::value and
+                         is_nothrow_move_assignable<nlohmann::json>::value
+                                                   )
+    {
+        j1.swap(j2);
+    }
+
+    /// hash value for JSON objects
+    template<>
+    struct hash<nlohmann::json>
+    {
+        /*!
+        @brief return a hash value for a JSON object
+
+        @since version 1.0.0
+        */
+        std::size_t operator()(const nlohmann::json& j) const
     {
         // a naive hashing via the string representation
         const auto& h = hash<nlohmann::json::string_t>();
         return h(j.dump());
     }
-};
+                        };
 } // namespace std
 
 /*!
diff --git a/src/json.hpp.re2c b/src/json.hpp.re2c
index f552a390..12fde56e 100644
--- a/src/json.hpp.re2c
+++ b/src/json.hpp.re2c
@@ -106,38 +106,356 @@ SOFTWARE.
 */
 namespace nlohmann
 {
+// alias templates to reduce boilerplate
+template <bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
 
+template <typename T>
+using remove_cv_t = typename std::remove_cv<T>::type;
 
+template <typename T>
+using remove_reference_t = typename std::remove_reference<T>::type;
+
+template <typename T>
+using uncvref_t = remove_cv_t<remove_reference_t<T>>;
+
+template <bool If, typename Then, typename Else>
+using conditional_t = typename std::conditional<If, Then, Else>::type;
+
+// Taken from http://stackoverflow.com/questions/26936640/how-to-implement-is-enum-class-type-trait
+template <typename T>
+using is_scoped_enum =
+    std::integral_constant<bool, not std::is_convertible<T, int>::value and
+    std::is_enum<T>::value>;
+
+template <typename T>
+using is_unscoped_enum =
+    std::integral_constant<bool, std::is_convertible<T, int>::value and
+    std::is_enum<T>::value>;
+
+// TODO update this doc
 /*!
 @brief unnamed namespace with internal helper functions
 @since version 1.0.0
 */
-namespace
+
+namespace detail
 {
+// Very useful construct against boilerplate (more boilerplate needed than in C++17: http://en.cppreference.com/w/cpp/types/void_t)
+template <typename...> struct make_void
+{
+    using type = void;
+};
+template <typename... Ts> using void_t = typename make_void<Ts...>::type;
+
+// Implementation of 3 C++17 constructs: conjunction, disjunction, negation.
+// This is needed to avoid evaluating all the traits in a condition
+//
+// For example: not std::is_same<void, T>::value and has_value_type<T>::value
+// will not compile when T = void (on MSVC at least)
+// Whereas conjunction<negation<std::is_same<void, T>>, has_value_type<T>>::value
+// will stop evaluating if negation<...>::value == false
+//
+// Please note that those constructs must be used with caution, since symbols can
+// become very long quickly (which can slow down compilation and cause MSVC internal compiler errors)
+// Only use it when you have too (see example ahead)
+template <class...> struct conjunction : std::true_type {};
+template <class B1> struct conjunction<B1> : B1 {};
+template <class B1, class... Bn>
+struct conjunction<B1, Bn...>
+: conditional_t<bool(B1::value), conjunction<Bn...>, B1> {};
+
+template <class B> struct negation : std::integral_constant < bool, !B::value > {};
+template <class...> struct disjunction : std::false_type {};
+template <class B1> struct disjunction<B1> : B1 {};
+template <class B1, class... Bn>
+struct disjunction<B1, Bn...>
+: conditional_t<bool(B1::value), B1, disjunction<Bn...>> {};
+
 /*!
 @brief Helper to determine whether there's a key_type for T.
-
 Thus helper is used to tell associative containers apart from other containers
 such as sequence containers. For instance, `std::map` passes the test as it
 contains a `mapped_type`, whereas `std::vector` fails the test.
-
 @sa http://stackoverflow.com/a/7728728/266378
 @since version 1.0.0, overworked in version 2.0.6
 */
-template<typename T>
-struct has_mapped_type
+#define NLOHMANN_JSON_HAS_HELPER(type)                                         \
+    template <typename T> struct has_##type {                                    \
+    private:                                                                     \
+        template <typename U, typename = typename U::type>                         \
+        static int detect(U &&);                                                   \
+        \
+        static void detect(...);                                                   \
+        \
+    public:                                                                      \
+        static constexpr bool value =                                              \
+                std::is_integral<decltype(detect(std::declval<T>()))>::value;          \
+    };
+
+NLOHMANN_JSON_HAS_HELPER(mapped_type)
+NLOHMANN_JSON_HAS_HELPER(key_type)
+NLOHMANN_JSON_HAS_HELPER(value_type)
+NLOHMANN_JSON_HAS_HELPER(iterator)
+
+#undef NLOHMANN_JSON_HAS_HELPER
+
+template <bool B, class RealType, class CompatibleObjectType>
+struct is_compatible_object_type_impl : std::false_type {};
+
+template <class RealType, class CompatibleObjectType>
+struct is_compatible_object_type_impl<true, RealType, CompatibleObjectType>
+{
+    static constexpr auto value =
+        std::is_constructible<typename RealType::key_type,
+        typename CompatibleObjectType::key_type>::value and
+        std::is_constructible<typename RealType::mapped_type,
+        typename CompatibleObjectType::mapped_type>::value;
+};
+
+template<class RealType, class CompatibleObjectType>
+struct is_compatible_object_type
+{
+    // As noted ahead, we need to stop evaluating traits if CompatibleObjectType = void
+    // hence the conjunction
+    static auto constexpr value = is_compatible_object_type_impl <
+                                  conjunction<negation<std::is_same<void, CompatibleObjectType>>,
+                                  has_mapped_type<CompatibleObjectType>,
+                                  has_key_type<CompatibleObjectType>>::value,
+                                  RealType, CompatibleObjectType >::value;
+};
+
+template <bool B, class BasicJson, class CompatibleArrayType>
+struct is_compatible_array_type_impl : std::false_type {};
+
+template <class BasicJson, class CompatibleArrayType>
+struct is_compatible_array_type_impl<true, BasicJson, CompatibleArrayType>
+{
+    static constexpr auto value =
+        not std::is_same<CompatibleArrayType,
+        typename BasicJson::iterator>::value and
+        not std::is_same<CompatibleArrayType,
+        typename BasicJson::const_iterator>::value and
+        not std::is_same<CompatibleArrayType,
+        typename BasicJson::reverse_iterator>::value and
+        not std::is_same<CompatibleArrayType,
+        typename BasicJson::const_reverse_iterator>::value and
+        not std::is_same<CompatibleArrayType,
+        typename BasicJson::array_t::iterator>::value and
+        not std::is_same<CompatibleArrayType,
+        typename BasicJson::array_t::const_iterator>::value;
+};
+
+template <class BasicJson, class CompatibleArrayType>
+struct is_compatible_array_type
+{
+    // the check for CompatibleArrayType = void is done in is_compatible_object_type
+    // but we need the conjunction here as well
+    static auto constexpr value = is_compatible_array_type_impl <
+                                  conjunction<negation<is_compatible_object_type<
+                                  typename BasicJson::object_t, CompatibleArrayType>>,
+                                  has_value_type<CompatibleArrayType>,
+                                  has_iterator<CompatibleArrayType>>::value,
+                                  BasicJson, CompatibleArrayType >::value;
+};
+
+template <bool, typename, typename>
+struct is_compatible_integer_type_impl : std::false_type {};
+
+template <typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type_impl<true, RealIntegerType, CompatibleNumberIntegerType>
+{
+    using RealLimits = std::numeric_limits<RealIntegerType>;
+    using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
+
+    static constexpr auto value =
+        std::is_constructible<RealIntegerType,
+        CompatibleNumberIntegerType>::value and
+        CompatibleLimits::is_integer and
+        RealLimits::is_signed == CompatibleLimits::is_signed;
+};
+
+template <typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type
+{
+    static constexpr auto value = is_compatible_integer_type_impl <
+                                  std::is_arithmetic<CompatibleNumberIntegerType>::value, RealIntegerType,
+                                  CompatibleNumberIntegerType >::value;
+};
+
+template <typename RealFloat, typename CompatibleFloat>
+struct is_compatible_float_type
+{
+    static constexpr auto value =
+        std::is_constructible<RealFloat, CompatibleFloat>::value and
+        std::is_floating_point<CompatibleFloat>::value;
+};
+
+template <typename T, typename BasicJson>
+struct is_compatible_basic_json_type
+{
+    static auto constexpr value =
+        is_unscoped_enum<T>::value or
+        std::is_same<T, BasicJson>::value or
+        std::is_constructible<typename BasicJson::string_t, T>::value or
+        std::is_same<typename BasicJson::boolean_t, T>::value or
+        is_compatible_array_type<BasicJson, T>::value or
+        is_compatible_object_type<typename BasicJson::object_t, T>::value or
+        is_compatible_float_type<typename BasicJson::number_float_t, T>::value or
+        is_compatible_integer_type<typename BasicJson::number_integer_t,
+        T>::value or
+        is_compatible_integer_type<typename BasicJson::number_unsigned_t,
+        T>::value;
+};
+
+template <typename T, typename BasicJson, typename PrimitiveIterator>
+struct is_basic_json_nested_class
+{
+    static auto constexpr value = std::is_same<T, typename BasicJson::iterator>::value or
+                                  std::is_same<T, typename BasicJson::const_iterator>::value or
+                                  std::is_same<T, typename BasicJson::reverse_iterator>::value or
+                                  std::is_same<T, typename BasicJson::const_reverse_iterator>::value or
+                                  std::is_same<T, PrimitiveIterator>::value or
+                                  std::is_same<T, typename BasicJson::json_pointer>::value;
+};
+
+// This trait checks if JSONSerializer<T>::from_json(json const&, udt&) exists
+template <template <typename, typename> class JSONSerializer, typename Json,
+          typename T>
+struct has_from_json
 {
   private:
-    template <typename U, typename = typename U::mapped_type>
+    // also check the return type of from_json
+    template <typename U, typename = enable_if_t<std::is_same<void, decltype(uncvref_t<U>::from_json(
+                  std::declval<Json>(), std::declval<T&>()))>::value>>
     static int detect(U&&);
 
     static void detect(...);
+
   public:
-    static constexpr bool value =
-        std::is_integral<decltype(detect(std::declval<T>()))>::value;
+    static constexpr bool value = std::is_integral<decltype(
+                                      detect(std::declval<JSONSerializer<T, void>>()))>::value;
 };
 
-} // namespace
+// This trait checks if JSONSerializer<T>::from_json(json const&) exists
+// this overload is used for non-default-constructible user-defined-types
+template <template <typename, typename> class JSONSerializer, typename Json,
+          typename T>
+struct has_non_default_from_json
+{
+  private:
+    template <typename U, typename = enable_if_t<std::is_same<T, decltype(uncvref_t<U>::from_json(std::declval<Json>()))>::value>>
+    static int detect(U&&);
+
+    static void detect(...);
+
+  public:
+    static constexpr bool value = std::is_integral<decltype(
+                                      detect(std::declval<JSONSerializer<T, void>>()))>::value;
+};
+
+// This trait checks if JSONSerializer<T>::to_json exists
+template <template <typename, typename> class JSONSerializer, typename Json,
+          typename T>
+struct has_to_json
+{
+  private:
+    template <typename U, typename = decltype(uncvref_t<U>::to_json(
+                  std::declval<Json&>(), std::declval<T>()))>
+    static int detect(U&&);
+
+    static void detect(...);
+
+  public:
+    static constexpr bool value = std::is_integral<decltype(
+                                      detect(std::declval<JSONSerializer<T, void>>()))>::value;
+};
+
+// those declarations are needed to workaround a MSVC bug related to ADL
+// (taken from MSVC-Ranges implementation)
+void to_json();
+void from_json();
+
+struct to_json_fn
+{
+    // is it really useful to mark those as constexpr?
+    template <typename Json, typename T>
+    constexpr auto operator()(Json&& j, T&& val) const
+    noexcept(noexcept(to_json(std::forward<Json>(j), std::forward<T>(val))))
+    -> decltype(to_json(std::forward<Json>(j), std::forward<T>(val)),
+                void())
+    {
+        return to_json(std::forward<Json>(j), std::forward<T>(val));
+    }
+};
+
+struct from_json_fn
+{
+    template <typename Json, typename T>
+    constexpr auto operator()(Json&& j, T& val) const
+    noexcept(noexcept(from_json(std::forward<Json>(j), val)))
+    -> decltype(from_json(std::forward<Json>(j), val), void())
+    {
+        return from_json(std::forward<Json>(j), val);
+    }
+};
+
+/*!
+@brief helper class to create locales with decimal point
+
+This struct is used a default locale during the JSON serialization. JSON
+requires the decimal point to be `.`, so this function overloads the
+`do_decimal_point()` function to return `.`. This function is called by
+float-to-string conversions to retrieve the decimal separator between integer
+and fractional parts.
+
+@sa https://github.com/nlohmann/json/issues/51#issuecomment-86869315
+@since version 2.0.0
+*/
+struct DecimalSeparator : std::numpunct<char>
+{
+    char do_decimal_point() const
+    {
+        return '.';
+    }
+};
+
+}
+
+// taken from ranges-v3
+// TODO add doc
+template <typename T>
+struct static_const
+{
+    static constexpr T value{};
+};
+
+template <typename T>
+constexpr T static_const<T>::value;
+
+inline namespace
+{
+constexpr auto const& to_json = static_const<detail::to_json_fn>::value;
+constexpr auto const& from_json = static_const<detail::from_json_fn>::value;
+}
+
+// default JSONSerializer template argument, doesn't care about template argument
+// will use ADL for serialization
+template <typename = void, typename = void>
+struct adl_serializer
+{
+    template <typename Json, typename T>
+    static void from_json(Json&& j, T& val)
+    {
+        ::nlohmann::from_json(std::forward<Json>(j), val);
+    }
+
+    template <typename Json, typename T>
+    static void to_json(Json& j, T&& val)
+    {
+        ::nlohmann::to_json(j, std::forward<T>(val));
+    }
+};
 
 /*!
 @brief a class to store JSON values
@@ -226,7 +544,8 @@ template <
     class NumberIntegerType = std::int64_t,
     class NumberUnsignedType = std::uint64_t,
     class NumberFloatType = double,
-    template<typename U> class AllocatorType = std::allocator
+    template<typename U> class AllocatorType = std::allocator,
+    template<typename T, typename SFINAE = void> class JSONSerializer = adl_serializer
     >
 class basic_json
 {
@@ -234,7 +553,8 @@ class basic_json
     /// workaround type for MSVC
     using basic_json_t = basic_json<ObjectType, ArrayType, StringType,
           BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType,
-          AllocatorType>;
+          AllocatorType, JSONSerializer>;
+    class primitive_iterator_t;
 
   public:
     // forward declarations
@@ -1215,11 +1535,11 @@ class basic_json
 
     @since version 1.0.0
     */
-    template<class CompatibleObjectType, typename std::enable_if<
-                 std::is_constructible<typename object_t::key_type, typename CompatibleObjectType::key_type>::value and
-                 std::is_constructible<basic_json, typename CompatibleObjectType::mapped_type>::value, int>::type = 0>
-    basic_json(const CompatibleObjectType& val)
-        : m_type(value_t::object)
+    template <class CompatibleObjectType,
+              enable_if_t<detail::is_compatible_object_type<
+                              object_t, CompatibleObjectType>::value,
+                          int> = 0>
+    basic_json(const CompatibleObjectType& val) : m_type(value_t::object)
     {
         using std::begin;
         using std::end;
@@ -1278,16 +1598,11 @@ class basic_json
 
     @since version 1.0.0
     */
-    template<class CompatibleArrayType, typename std::enable_if<
-                 not std::is_same<CompatibleArrayType, typename basic_json_t::iterator>::value and
-                 not std::is_same<CompatibleArrayType, typename basic_json_t::const_iterator>::value and
-                 not std::is_same<CompatibleArrayType, typename basic_json_t::reverse_iterator>::value and
-                 not std::is_same<CompatibleArrayType, typename basic_json_t::const_reverse_iterator>::value and
-                 not std::is_same<CompatibleArrayType, typename array_t::iterator>::value and
-                 not std::is_same<CompatibleArrayType, typename array_t::const_iterator>::value and
-                 std::is_constructible<basic_json, typename CompatibleArrayType::value_type>::value, int>::type = 0>
-    basic_json(const CompatibleArrayType& val)
-        : m_type(value_t::array)
+    template <class CompatibleArrayType,
+              enable_if_t<detail::is_compatible_array_type<
+                              basic_json_t, CompatibleArrayType>::value,
+                          int> = 0>
+    basic_json(const CompatibleArrayType& val) : m_type(value_t::array)
     {
         using std::begin;
         using std::end;
@@ -1295,6 +1610,28 @@ class basic_json
         assert_invariant();
     }
 
+
+    // constructor chosen when:
+    // - JSONSerializer::to_json exists for type T
+    // - T is not a istream, nor convertible to basic_json (float, vectors, etc)
+    // is_compatible_basic_json_type == not is_user_defined_type
+    template <
+        typename T,
+        enable_if_t<not std::is_base_of<std::istream, uncvref_t<T>>::value and
+                    not detail::is_basic_json_nested_class<uncvref_t<T>, basic_json_t, primitive_iterator_t>::value and
+                    not std::is_same<uncvref_t<T>, typename basic_json_t::array_t::iterator>::value and
+                    not std::is_same<uncvref_t<T>, typename basic_json_t::object_t::iterator>::value and
+
+                    detail::conjunction<detail::negation<detail::is_compatible_basic_json_type<
+                                            uncvref_t<T>, basic_json_t>>,
+                                        detail::has_to_json<JSONSerializer, basic_json,
+                                                uncvref_t<T>>>::value,
+                                                int> = 0 >
+                    basic_json(T && val)
+    {
+        JSONSerializer<uncvref_t<T>>::to_json(*this, std::forward<T>(val));
+    }
+
     /*!
     @brief create a string (explicit)
 
@@ -1456,7 +1793,10 @@ class basic_json
 
     @since version 1.0.0
     */
-    basic_json(const int val) noexcept
+
+    // Constructor for unscoped enums (not enum classes)
+    template <typename T, enable_if_t<is_unscoped_enum<T>::value, int> = 0>
+    basic_json(T val) noexcept
         : m_type(value_t::number_integer),
           m_value(static_cast<number_integer_t>(val))
     {
@@ -1488,11 +1828,11 @@ class basic_json
 
     @since version 1.0.0
     */
-    template<typename CompatibleNumberIntegerType, typename std::enable_if<
-                 std::is_constructible<number_integer_t, CompatibleNumberIntegerType>::value and
-                 std::numeric_limits<CompatibleNumberIntegerType>::is_integer and
-                 std::numeric_limits<CompatibleNumberIntegerType>::is_signed,
-                 CompatibleNumberIntegerType>::type = 0>
+    template <
+        typename CompatibleNumberIntegerType,
+        enable_if_t<detail::is_compatible_integer_type<
+                        number_integer_t, CompatibleNumberIntegerType>::value,
+                    int> = 0 >
     basic_json(const CompatibleNumberIntegerType val) noexcept
         : m_type(value_t::number_integer),
           m_value(static_cast<number_integer_t>(val))
@@ -1546,11 +1886,11 @@ class basic_json
 
     @since version 2.0.0
     */
-    template<typename CompatibleNumberUnsignedType, typename std::enable_if <
-                 std::is_constructible<number_unsigned_t, CompatibleNumberUnsignedType>::value and
-                 std::numeric_limits<CompatibleNumberUnsignedType>::is_integer and
-                 not std::numeric_limits<CompatibleNumberUnsignedType>::is_signed,
-                 CompatibleNumberUnsignedType>::type = 0>
+    template <
+        typename CompatibleNumberUnsignedType,
+        enable_if_t<detail::is_compatible_integer_type<
+                        number_unsigned_t, CompatibleNumberUnsignedType>::value,
+                    int> = 0 >
     basic_json(const CompatibleNumberUnsignedType val) noexcept
         : m_type(value_t::number_unsigned),
           m_value(static_cast<number_unsigned_t>(val))
@@ -1626,9 +1966,10 @@ class basic_json
 
     @since version 1.0.0
     */
-    template<typename CompatibleNumberFloatType, typename = typename std::enable_if<
-                 std::is_constructible<number_float_t, CompatibleNumberFloatType>::value and
-                 std::is_floating_point<CompatibleNumberFloatType>::value>::type>
+    template <typename CompatibleNumberFloatType,
+              enable_if_t<detail::is_compatible_float_type<
+                              number_float_t, CompatibleNumberFloatType>::value,
+                          int> = 0>
     basic_json(const CompatibleNumberFloatType val) noexcept
         : basic_json(number_float_t(val))
     {
@@ -1788,7 +2129,7 @@ class basic_json
     @since version 1.0.0
     */
     static basic_json array(std::initializer_list<basic_json> init =
-                                std::initializer_list<basic_json>())
+                            std::initializer_list<basic_json>())
     {
         return basic_json(init, false, value_t::array);
     }
@@ -1828,7 +2169,7 @@ class basic_json
     @since version 1.0.0
     */
     static basic_json object(std::initializer_list<basic_json> init =
-                                 std::initializer_list<basic_json>())
+                             std::initializer_list<basic_json>())
     {
         return basic_json(init, false, value_t::object);
     }
@@ -2169,7 +2510,7 @@ class basic_json
         std::is_nothrow_move_assignable<value_t>::value and
         std::is_nothrow_move_constructible<json_value>::value and
         std::is_nothrow_move_assignable<json_value>::value
-    )
+                                       )
     {
         // check that passed value is valid
         other.assert_invariant();
@@ -2182,6 +2523,18 @@ class basic_json
         return *this;
     }
 
+    // this overload is needed, since constructor for udt is explicit
+    template <typename T, enable_if_t<not detail::is_compatible_basic_json_type<
+                                          uncvref_t<T>, basic_json_t>::value and
+                                      detail::has_to_json<JSONSerializer, basic_json_t, uncvref_t<T>>::value>>
+    reference& operator=(T&& val) noexcept(std::is_nothrow_constructible<basic_json_t, uncvref_t<T>>::value and
+                                           std::is_nothrow_move_assignable<uncvref_t<T>>::value)
+    {
+        static_assert(sizeof(T) == 0 , "");
+        // I'm not sure this a is good practice...
+        return *this = basic_json_t{std::forward<T>(val)};
+    }
+
     /*!
     @brief destructor
 
@@ -2655,7 +3008,6 @@ class basic_json
     // value access //
     //////////////////
 
-    /// get an object (explicit)
     template<class T, typename std::enable_if<
                  std::is_convertible<typename object_t::key_type, typename T::key_type>::value and
                  std::is_convertible<basic_json_t, typename T::mapped_type>::value, int>::type = 0>
@@ -2681,13 +3033,16 @@ class basic_json
     }
 
     /// get an array (explicit)
-    template<class T, typename std::enable_if<
-                 std::is_convertible<basic_json_t, typename T::value_type>::value and
-                 not std::is_same<basic_json_t, typename T::value_type>::value and
-                 not std::is_arithmetic<T>::value and
-                 not std::is_convertible<std::string, T>::value and
-                 not has_mapped_type<T>::value, int>::type = 0>
-    T get_impl(T* /*unused*/) const
+    template <
+        class T,
+        typename std::enable_if <
+            std::is_convertible<basic_json_t, typename T::value_type>::value and
+            not std::is_same<basic_json_t,
+                             typename T::value_type>::value and
+            not std::is_arithmetic<T>::value and
+            not std::is_convertible<std::string, T>::value and
+            not detail::has_mapped_type<T>::value,
+            int >::type = 0 >
     {
         if (is_array())
         {
@@ -2727,7 +3082,7 @@ class basic_json
     /// get an array (explicit)
     template<class T, typename std::enable_if<
                  std::is_same<basic_json, typename T::value_type>::value and
-                 not has_mapped_type<T>::value, int>::type = 0>
+                 not detail::has_mapped_type<T>::value, int>::type = 0>
     T get_impl(T* /*unused*/) const
     {
         if (is_array())
@@ -2956,13 +3311,46 @@ class basic_json
 
     @since version 1.0.0
     */
-    template<typename ValueType, typename std::enable_if<
-                 not std::is_pointer<ValueType>::value, int>::type = 0>
-    ValueType get() const
+    template <typename ValueType,
+              enable_if_t<not std::is_pointer<ValueType>::value, int> = 0>
+    auto get() const
+    -> decltype(this->get_impl(static_cast<ValueType*>(nullptr)))
     {
         return get_impl(static_cast<ValueType*>(nullptr));
     }
 
+    template <
+        typename T,
+        enable_if_t<detail::conjunction<detail::negation<detail::is_compatible_basic_json_type<
+                                            uncvref_t<T>, basic_json_t>>,
+                                        detail::has_from_json<JSONSerializer, basic_json_t,
+                                                uncvref_t<T>>>::value,
+                                                int> = 0 >
+                    auto get() const -> uncvref_t<T>
+    {
+        using type = uncvref_t<T>;
+        static_assert(std::is_default_constructible<type>::value&&
+        std::is_copy_constructible<type>::value,
+        "user-defined types must be DefaultConstructible and "
+        "CopyConstructible when used with get");
+        type ret;
+        JSONSerializer<type>::from_json(*this, ret);
+        return ret;
+    }
+
+    // This overload is chosen for non-default constructible user-defined-types
+    template <
+        typename T,
+        enable_if_t<detail::conjunction<detail::negation<detail::is_compatible_basic_json_type<
+                                            uncvref_t<T>, basic_json_t>>,
+                                        detail::has_non_default_from_json<JSONSerializer, basic_json_t,
+                                                uncvref_t<T>>>::value,
+                                                short> = 0 >
+                    T get() const
+    {
+        return JSONSerializer<T>::from_json(*this);
+    }
+
     /*!
     @brief get a pointer value (explicit)
 
@@ -3042,8 +3430,8 @@ class basic_json
     {
         // get the type of the PointerType (remove pointer and const)
         using pointee_t = typename std::remove_const<typename
-                          std::remove_pointer<typename
-                          std::remove_const<PointerType>::type>::type>::type;
+                std::remove_pointer<typename
+                                    std::remove_const<PointerType>::type>::type>::type;
         // make sure the type matches the allowed types
         static_assert(
             std::is_same<object_t, pointee_t>::value
@@ -3070,8 +3458,8 @@ class basic_json
     {
         // get the type of the PointerType (remove pointer and const)
         using pointee_t = typename std::remove_const<typename
-                          std::remove_pointer<typename
-                          std::remove_const<PointerType>::type>::type>::type;
+                std::remove_pointer<typename
+                                    std::remove_const<PointerType>::type>::type>::type;
         // make sure the type matches the allowed types
         static_assert(
             std::is_same<object_t, pointee_t>::value
@@ -4124,14 +4512,14 @@ class basic_json
             case value_t::object:
             {
                 result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
-                                              last.m_it.object_iterator);
+                        last.m_it.object_iterator);
                 break;
             }
 
             case value_t::array:
             {
                 result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
-                                             last.m_it.array_iterator);
+                        last.m_it.array_iterator);
                 break;
             }
 
@@ -5348,9 +5736,9 @@ class basic_json
         // insert to array and return iterator
         iterator result(this);
         result.m_it.array_iterator = m_value.array->insert(
-                                         pos.m_it.array_iterator,
-                                         first.m_it.array_iterator,
-                                         last.m_it.array_iterator);
+            pos.m_it.array_iterator,
+            first.m_it.array_iterator,
+            last.m_it.array_iterator);
         return result;
     }
 
@@ -5420,7 +5808,7 @@ class basic_json
         std::is_nothrow_move_assignable<value_t>::value and
         std::is_nothrow_move_constructible<json_value>::value and
         std::is_nothrow_move_assignable<json_value>::value
-    )
+                                       )
     {
         std::swap(m_type, other.m_type);
         std::swap(m_value, other.m_value);
@@ -8020,13 +8408,13 @@ class basic_json
                         o << (pretty_print ? ",\n" : ",");
                     }
                     o << string_t(new_indent, ' ') << "\""
-                      << escape_string(i->first) << "\":"
-                      << (pretty_print ? " " : "");
-                    i->second.dump(o, pretty_print, indent_step, new_indent);
+                                                    << escape_string(i->first) << "\":"
+                                                            << (pretty_print ? " " : "");
+                                                            i->second.dump(o, pretty_print, indent_step, new_indent);
                 }
 
-                // decrease indentation
-                if (pretty_print)
+                                                        // decrease indentation
+                                                        if (pretty_print)
                 {
                     new_indent -= indent_step;
                     o << "\n";
@@ -8071,16 +8459,16 @@ class basic_json
                 }
 
                 o << string_t(new_indent, ' ') << "]";
-                return;
+                   return;
             }
 
-            case value_t::string:
+               case value_t::string:
             {
                 o << string_t("\"") << escape_string(*m_value.string) << "\"";
-                return;
+                                     return;
             }
 
-            case value_t::boolean:
+                                 case value_t::boolean:
             {
                 o << (m_value.boolean ? "true" : "false");
                 return;
@@ -8154,50 +8542,126 @@ class basic_json
     */
     class primitive_iterator_t
     {
-      public:
-        /// set iterator to a defined beginning
-        void set_begin() noexcept
-        {
-            m_it = begin_value;
-        }
+        public:
 
-        /// set iterator to a defined past the end
-        void set_end() noexcept
-        {
-            m_it = end_value;
-        }
+        difference_type get_value() const noexcept
+    {
+        return m_it;
+    }
+    /// set iterator to a defined beginning
+    void set_begin() noexcept
+    {
+        m_it = begin_value;
+    }
 
-        /// return whether the iterator can be dereferenced
-        constexpr bool is_begin() const noexcept
-        {
-            return (m_it == begin_value);
-        }
+    /// set iterator to a defined past the end
+    void set_end() noexcept
+    {
+        m_it = end_value;
+    }
 
-        /// return whether the iterator is at end
-        constexpr bool is_end() const noexcept
-        {
-            return (m_it == end_value);
-        }
+    /// return whether the iterator can be dereferenced
+    constexpr bool is_begin() const noexcept
+    {
+        return (m_it == begin_value);
+    }
 
-        /// return reference to the value to change and compare
-        operator difference_type& () noexcept
-        {
-            return m_it;
-        }
+    /// return whether the iterator is at end
+    constexpr bool is_end() const noexcept
+    {
+        return (m_it == end_value);
+    }
 
-        /// return value to compare
-        constexpr operator difference_type () const noexcept
-        {
-            return m_it;
-        }
+    friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it == rhs.m_it;
+    }
 
-      private:
-        static constexpr difference_type begin_value = 0;
-        static constexpr difference_type end_value = begin_value + 1;
+    friend constexpr bool operator!=(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return !(lhs == rhs);
+    }
 
-        /// iterator as signed integer type
-        difference_type m_it = std::numeric_limits<std::ptrdiff_t>::denorm_min();
-    };
+    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;
+    }
+
+    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 i)
+    {
+        auto result = *this;
+        result += i;
+        return result;
+    }
+
+    friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it - rhs.m_it;
+    }
+
+    friend std::ostream& operator<<(std::ostream& os, primitive_iterator_t it)
+    {
+        return os << it.m_it;
+    }
+
+    primitive_iterator_t& operator++()
+    {
+        ++m_it;
+        return *this;
+    }
+
+    primitive_iterator_t& operator++(int)
+    {
+        m_it++;
+        return *this;
+    }
+
+    primitive_iterator_t& operator--()
+    {
+        --m_it;
+        return *this;
+    }
+
+    primitive_iterator_t& operator--(int)
+    {
+        m_it--;
+        return *this;
+    }
+
+    primitive_iterator_t& operator+=(difference_type n)
+    {
+        m_it += n;
+        return *this;
+    }
+
+    primitive_iterator_t& operator-=(difference_type n)
+    {
+        m_it -= n;
+        return *this;
+    }
+
+    private:
+    static constexpr difference_type begin_value = 0;
+    static constexpr difference_type end_value = begin_value + 1;
+
+    /// iterator as signed integer type
+    difference_type m_it = std::numeric_limits<std::ptrdiff_t>::denorm_min();
+                                              };
 
     /*!
     @brief an iterator value
@@ -8217,104 +8681,104 @@ class basic_json
 
         /// create an uninitialized internal_iterator
         internal_iterator() noexcept
-            : object_iterator(), array_iterator(), primitive_iterator()
-        {}
+        : object_iterator(), array_iterator(), primitive_iterator()
+    {}
     };
 
     /// proxy class for the iterator_wrapper functions
     template<typename IteratorType>
     class iteration_proxy
     {
-      private:
+        private:
         /// helper class for iteration
         class iteration_proxy_internal
         {
-          private:
+            private:
             /// the iterator
             IteratorType anchor;
             /// an index for arrays (used to create key names)
             size_t array_index = 0;
 
-          public:
+            public:
             explicit iteration_proxy_internal(IteratorType it) noexcept
-                : anchor(it)
-            {}
+            : anchor(it)
+    {}
 
-            /// dereference operator (needed for range-based for)
-            iteration_proxy_internal& operator*()
+    /// dereference operator (needed for range-based for)
+    iteration_proxy_internal& operator*()
+    {
+        return *this;
+    }
+
+    /// increment operator (needed for range-based for)
+    iteration_proxy_internal& operator++()
+    {
+        ++anchor;
+        ++array_index;
+
+        return *this;
+    }
+
+    /// inequality operator (needed for range-based for)
+    bool operator!= (const iteration_proxy_internal& o) const
+    {
+        return anchor != o.anchor;
+    }
+
+    /// return key of the iterator
+    typename basic_json::string_t key() const
+    {
+        assert(anchor.m_object != nullptr);
+
+        switch (anchor.m_object->type())
+        {
+            // use integer array index as key
+            case value_t::array:
             {
-                return *this;
+                return std::to_string(array_index);
             }
 
-            /// increment operator (needed for range-based for)
-            iteration_proxy_internal& operator++()
+            // use key from the object
+            case value_t::object:
             {
-                ++anchor;
-                ++array_index;
-
-                return *this;
+                return anchor.key();
             }
 
-            /// inequality operator (needed for range-based for)
-            bool operator!= (const iteration_proxy_internal& o) const
+            // use an empty key for all primitive types
+            default:
             {
-                return anchor != o.anchor;
+                return "";
             }
+        }
+    }
 
-            /// return key of the iterator
-            typename basic_json::string_t key() const
-            {
-                assert(anchor.m_object != nullptr);
-
-                switch (anchor.m_object->type())
-                {
-                    // use integer array index as key
-                    case value_t::array:
-                    {
-                        return std::to_string(array_index);
-                    }
-
-                    // use key from the object
-                    case value_t::object:
-                    {
-                        return anchor.key();
-                    }
-
-                    // use an empty key for all primitive types
-                    default:
-                    {
-                        return "";
-                    }
-                }
-            }
-
-            /// return value of the iterator
-            typename IteratorType::reference value() const
-            {
-                return anchor.value();
-            }
+    /// return value of the iterator
+    typename IteratorType::reference value() const
+    {
+        return anchor.value();
+    }
         };
 
-        /// the container to iterate
-        typename IteratorType::reference container;
+    /// the container to iterate
+    typename IteratorType::reference container;
 
-      public:
-        /// construct iteration proxy from a container
-        explicit iteration_proxy(typename IteratorType::reference cont)
-            : container(cont)
-        {}
+    public:
+    /// construct iteration proxy from a container
+    explicit iteration_proxy(typename IteratorType::reference cont)
+    : container(cont)
+    {}
 
-        /// return iterator begin (needed for range-based for)
-        iteration_proxy_internal begin() noexcept
-        {
-            return iteration_proxy_internal(container.begin());
-        }
+    /// return iterator begin (needed for range-based for)
+    iteration_proxy_internal begin() noexcept
+    {
+        return iteration_proxy_internal(container.begin());
+    }
 
-        /// return iterator end (needed for range-based for)
-        iteration_proxy_internal end() noexcept
-        {
-            return iteration_proxy_internal(container.end());
-        }
+    /// return iterator end (needed for range-based for)
+    iteration_proxy_internal end() noexcept
+    {
+        return iteration_proxy_internal(container.end());
+    }
     };
 
   public:
@@ -8338,7 +8802,7 @@ class basic_json
     @since version 1.0.0, simplified in version 2.0.9
     */
     template<typename U>
-    class iter_impl : public std::iterator<std::random_access_iterator_tag, U>
+  class iter_impl : public std::iterator<std::random_access_iterator_tag, U>
     {
         /// allow basic_json to access private members
         friend class basic_json;
@@ -8348,19 +8812,19 @@ class basic_json
                       or std::is_same<U, const basic_json>::value,
                       "iter_impl only accepts (const) basic_json");
 
-      public:
+        public:
         /// the type of the values when the iterator is dereferenced
         using value_type = typename basic_json::value_type;
         /// a type to represent differences between iterators
         using difference_type = typename basic_json::difference_type;
         /// defines a pointer to the type iterated over (value_type)
         using pointer = typename std::conditional<std::is_const<U>::value,
-              typename basic_json::const_pointer,
-              typename basic_json::pointer>::type;
+                typename basic_json::const_pointer,
+                typename basic_json::pointer>::type;
         /// defines a reference to the type iterated over (value_type)
         using reference = typename std::conditional<std::is_const<U>::value,
-              typename basic_json::const_reference,
-              typename basic_json::reference>::type;
+                typename basic_json::const_reference,
+                typename basic_json::reference>::type;
         /// the category of the iterator
         using iterator_category = std::bidirectional_iterator_tag;
 
@@ -8374,566 +8838,566 @@ class basic_json
         @post The iterator is initialized; i.e. `m_object != nullptr`.
         */
         explicit iter_impl(pointer object) noexcept
-            : m_object(object)
+        : m_object(object)
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
         {
-            assert(m_object != nullptr);
-
-            switch (m_object->m_type)
+            case basic_json::value_t::object:
             {
-                case basic_json::value_t::object:
-                {
-                    m_it.object_iterator = typename object_t::iterator();
-                    break;
-                }
-
-                case basic_json::value_t::array:
-                {
-                    m_it.array_iterator = typename array_t::iterator();
-                    break;
-                }
-
-                default:
-                {
-                    m_it.primitive_iterator = primitive_iterator_t();
-                    break;
-                }
-            }
-        }
-
-        /*
-        Use operator `const_iterator` instead of `const_iterator(const iterator&
-        other) noexcept` to avoid two class definitions for @ref iterator and
-        @ref const_iterator.
-
-        This function is only called if this class is an @ref iterator. If this
-        class is a @ref const_iterator this function is not called.
-        */
-        operator const_iterator() const
-        {
-            const_iterator ret;
-
-            if (m_object)
-            {
-                ret.m_object = m_object;
-                ret.m_it = m_it;
+                m_it.object_iterator = typename object_t::iterator();
+                break;
             }
 
-            return ret;
-        }
-
-        /*!
-        @brief copy constructor
-        @param[in] other  iterator to copy from
-        @note It is not checked whether @a other is initialized.
-        */
-        iter_impl(const iter_impl& other) noexcept
-            : m_object(other.m_object), m_it(other.m_it)
-        {}
-
-        /*!
-        @brief copy assignment
-        @param[in,out] other  iterator to copy from
-        @note It is not checked whether @a other is initialized.
-        */
-        iter_impl& operator=(iter_impl other) noexcept(
-            std::is_nothrow_move_constructible<pointer>::value and
-            std::is_nothrow_move_assignable<pointer>::value and
-            std::is_nothrow_move_constructible<internal_iterator>::value and
-            std::is_nothrow_move_assignable<internal_iterator>::value
-        )
-        {
-            std::swap(m_object, other.m_object);
-            std::swap(m_it, other.m_it);
-            return *this;
-        }
-
-      private:
-        /*!
-        @brief set the iterator to the first value
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        void set_begin() noexcept
-        {
-            assert(m_object != nullptr);
-
-            switch (m_object->m_type)
+            case basic_json::value_t::array:
             {
-                case basic_json::value_t::object:
-                {
-                    m_it.object_iterator = m_object->m_value.object->begin();
-                    break;
-                }
+                m_it.array_iterator = typename array_t::iterator();
+                break;
+            }
 
-                case basic_json::value_t::array:
-                {
-                    m_it.array_iterator = m_object->m_value.array->begin();
-                    break;
-                }
-
-                case basic_json::value_t::null:
-                {
-                    // set to end so begin()==end() is true: null is empty
-                    m_it.primitive_iterator.set_end();
-                    break;
-                }
-
-                default:
-                {
-                    m_it.primitive_iterator.set_begin();
-                    break;
-                }
+            default:
+            {
+                m_it.primitive_iterator = primitive_iterator_t();
+                break;
             }
         }
+    }
 
-        /*!
-        @brief set the iterator past the last value
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        void set_end() noexcept
+    /*
+    Use operator `const_iterator` instead of `const_iterator(const iterator&
+    other) noexcept` to avoid two class definitions for @ref iterator and
+    @ref const_iterator.
+
+    This function is only called if this class is an @ref iterator. If this
+    class is a @ref const_iterator this function is not called.
+    */
+    operator const_iterator() const
+    {
+        const_iterator ret;
+
+        if (m_object)
         {
-            assert(m_object != nullptr);
-
-            switch (m_object->m_type)
-            {
-                case basic_json::value_t::object:
-                {
-                    m_it.object_iterator = m_object->m_value.object->end();
-                    break;
-                }
-
-                case basic_json::value_t::array:
-                {
-                    m_it.array_iterator = m_object->m_value.array->end();
-                    break;
-                }
-
-                default:
-                {
-                    m_it.primitive_iterator.set_end();
-                    break;
-                }
-            }
+            ret.m_object = m_object;
+            ret.m_it = m_it;
         }
 
-      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
+        return ret;
+    }
+
+    /*!
+    @brief copy constructor
+    @param[in] other  iterator to copy from
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl(const iter_impl& other) noexcept
+    : m_object(other.m_object), m_it(other.m_it)
+    {}
+
+    /*!
+    @brief copy assignment
+    @param[in,out] other  iterator to copy from
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(iter_impl other) noexcept(
+        std::is_nothrow_move_constructible<pointer>::value and
+        std::is_nothrow_move_assignable<pointer>::value and
+        std::is_nothrow_move_constructible<internal_iterator>::value and
+        std::is_nothrow_move_assignable<internal_iterator>::value
+                                       )
+    {
+        std::swap(m_object, other.m_object);
+        std::swap(m_it, other.m_it);
+        return *this;
+    }
+
+    private:
+    /*!
+    @brief set the iterator to the first value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_begin() noexcept
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
         {
-            assert(m_object != nullptr);
-
-            switch (m_object->m_type)
+            case basic_json::value_t::object:
             {
-                case basic_json::value_t::object:
-                {
-                    assert(m_it.object_iterator != m_object->m_value.object->end());
-                    return m_it.object_iterator->second;
-                }
+                m_it.object_iterator = m_object->m_value.object->begin();
+                break;
+            }
 
-                case basic_json::value_t::array:
-                {
-                    assert(m_it.array_iterator != m_object->m_value.array->end());
-                    return *m_it.array_iterator;
-                }
+            case basic_json::value_t::array:
+            {
+                m_it.array_iterator = m_object->m_value.array->begin();
+                break;
+            }
 
-                case basic_json::value_t::null:
-                {
+            case basic_json::value_t::null:
+            {
+                // set to end so begin()==end() is true: null is empty
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+
+            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
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case basic_json::value_t::object:
+            {
+                m_it.object_iterator = m_object->m_value.object->end();
+                break;
+            }
+
+            case basic_json::value_t::array:
+            {
+                m_it.array_iterator = m_object->m_value.array->end();
+                break;
+            }
+
+            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
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case basic_json::value_t::object:
+            {
+                assert(m_it.object_iterator != m_object->m_value.object->end());
+                return m_it.object_iterator->second;
+            }
+
+            case basic_json::value_t::array:
+            {
+                assert(m_it.array_iterator != m_object->m_value.array->end());
+                return *m_it.array_iterator;
+            }
+
+            case basic_json::value_t::null:
+            {
                     JSON_THROW(std::out_of_range("cannot get value"));
-                }
+            }
 
-                default:
+            default:
+            {
+                if (m_it.primitive_iterator.is_begin())
                 {
-                    if (m_it.primitive_iterator.is_begin())
-                    {
-                        return *m_object;
-                    }
+                    return *m_object;
+                }
 
                     JSON_THROW(std::out_of_range("cannot get value"));
-                }
             }
         }
+    }
 
-        /*!
-        @brief dereference the iterator
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        pointer operator->() const
+    /*!
+    @brief dereference the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    pointer operator->() const
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
         {
-            assert(m_object != nullptr);
-
-            switch (m_object->m_type)
+            case basic_json::value_t::object:
             {
-                case basic_json::value_t::object:
-                {
-                    assert(m_it.object_iterator != m_object->m_value.object->end());
-                    return &(m_it.object_iterator->second);
-                }
+                assert(m_it.object_iterator != m_object->m_value.object->end());
+                return &(m_it.object_iterator->second);
+            }
 
-                case basic_json::value_t::array:
-                {
-                    assert(m_it.array_iterator != m_object->m_value.array->end());
-                    return &*m_it.array_iterator;
-                }
+            case basic_json::value_t::array:
+            {
+                assert(m_it.array_iterator != m_object->m_value.array->end());
+                return &*m_it.array_iterator;
+            }
 
-                default:
+            default:
+            {
+                if (m_it.primitive_iterator.is_begin())
                 {
-                    if (m_it.primitive_iterator.is_begin())
-                    {
-                        return m_object;
-                    }
+                    return m_object;
+                }
 
                     JSON_THROW(std::out_of_range("cannot get value"));
-                }
+            }
+        }
+    }
+
+    /*!
+    @brief post-increment (it++)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator++(int)
+    {
+        auto result = *this;
+        ++(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-increment (++it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator++()
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case basic_json::value_t::object:
+            {
+                std::advance(m_it.object_iterator, 1);
+                break;
+            }
+
+            case basic_json::value_t::array:
+            {
+                std::advance(m_it.array_iterator, 1);
+                break;
+            }
+
+            default:
+            {
+                ++m_it.primitive_iterator;
+                break;
             }
         }
 
-        /*!
-        @brief post-increment (it++)
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        iter_impl operator++(int)
-        {
-            auto result = *this;
-            ++(*this);
-            return result;
-        }
+        return *this;
+    }
 
-        /*!
-        @brief pre-increment (++it)
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        iter_impl& operator++()
-        {
-            assert(m_object != nullptr);
+    /*!
+    @brief post-decrement (it--)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator--(int)
+    {
+        auto result = *this;
+        --(*this);
+        return result;
+    }
 
-            switch (m_object->m_type)
+    /*!
+    @brief pre-decrement (--it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator--()
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case basic_json::value_t::object:
             {
-                case basic_json::value_t::object:
-                {
-                    std::advance(m_it.object_iterator, 1);
-                    break;
-                }
-
-                case basic_json::value_t::array:
-                {
-                    std::advance(m_it.array_iterator, 1);
-                    break;
-                }
-
-                default:
-                {
-                    ++m_it.primitive_iterator;
-                    break;
-                }
+                std::advance(m_it.object_iterator, -1);
+                break;
             }
 
-            return *this;
-        }
-
-        /*!
-        @brief post-decrement (it--)
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        iter_impl operator--(int)
-        {
-            auto result = *this;
-            --(*this);
-            return result;
-        }
-
-        /*!
-        @brief pre-decrement (--it)
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        iter_impl& operator--()
-        {
-            assert(m_object != nullptr);
-
-            switch (m_object->m_type)
+            case basic_json::value_t::array:
             {
-                case basic_json::value_t::object:
-                {
-                    std::advance(m_it.object_iterator, -1);
-                    break;
-                }
-
-                case basic_json::value_t::array:
-                {
-                    std::advance(m_it.array_iterator, -1);
-                    break;
-                }
-
-                default:
-                {
-                    --m_it.primitive_iterator;
-                    break;
-                }
+                std::advance(m_it.array_iterator, -1);
+                break;
             }
 
-            return *this;
+            default:
+            {
+                --m_it.primitive_iterator;
+                break;
+            }
         }
 
-        /*!
-        @brief  comparison: equal
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        bool operator==(const iter_impl& other) const
+        return *this;
+    }
+
+    /*!
+    @brief  comparison: equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator==(const iter_impl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (m_object != other.m_object)
         {
-            // if objects are not the same, the comparison is undefined
-            if (m_object != other.m_object)
-            {
                 JSON_THROW(std::domain_error("cannot compare iterators of different containers"));
-            }
-
-            assert(m_object != nullptr);
-
-            switch (m_object->m_type)
-            {
-                case basic_json::value_t::object:
-                {
-                    return (m_it.object_iterator == other.m_it.object_iterator);
-                }
-
-                case basic_json::value_t::array:
-                {
-                    return (m_it.array_iterator == other.m_it.array_iterator);
-                }
-
-                default:
-                {
-                    return (m_it.primitive_iterator == other.m_it.primitive_iterator);
-                }
-            }
         }
 
-        /*!
-        @brief  comparison: not equal
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        bool operator!=(const iter_impl& other) const
-        {
-            return not operator==(other);
-        }
+        assert(m_object != nullptr);
 
-        /*!
-        @brief  comparison: smaller
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        bool operator<(const iter_impl& other) const
+        switch (m_object->m_type)
         {
-            // if objects are not the same, the comparison is undefined
-            if (m_object != other.m_object)
+            case basic_json::value_t::object:
             {
+                return (m_it.object_iterator == other.m_it.object_iterator);
+            }
+
+            case basic_json::value_t::array:
+            {
+                return (m_it.array_iterator == other.m_it.array_iterator);
+            }
+
+            default:
+            {
+                return (m_it.primitive_iterator == other.m_it.primitive_iterator);
+            }
+        }
+    }
+
+    /*!
+    @brief  comparison: not equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator!=(const iter_impl& other) const
+    {
+        return not operator==(other);
+    }
+
+    /*!
+    @brief  comparison: smaller
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<(const iter_impl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (m_object != other.m_object)
+        {
                 JSON_THROW(std::domain_error("cannot compare iterators of different containers"));
-            }
+        }
 
-            assert(m_object != nullptr);
+        assert(m_object != nullptr);
 
-            switch (m_object->m_type)
+        switch (m_object->m_type)
+        {
+            case basic_json::value_t::object:
             {
-                case basic_json::value_t::object:
-                {
                     JSON_THROW(std::domain_error("cannot compare order of object iterators"));
-                }
+            }
 
-                case basic_json::value_t::array:
-                {
-                    return (m_it.array_iterator < other.m_it.array_iterator);
-                }
+            case basic_json::value_t::array:
+            {
+                return (m_it.array_iterator < other.m_it.array_iterator);
+            }
 
-                default:
-                {
-                    return (m_it.primitive_iterator < other.m_it.primitive_iterator);
-                }
+            default:
+            {
+                return (m_it.primitive_iterator < other.m_it.primitive_iterator);
             }
         }
+    }
 
-        /*!
-        @brief  comparison: less than or equal
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        bool operator<=(const iter_impl& other) const
+    /*!
+    @brief  comparison: less than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<=(const iter_impl& other) const
+    {
+        return not other.operator < (*this);
+    }
+
+    /*!
+    @brief  comparison: greater than
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>(const iter_impl& other) const
+    {
+        return not operator<=(other);
+    }
+
+    /*!
+    @brief  comparison: greater than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>=(const iter_impl& other) const
+    {
+        return not operator<(other);
+    }
+
+    /*!
+    @brief  add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator+=(difference_type i)
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
         {
-            return not other.operator < (*this);
-        }
-
-        /*!
-        @brief  comparison: greater than
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        bool operator>(const iter_impl& other) const
-        {
-            return not operator<=(other);
-        }
-
-        /*!
-        @brief  comparison: greater than or equal
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        bool operator>=(const iter_impl& other) const
-        {
-            return not operator<(other);
-        }
-
-        /*!
-        @brief  add to iterator
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        iter_impl& operator+=(difference_type i)
-        {
-            assert(m_object != nullptr);
-
-            switch (m_object->m_type)
+            case basic_json::value_t::object:
             {
-                case basic_json::value_t::object:
-                {
                     JSON_THROW(std::domain_error("cannot use offsets with object iterators"));
-                }
-
-                case basic_json::value_t::array:
-                {
-                    std::advance(m_it.array_iterator, i);
-                    break;
-                }
-
-                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)
-        {
-            auto result = *this;
-            result += i;
-            return result;
-        }
-
-        /*!
-        @brief  subtract from iterator
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        iter_impl operator-(difference_type i)
-        {
-            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
-        {
-            assert(m_object != nullptr);
-
-            switch (m_object->m_type)
+            case basic_json::value_t::array:
+            {
+                std::advance(m_it.array_iterator, i);
+                break;
+            }
+
+            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)
+    {
+        auto result = *this;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief  subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator-(difference_type i)
+    {
+        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
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case basic_json::value_t::object:
             {
-                case basic_json::value_t::object:
-                {
                     JSON_THROW(std::domain_error("cannot use offsets with object iterators"));
-                }
+            }
 
-                case basic_json::value_t::array:
-                {
-                    return m_it.array_iterator - other.m_it.array_iterator;
-                }
+            case basic_json::value_t::array:
+            {
+                return m_it.array_iterator - other.m_it.array_iterator;
+            }
 
-                default:
-                {
-                    return m_it.primitive_iterator - other.m_it.primitive_iterator;
-                }
+            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
+    /*!
+    @brief  access to successor
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator[](difference_type n) const
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
         {
-            assert(m_object != nullptr);
-
-            switch (m_object->m_type)
+            case basic_json::value_t::object:
             {
-                case basic_json::value_t::object:
-                {
                     JSON_THROW(std::domain_error("cannot use operator[] for object iterators"));
-                }
+            }
 
-                case basic_json::value_t::array:
-                {
-                    return *std::next(m_it.array_iterator, n);
-                }
+            case basic_json::value_t::array:
+            {
+                return *std::next(m_it.array_iterator, n);
+            }
 
-                case basic_json::value_t::null:
-                {
+            case basic_json::value_t::null:
+            {
                     JSON_THROW(std::out_of_range("cannot get value"));
-                }
+            }
 
-                default:
+            default:
+            {
+                if (m_it.primitive_iterator.get_value() == -n)
                 {
-                    if (m_it.primitive_iterator == -n)
-                    {
-                        return *m_object;
-                    }
+                    return *m_object;
+                }
 
                     JSON_THROW(std::out_of_range("cannot get value"));
-                }
             }
         }
+    }
 
-        /*!
-        @brief  return the key of an object iterator
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        typename object_t::key_type key() const
+    /*!
+    @brief  return the key of an object iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    typename object_t::key_type key() const
+    {
+        assert(m_object != nullptr);
+
+        if (m_object->is_object())
         {
-            assert(m_object != nullptr);
-
-            if (m_object->is_object())
-            {
-                return m_it.object_iterator->first;
-            }
+            return m_it.object_iterator->first;
+        }
 
             JSON_THROW(std::domain_error("cannot use key() for non-object iterators"));
-        }
+    }
 
-        /*!
-        @brief  return the value of an iterator
-        @pre The iterator is initialized; i.e. `m_object != nullptr`.
-        */
-        reference value() const
-        {
-            return operator*();
-        }
+    /*!
+    @brief  return the value of an iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference value() const
+    {
+        return operator*();
+    }
 
-      private:
-        /// associated JSON instance
-        pointer m_object = nullptr;
-        /// the actual iterator of the associated instance
-        internal_iterator m_it = internal_iterator();
-    };
+    private:
+    /// associated JSON instance
+    pointer m_object = nullptr;
+    /// the actual iterator of the associated instance
+    internal_iterator m_it = internal_iterator();
+                       };
 
     /*!
     @brief a template for a reverse iterator class
@@ -8953,9 +9417,9 @@ class basic_json
     @since version 1.0.0
     */
     template<typename Base>
-    class json_reverse_iterator : public std::reverse_iterator<Base>
+  class json_reverse_iterator : public std::reverse_iterator<Base>
     {
-      public:
+        public:
         /// shortcut to the reverse iterator adaptor
         using base_iterator = std::reverse_iterator<Base>;
         /// the reference type for the pointed-to element
@@ -8963,89 +9427,89 @@ class basic_json
 
         /// create reverse iterator from iterator
         json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
-            : base_iterator(it)
-        {}
+        : base_iterator(it)
+    {}
 
-        /// create reverse iterator from base class
-        json_reverse_iterator(const base_iterator& it) noexcept
-            : base_iterator(it)
-        {}
+    /// create reverse iterator from base class
+    json_reverse_iterator(const base_iterator& it) noexcept
+    : base_iterator(it)
+    {}
 
-        /// post-increment (it++)
-        json_reverse_iterator operator++(int)
-        {
-            return base_iterator::operator++(1);
-        }
+    /// post-increment (it++)
+    json_reverse_iterator operator++(int)
+    {
+        return base_iterator::operator++(1);
+    }
 
-        /// pre-increment (++it)
-        json_reverse_iterator& operator++()
-        {
-            base_iterator::operator++();
-            return *this;
-        }
+    /// pre-increment (++it)
+    json_reverse_iterator& operator++()
+    {
+        base_iterator::operator++();
+        return *this;
+    }
 
-        /// post-decrement (it--)
-        json_reverse_iterator operator--(int)
-        {
-            return base_iterator::operator--(1);
-        }
+    /// post-decrement (it--)
+    json_reverse_iterator operator--(int)
+    {
+        return base_iterator::operator--(1);
+    }
 
-        /// pre-decrement (--it)
-        json_reverse_iterator& operator--()
-        {
-            base_iterator::operator--();
-            return *this;
-        }
+    /// pre-decrement (--it)
+    json_reverse_iterator& operator--()
+    {
+        base_iterator::operator--();
+        return *this;
+    }
 
-        /// add to iterator
-        json_reverse_iterator& operator+=(difference_type i)
-        {
-            base_iterator::operator+=(i);
-            return *this;
-        }
+    /// add to iterator
+    json_reverse_iterator& operator+=(difference_type i)
+    {
+        base_iterator::operator+=(i);
+        return *this;
+    }
 
-        /// add to iterator
-        json_reverse_iterator operator+(difference_type i) const
-        {
-            auto result = *this;
-            result += i;
-            return result;
-        }
+    /// add to iterator
+    json_reverse_iterator operator+(difference_type i) const
+    {
+        auto result = *this;
+        result += i;
+        return result;
+    }
 
-        /// subtract from iterator
-        json_reverse_iterator operator-(difference_type i) const
-        {
-            auto result = *this;
-            result -= i;
-            return result;
-        }
+    /// subtract from iterator
+    json_reverse_iterator operator-(difference_type i) const
+    {
+        auto result = *this;
+        result -= i;
+        return result;
+    }
 
-        /// return difference
-        difference_type operator-(const json_reverse_iterator& other) const
-        {
-            return this->base() - other.base();
-        }
+    /// return difference
+    difference_type operator-(const json_reverse_iterator& other) const
+    {
+        return this->base() - other.base();
+    }
 
-        /// access to successor
-        reference operator[](difference_type n) const
-        {
-            return *(this->operator+(n));
-        }
+    /// access to successor
+    reference operator[](difference_type n) const
+    {
+        return *(this->operator+(n));
+    }
 
-        /// return the key of an object iterator
-        typename object_t::key_type key() const
-        {
-            auto it = --this->base();
-            return it.key();
-        }
+    /// return the key of an object iterator
+    typename object_t::key_type key() const
+    {
+        auto it = --this->base();
+        return it.key();
+    }
 
-        /// return the value of an iterator
-        reference value() const
-        {
-            auto it = --this->base();
-            return it.operator * ();
-        }
-    };
+    /// return the value of an iterator
+    reference value() const
+    {
+        auto it = --this->base();
+        return it.operator * ();
+    }
+                                                   };
 
 
   private:
@@ -9062,761 +9526,761 @@ class basic_json
     */
     class lexer
     {
-      public:
+        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_number,    ///< a number -- use get_number() 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
-        };
+    {
+        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_number,    ///< a number -- use get_number() 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
+    };
 
-        /// the char type to use in the lexer
-        using lexer_char_t = unsigned char;
+    /// the char type to use in the lexer
+    using lexer_char_t = unsigned char;
 
-        /// a lexer from a buffer with given length
-        lexer(const lexer_char_t* buff, const size_t len) noexcept
-            : m_content(buff)
-        {
-            assert(m_content != nullptr);
-            m_start = m_cursor = m_content;
-            m_limit = m_content + len;
-        }
+    /// a lexer from a buffer with given length
+    lexer(const lexer_char_t* buff, const size_t len) noexcept
+    : m_content(buff)
+    {
+        assert(m_content != nullptr);
+        m_start = m_cursor = m_content;
+        m_limit = m_content + len;
+    }
 
-        /// a lexer from an input stream
-        explicit lexer(std::istream& s)
-            : m_stream(&s), m_line_buffer()
+    /// a lexer from an input stream
+    explicit lexer(std::istream& s)
+    : m_stream(&s), m_line_buffer()
+    {
+        // immediately abort if stream is erroneous
+        if (s.fail())
         {
-            // immediately abort if stream is erroneous
-            if (s.fail())
-            {
                 JSON_THROW(std::invalid_argument("stream error"));
-            }
-
-            // fill buffer
-            fill_line_buffer();
-
-            // skip UTF-8 byte-order mark
-            if (m_line_buffer.size() >= 3 and m_line_buffer.substr(0, 3) == "\xEF\xBB\xBF")
-            {
-                m_line_buffer[0] = ' ';
-                m_line_buffer[1] = ' ';
-                m_line_buffer[2] = ' ';
-            }
         }
 
-        // switch off unwanted functions (due to pointer members)
-        lexer() = delete;
-        lexer(const lexer&) = delete;
-        lexer operator=(const lexer&) = delete;
+        // fill buffer
+        fill_line_buffer();
 
-        /*!
-        @brief create a string from one or two Unicode code points
-
-        There are two cases: (1) @a codepoint1 is in the Basic Multilingual
-        Plane (U+0000 through U+FFFF) and @a codepoint2 is 0, or (2)
-        @a codepoint1 and @a codepoint2 are a UTF-16 surrogate pair to
-        represent a code point above U+FFFF.
-
-        @param[in] codepoint1  the code point (can be high surrogate)
-        @param[in] codepoint2  the code point (can be low surrogate or 0)
-
-        @return string representation of the code point; the length of the
-        result string is between 1 and 4 characters.
-
-        @throw std::out_of_range if code point is > 0x10ffff; example: `"code
-        points above 0x10FFFF are invalid"`
-        @throw std::invalid_argument if the low surrogate is invalid; example:
-        `""missing or wrong low surrogate""`
-
-        @complexity Constant.
-
-        @see <http://en.wikipedia.org/wiki/UTF-8#Sample_code>
-        */
-        static string_t to_unicode(const std::size_t codepoint1,
-                                   const std::size_t codepoint2 = 0)
+        // skip UTF-8 byte-order mark
+        if (m_line_buffer.size() >= 3 and m_line_buffer.substr(0, 3) == "\xEF\xBB\xBF")
         {
-            // calculate the code point from the given code points
-            std::size_t codepoint = codepoint1;
+            m_line_buffer[0] = ' ';
+            m_line_buffer[1] = ' ';
+            m_line_buffer[2] = ' ';
+        }
+    }
 
-            // check if codepoint1 is a high surrogate
-            if (codepoint1 >= 0xD800 and codepoint1 <= 0xDBFF)
+    // switch off unwanted functions (due to pointer members)
+    lexer() = delete;
+    lexer(const lexer&) = delete;
+    lexer operator=(const lexer&) = delete;
+
+    /*!
+    @brief create a string from one or two Unicode code points
+
+    There are two cases: (1) @a codepoint1 is in the Basic Multilingual
+    Plane (U+0000 through U+FFFF) and @a codepoint2 is 0, or (2)
+    @a codepoint1 and @a codepoint2 are a UTF-16 surrogate pair to
+    represent a code point above U+FFFF.
+
+    @param[in] codepoint1  the code point (can be high surrogate)
+    @param[in] codepoint2  the code point (can be low surrogate or 0)
+
+    @return string representation of the code point; the length of the
+    result string is between 1 and 4 characters.
+
+    @throw std::out_of_range if code point is > 0x10ffff; example: `"code
+    points above 0x10FFFF are invalid"`
+    @throw std::invalid_argument if the low surrogate is invalid; example:
+    `""missing or wrong low surrogate""`
+
+    @complexity Constant.
+
+    @see <http://en.wikipedia.org/wiki/UTF-8#Sample_code>
+    */
+    static string_t to_unicode(const std::size_t codepoint1,
+                               const std::size_t codepoint2 = 0)
+    {
+        // calculate the code point from the given code points
+        std::size_t codepoint = codepoint1;
+
+        // check if codepoint1 is a high surrogate
+        if (codepoint1 >= 0xD800 and codepoint1 <= 0xDBFF)
+        {
+            // check if codepoint2 is a low surrogate
+            if (codepoint2 >= 0xDC00 and codepoint2 <= 0xDFFF)
+            {
+                codepoint =
+                // high surrogate occupies the most significant 22 bits
+                (codepoint1 << 10)
+                 // low surrogate occupies the least significant 15 bits
+                 + codepoint2
+                 // there is still the 0xD800, 0xDC00 and 0x10000 noise
+                 // in the result so we have to subtract with:
+                 // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
+                 - 0x35FDC00;
+            }
+            else
             {
-                // check if codepoint2 is a low surrogate
-                if (codepoint2 >= 0xDC00 and codepoint2 <= 0xDFFF)
-                {
-                    codepoint =
-                        // high surrogate occupies the most significant 22 bits
-                        (codepoint1 << 10)
-                        // low surrogate occupies the least significant 15 bits
-                        + codepoint2
-                        // there is still the 0xD800, 0xDC00 and 0x10000 noise
-                        // in the result so we have to subtract with:
-                        // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
-                        - 0x35FDC00;
-                }
-                else
-                {
                     JSON_THROW(std::invalid_argument("missing or wrong low surrogate"));
-                }
             }
+        }
 
-            string_t result;
+        string_t result;
 
-            if (codepoint < 0x80)
-            {
-                // 1-byte characters: 0xxxxxxx (ASCII)
-                result.append(1, static_cast<typename string_t::value_type>(codepoint));
-            }
-            else if (codepoint <= 0x7ff)
-            {
-                // 2-byte characters: 110xxxxx 10xxxxxx
-                result.append(1, static_cast<typename string_t::value_type>(0xC0 | ((codepoint >> 6) & 0x1F)));
-                result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
-            }
-            else if (codepoint <= 0xffff)
-            {
-                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
-                result.append(1, static_cast<typename string_t::value_type>(0xE0 | ((codepoint >> 12) & 0x0F)));
-                result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
-                result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
-            }
-            else if (codepoint <= 0x10ffff)
-            {
-                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-                result.append(1, static_cast<typename string_t::value_type>(0xF0 | ((codepoint >> 18) & 0x07)));
-                result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 12) & 0x3F)));
-                result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
-                result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
-            }
-            else
-            {
+        if (codepoint < 0x80)
+        {
+            // 1-byte characters: 0xxxxxxx (ASCII)
+            result.append(1, static_cast<typename string_t::value_type>(codepoint));
+        }
+        else if (codepoint <= 0x7ff)
+        {
+            // 2-byte characters: 110xxxxx 10xxxxxx
+            result.append(1, static_cast<typename string_t::value_type>(0xC0 | ((codepoint >> 6) & 0x1F)));
+            result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
+        }
+        else if (codepoint <= 0xffff)
+        {
+            // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
+            result.append(1, static_cast<typename string_t::value_type>(0xE0 | ((codepoint >> 12) & 0x0F)));
+            result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
+            result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
+        }
+        else if (codepoint <= 0x10ffff)
+        {
+            // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+            result.append(1, static_cast<typename string_t::value_type>(0xF0 | ((codepoint >> 18) & 0x07)));
+            result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 12) & 0x3F)));
+            result.append(1, static_cast<typename string_t::value_type>(0x80 | ((codepoint >> 6) & 0x3F)));
+            result.append(1, static_cast<typename string_t::value_type>(0x80 | (codepoint & 0x3F)));
+        }
+        else
+        {
                 JSON_THROW(std::out_of_range("code points above 0x10FFFF are invalid"));
-            }
-
-            return result;
         }
 
-        /// return name of values of type token_type (only used for errors)
-        static std::string token_type_name(const token_type t)
+        return result;
+    }
+
+    /// return name of values of type token_type (only used for errors)
+    static std::string token_type_name(const token_type t)
+    {
+        switch (t)
         {
-            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_number:
+                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";
+            default:
             {
-                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_number:
-                    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";
-                default:
-                {
-                    // catch non-enum values
-                    return "unknown token"; // LCOV_EXCL_LINE
-                }
+                // catch non-enum values
+                return "unknown token"; // LCOV_EXCL_LINE
             }
         }
+    }
 
-        /*!
-        This function implements a scanner for JSON. It is specified using
-        regular expressions that try to follow RFC 7159 as close as possible.
-        These regular expressions are then translated into a minimized
-        deterministic finite automaton (DFA) by the tool
-        [re2c](http://re2c.org). As a result, the translated code for this
-        function consists of a large block of code with `goto` jumps.
+    /*!
+    This function implements a scanner for JSON. It is specified using
+    regular expressions that try to follow RFC 7159 as close as possible.
+    These regular expressions are then translated into a minimized
+    deterministic finite automaton (DFA) by the tool
+    [re2c](http://re2c.org). As a result, the translated code for this
+    function consists of a large block of code with `goto` jumps.
 
-        @return the class of the next token read from the buffer
+    @return the class of the next token read from the buffer
 
-        @complexity Linear in the length of the input.\n
+    @complexity Linear in the length of the input.\n
 
-        Proposition: The loop below will always terminate for finite input.\n
+    Proposition: The loop below will always terminate for finite input.\n
 
-        Proof (by contradiction): Assume a finite input. To loop forever, the
-        loop must never hit code with a `break` statement. The only code
-        snippets without a `break` statement are the continue statements for
-        whitespace and byte-order-marks. To loop forever, the input must be an
-        infinite sequence of whitespace or byte-order-marks. This contradicts
-        the assumption of finite input, q.e.d.
-        */
-        token_type scan()
+    Proof (by contradiction): Assume a finite input. To loop forever, the
+    loop must never hit code with a `break` statement. The only code
+    snippets without a `break` statement are the continue statements for
+    whitespace and byte-order-marks. To loop forever, the input must be an
+    infinite sequence of whitespace or byte-order-marks. This contradicts
+    the assumption of finite input, q.e.d.
+    */
+    token_type scan()
+    {
+        while (true)
         {
-            while (true)
-            {
-                // pointer for backtracking information
-                m_marker = nullptr;
+            // pointer for backtracking information
+            m_marker = nullptr;
 
-                // remember the begin of the token
-                m_start = m_cursor;
-                assert(m_start != nullptr);
+            // remember the begin of the token
+            m_start = m_cursor;
+            assert(m_start != nullptr);
 
-                /*!re2c
-                    re2c:define:YYCTYPE      = lexer_char_t;
-                    re2c:define:YYCURSOR     = m_cursor;
-                    re2c:define:YYLIMIT      = m_limit;
-                    re2c:define:YYMARKER     = m_marker;
-                    re2c:define:YYFILL       = "fill_line_buffer(@@); // LCOV_EXCL_LINE";
-                    re2c:define:YYFILL:naked = 1;
-                    re2c:yyfill:enable       = 1;
-                    re2c:indent:string       = "    ";
-                    re2c:indent:top          = 1;
-                    re2c:labelprefix         = "basic_json_parser_";
+            /*!re2c
+                re2c:define:YYCTYPE      = lexer_char_t;
+                re2c:define:YYCURSOR     = m_cursor;
+                re2c:define:YYLIMIT      = m_limit;
+                re2c:define:YYMARKER     = m_marker;
+                re2c:define:YYFILL       = "fill_line_buffer(@@); // LCOV_EXCL_LINE";
+                re2c:define:YYFILL:naked = 1;
+                re2c:yyfill:enable       = 1;
+                re2c:indent:string       = "    ";
+                re2c:indent:top          = 1;
+                re2c:labelprefix         = "basic_json_parser_";
 
-                    // ignore whitespace
-                    ws = [ \t\n\r]+;
-                    ws   { continue; }
+                // ignore whitespace
+                ws = [ \t\n\r]+;
+                ws   { continue; }
 
-                    // structural characters
-                    "[" { last_token_type = token_type::begin_array; break; }
-                    "]" { last_token_type = token_type::end_array; break; }
-                    "{" { last_token_type = token_type::begin_object; break; }
-                    "}" { last_token_type = token_type::end_object; break; }
-                    "," { last_token_type = token_type::value_separator; break; }
-                    ":" { last_token_type = token_type::name_separator; break; }
+                // structural characters
+                "[" { last_token_type = token_type::begin_array; break; }
+                "]" { last_token_type = token_type::end_array; break; }
+                "{" { last_token_type = token_type::begin_object; break; }
+                "}" { last_token_type = token_type::end_object; break; }
+                "," { last_token_type = token_type::value_separator; break; }
+                ":" { last_token_type = token_type::name_separator; break; }
 
-                    // literal names
-                    "null"  { last_token_type = token_type::literal_null; break; }
-                    "true"  { last_token_type = token_type::literal_true; break; }
-                    "false" { last_token_type = token_type::literal_false; break; }
+                // literal names
+                "null"  { last_token_type = token_type::literal_null; break; }
+                "true"  { last_token_type = token_type::literal_true; break; }
+                "false" { last_token_type = token_type::literal_false; break; }
 
-                    // number
-                    decimal_point = ".";
-                    digit         = [0-9];
-                    digit_1_9     = [1-9];
-                    e             = "e" | "E";
-                    minus         = "-";
-                    plus          = "+";
-                    zero          = "0";
-                    exp           = e (minus | plus)? digit+;
-                    frac          = decimal_point digit+;
-                    int           = (zero | digit_1_9 digit*);
-                    number        = minus? int frac? exp?;
-                    number        { last_token_type = token_type::value_number; break; }
+                // number
+                decimal_point = ".";
+                digit         = [0-9];
+                digit_1_9     = [1-9];
+                e             = "e" | "E";
+                minus         = "-";
+                plus          = "+";
+                zero          = "0";
+                exp           = e (minus | plus)? digit+;
+                frac          = decimal_point digit+;
+                int           = (zero | digit_1_9 digit*);
+                number        = minus? int frac? exp?;
+                number        { last_token_type = token_type::value_number; break; }
 
-                    // string
-                    quotation_mark  = "\"";
-                    escape          = "\\";
-                    unescaped       = [^"\\\x00-\x1f];
-                    single_escaped  = "\"" | "\\" | "/" | "b" | "f" | "n" | "r" | "t";
-                    unicode_escaped = "u" [0-9a-fA-F]{4};
-                    escaped         = escape (single_escaped | unicode_escaped);
-                    char            = unescaped | escaped;
-                    string          = quotation_mark char* quotation_mark;
-                    string          { last_token_type = token_type::value_string; break; }
+                // string
+                quotation_mark  = "\"";
+                escape          = "\\";
+                unescaped       = [^"\\\x00-\x1f];
+                single_escaped  = "\"" | "\\" | "/" | "b" | "f" | "n" | "r" | "t";
+                unicode_escaped = "u" [0-9a-fA-F]{4};
+                escaped         = escape (single_escaped | unicode_escaped);
+                char            = unescaped | escaped;
+                string          = quotation_mark char* quotation_mark;
+                string          { last_token_type = token_type::value_string; break; }
 
-                    // end of file
-                    "\x00"         { last_token_type = token_type::end_of_input; break; }
+                // end of file
+                "\x00"         { last_token_type = token_type::end_of_input; break; }
 
-                    // anything else is an error
-                    *              { last_token_type = token_type::parse_error; break; }
-                */
-            }
-
-            return last_token_type;
+                // anything else is an error
+                *              { last_token_type = token_type::parse_error; break; }
+            */
         }
 
-        /*!
-        @brief append data from the stream to the line buffer
+        return last_token_type;
+    }
 
-        This function is called by the scan() function when the end of the
-        buffer (`m_limit`) is reached and the `m_cursor` pointer cannot be
-        incremented without leaving the limits of the line buffer. Note re2c
-        decides when to call this function.
+    /*!
+    @brief append data from the stream to the line buffer
 
-        If the lexer reads from contiguous storage, there is no trailing null
-        byte. Therefore, this function must make sure to add these padding
-        null bytes.
+    This function is called by the scan() function when the end of the
+    buffer (`m_limit`) is reached and the `m_cursor` pointer cannot be
+    incremented without leaving the limits of the line buffer. Note re2c
+    decides when to call this function.
 
-        If the lexer reads from an input stream, this function reads the next
-        line of the input.
+    If the lexer reads from contiguous storage, there is no trailing null
+    byte. Therefore, this function must make sure to add these padding
+    null bytes.
 
-        @pre
-            p p p p p p u u u u u x . . . . . .
-            ^           ^       ^   ^
-            m_content   m_start |   m_limit
-                                m_cursor
+    If the lexer reads from an input stream, this function reads the next
+    line of the input.
 
-        @post
-            u u u u u x x x x x x x . . . . . .
-            ^       ^               ^
-            |       m_cursor        m_limit
-            m_start
-            m_content
-        */
-        void fill_line_buffer(size_t n = 0)
-        {
-            // if line buffer is used, m_content points to its data
-            assert(m_line_buffer.empty()
-                   or m_content == reinterpret_cast<const lexer_char_t*>(m_line_buffer.data()));
+    @pre
+        p p p p p p u u u u u x . . . . . .
+        ^           ^       ^   ^
+        m_content   m_start |   m_limit
+                            m_cursor
 
-            // if line buffer is used, m_limit is set past the end of its data
-            assert(m_line_buffer.empty()
-                   or m_limit == m_content + m_line_buffer.size());
+    @post
+        u u u u u x x x x x x x . . . . . .
+        ^       ^               ^
+        |       m_cursor        m_limit
+        m_start
+        m_content
+    */
+    void fill_line_buffer(size_t n = 0)
+    {
+        // if line buffer is used, m_content points to its data
+        assert(m_line_buffer.empty()
+               or m_content == reinterpret_cast<const lexer_char_t*>(m_line_buffer.data()));
 
-            // pointer relationships
-            assert(m_content <= m_start);
-            assert(m_start <= m_cursor);
-            assert(m_cursor <= m_limit);
-            assert(m_marker == nullptr or m_marker  <= m_limit);
+        // if line buffer is used, m_limit is set past the end of its data
+        assert(m_line_buffer.empty()
+               or m_limit == m_content + m_line_buffer.size());
 
-            // number of processed characters (p)
+        // pointer relationships
+        assert(m_content <= m_start);
+        assert(m_start <= m_cursor);
+        assert(m_cursor <= m_limit);
+        assert(m_marker == nullptr or m_marker  <= m_limit);
+
+        // number of processed characters (p)
             const auto num_processed_chars = static_cast<size_t>(m_start - m_content);
-            // offset for m_marker wrt. to m_start
-            const auto offset_marker = (m_marker == nullptr) ? 0 : m_marker - m_start;
-            // number of unprocessed characters (u)
-            const auto offset_cursor = m_cursor - m_start;
+        // offset for m_marker wrt. to m_start
+        const auto offset_marker = (m_marker == nullptr) ? 0 : m_marker - m_start;
+        // number of unprocessed characters (u)
+        const auto offset_cursor = m_cursor - m_start;
 
-            // no stream is used or end of file is reached
-            if (m_stream == nullptr or m_stream->eof())
+        // no stream is used or end of file is reached
+        if (m_stream == nullptr or m_stream->eof())
+        {
+            // m_start may or may not be pointing into m_line_buffer at
+            // this point. We trust the standand library to do the right
+            // thing. See http://stackoverflow.com/q/28142011/266378
+            m_line_buffer.assign(m_start, m_limit);
+
+            // append n characters to make sure that there is sufficient
+            // space between m_cursor and m_limit
+            m_line_buffer.append(1, '\x00');
+            if (n > 0)
             {
-                // m_start may or may not be pointing into m_line_buffer at
-                // this point. We trust the standand library to do the right
-                // thing. See http://stackoverflow.com/q/28142011/266378
-                m_line_buffer.assign(m_start, m_limit);
+                m_line_buffer.append(n - 1, '\x01');
+            }
+        }
+        else
+        {
+            // delete processed characters from line buffer
+            m_line_buffer.erase(0, num_processed_chars);
+            // read next line from input stream
+            m_line_buffer_tmp.clear();
+            std::getline(*m_stream, m_line_buffer_tmp, '\n');
 
-                // append n characters to make sure that there is sufficient
-                // space between m_cursor and m_limit
-                m_line_buffer.append(1, '\x00');
-                if (n > 0)
+            // add line with newline symbol to the line buffer
+            m_line_buffer += m_line_buffer_tmp;
+            m_line_buffer.push_back('\n');
+        }
+
+        // set pointers
+        m_content = reinterpret_cast<const lexer_char_t*>(m_line_buffer.data());
+        assert(m_content != nullptr);
+        m_start  = m_content;
+        m_marker = m_start + offset_marker;
+        m_cursor = m_start + offset_cursor;
+        m_limit  = m_start + m_line_buffer.size();
+    }
+
+    /// return string representation of last read token
+    string_t get_token_string() const
+    {
+        assert(m_start != nullptr);
+        return string_t(reinterpret_cast<typename string_t::const_pointer>(m_start),
+                        static_cast<size_t>(m_cursor - m_start));
+    }
+
+    /*!
+    @brief return string value for string tokens
+
+    The function iterates the characters between the opening and closing
+    quotes of the string value. The complete string is the range
+    [m_start,m_cursor). Consequently, we iterate from m_start+1 to
+    m_cursor-1.
+
+    We differentiate two cases:
+
+    1. Escaped characters. In this case, a new character is constructed
+       according to the nature of the escape. Some escapes create new
+       characters (e.g., `"\\n"` is replaced by `"\n"`), some are copied
+       as is (e.g., `"\\\\"`). Furthermore, Unicode escapes of the shape
+       `"\\uxxxx"` need special care. In this case, to_unicode takes care
+       of the construction of the values.
+    2. Unescaped characters are copied as is.
+
+    @pre `m_cursor - m_start >= 2`, meaning the length of the last token
+    is at least 2 bytes which is trivially true for any string (which
+    consists of at least two quotes).
+
+        " c1 c2 c3 ... "
+        ^                ^
+        m_start          m_cursor
+
+    @complexity Linear in the length of the string.\n
+
+    Lemma: The loop body will always terminate.\n
+
+    Proof (by contradiction): Assume the loop body does not terminate. As
+    the loop body does not contain another loop, one of the called
+    functions must never return. The called functions are `std::strtoul`
+    and to_unicode. Neither function can loop forever, so the loop body
+    will never loop forever which contradicts the assumption that the loop
+    body does not terminate, q.e.d.\n
+
+    Lemma: The loop condition for the for loop is eventually false.\n
+
+    Proof (by contradiction): Assume the loop does not terminate. Due to
+    the above lemma, this can only be due to a tautological loop
+    condition; that is, the loop condition i < m_cursor - 1 must always be
+    true. Let x be the change of i for any loop iteration. Then
+    m_start + 1 + x < m_cursor - 1 must hold to loop indefinitely. This
+    can be rephrased to m_cursor - m_start - 2 > x. With the
+    precondition, we x <= 0, meaning that the loop condition holds
+    indefinitly if i is always decreased. However, observe that the value
+    of i is strictly increasing with each iteration, as it is incremented
+    by 1 in the iteration expression and never decremented inside the loop
+    body. Hence, the loop condition will eventually be false which
+    contradicts the assumption that the loop condition is a tautology,
+    q.e.d.
+
+    @return string value of current token without opening and closing
+    quotes
+    @throw std::out_of_range if to_unicode fails
+    */
+    string_t get_string() const
+    {
+        assert(m_cursor - m_start >= 2);
+
+        string_t result;
+        result.reserve(static_cast<size_t>(m_cursor - m_start - 2));
+
+        // iterate the result between the quotes
+        for (const lexer_char_t* i = m_start + 1; i < m_cursor - 1; ++i)
+        {
+            // find next escape character
+            auto e = std::find(i, m_cursor - 1, '\\');
+            if (e != i)
+            {
+                // see https://github.com/nlohmann/json/issues/365#issuecomment-262874705
+                for (auto k = i; k < e; k++)
                 {
-                    m_line_buffer.append(n - 1, '\x01');
+                    result.push_back(static_cast<typename string_t::value_type>(*k));
                 }
+                i = e - 1; // -1 because of ++i
             }
             else
             {
-                // delete processed characters from line buffer
-                m_line_buffer.erase(0, num_processed_chars);
-                // read next line from input stream
-                m_line_buffer_tmp.clear();
-                std::getline(*m_stream, m_line_buffer_tmp, '\n');
+                // processing escaped character
+                // read next character
+                ++i;
 
-                // add line with newline symbol to the line buffer
-                m_line_buffer += m_line_buffer_tmp;
-                m_line_buffer.push_back('\n');
-            }
-
-            // set pointers
-            m_content = reinterpret_cast<const lexer_char_t*>(m_line_buffer.data());
-            assert(m_content != nullptr);
-            m_start  = m_content;
-            m_marker = m_start + offset_marker;
-            m_cursor = m_start + offset_cursor;
-            m_limit  = m_start + m_line_buffer.size();
-        }
-
-        /// return string representation of last read token
-        string_t get_token_string() const
-        {
-            assert(m_start != nullptr);
-            return string_t(reinterpret_cast<typename string_t::const_pointer>(m_start),
-                            static_cast<size_t>(m_cursor - m_start));
-        }
-
-        /*!
-        @brief return string value for string tokens
-
-        The function iterates the characters between the opening and closing
-        quotes of the string value. The complete string is the range
-        [m_start,m_cursor). Consequently, we iterate from m_start+1 to
-        m_cursor-1.
-
-        We differentiate two cases:
-
-        1. Escaped characters. In this case, a new character is constructed
-           according to the nature of the escape. Some escapes create new
-           characters (e.g., `"\\n"` is replaced by `"\n"`), some are copied
-           as is (e.g., `"\\\\"`). Furthermore, Unicode escapes of the shape
-           `"\\uxxxx"` need special care. In this case, to_unicode takes care
-           of the construction of the values.
-        2. Unescaped characters are copied as is.
-
-        @pre `m_cursor - m_start >= 2`, meaning the length of the last token
-        is at least 2 bytes which is trivially true for any string (which
-        consists of at least two quotes).
-
-            " c1 c2 c3 ... "
-            ^                ^
-            m_start          m_cursor
-
-        @complexity Linear in the length of the string.\n
-
-        Lemma: The loop body will always terminate.\n
-
-        Proof (by contradiction): Assume the loop body does not terminate. As
-        the loop body does not contain another loop, one of the called
-        functions must never return. The called functions are `std::strtoul`
-        and to_unicode. Neither function can loop forever, so the loop body
-        will never loop forever which contradicts the assumption that the loop
-        body does not terminate, q.e.d.\n
-
-        Lemma: The loop condition for the for loop is eventually false.\n
-
-        Proof (by contradiction): Assume the loop does not terminate. Due to
-        the above lemma, this can only be due to a tautological loop
-        condition; that is, the loop condition i < m_cursor - 1 must always be
-        true. Let x be the change of i for any loop iteration. Then
-        m_start + 1 + x < m_cursor - 1 must hold to loop indefinitely. This
-        can be rephrased to m_cursor - m_start - 2 > x. With the
-        precondition, we x <= 0, meaning that the loop condition holds
-        indefinitly if i is always decreased. However, observe that the value
-        of i is strictly increasing with each iteration, as it is incremented
-        by 1 in the iteration expression and never decremented inside the loop
-        body. Hence, the loop condition will eventually be false which
-        contradicts the assumption that the loop condition is a tautology,
-        q.e.d.
-
-        @return string value of current token without opening and closing
-        quotes
-        @throw std::out_of_range if to_unicode fails
-        */
-        string_t get_string() const
-        {
-            assert(m_cursor - m_start >= 2);
-
-            string_t result;
-            result.reserve(static_cast<size_t>(m_cursor - m_start - 2));
-
-            // iterate the result between the quotes
-            for (const lexer_char_t* i = m_start + 1; i < m_cursor - 1; ++i)
-            {
-                // find next escape character
-                auto e = std::find(i, m_cursor - 1, '\\');
-                if (e != i)
+                switch (*i)
                 {
-                    // see https://github.com/nlohmann/json/issues/365#issuecomment-262874705
-                    for (auto k = i; k < e; k++)
+                    // the default escapes
+                    case 't':
                     {
-                        result.push_back(static_cast<typename string_t::value_type>(*k));
+                        result += "\t";
+                        break;
                     }
-                    i = e - 1; // -1 because of ++i
-                }
-                else
-                {
-                    // processing escaped character
-                    // read next character
-                    ++i;
-
-                    switch (*i)
+                    case 'b':
                     {
-                        // the default escapes
-                        case 't':
-                        {
-                            result += "\t";
-                            break;
-                        }
-                        case 'b':
-                        {
-                            result += "\b";
-                            break;
-                        }
-                        case 'f':
-                        {
-                            result += "\f";
-                            break;
-                        }
-                        case 'n':
-                        {
-                            result += "\n";
-                            break;
-                        }
-                        case 'r':
-                        {
-                            result += "\r";
-                            break;
-                        }
-                        case '\\':
-                        {
-                            result += "\\";
-                            break;
-                        }
-                        case '/':
-                        {
-                            result += "/";
-                            break;
-                        }
-                        case '"':
-                        {
-                            result += "\"";
-                            break;
-                        }
+                        result += "\b";
+                        break;
+                    }
+                    case 'f':
+                    {
+                        result += "\f";
+                        break;
+                    }
+                    case 'n':
+                    {
+                        result += "\n";
+                        break;
+                    }
+                    case 'r':
+                    {
+                        result += "\r";
+                        break;
+                    }
+                    case '\\':
+                    {
+                        result += "\\";
+                        break;
+                    }
+                    case '/':
+                    {
+                        result += "/";
+                        break;
+                    }
+                    case '"':
+                    {
+                        result += "\"";
+                        break;
+                    }
 
-                        // unicode
-                        case 'u':
-                        {
-                            // get code xxxx from uxxxx
-                            auto codepoint = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>(i + 1),
-                                                          4).c_str(), nullptr, 16);
+                    // unicode
+                    case 'u':
+                    {
+                        // get code xxxx from uxxxx
+                        auto codepoint = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>(i + 1),
+                                                      4).c_str(), nullptr, 16);
 
-                            // check if codepoint is a high surrogate
-                            if (codepoint >= 0xD800 and codepoint <= 0xDBFF)
+                        // check if codepoint is a high surrogate
+                        if (codepoint >= 0xD800 and codepoint <= 0xDBFF)
+                        {
+                            // make sure there is a subsequent unicode
+                            if ((i + 6 >= m_limit) or * (i + 5) != '\\' or * (i + 6) != 'u')
                             {
-                                // make sure there is a subsequent unicode
-                                if ((i + 6 >= m_limit) or * (i + 5) != '\\' or * (i + 6) != 'u')
-                                {
                                     JSON_THROW(std::invalid_argument("missing low surrogate"));
-                                }
+                            }
 
-                                // get code yyyy from uxxxx\uyyyy
-                                auto codepoint2 = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>
-                                                               (i + 7), 4).c_str(), nullptr, 16);
-                                result += to_unicode(codepoint, codepoint2);
-                                // skip the next 10 characters (xxxx\uyyyy)
-                                i += 10;
-                            }
-                            else if (codepoint >= 0xDC00 and codepoint <= 0xDFFF)
-                            {
-                                // we found a lone low surrogate
-                                JSON_THROW(std::invalid_argument("missing high surrogate"));
-                            }
-                            else
-                            {
-                                // add unicode character(s)
-                                result += to_unicode(codepoint);
-                                // skip the next four characters (xxxx)
-                                i += 4;
-                            }
-                            break;
+                            // get code yyyy from uxxxx\uyyyy
+                            auto codepoint2 = std::strtoul(std::string(reinterpret_cast<typename string_t::const_pointer>
+                                                           (i + 7), 4).c_str(), nullptr, 16);
+                            result += to_unicode(codepoint, codepoint2);
+                            // skip the next 10 characters (xxxx\uyyyy)
+                            i += 10;
                         }
+                        else if (codepoint >= 0xDC00 and codepoint <= 0xDFFF)
+                        {
+                            // we found a lone low surrogate
+                                JSON_THROW(std::invalid_argument("missing high surrogate"));
+                        }
+                        else
+                        {
+                            // add unicode character(s)
+                            result += to_unicode(codepoint);
+                            // skip the next four characters (xxxx)
+                            i += 4;
+                        }
+                        break;
                     }
                 }
             }
-
-            return result;
         }
 
-        /*!
-        @brief parse floating point number
+        return result;
+    }
 
-        This function (and its overloads) serves to select the most approprate
-        standard floating point number parsing function based on the type
-        supplied via the first parameter.  Set this to @a
-        static_cast<number_float_t*>(nullptr).
+    /*!
+    @brief parse floating point number
 
-        @param[in,out] endptr recieves a pointer to the first character after
-        the number
+    This function (and its overloads) serves to select the most approprate
+    standard floating point number parsing function based on the type
+    supplied via the first parameter.  Set this to @a
+    static_cast<number_float_t*>(nullptr).
 
-        @return the floating point number
-        */
-        long double str_to_float_t(long double* /* type */, char** endptr) const
+    @param[in,out] endptr recieves a pointer to the first character after
+    the number
+
+    @return the floating point number
+    */
+    long double str_to_float_t(long double* /* type */, char** endptr) const
+    {
+        return std::strtold(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
+    }
+
+    /*!
+    @brief parse floating point number
+
+    This function (and its overloads) serves to select the most approprate
+    standard floating point number parsing function based on the type
+    supplied via the first parameter.  Set this to @a
+    static_cast<number_float_t*>(nullptr).
+
+    @param[in,out] endptr  recieves a pointer to the first character after
+    the number
+
+    @return the floating point number
+    */
+    double str_to_float_t(double* /* type */, char** endptr) const
+    {
+        return std::strtod(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
+    }
+
+    /*!
+    @brief parse floating point number
+
+    This function (and its overloads) serves to select the most approprate
+    standard floating point number parsing function based on the type
+    supplied via the first parameter.  Set this to @a
+    static_cast<number_float_t*>(nullptr).
+
+    @param[in,out] endptr  recieves a pointer to the first character after
+    the number
+
+    @return the floating point number
+    */
+    float str_to_float_t(float* /* type */, char** endptr) const
+    {
+        return std::strtof(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
+    }
+
+    /*!
+    @brief return number value for number tokens
+
+    This function translates the last token into the most appropriate
+    number type (either integer, unsigned integer or floating point),
+    which is passed back to the caller via the result parameter.
+
+    This function parses the integer component up to the radix point or
+    exponent while collecting information about the 'floating point
+    representation', which it stores in the result parameter. If there is
+    no radix point or exponent, and the number can fit into a @ref
+    number_integer_t or @ref number_unsigned_t then it sets the result
+    parameter accordingly.
+
+    If the number is a floating point number the number is then parsed
+    using @a std:strtod (or @a std:strtof or @a std::strtold).
+
+    @param[out] result  @ref basic_json object to receive the number, or
+    NAN if the conversion read past the current token. The latter case
+    needs to be treated by the caller function.
+    */
+    void get_number(basic_json& result) const
+    {
+        assert(m_start != nullptr);
+
+        const lexer::lexer_char_t* curptr = m_start;
+
+        // accumulate the integer conversion result (unsigned for now)
+        number_unsigned_t value = 0;
+
+        // maximum absolute value of the relevant integer type
+        number_unsigned_t max;
+
+        // temporarily store the type to avoid unecessary bitfield access
+        value_t type;
+
+        // look for sign
+        if (*curptr == '-')
         {
-            return std::strtold(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
+            type = value_t::number_integer;
+            max = static_cast<uint64_t>((std::numeric_limits<number_integer_t>::max)()) + 1;
+            curptr++;
+        }
+        else
+        {
+            type = value_t::number_unsigned;
+            max = static_cast<uint64_t>((std::numeric_limits<number_unsigned_t>::max)());
         }
 
-        /*!
-        @brief parse floating point number
-
-        This function (and its overloads) serves to select the most approprate
-        standard floating point number parsing function based on the type
-        supplied via the first parameter.  Set this to @a
-        static_cast<number_float_t*>(nullptr).
-
-        @param[in,out] endptr  recieves a pointer to the first character after
-        the number
-
-        @return the floating point number
-        */
-        double str_to_float_t(double* /* type */, char** endptr) const
+        // count the significant figures
+        for (; curptr < m_cursor; curptr++)
         {
-            return std::strtod(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
-        }
-
-        /*!
-        @brief parse floating point number
-
-        This function (and its overloads) serves to select the most approprate
-        standard floating point number parsing function based on the type
-        supplied via the first parameter.  Set this to @a
-        static_cast<number_float_t*>(nullptr).
-
-        @param[in,out] endptr  recieves a pointer to the first character after
-        the number
-
-        @return the floating point number
-        */
-        float str_to_float_t(float* /* type */, char** endptr) const
-        {
-            return std::strtof(reinterpret_cast<typename string_t::const_pointer>(m_start), endptr);
-        }
-
-        /*!
-        @brief return number value for number tokens
-
-        This function translates the last token into the most appropriate
-        number type (either integer, unsigned integer or floating point),
-        which is passed back to the caller via the result parameter.
-
-        This function parses the integer component up to the radix point or
-        exponent while collecting information about the 'floating point
-        representation', which it stores in the result parameter. If there is
-        no radix point or exponent, and the number can fit into a @ref
-        number_integer_t or @ref number_unsigned_t then it sets the result
-        parameter accordingly.
-
-        If the number is a floating point number the number is then parsed
-        using @a std:strtod (or @a std:strtof or @a std::strtold).
-
-        @param[out] result  @ref basic_json object to receive the number, or
-        NAN if the conversion read past the current token. The latter case
-        needs to be treated by the caller function.
-        */
-        void get_number(basic_json& result) const
-        {
-            assert(m_start != nullptr);
-
-            const lexer::lexer_char_t* curptr = m_start;
-
-            // accumulate the integer conversion result (unsigned for now)
-            number_unsigned_t value = 0;
-
-            // maximum absolute value of the relevant integer type
-            number_unsigned_t max;
-
-            // temporarily store the type to avoid unecessary bitfield access
-            value_t type;
-
-            // look for sign
-            if (*curptr == '-')
+            // quickly skip tests if a digit
+            if (*curptr < '0' || *curptr > '9')
             {
-                type = value_t::number_integer;
-                max = static_cast<uint64_t>((std::numeric_limits<number_integer_t>::max)()) + 1;
-                curptr++;
-            }
-            else
-            {
-                type = value_t::number_unsigned;
-                max = static_cast<uint64_t>((std::numeric_limits<number_unsigned_t>::max)());
-            }
-
-            // count the significant figures
-            for (; curptr < m_cursor; curptr++)
-            {
-                // quickly skip tests if a digit
-                if (*curptr < '0' || *curptr > '9')
+                if (*curptr == '.')
                 {
-                    if (*curptr == '.')
-                    {
-                        // don't count '.' but change to float
-                        type = value_t::number_float;
-                        continue;
-                    }
-                    // assume exponent (if not then will fail parse): change to
-                    // float, stop counting and record exponent details
+                    // don't count '.' but change to float
                     type = value_t::number_float;
-                    break;
-                }
-
-                // skip if definitely not an integer
-                if (type != value_t::number_float)
-                {
-                    auto digit = static_cast<number_unsigned_t>(*curptr - '0');
-
-                    // overflow if value * 10 + digit > max, move terms around
-                    // to avoid overflow in intermediate values
-                    if (value > (max - digit) / 10)
-                    {
-                        // overflow
-                        type = value_t::number_float;
-                    }
-                    else
-                    {
-                        // no overflow
-                        value = value * 10 + digit;
-                    }
+                    continue;
                 }
+                // assume exponent (if not then will fail parse): change to
+                // float, stop counting and record exponent details
+                type = value_t::number_float;
+                break;
             }
 
-            // save the value (if not a float)
-            if (type == value_t::number_unsigned)
+            // skip if definitely not an integer
+            if (type != value_t::number_float)
             {
-                result.m_value.number_unsigned = value;
-            }
-            else if (type == value_t::number_integer)
-            {
-                // invariant: if we parsed a '-', the absolute value is between
-                // 0 (we allow -0) and max == -INT64_MIN
-                assert(value >= 0);
-                assert(value <= max);
+                auto digit = static_cast<number_unsigned_t>(*curptr - '0');
 
-                if (value == max)
+                // overflow if value * 10 + digit > max, move terms around
+                // to avoid overflow in intermediate values
+                if (value > (max - digit) / 10)
                 {
-                    // we cannot simply negate value (== max == -INT64_MIN),
-                    // see https://github.com/nlohmann/json/issues/389
-                    result.m_value.number_integer = static_cast<number_integer_t>(INT64_MIN);
+                    // overflow
+                    type = value_t::number_float;
                 }
                 else
                 {
-                    // all other values can be negated safely
-                    result.m_value.number_integer = -static_cast<number_integer_t>(value);
+                    // no overflow
+                    value = value * 10 + digit;
                 }
             }
+        }
+
+        // save the value (if not a float)
+        if (type == value_t::number_unsigned)
+        {
+            result.m_value.number_unsigned = value;
+        }
+        else if (type == value_t::number_integer)
+        {
+            // invariant: if we parsed a '-', the absolute value is between
+            // 0 (we allow -0) and max == -INT64_MIN
+            assert(value >= 0);
+            assert(value <= max);
+
+            if (value == max)
+            {
+                // we cannot simply negate value (== max == -INT64_MIN),
+                // see https://github.com/nlohmann/json/issues/389
+                result.m_value.number_integer = static_cast<number_integer_t>(INT64_MIN);
+            }
             else
             {
-                // parse with strtod
+                // all other values can be negated safely
+                result.m_value.number_integer = -static_cast<number_integer_t>(value);
+            }
+        }
+        else
+        {
+            // parse with strtod
                 result.m_value.number_float = str_to_float_t(static_cast<number_float_t*>(nullptr), nullptr);
 
-                // replace infinity and NAN by null
-                if (not std::isfinite(result.m_value.number_float))
-                {
-                    type = value_t::null;
-                    result.m_value = basic_json::json_value();
-                }
+            // replace infinity and NAN by null
+            if (not std::isfinite(result.m_value.number_float))
+            {
+                type = value_t::null;
+                result.m_value = basic_json::json_value();
             }
-
-            // save the type
-            result.m_type = type;
         }
 
-      private:
-        /// optional input stream
-        std::istream* m_stream = nullptr;
-        /// line buffer buffer for m_stream
-        string_t m_line_buffer {};
-        /// used for filling m_line_buffer
-        string_t m_line_buffer_tmp {};
-        /// the buffer pointer
-        const lexer_char_t* m_content = nullptr;
-        /// pointer to the beginning of the current symbol
-        const lexer_char_t* m_start = nullptr;
-        /// pointer for backtracking information
-        const lexer_char_t* m_marker = nullptr;
-        /// pointer to the current symbol
-        const lexer_char_t* m_cursor = nullptr;
-        /// pointer to the end of the buffer
-        const lexer_char_t* m_limit = nullptr;
-        /// the last token type
-        token_type last_token_type = token_type::end_of_input;
-    };
+        // save the type
+        result.m_type = type;
+    }
+
+    private:
+    /// optional input stream
+    std::istream* m_stream = nullptr;
+    /// line buffer buffer for m_stream
+    string_t m_line_buffer {};
+    /// used for filling m_line_buffer
+    string_t m_line_buffer_tmp {};
+    /// the buffer pointer
+    const lexer_char_t* m_content = nullptr;
+    /// pointer to the beginning of the current symbol
+    const lexer_char_t* m_start = nullptr;
+    /// pointer for backtracking information
+    const lexer_char_t* m_marker = nullptr;
+    /// pointer to the current symbol
+    const lexer_char_t* m_cursor = nullptr;
+    /// pointer to the end of the buffer
+    const lexer_char_t* m_limit = nullptr;
+    /// the last token type
+    token_type last_token_type = token_type::end_of_input;
+                                                };
 
     /*!
     @brief syntax analysis
@@ -9825,282 +10289,282 @@ class basic_json
     */
     class parser
     {
-      public:
+        public:
         /// a parser reading from a string literal
         parser(const char* buff, const parser_callback_t cb = nullptr)
-            : callback(cb),
-              m_lexer(reinterpret_cast<const typename lexer::lexer_char_t*>(buff), std::strlen(buff))
-        {}
+        : callback(cb),
+        m_lexer(reinterpret_cast<const typename lexer::lexer_char_t*>(buff), std::strlen(buff))
+    {}
 
-        /// a parser reading from an input stream
-        parser(std::istream& is, const parser_callback_t cb = nullptr)
-            : callback(cb), m_lexer(is)
-        {}
+    /// a parser reading from an input stream
+    parser(std::istream& is, const parser_callback_t cb = nullptr)
+    : callback(cb), m_lexer(is)
+    {}
 
-        /// a parser reading from an iterator range with contiguous storage
-        template<class IteratorType, typename std::enable_if<
-                     std::is_same<typename std::iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value
-                     , int>::type
-                 = 0>
-        parser(IteratorType first, IteratorType last, const parser_callback_t cb = nullptr)
-            : callback(cb),
-              m_lexer(reinterpret_cast<const typename lexer::lexer_char_t*>(&(*first)),
-                      static_cast<size_t>(std::distance(first, last)))
-        {}
+    /// a parser reading from an iterator range with contiguous storage
+    template<class IteratorType, typename std::enable_if<
+                 std::is_same<typename std::iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value
+                 , int>::type
+             = 0>
+    parser(IteratorType first, IteratorType last, const parser_callback_t cb = nullptr)
+    : callback(cb),
+    m_lexer(reinterpret_cast<const typename lexer::lexer_char_t*>(&(*first)),
+            static_cast<size_t>(std::distance(first, last)))
+    {}
 
-        /// public parser interface
-        basic_json parse()
+    /// public parser interface
+    basic_json parse()
+    {
+        // read first token
+        get_token();
+
+        basic_json result = parse_internal(true);
+        result.assert_invariant();
+
+        expect(lexer::token_type::end_of_input);
+
+        // return parser result and replace it with null in case the
+        // top-level value was discarded by the callback function
+        return result.is_discarded() ? basic_json() : std::move(result);
+    }
+
+    private:
+    /// the actual parser
+    basic_json parse_internal(bool keep)
+    {
+        auto result = basic_json(value_t::discarded);
+
+        switch (last_token)
         {
-            // read first token
-            get_token();
-
-            basic_json result = parse_internal(true);
-            result.assert_invariant();
-
-            expect(lexer::token_type::end_of_input);
-
-            // return parser result and replace it with null in case the
-            // top-level value was discarded by the callback function
-            return result.is_discarded() ? basic_json() : std::move(result);
-        }
-
-      private:
-        /// the actual parser
-        basic_json parse_internal(bool keep)
-        {
-            auto result = basic_json(value_t::discarded);
-
-            switch (last_token)
+            case lexer::token_type::begin_object:
             {
-                case lexer::token_type::begin_object:
+                if (keep and (not callback
+                              or ((keep = callback(depth++, parse_event_t::object_start, result)) != 0)))
                 {
-                    if (keep and (not callback
-                                  or ((keep = callback(depth++, parse_event_t::object_start, result)) != 0)))
-                    {
-                        // explicitly set result to object to cope with {}
-                        result.m_type = value_t::object;
-                        result.m_value = value_t::object;
-                    }
+                    // explicitly set result to object to cope with {}
+                    result.m_type = value_t::object;
+                    result.m_value = value_t::object;
+                }
 
-                    // read next token
-                    get_token();
+                // read next token
+                get_token();
 
-                    // closing } -> we are done
-                    if (last_token == lexer::token_type::end_object)
-                    {
-                        get_token();
-                        if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
-                        {
-                            result = basic_json(value_t::discarded);
-                        }
-                        return result;
-                    }
-
-                    // no comma is expected here
-                    unexpect(lexer::token_type::value_separator);
-
-                    // otherwise: parse key-value pairs
-                    do
-                    {
-                        // ugly, but could be fixed with loop reorganization
-                        if (last_token == lexer::token_type::value_separator)
-                        {
-                            get_token();
-                        }
-
-                        // store key
-                        expect(lexer::token_type::value_string);
-                        const auto key = m_lexer.get_string();
-
-                        bool keep_tag = false;
-                        if (keep)
-                        {
-                            if (callback)
-                            {
-                                basic_json k(key);
-                                keep_tag = callback(depth, parse_event_t::key, k);
-                            }
-                            else
-                            {
-                                keep_tag = true;
-                            }
-                        }
-
-                        // parse separator (:)
-                        get_token();
-                        expect(lexer::token_type::name_separator);
-
-                        // parse and add value
-                        get_token();
-                        auto value = parse_internal(keep);
-                        if (keep and keep_tag and not value.is_discarded())
-                        {
-                            result[key] = std::move(value);
-                        }
-                    }
-                    while (last_token == lexer::token_type::value_separator);
-
-                    // closing }
-                    expect(lexer::token_type::end_object);
+                // closing } -> we are done
+                if (last_token == lexer::token_type::end_object)
+                {
                     get_token();
                     if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
                     {
                         result = basic_json(value_t::discarded);
                     }
-
                     return result;
                 }
 
-                case lexer::token_type::begin_array:
+                // no comma is expected here
+                unexpect(lexer::token_type::value_separator);
+
+                // otherwise: parse key-value pairs
+                do
                 {
-                    if (keep and (not callback
-                                  or ((keep = callback(depth++, parse_event_t::array_start, result)) != 0)))
-                    {
-                        // explicitly set result to object to cope with []
-                        result.m_type = value_t::array;
-                        result.m_value = value_t::array;
-                    }
-
-                    // read next token
-                    get_token();
-
-                    // closing ] -> we are done
-                    if (last_token == lexer::token_type::end_array)
+                    // ugly, but could be fixed with loop reorganization
+                    if (last_token == lexer::token_type::value_separator)
                     {
                         get_token();
-                        if (callback and not callback(--depth, parse_event_t::array_end, result))
-                        {
-                            result = basic_json(value_t::discarded);
-                        }
-                        return result;
                     }
 
-                    // no comma is expected here
-                    unexpect(lexer::token_type::value_separator);
+                    // store key
+                    expect(lexer::token_type::value_string);
+                    const auto key = m_lexer.get_string();
 
-                    // otherwise: parse values
-                    do
+                    bool keep_tag = false;
+                    if (keep)
                     {
-                        // ugly, but could be fixed with loop reorganization
-                        if (last_token == lexer::token_type::value_separator)
+                        if (callback)
                         {
-                            get_token();
+                            basic_json k(key);
+                            keep_tag = callback(depth, parse_event_t::key, k);
                         }
-
-                        // parse value
-                        auto value = parse_internal(keep);
-                        if (keep and not value.is_discarded())
+                        else
                         {
-                            result.push_back(std::move(value));
+                            keep_tag = true;
                         }
                     }
-                    while (last_token == lexer::token_type::value_separator);
 
-                    // closing ]
-                    expect(lexer::token_type::end_array);
+                    // parse separator (:)
                     get_token();
-                    if (keep and callback and not callback(--depth, parse_event_t::array_end, result))
+                    expect(lexer::token_type::name_separator);
+
+                    // parse and add value
+                    get_token();
+                    auto value = parse_internal(keep);
+                    if (keep and keep_tag and not value.is_discarded())
+                    {
+                        result[key] = std::move(value);
+                    }
+                }
+                while (last_token == lexer::token_type::value_separator);
+
+                // closing }
+                expect(lexer::token_type::end_object);
+                get_token();
+                if (keep and callback and not callback(--depth, parse_event_t::object_end, result))
+                {
+                    result = basic_json(value_t::discarded);
+                }
+
+                return result;
+            }
+
+            case lexer::token_type::begin_array:
+            {
+                if (keep and (not callback
+                              or ((keep = callback(depth++, parse_event_t::array_start, result)) != 0)))
+                {
+                    // explicitly set result to object to cope with []
+                    result.m_type = value_t::array;
+                    result.m_value = value_t::array;
+                }
+
+                // read next token
+                get_token();
+
+                // closing ] -> we are done
+                if (last_token == lexer::token_type::end_array)
+                {
+                    get_token();
+                    if (callback and not callback(--depth, parse_event_t::array_end, result))
                     {
                         result = basic_json(value_t::discarded);
                     }
-
                     return result;
                 }
 
-                case lexer::token_type::literal_null:
+                // no comma is expected here
+                unexpect(lexer::token_type::value_separator);
+
+                // otherwise: parse values
+                do
                 {
-                    get_token();
-                    result.m_type = value_t::null;
-                    break;
+                    // ugly, but could be fixed with loop reorganization
+                    if (last_token == lexer::token_type::value_separator)
+                    {
+                        get_token();
+                    }
+
+                    // parse value
+                    auto value = parse_internal(keep);
+                    if (keep and not value.is_discarded())
+                    {
+                        result.push_back(std::move(value));
+                    }
+                }
+                while (last_token == lexer::token_type::value_separator);
+
+                // closing ]
+                expect(lexer::token_type::end_array);
+                get_token();
+                if (keep and callback and not callback(--depth, parse_event_t::array_end, result))
+                {
+                    result = basic_json(value_t::discarded);
                 }
 
-                case lexer::token_type::value_string:
-                {
-                    const auto s = m_lexer.get_string();
-                    get_token();
-                    result = basic_json(s);
-                    break;
-                }
-
-                case lexer::token_type::literal_true:
-                {
-                    get_token();
-                    result.m_type = value_t::boolean;
-                    result.m_value = true;
-                    break;
-                }
-
-                case lexer::token_type::literal_false:
-                {
-                    get_token();
-                    result.m_type = value_t::boolean;
-                    result.m_value = false;
-                    break;
-                }
-
-                case lexer::token_type::value_number:
-                {
-                    m_lexer.get_number(result);
-                    get_token();
-                    break;
-                }
-
-                default:
-                {
-                    // the last token was unexpected
-                    unexpect(last_token);
-                }
+                return result;
             }
 
-            if (keep and callback and not callback(depth, parse_event_t::value, result))
+            case lexer::token_type::literal_null:
             {
-                result = basic_json(value_t::discarded);
+                get_token();
+                result.m_type = value_t::null;
+                break;
             }
-            return result;
-        }
 
-        /// get next token from lexer
-        typename lexer::token_type get_token()
-        {
-            last_token = m_lexer.scan();
-            return last_token;
-        }
-
-        void expect(typename lexer::token_type t) const
-        {
-            if (t != last_token)
+            case lexer::token_type::value_string:
             {
-                std::string error_msg = "parse error - unexpected ";
-                error_msg += (last_token == lexer::token_type::parse_error ? ("'" +  m_lexer.get_token_string() +
-                              "'") :
-                              lexer::token_type_name(last_token));
-                error_msg += "; expected " + lexer::token_type_name(t);
+                const auto s = m_lexer.get_string();
+                get_token();
+                result = basic_json(s);
+                break;
+            }
+
+            case lexer::token_type::literal_true:
+            {
+                get_token();
+                result.m_type = value_t::boolean;
+                result.m_value = true;
+                break;
+            }
+
+            case lexer::token_type::literal_false:
+            {
+                get_token();
+                result.m_type = value_t::boolean;
+                result.m_value = false;
+                break;
+            }
+
+            case lexer::token_type::value_number:
+            {
+                m_lexer.get_number(result);
+                get_token();
+                break;
+            }
+
+            default:
+            {
+                // the last token was unexpected
+                unexpect(last_token);
+            }
+        }
+
+        if (keep and callback and not callback(depth, parse_event_t::value, result))
+        {
+            result = basic_json(value_t::discarded);
+        }
+        return result;
+    }
+
+    /// get next token from lexer
+    typename lexer::token_type get_token()
+    {
+        last_token = m_lexer.scan();
+        return last_token;
+    }
+
+    void expect(typename lexer::token_type t) const
+    {
+        if (t != last_token)
+        {
+            std::string error_msg = "parse error - unexpected ";
+            error_msg += (last_token == lexer::token_type::parse_error ? ("'" +  m_lexer.get_token_string() +
+                          "'") :
+                          lexer::token_type_name(last_token));
+            error_msg += "; expected " + lexer::token_type_name(t);
                 JSON_THROW(std::invalid_argument(error_msg));
-            }
         }
+    }
 
-        void unexpect(typename lexer::token_type t) const
+    void unexpect(typename lexer::token_type t) const
+    {
+        if (t == last_token)
         {
-            if (t == last_token)
-            {
-                std::string error_msg = "parse error - unexpected ";
-                error_msg += (last_token == lexer::token_type::parse_error ? ("'" +  m_lexer.get_token_string() +
-                              "'") :
-                              lexer::token_type_name(last_token));
+            std::string error_msg = "parse error - unexpected ";
+            error_msg += (last_token == lexer::token_type::parse_error ? ("'" +  m_lexer.get_token_string() +
+                          "'") :
+                          lexer::token_type_name(last_token));
                 JSON_THROW(std::invalid_argument(error_msg));
-            }
         }
+    }
 
-      private:
-        /// current level of recursion
-        int depth = 0;
-        /// callback function
-        const parser_callback_t callback = nullptr;
-        /// the type of the last read token
-        typename lexer::token_type last_token = lexer::token_type::uninitialized;
-        /// the lexer
-        lexer m_lexer;
-    };
+    private:
+    /// current level of recursion
+    int depth = 0;
+    /// callback function
+    const parser_callback_t callback = nullptr;
+    /// the type of the last read token
+    typename lexer::token_type last_token = lexer::token_type::uninitialized;
+    /// the lexer
+    lexer m_lexer;
+                            };
 
   public:
     /*!
@@ -10119,7 +10583,7 @@ class basic_json
         /// allow basic_json to access private members
         friend class basic_json;
 
-      public:
+        public:
         /*!
         @brief create JSON pointer
 
@@ -10143,562 +10607,562 @@ class basic_json
         @since version 2.0.0
         */
         explicit json_pointer(const std::string& s = "")
-            : reference_tokens(split(s))
-        {}
+        : reference_tokens(split(s))
+    {}
 
-        /*!
-        @brief return a string representation of the JSON pointer
+    /*!
+    @brief return a string representation of the JSON pointer
 
-        @invariant For each JSON pointer `ptr`, it holds:
-        @code {.cpp}
-        ptr == json_pointer(ptr.to_string());
-        @endcode
+    @invariant For each JSON pointer `ptr`, it holds:
+    @code {.cpp}
+    ptr == json_pointer(ptr.to_string());
+    @endcode
 
-        @return a string representation of the JSON pointer
+    @return a string representation of the JSON pointer
 
-        @liveexample{The example shows the result of `to_string`.,
-        json_pointer__to_string}
+    @liveexample{The example shows the result of `to_string`.,
+    json_pointer__to_string}
 
-        @since version 2.0.0
-        */
-        std::string to_string() const noexcept
+    @since version 2.0.0
+    */
+    std::string to_string() const noexcept
+    {
+        return std::accumulate(reference_tokens.begin(),
+                               reference_tokens.end(), std::string{},
+                               [](const std::string & a, const std::string & b)
         {
-            return std::accumulate(reference_tokens.begin(),
-                                   reference_tokens.end(), std::string{},
-                                   [](const std::string & a, const std::string & b)
-            {
-                return a + "/" + escape(b);
-            });
-        }
+            return a + "/" + escape(b);
+        });
+    }
 
-        /// @copydoc to_string()
-        operator std::string() const
-        {
-            return to_string();
-        }
+    /// @copydoc to_string()
+    operator std::string() const
+    {
+        return to_string();
+    }
 
-      private:
-        /// remove and return last reference pointer
-        std::string pop_back()
+    private:
+    /// remove and return last reference pointer
+    std::string pop_back()
+    {
+        if (is_root())
         {
-            if (is_root())
-            {
                 JSON_THROW(std::domain_error("JSON pointer has no parent"));
-            }
-
-            auto last = reference_tokens.back();
-            reference_tokens.pop_back();
-            return last;
         }
 
-        /// return whether pointer points to the root document
-        bool is_root() const
-        {
-            return reference_tokens.empty();
-        }
+        auto last = reference_tokens.back();
+        reference_tokens.pop_back();
+        return last;
+    }
 
-        json_pointer top() const
+    /// return whether pointer points to the root document
+    bool is_root() const
+    {
+        return reference_tokens.empty();
+    }
+
+    json_pointer top() const
+    {
+        if (is_root())
         {
-            if (is_root())
-            {
                 JSON_THROW(std::domain_error("JSON pointer has no parent"));
-            }
-
-            json_pointer result = *this;
-            result.reference_tokens = {reference_tokens[0]};
-            return result;
         }
 
-        /*!
-        @brief create and return a reference to the pointed to value
+        json_pointer result = *this;
+        result.reference_tokens = {reference_tokens[0]};
+        return result;
+    }
 
-        @complexity Linear in the number of reference tokens.
-        */
-        reference get_and_create(reference j) const
+    /*!
+    @brief create and return a reference to the pointed to value
+
+    @complexity Linear in the number of reference tokens.
+    */
+    reference get_and_create(reference j) const
+    {
+        pointer 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)
         {
-            pointer 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->m_type)
             {
-                switch (result->m_type)
+                case value_t::null:
                 {
-                    case value_t::null:
+                    if (reference_token == "0")
                     {
-                        if (reference_token == "0")
-                        {
-                            // start a new array if reference token is 0
-                            result = &result->operator[](0);
-                        }
-                        else
-                        {
-                            // start a new object otherwise
-                            result = &result->operator[](reference_token);
-                        }
-                        break;
+                        // start a new array if reference token is 0
+                        result = &result->operator[](0);
                     }
-
-                    case value_t::object:
+                    else
                     {
-                        // create an entry in the object
+                        // start a new object otherwise
                         result = &result->operator[](reference_token);
-                        break;
-                    }
-
-                    case value_t::array:
-                    {
-                        // create an entry in the array
-                        result = &result->operator[](static_cast<size_type>(std::stoi(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 single value; that is, with an
-                    empty list of reference tokens.
-                    */
-                    default:
-                    {
-                        JSON_THROW(std::domain_error("invalid value to unflatten"));
-                    }
-                }
-            }
-
-            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 std::out_of_range      if the JSON pointer can not be resolved
-        @throw std::domain_error      if an array index begins with '0'
-        @throw std::invalid_argument  if an array index was not a number
-        */
-        reference get_unchecked(pointer ptr) const
-        {
-            for (const auto& reference_token : reference_tokens)
-            {
-                // convert null values to arrays or objects before continuing
-                if (ptr->m_type == value_t::null)
-                {
-                    // check if reference token is a number
-                    const bool nums = std::all_of(reference_token.begin(),
-                                                  reference_token.end(),
-                                                  [](const char x)
-                    {
-                        return std::isdigit(x);
-                    });
-
-                    // change value to array for numbers or "-" or to object
-                    // otherwise
-                    if (nums or reference_token == "-")
-                    {
-                        *ptr = value_t::array;
-                    }
-                    else
-                    {
-                        *ptr = value_t::object;
-                    }
-                }
-
-                switch (ptr->m_type)
-                {
-                    case value_t::object:
-                    {
-                        // use unchecked object access
-                        ptr = &ptr->operator[](reference_token);
-                        break;
-                    }
-
-                    case value_t::array:
-                    {
-                        // error condition (cf. RFC 6901, Sect. 4)
-                        if (reference_token.size() > 1 and reference_token[0] == '0')
-                        {
-                            JSON_THROW(std::domain_error("array index must not begin with '0'"));
-                        }
-
-                        if (reference_token == "-")
-                        {
-                            // explicityly treat "-" as index beyond the end
-                            ptr = &ptr->operator[](ptr->m_value.array->size());
-                        }
-                        else
-                        {
-                            // convert array index to number; unchecked access
-                            ptr = &ptr->operator[](static_cast<size_type>(std::stoi(reference_token)));
-                        }
-                        break;
-                    }
-
-                    default:
-                    {
-                        JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));
-                    }
-                }
-            }
-
-            return *ptr;
-        }
-
-        reference get_checked(pointer ptr) const
-        {
-            for (const auto& reference_token : reference_tokens)
-            {
-                switch (ptr->m_type)
-                {
-                    case value_t::object:
-                    {
-                        // note: at performs range check
-                        ptr = &ptr->at(reference_token);
-                        break;
-                    }
-
-                    case value_t::array:
-                    {
-                        if (reference_token == "-")
-                        {
-                            // "-" always fails the range check
-                            throw std::out_of_range("array index '-' (" +
-                                                    std::to_string(ptr->m_value.array->size()) +
-                                                    ") is out of range");
-                        }
-
-                        // error condition (cf. RFC 6901, Sect. 4)
-                        if (reference_token.size() > 1 and reference_token[0] == '0')
-                        {
-                            JSON_THROW(std::domain_error("array index must not begin with '0'"));
-                        }
-
-                        // note: at performs range check
-                        ptr = &ptr->at(static_cast<size_type>(std::stoi(reference_token)));
-                        break;
-                    }
-
-                    default:
-                    {
-                        JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));
-                    }
-                }
-            }
-
-            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
-        */
-        const_reference get_unchecked(const_pointer ptr) const
-        {
-            for (const auto& reference_token : reference_tokens)
-            {
-                switch (ptr->m_type)
-                {
-                    case value_t::object:
-                    {
-                        // use unchecked object access
-                        ptr = &ptr->operator[](reference_token);
-                        break;
-                    }
-
-                    case value_t::array:
-                    {
-                        if (reference_token == "-")
-                        {
-                            // "-" cannot be used for const access
-                            throw std::out_of_range("array index '-' (" +
-                                                    std::to_string(ptr->m_value.array->size()) +
-                                                    ") is out of range");
-                        }
-
-                        // error condition (cf. RFC 6901, Sect. 4)
-                        if (reference_token.size() > 1 and reference_token[0] == '0')
-                        {
-                            JSON_THROW(std::domain_error("array index must not begin with '0'"));
-                        }
-
-                        // use unchecked array access
-                        ptr = &ptr->operator[](static_cast<size_type>(std::stoi(reference_token)));
-                        break;
-                    }
-
-                    default:
-                    {
-                        JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));
-                    }
-                }
-            }
-
-            return *ptr;
-        }
-
-        const_reference get_checked(const_pointer ptr) const
-        {
-            for (const auto& reference_token : reference_tokens)
-            {
-                switch (ptr->m_type)
-                {
-                    case value_t::object:
-                    {
-                        // note: at performs range check
-                        ptr = &ptr->at(reference_token);
-                        break;
-                    }
-
-                    case value_t::array:
-                    {
-                        if (reference_token == "-")
-                        {
-                            // "-" always fails the range check
-                            throw std::out_of_range("array index '-' (" +
-                                                    std::to_string(ptr->m_value.array->size()) +
-                                                    ") is out of range");
-                        }
-
-                        // error condition (cf. RFC 6901, Sect. 4)
-                        if (reference_token.size() > 1 and reference_token[0] == '0')
-                        {
-                            JSON_THROW(std::domain_error("array index must not begin with '0'"));
-                        }
-
-                        // note: at performs range check
-                        ptr = &ptr->at(static_cast<size_type>(std::stoi(reference_token)));
-                        break;
-                    }
-
-                    default:
-                    {
-                        JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));
-                    }
-                }
-            }
-
-            return *ptr;
-        }
-
-        /// split the string input to reference tokens
-        static std::vector<std::string> split(const std::string& reference_string)
-        {
-            std::vector<std::string> result;
-
-            // special case: empty reference string -> no reference tokens
-            if (reference_string.empty())
-            {
-                return result;
-            }
-
-            // check if nonempty reference string begins with slash
-            if (reference_string[0] != '/')
-            {
-                JSON_THROW(std::domain_error("JSON pointer must be empty or begin with '/'"));
-            }
-
-            // 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
-                size_t slash = reference_string.find_first_of('/', 1),
-                // set the beginning of the first reference token
-                start = 1;
-                // we can stop if start == string::npos+1 = 0
-                start != 0;
-                // set the beginning of the next reference token
-                // (will eventually be 0 if slash == std::string::npos)
-                start = 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 (size_t pos = reference_token.find_first_of('~');
-                        pos != std::string::npos;
-                        pos = reference_token.find_first_of('~', pos + 1))
-                {
-                    assert(reference_token[pos] == '~');
-
-                    // ~ must be followed by 0 or 1
-                    if (pos == reference_token.size() - 1 or
-                            (reference_token[pos + 1] != '0' and
-                             reference_token[pos + 1] != '1'))
-                    {
-                        JSON_THROW(std::domain_error("escape error: '~' must be followed with '0' or '1'"));
-                    }
-                }
-
-                // finally, store the reference token
-                unescape(reference_token);
-                result.push_back(reference_token);
-            }
-
-            return result;
-        }
-
-      private:
-        /*!
-        @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.
-
-        @since version 2.0.0
-        */
-        static void replace_substring(std::string& s,
-                                      const std::string& f,
-                                      const std::string& t)
-        {
-            assert(not f.empty());
-
-            for (
-                size_t pos = s.find(f);         // find first occurrence of f
-                pos != std::string::npos;       // make sure f was found
-                s.replace(pos, f.size(), t),    // replace with t
-                pos = s.find(f, pos + t.size()) // find next occurrence of f
-            );
-        }
-
-        /// escape tilde and slash
-        static std::string escape(std::string s)
-        {
-            // escape "~"" to "~0" and "/" to "~1"
-            replace_substring(s, "~", "~0");
-            replace_substring(s, "/", "~1");
-            return s;
-        }
-
-        /// unescape tilde and slash
-        static void unescape(std::string& s)
-        {
-            // first transform any occurrence of the sequence '~1' to '/'
-            replace_substring(s, "~1", "/");
-            // then transform any occurrence of the sequence '~0' to '~'
-            replace_substring(s, "~0", "~");
-        }
-
-        /*!
-        @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`.
-        */
-        static void flatten(const std::string& reference_string,
-                            const basic_json& value,
-                            basic_json& result)
-        {
-            switch (value.m_type)
-            {
-                case value_t::array:
-                {
-                    if (value.m_value.array->empty())
-                    {
-                        // flatten empty array as null
-                        result[reference_string] = nullptr;
-                    }
-                    else
-                    {
-                        // iterate array and use index as reference string
-                        for (size_t i = 0; i < value.m_value.array->size(); ++i)
-                        {
-                            flatten(reference_string + "/" + std::to_string(i),
-                                    value.m_value.array->operator[](i), result);
-                        }
                     }
                     break;
                 }
 
                 case value_t::object:
                 {
-                    if (value.m_value.object->empty())
+                    // create an entry in the object
+                    result = &result->operator[](reference_token);
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    // create an entry in the array
+                    result = &result->operator[](static_cast<size_type>(std::stoi(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 single value; that is, with an
+                empty list of reference tokens.
+                */
+                default:
+                {
+                        JSON_THROW(std::domain_error("invalid value to unflatten"));
+                }
+            }
+        }
+
+        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 std::out_of_range      if the JSON pointer can not be resolved
+    @throw std::domain_error      if an array index begins with '0'
+    @throw std::invalid_argument  if an array index was not a number
+    */
+    reference get_unchecked(pointer ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            // convert null values to arrays or objects before continuing
+            if (ptr->m_type == value_t::null)
+            {
+                // check if reference token is a number
+                const bool nums = std::all_of(reference_token.begin(),
+                                              reference_token.end(),
+                                              [](const char x)
+                {
+                    return std::isdigit(x);
+                });
+
+                // change value to array for numbers or "-" or to object
+                // otherwise
+                if (nums or reference_token == "-")
+                {
+                    *ptr = value_t::array;
+                }
+                else
+                {
+                    *ptr = value_t::object;
+                }
+            }
+
+            switch (ptr->m_type)
+            {
+                case value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    // error condition (cf. RFC 6901, Sect. 4)
+                    if (reference_token.size() > 1 and reference_token[0] == '0')
                     {
-                        // flatten empty object as null
-                        result[reference_string] = nullptr;
+                            JSON_THROW(std::domain_error("array index must not begin with '0'"));
+                    }
+
+                    if (reference_token == "-")
+                    {
+                        // explicityly treat "-" as index beyond the end
+                        ptr = &ptr->operator[](ptr->m_value.array->size());
                     }
                     else
                     {
-                        // iterate object and use keys as reference string
-                        for (const auto& element : *value.m_value.object)
-                        {
-                            flatten(reference_string + "/" + escape(element.first),
-                                    element.second, result);
-                        }
+                        // convert array index to number; unchecked access
+                        ptr = &ptr->operator[](static_cast<size_type>(std::stoi(reference_token)));
                     }
                     break;
                 }
 
                 default:
                 {
-                    // add primitive value with its reference string
-                    result[reference_string] = value;
-                    break;
+                        JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));
                 }
             }
         }
 
-        /*!
-        @param[in] value  flattened JSON
+        return *ptr;
+    }
 
-        @return unflattened JSON
-        */
-        static basic_json unflatten(const basic_json& value)
+    reference get_checked(pointer ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
         {
-            if (not value.is_object())
+            switch (ptr->m_type)
             {
-                JSON_THROW(std::domain_error("only objects can be unflattened"));
-            }
-
-            basic_json result;
-
-            // iterate the JSON object values
-            for (const auto& element : *value.m_value.object)
-            {
-                if (not element.second.is_primitive())
+                case value_t::object:
                 {
-                    JSON_THROW(std::domain_error("values in object must be primitive"));
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
                 }
 
-                // assign value to 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
-                // result itself. An assignment will then create a primitive
-                // value.
-                json_pointer(element.first).get_and_create(result) = element.second;
-            }
+                case value_t::array:
+                {
+                    if (reference_token == "-")
+                    {
+                        // "-" always fails the range check
+                        throw std::out_of_range("array index '-' (" +
+                                                std::to_string(ptr->m_value.array->size()) +
+                                                ") is out of range");
+                    }
 
+                    // error condition (cf. RFC 6901, Sect. 4)
+                    if (reference_token.size() > 1 and reference_token[0] == '0')
+                    {
+                            JSON_THROW(std::domain_error("array index must not begin with '0'"));
+                    }
+
+                    // note: at performs range check
+                    ptr = &ptr->at(static_cast<size_type>(std::stoi(reference_token)));
+                    break;
+                }
+
+                default:
+                {
+                        JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));
+                }
+            }
+        }
+
+        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
+    */
+    const_reference get_unchecked(const_pointer ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->m_type)
+            {
+                case value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    if (reference_token == "-")
+                    {
+                        // "-" cannot be used for const access
+                        throw std::out_of_range("array index '-' (" +
+                                                std::to_string(ptr->m_value.array->size()) +
+                                                ") is out of range");
+                    }
+
+                    // error condition (cf. RFC 6901, Sect. 4)
+                    if (reference_token.size() > 1 and reference_token[0] == '0')
+                    {
+                            JSON_THROW(std::domain_error("array index must not begin with '0'"));
+                    }
+
+                    // use unchecked array access
+                    ptr = &ptr->operator[](static_cast<size_type>(std::stoi(reference_token)));
+                    break;
+                }
+
+                default:
+                {
+                        JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));
+                }
+            }
+        }
+
+        return *ptr;
+    }
+
+    const_reference get_checked(const_pointer ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->m_type)
+            {
+                case value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    if (reference_token == "-")
+                    {
+                        // "-" always fails the range check
+                        throw std::out_of_range("array index '-' (" +
+                                                std::to_string(ptr->m_value.array->size()) +
+                                                ") is out of range");
+                    }
+
+                    // error condition (cf. RFC 6901, Sect. 4)
+                    if (reference_token.size() > 1 and reference_token[0] == '0')
+                    {
+                            JSON_THROW(std::domain_error("array index must not begin with '0'"));
+                    }
+
+                    // note: at performs range check
+                    ptr = &ptr->at(static_cast<size_type>(std::stoi(reference_token)));
+                    break;
+                }
+
+                default:
+                {
+                        JSON_THROW(std::out_of_range("unresolved reference token '" + reference_token + "'"));
+                }
+            }
+        }
+
+        return *ptr;
+    }
+
+    /// split the string input to reference tokens
+    static std::vector<std::string> split(const std::string& reference_string)
+    {
+        std::vector<std::string> result;
+
+        // special case: empty reference string -> no reference tokens
+        if (reference_string.empty())
+        {
             return result;
         }
 
-      private:
-        /// the reference tokens
-        std::vector<std::string> reference_tokens {};
-    };
+        // check if nonempty reference string begins with slash
+        if (reference_string[0] != '/')
+        {
+                JSON_THROW(std::domain_error("JSON pointer must be empty or begin with '/'"));
+        }
+
+        // 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
+                size_t slash = reference_string.find_first_of('/', 1),
+            // set the beginning of the first reference token
+            start = 1;
+            // we can stop if start == string::npos+1 = 0
+            start != 0;
+            // set the beginning of the next reference token
+            // (will eventually be 0 if slash == std::string::npos)
+            start = 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 (size_t pos = reference_token.find_first_of('~');
+                    pos != std::string::npos;
+                        pos = reference_token.find_first_of('~', pos + 1))
+            {
+                assert(reference_token[pos] == '~');
+
+                // ~ must be followed by 0 or 1
+                if (pos == reference_token.size() - 1 or
+                        (reference_token[pos + 1] != '0' and
+                         reference_token[pos + 1] != '1'))
+                {
+                        JSON_THROW(std::domain_error("escape error: '~' must be followed with '0' or '1'"));
+                }
+            }
+
+            // finally, store the reference token
+            unescape(reference_token);
+            result.push_back(reference_token);
+        }
+
+        return result;
+    }
+
+    private:
+    /*!
+    @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.
+
+    @since version 2.0.0
+    */
+    static void replace_substring(std::string& s,
+                                  const std::string& f,
+                                  const std::string& t)
+    {
+        assert(not f.empty());
+
+        for (
+            size_t pos = s.find(f);         // find first occurrence of f
+            pos != std::string::npos;       // make sure f was found
+            s.replace(pos, f.size(), t),    // replace with t
+            pos = s.find(f, pos + t.size()) // find next occurrence of f
+        );
+    }
+
+    /// escape tilde and slash
+    static std::string escape(std::string s)
+    {
+        // escape "~"" to "~0" and "/" to "~1"
+        replace_substring(s, "~", "~0");
+        replace_substring(s, "/", "~1");
+        return s;
+    }
+
+    /// unescape tilde and slash
+    static void unescape(std::string& s)
+    {
+        // first transform any occurrence of the sequence '~1' to '/'
+        replace_substring(s, "~1", "/");
+        // then transform any occurrence of the sequence '~0' to '~'
+        replace_substring(s, "~0", "~");
+    }
+
+    /*!
+    @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`.
+    */
+    static void flatten(const std::string& reference_string,
+                        const basic_json& value,
+                        basic_json& result)
+    {
+        switch (value.m_type)
+        {
+            case value_t::array:
+            {
+                if (value.m_value.array->empty())
+                {
+                    // flatten empty array as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate array and use index as reference string
+                    for (size_t i = 0; i < value.m_value.array->size(); ++i)
+                    {
+                        flatten(reference_string + "/" + std::to_string(i),
+                                value.m_value.array->operator[](i), result);
+                    }
+                }
+                break;
+            }
+
+            case value_t::object:
+            {
+                if (value.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_value.object)
+                    {
+                        flatten(reference_string + "/" + escape(element.first),
+                                element.second, result);
+                    }
+                }
+                break;
+            }
+
+            default:
+            {
+                // add primitive value with its reference string
+                result[reference_string] = value;
+                break;
+            }
+        }
+    }
+
+    /*!
+    @param[in] value  flattened JSON
+
+    @return unflattened JSON
+    */
+    static basic_json unflatten(const basic_json& value)
+    {
+        if (not value.is_object())
+        {
+                JSON_THROW(std::domain_error("only objects can be unflattened"));
+        }
+
+        basic_json result;
+
+        // iterate the JSON object values
+        for (const auto& element : *value.m_value.object)
+        {
+            if (not element.second.is_primitive())
+            {
+                    JSON_THROW(std::domain_error("values in object must be primitive"));
+            }
+
+            // assign value to 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
+            // result itself. An assignment will then create a primitive
+            // value.
+            json_pointer(element.first).get_and_create(result) = element.second;
+        }
+
+        return result;
+    }
+
+    private:
+    /// the reference tokens
+    std::vector<std::string> reference_tokens {};
+               };
 
     //////////////////////////
     // JSON Pointer support //
@@ -11379,38 +11843,38 @@ using json = basic_json<>;
 
 // specialization of std::swap, and std::hash
 namespace std
-{
-/*!
-@brief exchanges the values of two JSON objects
-
-@since version 1.0.0
-*/
-template<>
-inline void swap(nlohmann::json& j1,
-                 nlohmann::json& j2) noexcept(
-                     is_nothrow_move_constructible<nlohmann::json>::value and
-                     is_nothrow_move_assignable<nlohmann::json>::value
-                 )
-{
-    j1.swap(j2);
-}
-
-/// hash value for JSON objects
-template<>
-struct hash<nlohmann::json>
 {
     /*!
-    @brief return a hash value for a JSON object
+    @brief exchanges the values of two JSON objects
 
     @since version 1.0.0
     */
-    std::size_t operator()(const nlohmann::json& j) const
+    template<>
+    inline void swap(nlohmann::json& j1,
+                     nlohmann::json& j2) noexcept(
+                         is_nothrow_move_constructible<nlohmann::json>::value and
+                         is_nothrow_move_assignable<nlohmann::json>::value
+                                                   )
+    {
+        j1.swap(j2);
+    }
+
+    /// hash value for JSON objects
+    template<>
+    struct hash<nlohmann::json>
+    {
+        /*!
+        @brief return a hash value for a JSON object
+
+        @since version 1.0.0
+        */
+        std::size_t operator()(const nlohmann::json& j) const
     {
         // a naive hashing via the string representation
         const auto& h = hash<nlohmann::json::string_t>();
         return h(j.dump());
     }
-};
+                        };
 } // namespace std
 
 /*!
diff --git a/test/src/unit-class_lexer.cpp b/test/src/unit-class_lexer.cpp
index 40867b19..71e75df4 100644
--- a/test/src/unit-class_lexer.cpp
+++ b/test/src/unit-class_lexer.cpp
@@ -39,66 +39,66 @@ TEST_CASE("lexer class")
         SECTION("structural characters")
         {
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>("["),
-                              1).scan() == json::lexer::token_type::begin_array));
+                               1).scan() == json::lexer::token_type::begin_array));
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>("]"),
-                              1).scan() == json::lexer::token_type::end_array));
+                               1).scan() == json::lexer::token_type::end_array));
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>("{"),
-                              1).scan() == json::lexer::token_type::begin_object));
+                               1).scan() == json::lexer::token_type::begin_object));
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>("}"),
-                              1).scan() == json::lexer::token_type::end_object));
+                               1).scan() == json::lexer::token_type::end_object));
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>(","),
-                              1).scan() == json::lexer::token_type::value_separator));
+                               1).scan() == json::lexer::token_type::value_separator));
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>(":"),
-                              1).scan() == json::lexer::token_type::name_separator));
+                               1).scan() == json::lexer::token_type::name_separator));
         }
 
         SECTION("literal names")
         {
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>("null"),
-                              4).scan() == json::lexer::token_type::literal_null));
+                               4).scan() == json::lexer::token_type::literal_null));
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>("true"),
-                              4).scan() == json::lexer::token_type::literal_true));
+                               4).scan() == json::lexer::token_type::literal_true));
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>("false"),
-                              5).scan() == json::lexer::token_type::literal_false));
+                               5).scan() == json::lexer::token_type::literal_false));
         }
 
         SECTION("numbers")
         {
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>("0"),
-                              1).scan() == json::lexer::token_type::value_number));
+                               1).scan() == json::lexer::token_type::value_number));
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>("1"),
-                              1).scan() == json::lexer::token_type::value_number));
+                               1).scan() == json::lexer::token_type::value_number));
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>("2"),
-                              1).scan() == json::lexer::token_type::value_number));
+                               1).scan() == json::lexer::token_type::value_number));
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>("3"),
-                              1).scan() == json::lexer::token_type::value_number));
+                               1).scan() == json::lexer::token_type::value_number));
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>("4"),
-                              1).scan() == json::lexer::token_type::value_number));
+                               1).scan() == json::lexer::token_type::value_number));
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>("5"),
-                              1).scan() == json::lexer::token_type::value_number));
+                               1).scan() == json::lexer::token_type::value_number));
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>("6"),
-                              1).scan() == json::lexer::token_type::value_number));
+                               1).scan() == json::lexer::token_type::value_number));
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>("7"),
-                              1).scan() == json::lexer::token_type::value_number));
+                               1).scan() == json::lexer::token_type::value_number));
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>("8"),
-                              1).scan() == json::lexer::token_type::value_number));
+                               1).scan() == json::lexer::token_type::value_number));
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>("9"),
-                              1).scan() == json::lexer::token_type::value_number));
+                               1).scan() == json::lexer::token_type::value_number));
         }
 
         SECTION("whitespace")
         {
             // result is end_of_input, because not token is following
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>(" "),
-                              1).scan() == json::lexer::token_type::end_of_input));
+                               1).scan() == json::lexer::token_type::end_of_input));
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>("\t"),
-                              1).scan() == json::lexer::token_type::end_of_input));
+                               1).scan() == json::lexer::token_type::end_of_input));
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>("\n"),
-                              1).scan() == json::lexer::token_type::end_of_input));
+                               1).scan() == json::lexer::token_type::end_of_input));
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>("\r"),
-                              1).scan() == json::lexer::token_type::end_of_input));
+                               1).scan() == json::lexer::token_type::end_of_input));
             CHECK((json::lexer(reinterpret_cast<const json::lexer::lexer_char_t*>(" \t\n\r\n\t "),
-                              7).scan() == json::lexer::token_type::end_of_input));
+                               7).scan() == json::lexer::token_type::end_of_input));
         }
     }
 
diff --git a/test/src/unit-udt.cpp b/test/src/unit-udt.cpp
index 364c5ae7..0cd834d6 100644
--- a/test/src/unit-udt.cpp
+++ b/test/src/unit-udt.cpp
@@ -38,252 +38,257 @@ using nlohmann::json;
 
 namespace udt
 {
-  enum class country
-  {
+enum class country
+{
     china,
     france,
     russia
-  };
+};
 
-  struct age
-  {
+struct age
+{
     int m_val;
-  };
+};
 
-  struct name
-  {
+struct name
+{
     std::string m_val;
-  };
+};
 
-  struct address
-  {
+struct address
+{
     std::string m_val;
-  };
+};
 
-  struct person
-  {
+struct person
+{
     age m_age;
     name m_name;
     country m_country;
-  };
+};
 
-  struct contact
-  {
+struct contact
+{
     person m_person;
     address m_address;
-  };
+};
 
-  struct contact_book
-  {
+struct contact_book
+{
     name m_book_name;
     std::vector<contact> m_contacts;
-  };
+};
 }
 
 // to_json methods
 namespace udt
 {
-  // templates because of the custom_json tests (see below)
-  template <typename Json>
-  void to_json(Json& j, age a)
-  {
+// templates because of the custom_json tests (see below)
+template <typename Json>
+void to_json(Json& j, age a)
+{
     j = a.m_val;
-  }
+}
 
-  template <typename Json>
-  void to_json(Json& j, name const& n)
-  {
+template <typename Json>
+void to_json(Json& j, name const& n)
+{
     j = n.m_val;
-  }
+}
 
-  template <typename Json>
-  void to_json(Json& j, country c)
-  {
+template <typename Json>
+void to_json(Json& j, country c)
+{
     switch (c)
     {
-    case country::china:
-      j = u8"中华人民共和国";
-      return;
-    case country::france:
-      j = "France";
-      return;
-    case country::russia:
-      j = u8"Российская Федерация";
-      return;
+        case country::china:
+            j = u8"中华人民共和国";
+            return;
+        case country::france:
+            j = "France";
+            return;
+        case country::russia:
+            j = u8"Российская Федерация";
+            return;
     }
-  }
+}
 
-  template <typename Json>
-  void to_json(Json& j, person const& p)
-  {
+template <typename Json>
+void to_json(Json& j, person const& p)
+{
     j = Json{{"age", p.m_age}, {"name", p.m_name}, {"country", p.m_country}};
-  }
+}
 
-  void to_json(nlohmann::json& j, address const& a)
-  {
+void to_json(nlohmann::json& j, address const& a)
+{
     j = a.m_val;
-  }
+}
 
-  void to_json(nlohmann::json& j, contact const& c)
-  {
+void to_json(nlohmann::json& j, contact const& c)
+{
     j = json{{"person", c.m_person}, {"address", c.m_address}};
-  }
+}
 
-  void to_json(nlohmann::json& j, contact_book const& cb)
-  {
+void to_json(nlohmann::json& j, contact_book const& cb)
+{
     j = json{{"name", cb.m_book_name}, {"contacts", cb.m_contacts}};
-  }
+}
 
-  // operators
-  bool operator==(age lhs, age rhs)
-  {
+// operators
+bool operator==(age lhs, age rhs)
+{
     return lhs.m_val == rhs.m_val;
-  }
+}
 
-  bool operator==(address const &lhs, address const &rhs)
-  {
+bool operator==(address const& lhs, address const& rhs)
+{
     return lhs.m_val == rhs.m_val;
-  }
+}
 
-  bool operator==(name const &lhs, name const &rhs)
-  {
+bool operator==(name const& lhs, name const& rhs)
+{
     return lhs.m_val == rhs.m_val;
-  }
+}
 
-  bool operator==(person const &lhs, person const &rhs)
-  {
+bool operator==(person const& lhs, person const& rhs)
+{
     return std::tie(lhs.m_name, lhs.m_age) == std::tie(rhs.m_name, rhs.m_age);
-  }
+}
 
-  bool operator==(contact const &lhs, contact const &rhs)
-  {
+bool operator==(contact const& lhs, contact const& rhs)
+{
     return std::tie(lhs.m_person, lhs.m_address) ==
            std::tie(rhs.m_person, rhs.m_address);
-  }
+}
 
-  bool operator==(contact_book const &lhs, contact_book const &rhs)
-  {
+bool operator==(contact_book const& lhs, contact_book const& rhs)
+{
     return std::tie(lhs.m_book_name, lhs.m_contacts) ==
            std::tie(rhs.m_book_name, rhs.m_contacts);
-  }
+}
 }
 
 // from_json methods
 namespace udt
 {
-  template <typename Json>
-  void from_json(Json const& j, age &a)
-  {
+template <typename Json>
+void from_json(Json const& j, age& a)
+{
     a.m_val = j.template get<int>();
-  }
+}
 
-  template <typename Json>
-  void from_json(Json const& j, name &n)
-  {
+template <typename Json>
+void from_json(Json const& j, name& n)
+{
     n.m_val = j.template get<std::string>();
-  }
+}
 
-  template <typename Json>
-  void from_json(Json const &j, country &c)
-  {
+template <typename Json>
+void from_json(Json const& j, country& c)
+{
     const auto str = j.template get<std::string>();
-    static const std::map<std::string, country> m = {
+    static const std::map<std::string, country> m =
+    {
         {u8"中华人民共和国", country::china},
         {"France", country::france},
-        {"Российская Федерация", country::russia}};
+        {"Российская Федерация", country::russia}
+    };
 
     const auto it = m.find(str);
     // TODO test exceptions
     c = it->second;
-  }
+}
 
-  template <typename Json>
-  void from_json(Json const& j, person &p)
-  {
+template <typename Json>
+void from_json(Json const& j, person& p)
+{
     p.m_age = j["age"].template get<age>();
     p.m_name = j["name"].template get<name>();
     p.m_country = j["country"].template get<country>();
-  }
+}
 
-  void from_json(nlohmann::json const &j, address &a)
-  {
+void from_json(nlohmann::json const& j, address& a)
+{
     a.m_val = j.get<std::string>();
-  }
+}
 
-  void from_json(nlohmann::json const& j, contact &c)
-  {
+void from_json(nlohmann::json const& j, contact& c)
+{
     c.m_person = j["person"].get<person>();
     c.m_address = j["address"].get<address>();
-  }
+}
 
-  void from_json(nlohmann::json const&j, contact_book &cb)
-  {
+void from_json(nlohmann::json const& j, contact_book& cb)
+{
     cb.m_book_name = j["name"].get<name>();
     cb.m_contacts = j["contacts"].get<std::vector<contact>>();
-  }
+}
 }
 
 TEST_CASE("basic usage", "[udt]")
 {
 
-  // a bit narcissic maybe :) ?
-  const udt::age a{23};
-  const udt::name n{"theo"};
-  const udt::country c{udt::country::france};
-  const udt::person sfinae_addict{a, n, c};
-  const udt::person senior_programmer{{42}, {u8"王芳"}, udt::country::china};
-  const udt::address addr{"Paris"};
-  const udt::contact cpp_programmer{sfinae_addict, addr};
-  const udt::contact_book book{{"C++"}, {cpp_programmer, {senior_programmer, addr}}};
+    // a bit narcissic maybe :) ?
+    const udt::age a
+    {
+        23
+    };
+    const udt::name n{"theo"};
+    const udt::country c{udt::country::france};
+    const udt::person sfinae_addict{a, n, c};
+    const udt::person senior_programmer{{42}, {u8"王芳"}, udt::country::china};
+    const udt::address addr{"Paris"};
+    const udt::contact cpp_programmer{sfinae_addict, addr};
+    const udt::contact_book book{{"C++"}, {cpp_programmer, {senior_programmer, addr}}};
 
-  SECTION("conversion to json via free-functions")
-  {
-    CHECK(json(a) == json(23));
-    CHECK(json(n) == json("theo"));
-    CHECK(json(c) == json("France"));
-    CHECK(json(sfinae_addict) == R"({"name":"theo", "age":23, "country":"France"})"_json);
-    CHECK(json("Paris") == json(addr));
-    CHECK(json(cpp_programmer) ==
-          R"({"person" : {"age":23, "name":"theo", "country":"France"}, "address":"Paris"})"_json);
+    SECTION("conversion to json via free-functions")
+    {
+        CHECK(json(a) == json(23));
+        CHECK(json(n) == json("theo"));
+        CHECK(json(c) == json("France"));
+        CHECK(json(sfinae_addict) == R"({"name":"theo", "age":23, "country":"France"})"_json);
+        CHECK(json("Paris") == json(addr));
+        CHECK(json(cpp_programmer) ==
+              R"({"person" : {"age":23, "name":"theo", "country":"France"}, "address":"Paris"})"_json);
 
-    CHECK(
-        json(book) ==
-        u8R"({"name":"C++", "contacts" : [{"person" : {"age":23, "name":"theo", "country":"France"}, "address":"Paris"}, {"person" : {"age":42, "country":"中华人民共和国", "name":"王芳"}, "address":"Paris"}]})"_json);
+        CHECK(
+            json(book) ==
+            u8R"({"name":"C++", "contacts" : [{"person" : {"age":23, "name":"theo", "country":"France"}, "address":"Paris"}, {"person" : {"age":42, "country":"中华人民共和国", "name":"王芳"}, "address":"Paris"}]})"_json);
 
-  }
+    }
 
-  SECTION("conversion from json via free-functions")
-  {
-    const auto big_json =
-        u8R"({"name":"C++", "contacts" : [{"person" : {"age":23, "name":"theo", "country":"France"}, "address":"Paris"}, {"person" : {"age":42, "country":"中华人民共和国", "name":"王芳"}, "address":"Paris"}]})"_json;
-    const auto parsed_book = big_json.get<udt::contact_book>();
-    const auto book_name = big_json["name"].get<udt::name>();
-    const auto contacts = big_json["contacts"].get<std::vector<udt::contact>>();
-    const auto contact_json = big_json["contacts"].at(0);
-    const auto contact = contact_json.get<udt::contact>();
-    const auto person = contact_json["person"].get<udt::person>();
-    const auto address = contact_json["address"].get<udt::address>();
-    const auto age = contact_json["person"]["age"].get<udt::age>();
-    const auto country = contact_json["person"]["country"].get<udt::country>();
-    const auto name = contact_json["person"]["name"].get<udt::name>();
+    SECTION("conversion from json via free-functions")
+    {
+        const auto big_json =
+            u8R"({"name":"C++", "contacts" : [{"person" : {"age":23, "name":"theo", "country":"France"}, "address":"Paris"}, {"person" : {"age":42, "country":"中华人民共和国", "name":"王芳"}, "address":"Paris"}]})"_json;
+        const auto parsed_book = big_json.get<udt::contact_book>();
+        const auto book_name = big_json["name"].get<udt::name>();
+        const auto contacts = big_json["contacts"].get<std::vector<udt::contact>>();
+        const auto contact_json = big_json["contacts"].at(0);
+        const auto contact = contact_json.get<udt::contact>();
+        const auto person = contact_json["person"].get<udt::person>();
+        const auto address = contact_json["address"].get<udt::address>();
+        const auto age = contact_json["person"]["age"].get<udt::age>();
+        const auto country = contact_json["person"]["country"].get<udt::country>();
+        const auto name = contact_json["person"]["name"].get<udt::name>();
 
-    CHECK(age == a);
-    CHECK(name == n);
-    CHECK(country == c);
-    CHECK(address == addr);
-    CHECK(person == sfinae_addict);
-    CHECK(contact == cpp_programmer);
-    CHECK(contacts == book.m_contacts);
-    CHECK(book_name == udt::name{"C++"});
-    CHECK(book == parsed_book);
-  }
+        CHECK(age == a);
+        CHECK(name == n);
+        CHECK(country == c);
+        CHECK(address == addr);
+        CHECK(person == sfinae_addict);
+        CHECK(contact == cpp_programmer);
+        CHECK(contacts == book.m_contacts);
+        CHECK(book_name == udt::name{"C++"});
+        CHECK(book == parsed_book);
+    }
 }
 
 namespace udt
 {
 struct legacy_type
 {
-  std::string number;
+    std::string number;
 };
 }
 
@@ -292,88 +297,96 @@ namespace nlohmann
 template <typename T>
 struct adl_serializer<std::shared_ptr<T>>
 {
-  static void to_json(json& j, std::shared_ptr<T> const& opt)
-  {
-    if (opt)
-      j = *opt;
-    else
-      j = nullptr;
-  }
+    static void to_json(json& j, std::shared_ptr<T> const& opt)
+    {
+        if (opt)
+        {
+            j = *opt;
+        }
+        else
+        {
+            j = nullptr;
+        }
+    }
 
-  static void from_json(json const &j, std::shared_ptr<T> &opt)
-  {
-    if (j.is_null())
-      opt = nullptr;
-    else
-      opt.reset(new T(j.get<T>()));
-  }
+    static void from_json(json const& j, std::shared_ptr<T>& opt)
+    {
+        if (j.is_null())
+        {
+            opt = nullptr;
+        }
+        else
+        {
+            opt.reset(new T(j.get<T>()));
+        }
+    }
 };
 
 template <>
 struct adl_serializer<udt::legacy_type>
 {
-  static void to_json(json& j, udt::legacy_type const& l)
-  {
-    j = std::stoi(l.number);
-  }
+    static void to_json(json& j, udt::legacy_type const& l)
+    {
+        j = std::stoi(l.number);
+    }
 
-  static void from_json(json const& j, udt::legacy_type& l)
-  {
-    l.number = std::to_string(j.get<int>());
-  }
+    static void from_json(json const& j, udt::legacy_type& l)
+    {
+        l.number = std::to_string(j.get<int>());
+    }
 };
 }
 
 TEST_CASE("adl_serializer specialization", "[udt]")
 {
-  SECTION("partial specialization")
-  {
-    SECTION("to_json")
+    SECTION("partial specialization")
     {
-      std::shared_ptr<udt::person> optPerson;
+        SECTION("to_json")
+        {
+            std::shared_ptr<udt::person> optPerson;
 
-      json j = optPerson;
-      CHECK(j.is_null());
+            json j = optPerson;
+            CHECK(j.is_null());
 
-      optPerson.reset(new udt::person{{42}, {"John Doe"}});
-      j = optPerson;
-      CHECK_FALSE(j.is_null());
+            optPerson.reset(new udt::person{{42}, {"John Doe"}});
+            j = optPerson;
+            CHECK_FALSE(j.is_null());
 
-      CHECK(j.get<udt::person>() == *optPerson);
+            CHECK(j.get<udt::person>() == *optPerson);
+        }
+
+        SECTION("from_json")
+        {
+            auto person = udt::person{{42}, {"John Doe"}};
+            json j = person;
+
+            auto optPerson = j.get<std::shared_ptr<udt::person>>();
+            REQUIRE(optPerson);
+            CHECK(*optPerson == person);
+
+            j = nullptr;
+            optPerson = j.get<std::shared_ptr<udt::person>>();
+            CHECK(!optPerson);
+        }
     }
 
-    SECTION("from_json")
+    SECTION("total specialization")
     {
-      auto person = udt::person{{42}, {"John Doe"}};
-      json j = person;
+        SECTION("to_json")
+        {
+            udt::legacy_type lt{"4242"};
 
-      auto optPerson = j.get<std::shared_ptr<udt::person>>();
-      REQUIRE(optPerson);
-      CHECK(*optPerson == person);
+            json j = lt;
+            CHECK(j.get<int>() == 4242);
+        }
 
-      j = nullptr;
-      optPerson = j.get<std::shared_ptr<udt::person>>();
-      CHECK(!optPerson);
+        SECTION("from_json")
+        {
+            json j = 4242;
+            auto lt = j.get<udt::legacy_type>();
+            CHECK(lt.number == "4242");
+        }
     }
-  }
-
-  SECTION("total specialization")
-  {
-    SECTION("to_json")
-    {
-      udt::legacy_type lt{"4242"};
-
-      json j = lt;
-      CHECK(j.get<int>() == 4242);
-    }
-
-    SECTION("from_json")
-    {
-      json j = 4242;
-      auto lt = j.get<udt::legacy_type>();
-      CHECK(lt.number == "4242");
-    }
-  }
 }
 
 namespace nlohmann
@@ -383,22 +396,22 @@ namespace nlohmann
 template <typename T>
 struct adl_serializer<std::vector<T>>
 {
-  static void to_json(json& j, std::vector<T> const& opt)
-  {
-  }
+    static void to_json(json& j, std::vector<T> const& opt)
+    {
+    }
 
-  static void from_json(json const &j, std::vector<T> &opt)
-  {
-  }
+    static void from_json(json const& j, std::vector<T>& opt)
+    {
+    }
 };
 }
 
 TEST_CASE("current supported types are preferred over specializations", "[udt]")
 {
 
-  json j = std::vector<int>{1, 2, 3};
-  auto f = j.get<std::vector<int>>();
-  CHECK((f == std::vector<int>{1, 2, 3}));
+    json j = std::vector<int> {1, 2, 3};
+    auto f = j.get<std::vector<int>>();
+    CHECK((f == std::vector<int> {1, 2, 3}));
 }
 
 namespace nlohmann
@@ -406,55 +419,63 @@ namespace nlohmann
 template <typename T>
 struct adl_serializer<std::unique_ptr<T>>
 {
-  static void to_json(json& j, std::unique_ptr<T> const& opt)
-  {
-    if (opt)
-      j = *opt;
-    else
-      j = nullptr;
-  }
+    static void to_json(json& j, std::unique_ptr<T> const& opt)
+    {
+        if (opt)
+        {
+            j = *opt;
+        }
+        else
+        {
+            j = nullptr;
+        }
+    }
 
-  // this is the overload needed for non-copyable types,
-  // should we add a priority tag in the implementation to prefer this overload if it exists?
-  static std::unique_ptr<T> from_json(json const &j)
-  {
-    if (j.is_null())
-      return nullptr;
-    else
-      return std::unique_ptr<T>(new T(j.get<T>()));
-  }
+    // this is the overload needed for non-copyable types,
+    // should we add a priority tag in the implementation to prefer this overload if it exists?
+    static std::unique_ptr<T> from_json(json const& j)
+    {
+        if (j.is_null())
+        {
+            return nullptr;
+        }
+        else
+        {
+            return std::unique_ptr<T>(new T(j.get<T>()));
+        }
+    }
 };
 }
 
 TEST_CASE("Non-copyable types", "[udt]")
 {
-  SECTION("to_json")
-  {
-    std::unique_ptr<udt::person> optPerson;
+    SECTION("to_json")
+    {
+        std::unique_ptr<udt::person> optPerson;
 
-    json j = optPerson;
-    CHECK(j.is_null());
+        json j = optPerson;
+        CHECK(j.is_null());
 
-    optPerson.reset(new udt::person{{42}, {"John Doe"}});
-    j = optPerson;
-    CHECK_FALSE(j.is_null());
+        optPerson.reset(new udt::person{{42}, {"John Doe"}});
+        j = optPerson;
+        CHECK_FALSE(j.is_null());
 
-    CHECK(j.get<udt::person>() == *optPerson);
-  }
+        CHECK(j.get<udt::person>() == *optPerson);
+    }
 
-  SECTION("from_json")
-  {
-    auto person = udt::person{{42}, {"John Doe"}};
-    json j = person;
+    SECTION("from_json")
+    {
+        auto person = udt::person{{42}, {"John Doe"}};
+        json j = person;
 
-    auto optPerson = j.get<std::unique_ptr<udt::person>>();
-    REQUIRE(optPerson);
-    CHECK(*optPerson == person);
+        auto optPerson = j.get<std::unique_ptr<udt::person>>();
+        REQUIRE(optPerson);
+        CHECK(*optPerson == person);
 
-    j = nullptr;
-    optPerson = j.get<std::unique_ptr<udt::person>>();
-    CHECK(!optPerson);
-  }
+        j = nullptr;
+        optPerson = j.get<std::unique_ptr<udt::person>>();
+        CHECK(!optPerson);
+    }
 }
 
 // custom serializer
@@ -462,87 +483,89 @@ TEST_CASE("Non-copyable types", "[udt]")
 template <typename T, typename = typename std::enable_if<std::is_pod<T>::value>::type>
 struct pod_serializer
 {
-  // I could forward-declare this struct, and add a basic_json alias
-  template <typename Json>
-  static void from_json(Json const& j , T& t)
-  {
-    auto value = j.template get<std::uint64_t>();
-    auto bytes = static_cast<char*>(static_cast<void*>(&value));
-    std::memcpy(&t, bytes, sizeof(value));
-  }
+    // I could forward-declare this struct, and add a basic_json alias
+    template <typename Json>
+    static void from_json(Json const& j , T& t)
+    {
+        auto value = j.template get<std::uint64_t>();
+        auto bytes = static_cast<char*>(static_cast<void*>(&value));
+        std::memcpy(&t, bytes, sizeof(value));
+    }
 
-  template <typename Json>
-  static void to_json(Json& j, T const& t)
-  {
-    auto bytes = static_cast<char const*>(static_cast<void const*>(&t));
-    std::uint64_t value = bytes[0];
-    for (auto i = 1; i < 8; ++i)
-      value |= bytes[i] << 8 * i;
+    template <typename Json>
+    static void to_json(Json& j, T const& t)
+    {
+        auto bytes = static_cast<char const*>(static_cast<void const*>(&t));
+        std::uint64_t value = bytes[0];
+        for (auto i = 1; i < 8; ++i)
+        {
+            value |= bytes[i] << 8 * i;
+        }
 
-    j = value;
-  }
+        j = value;
+    }
 };
 
 namespace udt
 {
 struct small_pod
 {
-  int begin;
-  char middle;
-  short end;
+    int begin;
+    char middle;
+    short end;
 };
 
 bool operator==(small_pod lhs, small_pod rhs)
 {
-  return std::tie(lhs.begin, lhs.middle, lhs.end) ==
-         std::tie(lhs.begin, lhs.middle, lhs.end);
+    return std::tie(lhs.begin, lhs.middle, lhs.end) ==
+           std::tie(lhs.begin, lhs.middle, lhs.end);
 }
 }
 
 TEST_CASE("custom serializer for pods", "[udt]")
 {
-  using custom_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, double, std::allocator, pod_serializer>;
+    using custom_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, double, std::allocator, pod_serializer>;
 
-  auto p = udt::small_pod{42, '/', 42};
-  custom_json j = p;
+    auto p = udt::small_pod{42, '/', 42};
+    custom_json j = p;
 
-  auto p2 = j.get<udt::small_pod>();
+    auto p2 = j.get<udt::small_pod>();
 
-  CHECK(p == p2);
+    CHECK(p == p2);
 }
 
 template <typename T, typename>
 struct another_adl_serializer;
 
-  using custom_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, double, std::allocator, another_adl_serializer>;
+using custom_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, double, std::allocator, another_adl_serializer>;
 
 template <typename T, typename>
 struct another_adl_serializer
 {
-  static void from_json(custom_json const& j , T& t)
-  {
-    using nlohmann::from_json;
-    from_json(j, t);
-  }
+    static void from_json(custom_json const& j , T& t)
+    {
+        using nlohmann::from_json;
+        from_json(j, t);
+    }
 
-  static void to_json(custom_json& j , T const& t)
-  {
-    using nlohmann::to_json;
-    to_json(j, t);
-  }
+    static void to_json(custom_json& j , T const& t)
+    {
+        using nlohmann::to_json;
+        to_json(j, t);
+    }
 };
 
 TEST_CASE("custom serializer that does adl by default", "[udt]")
 {
-  using json = nlohmann::json;
+    using json = nlohmann::json;
 
-  auto me = udt::person{23, "theo", udt::country::france};
+    auto me = udt::person{23, "theo", udt::country::france};
 
-  json j = me;
-  custom_json cj = me;
+    json j = me;
+    custom_json cj = me;
 
-  CHECK(j.dump() == cj.dump());
+    CHECK(j.dump() == cj.dump());
 
-  CHECK(me == j.get<udt::person>());
-  CHECK(me == cj.get<udt::person>());
+    CHECK(me == j.get<udt::person>());
+    CHECK(me == cj.get<udt::person>());
 }