diff --git a/src/json.hpp b/src/json.hpp
index 2df26ae0..fd63fe13 100644
--- a/src/json.hpp
+++ b/src/json.hpp
@@ -1265,6 +1265,270 @@ struct static_const
 
 template<typename T>
 constexpr T static_const<T>::value;
+
+////////////////////
+// input adapters //
+////////////////////
+
+/// abstract input adapter interface
+struct input_adapter
+{
+    virtual int get_character() = 0;
+    virtual std::string read(size_t offset, size_t length) = 0;
+    virtual ~input_adapter() {}
+};
+
+/// a type to simplify interfaces
+using input_adapter_t = std::shared_ptr<input_adapter>;
+
+/// input adapter for cached stream input
+template<std::size_t N>
+class cached_input_stream_adapter : public input_adapter
+{
+  public:
+    cached_input_stream_adapter(std::istream& i)
+        : is(i), start_position(is.tellg())
+    {
+        fill_buffer();
+
+        // skip byte order mark
+        if (fill_size >= 3 and buffer[0] == '\xEF' and buffer[1] == '\xBB' and buffer[2] == '\xBF')
+        {
+            buffer_pos += 3;
+            processed_chars += 3;
+        }
+    }
+
+    ~cached_input_stream_adapter() override
+    {
+        // clear stream flags
+        is.clear();
+        // We initially read a lot of characters into the buffer, and we
+        // may not have processed all of them. Therefore, we need to
+        // "rewind" the stream after the last processed char.
+        is.seekg(start_position);
+        is.ignore(static_cast<std::streamsize>(processed_chars));
+        // clear stream flags
+        is.clear();
+    }
+
+    int get_character() override
+    {
+        // check if refilling is necessary and possible
+        if (buffer_pos == fill_size and not eof)
+        {
+            fill_buffer();
+
+            // check and remember that filling did not yield new input
+            if (fill_size == 0)
+            {
+                eof = true;
+                return std::char_traits<char>::eof();
+            }
+
+            // the buffer is ready
+            buffer_pos = 0;
+        }
+
+        ++processed_chars;
+        assert(buffer_pos < buffer.size());
+        return buffer[buffer_pos++] & 0xFF;
+    }
+
+    std::string read(size_t offset, size_t length) override
+    {
+        // create buffer
+        std::string result(length, '\0');
+
+        // save stream position
+        const auto current_pos = is.tellg();
+        // save stream flags
+        const auto flags = is.rdstate();
+
+        // clear stream flags
+        is.clear();
+        // set stream position
+        is.seekg(static_cast<std::streamoff>(offset));
+        // read bytes
+        is.read(&result[0], static_cast<std::streamsize>(length));
+
+        // reset stream position
+        is.seekg(current_pos);
+        // reset stream flags
+        is.setstate(flags);
+
+        return result;
+    }
+
+  private:
+    void fill_buffer()
+    {
+        // fill
+        is.read(buffer.data(), static_cast<std::streamsize>(buffer.size()));
+        // store number of bytes in the buffer
+        fill_size = static_cast<size_t>(is.gcount());
+    }
+
+    /// the associated input stream
+    std::istream& is;
+
+    /// chars returned via get_character()
+    size_t processed_chars = 0;
+    /// chars processed in the current buffer
+    size_t buffer_pos = 0;
+
+    /// whether stream reached eof
+    bool eof = false;
+    /// how many chars have been copied to the buffer by last (re)fill
+    size_t fill_size = 0;
+
+    /// position of the stream when we started
+    const std::streampos start_position;
+
+    /// internal buffer
+    std::array<char, N> buffer{{}};
+};
+
+/// input adapter for buffer input
+class input_buffer_adapter : public input_adapter
+{
+  public:
+    input_buffer_adapter(const char* b, size_t l)
+        : input_adapter(), cursor(b), limit(b + l), start(b)
+    {
+        // skip byte order mark
+        if (l >= 3 and b[0] == '\xEF' and b[1] == '\xBB' and b[2] == '\xBF')
+        {
+            cursor += 3;
+        }
+    }
+
+    // delete because of pointer members
+    input_buffer_adapter(const input_buffer_adapter&) = delete;
+    input_buffer_adapter& operator=(input_buffer_adapter&) = delete;
+
+    int get_character() noexcept override
+    {
+        if (JSON_LIKELY(cursor < limit))
+        {
+            return *(cursor++) & 0xFF;
+        }
+        else
+        {
+            return std::char_traits<char>::eof();
+        }
+    }
+
+    std::string read(size_t offset, size_t length) override
+    {
+        // avoid reading too many characters
+        const size_t max_length = static_cast<size_t>(limit - start);
+        return std::string(start + offset, (std::min)(length, max_length - offset));
+    }
+
+  private:
+    /// pointer to the current character
+    const char* cursor;
+    /// pointer past the last character
+    const char* limit;
+    /// pointer to the first character
+    const char* start;
+};
+
+struct input_adapter_factory
+{
+    // native support
+
+    /// input adapter for input stream
+    static std::shared_ptr<input_adapter> create(std::istream& i)
+    {
+        return std::make_shared<cached_input_stream_adapter<16384>> (i);
+    }
+
+    /// input adapter for input stream
+    static std::shared_ptr<input_adapter> create(std::istream&& i)
+    {
+        return std::make_shared<cached_input_stream_adapter<16384>>(i);
+    }
+
+    /// input adapter for buffer
+    static std::shared_ptr<input_adapter> create(const char* b, size_t l)
+    {
+        return std::make_shared<input_buffer_adapter>(b, l);
+    }
+
+    // derived support
+
+    /// input adapter for string literal
+    template <typename CharT,
+              typename std::enable_if<
+                  std::is_pointer<CharT>::value and
+                  std::is_integral<
+                      typename std::remove_pointer<CharT>::type>::value and
+                  sizeof(typename std::remove_pointer<CharT>::type) == 1,
+                  int>::type = 0>
+    static std::shared_ptr<input_adapter> create(CharT b)
+    {
+        return create(reinterpret_cast<const char*>(b),
+                      std::strlen(reinterpret_cast<const char*>(b)));
+    }
+
+    /// input adapter for 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>
+    static std::shared_ptr<input_adapter> create(IteratorType first,
+            IteratorType last)
+    {
+        // assertion to check that the iterator range is indeed contiguous,
+        // see http://stackoverflow.com/a/35008842/266378 for more discussion
+        assert(std::accumulate(
+                   first, last, std::pair<bool, int>(true, 0),
+                   [&first](std::pair<bool, int> res, decltype(*first) val)
+        {
+            res.first &=
+                (val ==
+                 *(std::next(std::addressof(*first), res.second++)));
+            return res;
+        })
+        .first);
+
+        // assertion to check that each element is 1 byte long
+        static_assert(
+            sizeof(typename std::iterator_traits<IteratorType>::value_type) == 1, "each element in the iterator range must have the size of 1 byte");
+
+        return create(reinterpret_cast<const char*>(&(*first)),
+                      static_cast<size_t>(std::distance(first, last)));
+    }
+
+    /// input adapter for array
+    template <class T, std::size_t N>
+    static std::shared_ptr<input_adapter> create(T (&array)[N])
+    {
+        // delegate the call to the iterator-range overload
+        return create(std::begin(array), std::end(array));
+    }
+
+    /// input adapter for contiguous container
+    template <
+        class ContiguousContainer,
+        typename std::enable_if <
+            not std::is_pointer<ContiguousContainer>::value and
+            std::is_base_of<std::random_access_iterator_tag,
+                            typename std::iterator_traits<decltype(std::begin(
+                                        std::declval<ContiguousContainer const>()))>::
+                            iterator_category>::value,
+            int >::type = 0 >
+    static std::shared_ptr<input_adapter> create(const ContiguousContainer& c)
+    {
+        // delegate the call to the iterator-range overload
+        return create(std::begin(c), std::end(c));
+    }
+};
+
 } // namespace detail
 
 
@@ -7822,7 +8086,7 @@ class basic_json
     static basic_json parse(const CharT s,
                             const parser_callback_t cb = nullptr)
     {
-        return parser(input_adapter::create(s), cb).parse(true);
+        return parser(detail::input_adapter_factory::create(s), cb).parse(true);
     }
 
     template<typename CharT, typename std::enable_if<
@@ -7831,7 +8095,7 @@ class basic_json
                  sizeof(typename std::remove_pointer<CharT>::type) == 1, int>::type = 0>
     static bool accept(const CharT s)
     {
-        return parser(input_adapter::create(s)).accept(true);
+        return parser(detail::input_adapter_factory::create(s)).accept(true);
     }
 
     /*!
@@ -7865,12 +8129,12 @@ class basic_json
     static basic_json parse(std::istream& i,
                             const parser_callback_t cb = nullptr)
     {
-        return parser(input_adapter::create(i), cb).parse(true);
+        return parser(detail::input_adapter_factory::create(i), cb).parse(true);
     }
 
     static bool accept(std::istream& i)
     {
-        return parser(input_adapter::create(i)).accept(true);
+        return parser(detail::input_adapter_factory::create(i)).accept(true);
     }
 
     /*!
@@ -7879,12 +8143,12 @@ class basic_json
     static basic_json parse(std::istream&& i,
                             const parser_callback_t cb = nullptr)
     {
-        return parser(input_adapter::create(i), cb).parse(true);
+        return parser(detail::input_adapter_factory::create(i), cb).parse(true);
     }
 
     static bool accept(std::istream&& i)
     {
-        return parser(input_adapter::create(i)).accept(true);
+        return parser(detail::input_adapter_factory::create(i)).accept(true);
     }
 
     /*!
@@ -7939,7 +8203,7 @@ class basic_json
     static basic_json parse(IteratorType first, IteratorType last,
                             const parser_callback_t cb = nullptr)
     {
-        return parser(input_adapter::create(first, last), cb).parse(true);
+        return parser(detail::input_adapter_factory::create(first, last), cb).parse(true);
     }
 
     template<class IteratorType, typename std::enable_if<
@@ -7948,7 +8212,7 @@ class basic_json
                      typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0>
     static bool accept(IteratorType first, IteratorType last)
     {
-        return parser(input_adapter::create(first, last)).accept(true);
+        return parser(detail::input_adapter_factory::create(first, last)).accept(true);
     }
 
     /*!
@@ -8030,7 +8294,7 @@ class basic_json
     JSON_DEPRECATED
     friend std::istream& operator<<(basic_json& j, std::istream& i)
     {
-        j = parser(input_adapter::create(i)).parse(false);
+        j = parser(detail::input_adapter_factory::create(i)).parse(false);
         return i;
     }
 
@@ -8061,7 +8325,7 @@ class basic_json
     */
     friend std::istream& operator>>(std::istream& i, basic_json& j)
     {
-        j = parser(input_adapter::create(i)).parse(false);
+        j = parser(detail::input_adapter_factory::create(i)).parse(false);
         return i;
     }
 
@@ -9100,263 +9364,6 @@ class basic_json
 
 
   private:
-    ////////////////////
-    // input adapters //
-    ////////////////////
-
-    /// abstract input adapter interface
-    class input_adapter
-    {
-      public:
-        virtual int get_character() = 0;
-        virtual std::string read(size_t offset, size_t length) = 0;
-        virtual ~input_adapter() {}
-
-        // native support
-
-        /// input adapter for input stream
-        static std::shared_ptr<input_adapter> create(std::istream& i)
-        {
-            return std::make_shared<cached_input_stream_adapter<16384>> (i);
-        }
-
-        /// input adapter for input stream
-        static std::shared_ptr<input_adapter> create(std::istream&& i)
-        {
-            return std::make_shared<cached_input_stream_adapter<16384>>(i);
-        }
-
-        /// input adapter for buffer
-        static std::shared_ptr<input_adapter> create(const char* b, size_t l)
-        {
-            return std::make_shared<input_buffer_adapter>(b, l);
-        }
-
-        // derived support
-
-        /// input adapter for string literal
-        template<typename CharT, typename std::enable_if<
-                     std::is_pointer<CharT>::value and
-                     std::is_integral<typename std::remove_pointer<CharT>::type>::value and
-                     sizeof(typename std::remove_pointer<CharT>::type) == 1, int>::type = 0>
-        static std::shared_ptr<input_adapter> create(CharT b)
-        {
-            return create(reinterpret_cast<const char*>(b),
-                          std::strlen(reinterpret_cast<const char*>(b)));
-        }
-
-        /// input adapter for 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>
-        static std::shared_ptr<input_adapter> create(IteratorType first, IteratorType last)
-        {
-            // assertion to check that the iterator range is indeed contiguous,
-            // see http://stackoverflow.com/a/35008842/266378 for more discussion
-            assert(std::accumulate(first, last, std::pair<bool, int>(true, 0),
-                                   [&first](std::pair<bool, int> res, decltype(*first) val)
-            {
-                res.first &= (val == *(std::next(std::addressof(*first), res.second++)));
-                return res;
-            }).first);
-
-            // assertion to check that each element is 1 byte long
-            static_assert(sizeof(typename std::iterator_traits<IteratorType>::value_type) == 1,
-                          "each element in the iterator range must have the size of 1 byte");
-
-            const auto len = static_cast<size_t>(std::distance(first, last));
-            if (JSON_LIKELY(len > 0))
-            {
-                // there is at least one element: use the address of first
-                return create(reinterpret_cast<const char*>(&(*first)), len);
-            }
-            else
-            {
-                // the address of first cannot be used - use nullptr
-                return create(nullptr, len);
-            }
-        }
-
-        /// input adapter for array
-        template<class T, std::size_t N>
-        static std::shared_ptr<input_adapter> create(T (&array)[N])
-        {
-            // delegate the call to the iterator-range overload
-            return create(std::begin(array), std::end(array));
-        }
-
-        /// input adapter for contiguous container
-        template<class ContiguousContainer, typename std::enable_if<
-                     not std::is_pointer<ContiguousContainer>::value and
-                     std::is_base_of<
-                         std::random_access_iterator_tag,
-                         typename std::iterator_traits<decltype(std::begin(std::declval<ContiguousContainer const>()))>::iterator_category>::value
-                     , int>::type = 0>
-        static std::shared_ptr<input_adapter> create(const ContiguousContainer& c)
-        {
-            // delegate the call to the iterator-range overload
-            return create(std::begin(c), std::end(c));
-        }
-    };
-
-    /// a type to simplify interfaces
-    using input_adapter_t = std::shared_ptr<input_adapter>;
-
-    /// input adapter for cached stream input
-    template<std::size_t N>
-    class cached_input_stream_adapter : public input_adapter
-    {
-      public:
-        cached_input_stream_adapter(std::istream& i)
-            : is(i), start_position(is.tellg())
-        {
-            fill_buffer();
-
-            // skip byte order mark
-            if (fill_size >= 3 and buffer[0] == '\xEF' and buffer[1] == '\xBB' and buffer[2] == '\xBF')
-            {
-                buffer_pos += 3;
-                processed_chars += 3;
-            }
-        }
-
-        ~cached_input_stream_adapter() override
-        {
-            // clear stream flags
-            is.clear();
-            // We initially read a lot of characters into the buffer, and we
-            // may not have processed all of them. Therefore, we need to
-            // "rewind" the stream after the last processed char.
-            is.seekg(start_position);
-            is.ignore(static_cast<std::streamsize>(processed_chars));
-            // clear stream flags
-            is.clear();
-        }
-
-        int get_character() override
-        {
-            // check if refilling is necessary and possible
-            if (buffer_pos == fill_size and not eof)
-            {
-                fill_buffer();
-
-                // check and remember that filling did not yield new input
-                if (fill_size == 0)
-                {
-                    eof = true;
-                    return std::char_traits<char>::eof();
-                }
-
-                // the buffer is ready
-                buffer_pos = 0;
-            }
-
-            ++processed_chars;
-            assert(buffer_pos < buffer.size());
-            return buffer[buffer_pos++] & 0xFF;
-        }
-
-        std::string read(size_t offset, size_t length) override
-        {
-            // create buffer
-            std::string result(length, '\0');
-
-            // save stream position
-            const auto current_pos = is.tellg();
-            // save stream flags
-            const auto flags = is.rdstate();
-
-            // clear stream flags
-            is.clear();
-            // set stream position
-            is.seekg(static_cast<std::streamoff>(offset));
-            // read bytes
-            is.read(&result[0], static_cast<std::streamsize>(length));
-
-            // reset stream position
-            is.seekg(current_pos);
-            // reset stream flags
-            is.setstate(flags);
-
-            return result;
-        }
-
-      private:
-        void fill_buffer()
-        {
-            // fill
-            is.read(buffer.data(), static_cast<std::streamsize>(buffer.size()));
-            // store number of bytes in the buffer
-            fill_size = static_cast<size_t>(is.gcount());
-        }
-
-        /// the associated input stream
-        std::istream& is;
-
-        /// chars returned via get_character()
-        size_t processed_chars = 0;
-        /// chars processed in the current buffer
-        size_t buffer_pos = 0;
-
-        /// whether stream reached eof
-        bool eof = false;
-        /// how many chars have been copied to the buffer by last (re)fill
-        size_t fill_size = 0;
-
-        /// position of the stream when we started
-        const std::streampos start_position;
-
-        /// internal buffer
-        std::array<char, N> buffer{{}};
-    };
-
-    /// input adapter for buffer input
-    class input_buffer_adapter : public input_adapter
-    {
-      public:
-        input_buffer_adapter(const char* b, size_t l)
-            : input_adapter(), cursor(b), limit(b + l), start(b)
-        {
-            // skip byte order mark
-            if (l >= 3 and b[0] == '\xEF' and b[1] == '\xBB' and b[2] == '\xBF')
-            {
-                cursor += 3;
-            }
-        }
-
-        // delete because of pointer members
-        input_buffer_adapter(const input_buffer_adapter&) = delete;
-        input_buffer_adapter& operator=(input_buffer_adapter&) = delete;
-
-        int get_character() noexcept override
-        {
-            if (JSON_LIKELY(cursor < limit))
-            {
-                return *(cursor++) & 0xFF;
-            }
-            else
-            {
-                return std::char_traits<char>::eof();
-            }
-        }
-
-        std::string read(size_t offset, size_t length) override
-        {
-            // avoid reading too many characters
-            const size_t max_length = static_cast<size_t>(limit - start);
-            return std::string(start + offset, (std::min)(length, max_length - offset));
-        }
-
-      private:
-        /// pointer to the current character
-        const char* cursor;
-        /// pointer past the last character
-        const char* limit;
-        /// pointer to the first character
-        const char* start;
-    };
-
     //////////////////////////////////////////
     // binary serialization/deserialization //
     //////////////////////////////////////////
@@ -9364,7 +9371,6 @@ class basic_json
     /// @name binary serialization/deserialization support
     /// @{
 
-  private:
     /*!
     @brief deserialization of CBOR and MessagePack values
     */
@@ -9376,7 +9382,7 @@ class basic_json
 
         @param[in] adapter  input adapter to read from
         */
-        explicit binary_reader(input_adapter_t adapter)
+        explicit binary_reader(detail::input_adapter_t adapter)
             : ia(adapter), is_little_endian(little_endianess())
         {
             assert(ia);
@@ -10489,7 +10495,7 @@ class basic_json
 
       private:
         /// input adapter
-        input_adapter_t ia = nullptr;
+        detail::input_adapter_t ia = nullptr;
 
         /// the current character
         int current = std::char_traits<char>::eof();
@@ -11299,7 +11305,7 @@ class basic_json
     static basic_json from_cbor(const std::vector<uint8_t>& v,
                                 const size_t start_index = 0)
     {
-        binary_reader br(input_adapter::create(v.begin() + static_cast<difference_type>(start_index), v.end()));
+        binary_reader br(detail::input_adapter_factory::create(v.begin() + static_cast<difference_type>(start_index), v.end()));
         return br.parse_cbor();
     }
 
@@ -11374,7 +11380,7 @@ class basic_json
     static basic_json from_msgpack(const std::vector<uint8_t>& v,
                                    const size_t start_index = 0)
     {
-        binary_reader br(input_adapter::create(v.begin() + static_cast<difference_type>(start_index), v.end()));
+        binary_reader br(detail::input_adapter_factory::create(v.begin() + static_cast<difference_type>(start_index), v.end()));
         return br.parse_msgpack();
     }
 
@@ -11460,7 +11466,7 @@ class basic_json
             }
         }
 
-        explicit lexer(input_adapter_t adapter)
+        explicit lexer(detail::input_adapter_t adapter)
             : ia(adapter), decimal_point_char(get_decimal_point())
         {}
 
@@ -12864,7 +12870,7 @@ scan_number_done:
 
       private:
         /// input adapter
-        input_adapter_t ia = nullptr;
+        detail::input_adapter_t ia = nullptr;
 
         /// the current character
         int current = std::char_traits<char>::eof();
@@ -12903,7 +12909,7 @@ scan_number_done:
     {
       public:
         /// a parser reading from an input adapter
-        explicit parser(input_adapter_t adapter,
+        explicit parser(detail::input_adapter_t adapter,
                         const parser_callback_t cb = nullptr)
             : callback(cb), m_lexer(adapter)
         {}
diff --git a/test/src/unit-class_lexer.cpp b/test/src/unit-class_lexer.cpp
index 071337b5..794feb4e 100644
--- a/test/src/unit-class_lexer.cpp
+++ b/test/src/unit-class_lexer.cpp
@@ -36,7 +36,7 @@ using nlohmann::json;
 json::lexer::token_type scan_string(const char* s);
 json::lexer::token_type scan_string(const char* s)
 {
-    return json::lexer(json::input_adapter::create(s)).scan();
+    return json::lexer(nlohmann::detail::input_adapter_factory::create(s)).scan();
 }
 
 TEST_CASE("lexer class")
diff --git a/test/src/unit-class_parser.cpp b/test/src/unit-class_parser.cpp
index 7a8378a7..59765eda 100644
--- a/test/src/unit-class_parser.cpp
+++ b/test/src/unit-class_parser.cpp
@@ -40,30 +40,30 @@ TEST_CASE("parser class")
     {
         SECTION("null")
         {
-            CHECK(json::parser(json::input_adapter::create(std::string("null"))).parse() == json(nullptr));
+            CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("null"))).parse() == json(nullptr));
         }
 
         SECTION("true")
         {
-            CHECK(json::parser(json::input_adapter::create(std::string("true"))).parse() == json(true));
+            CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("true"))).parse() == json(true));
         }
 
         SECTION("false")
         {
-            CHECK(json::parser(json::input_adapter::create(std::string("false"))).parse() == json(false));
+            CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("false"))).parse() == json(false));
         }
 
         SECTION("array")
         {
             SECTION("empty array")
             {
-                CHECK(json::parser(json::input_adapter::create(std::string("[]"))).parse() == json(json::value_t::array));
-                CHECK(json::parser(json::input_adapter::create(std::string("[ ]"))).parse() == json(json::value_t::array));
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[]"))).parse() == json(json::value_t::array));
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[ ]"))).parse() == json(json::value_t::array));
             }
 
             SECTION("nonempty array")
             {
-                CHECK(json::parser(json::input_adapter::create(std::string("[true, false, null]"))).parse() == json({true, false, nullptr}));
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[true, false, null]"))).parse() == json({true, false, nullptr}));
             }
         }
 
@@ -71,113 +71,113 @@ TEST_CASE("parser class")
         {
             SECTION("empty object")
             {
-                CHECK(json::parser(json::input_adapter::create(std::string("{}"))).parse() == json(json::value_t::object));
-                CHECK(json::parser(json::input_adapter::create(std::string("{ }"))).parse() == json(json::value_t::object));
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{}"))).parse() == json(json::value_t::object));
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{ }"))).parse() == json(json::value_t::object));
             }
 
             SECTION("nonempty object")
             {
-                CHECK(json::parser(json::input_adapter::create(std::string("{\"\": true, \"one\": 1, \"two\": null}"))).parse() == json({{"", true}, {"one", 1}, {"two", nullptr}}));
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"\": true, \"one\": 1, \"two\": null}"))).parse() == json({{"", true}, {"one", 1}, {"two", nullptr}}));
             }
         }
 
         SECTION("string")
         {
             // empty string
-            CHECK(json::parser(json::input_adapter::create(std::string("\"\""))).parse() == json(json::value_t::string));
+            CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\""))).parse() == json(json::value_t::string));
 
             SECTION("errors")
             {
                 // error: tab in string
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\t\""))).parse(), json::parse_error&);
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\t\""))).parse(),
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\t\""))).parse(), json::parse_error&);
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\t\""))).parse(),
                                   "[json.exception.parse_error.101] parse error at 2: syntax error - invalid string: control character must be escaped; last read: '\"<U+0009>'");
                 // error: newline in string
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\n\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\r\""))).parse(), json::parse_error&);
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\n\""))).parse(),
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\n\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\r\""))).parse(), json::parse_error&);
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\n\""))).parse(),
                                   "[json.exception.parse_error.101] parse error at 2: syntax error - invalid string: control character must be escaped; last read: '\"<U+000A>'");
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\r\""))).parse(),
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\r\""))).parse(),
                                   "[json.exception.parse_error.101] parse error at 2: syntax error - invalid string: control character must be escaped; last read: '\"<U+000D>'");
                 // error: backspace in string
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\b\""))).parse(), json::parse_error&);
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\b\""))).parse(),
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\b\""))).parse(), json::parse_error&);
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\b\""))).parse(),
                                   "[json.exception.parse_error.101] parse error at 2: syntax error - invalid string: control character must be escaped; last read: '\"<U+0008>'");
                 // improve code coverage
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\uFF01"))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("[-4:1,]"))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\uFF01"))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[-4:1,]"))).parse(), json::parse_error&);
                 // unescaped control characters
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x00\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x01\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x02\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x03\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x04\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x05\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x06\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x07\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x08\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x09\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x0a\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x0b\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x0c\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x0d\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x0e\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x0f\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x10\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x11\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x12\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x13\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x14\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x15\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x16\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x17\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x18\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x19\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x1a\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x1b\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x1c\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x1d\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x1e\""))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\x1f\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x00\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x01\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x02\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x03\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x04\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x05\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x06\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x07\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x08\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x09\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0a\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0b\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0c\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0d\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0e\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0f\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x10\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x11\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x12\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x13\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x14\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x15\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x16\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x17\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x18\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x19\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1a\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1b\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1c\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1d\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1e\""))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1f\""))).parse(), json::parse_error&);
             }
 
             SECTION("escaped")
             {
                 // quotation mark "\""
                 auto r1 = R"("\"")"_json;
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\\"\""))).parse() == r1);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\\"\""))).parse() == r1);
                 // reverse solidus "\\"
                 auto r2 = R"("\\")"_json;
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\\\\""))).parse() == r2);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\\\\""))).parse() == r2);
                 // solidus
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\/\""))).parse() == R"("/")"_json);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\/\""))).parse() == R"("/")"_json);
                 // backspace
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\b\""))).parse() == json("\b"));
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\b\""))).parse() == json("\b"));
                 // formfeed
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\f\""))).parse() == json("\f"));
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\f\""))).parse() == json("\f"));
                 // newline
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\n\""))).parse() == json("\n"));
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\n\""))).parse() == json("\n"));
                 // carriage return
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\r\""))).parse() == json("\r"));
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\r\""))).parse() == json("\r"));
                 // horizontal tab
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\t\""))).parse() == json("\t"));
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\t\""))).parse() == json("\t"));
 
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\u0001\""))).parse().get<json::string_t>() == "\x01");
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\u000a\""))).parse().get<json::string_t>() == "\n");
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\u00b0\""))).parse().get<json::string_t>() == "°");
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\u0c00\""))).parse().get<json::string_t>() == "ఀ");
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\ud000\""))).parse().get<json::string_t>() == "퀀");
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\u000E\""))).parse().get<json::string_t>() == "\x0E");
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\u00F0\""))).parse().get<json::string_t>() == "ð");
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\u0100\""))).parse().get<json::string_t>() == "Ā");
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\u2000\""))).parse().get<json::string_t>() == " ");
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\uFFFF\""))).parse().get<json::string_t>() == "￿");
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\u20AC\""))).parse().get<json::string_t>() == "€");
-                CHECK(json::parser(json::input_adapter::create(std::string("\"€\""))).parse().get<json::string_t>() == "€");
-                CHECK(json::parser(json::input_adapter::create(std::string("\"🎈\""))).parse().get<json::string_t>() == "🎈");
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0001\""))).parse().get<json::string_t>() == "\x01");
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u000a\""))).parse().get<json::string_t>() == "\n");
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u00b0\""))).parse().get<json::string_t>() == "°");
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0c00\""))).parse().get<json::string_t>() == "ఀ");
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\ud000\""))).parse().get<json::string_t>() == "퀀");
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u000E\""))).parse().get<json::string_t>() == "\x0E");
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u00F0\""))).parse().get<json::string_t>() == "ð");
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0100\""))).parse().get<json::string_t>() == "Ā");
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u2000\""))).parse().get<json::string_t>() == " ");
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\uFFFF\""))).parse().get<json::string_t>() == "￿");
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u20AC\""))).parse().get<json::string_t>() == "€");
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"€\""))).parse().get<json::string_t>() == "€");
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"🎈\""))).parse().get<json::string_t>() == "🎈");
 
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\ud80c\\udc60\""))).parse().get<json::string_t>() == u8"\U00013060");
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\ud83c\\udf1e\""))).parse().get<json::string_t>() == "🌞");
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\ud80c\\udc60\""))).parse().get<json::string_t>() == u8"\U00013060");
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\ud83c\\udf1e\""))).parse().get<json::string_t>() == "🌞");
             }
         }
 
@@ -187,40 +187,40 @@ TEST_CASE("parser class")
             {
                 SECTION("without exponent")
                 {
-                    CHECK(json::parser(json::input_adapter::create(std::string("-128"))).parse() == json(-128));
-                    CHECK(json::parser(json::input_adapter::create(std::string("-0"))).parse() == json(-0));
-                    CHECK(json::parser(json::input_adapter::create(std::string("0"))).parse() == json(0));
-                    CHECK(json::parser(json::input_adapter::create(std::string("128"))).parse() == json(128));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-128"))).parse() == json(-128));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0"))).parse() == json(-0));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0"))).parse() == json(0));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("128"))).parse() == json(128));
                 }
 
                 SECTION("with exponent")
                 {
-                    CHECK(json::parser(json::input_adapter::create(std::string("0e1"))).parse() == json(0e1));
-                    CHECK(json::parser(json::input_adapter::create(std::string("0E1"))).parse() == json(0e1));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0e1"))).parse() == json(0e1));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0E1"))).parse() == json(0e1));
 
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000E-4"))).parse() == json(10000e-4));
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000E-3"))).parse() == json(10000e-3));
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000E-2"))).parse() == json(10000e-2));
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000E-1"))).parse() == json(10000e-1));
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000E0"))).parse() == json(10000e0));
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000E1"))).parse() == json(10000e1));
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000E2"))).parse() == json(10000e2));
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000E3"))).parse() == json(10000e3));
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000E4"))).parse() == json(10000e4));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E-4"))).parse() == json(10000e-4));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E-3"))).parse() == json(10000e-3));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E-2"))).parse() == json(10000e-2));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E-1"))).parse() == json(10000e-1));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E0"))).parse() == json(10000e0));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E1"))).parse() == json(10000e1));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E2"))).parse() == json(10000e2));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E3"))).parse() == json(10000e3));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E4"))).parse() == json(10000e4));
 
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000e-4"))).parse() == json(10000e-4));
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000e-3"))).parse() == json(10000e-3));
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000e-2"))).parse() == json(10000e-2));
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000e-1"))).parse() == json(10000e-1));
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000e0"))).parse() == json(10000e0));
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000e1"))).parse() == json(10000e1));
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000e2"))).parse() == json(10000e2));
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000e3"))).parse() == json(10000e3));
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000e4"))).parse() == json(10000e4));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e-4"))).parse() == json(10000e-4));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e-3"))).parse() == json(10000e-3));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e-2"))).parse() == json(10000e-2));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e-1"))).parse() == json(10000e-1));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e0"))).parse() == json(10000e0));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e1"))).parse() == json(10000e1));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e2"))).parse() == json(10000e2));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e3"))).parse() == json(10000e3));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e4"))).parse() == json(10000e4));
 
-                    CHECK(json::parser(json::input_adapter::create(std::string("-0e1"))).parse() == json(-0e1));
-                    CHECK(json::parser(json::input_adapter::create(std::string("-0E1"))).parse() == json(-0e1));
-                    CHECK(json::parser(json::input_adapter::create(std::string("-0E123"))).parse() == json(-0e123));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0e1"))).parse() == json(-0e1));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E1"))).parse() == json(-0e1));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E123"))).parse() == json(-0e123));
                 }
 
                 SECTION("edge cases")
@@ -232,9 +232,9 @@ TEST_CASE("parser class")
                     // agree exactly on their numeric values.
 
                     // -(2**53)+1
-                    CHECK(json::parser(json::input_adapter::create(std::string("-9007199254740991"))).parse().get<int64_t>() == -9007199254740991);
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-9007199254740991"))).parse().get<int64_t>() == -9007199254740991);
                     // (2**53)-1
-                    CHECK(json::parser(json::input_adapter::create(std::string("9007199254740991"))).parse().get<int64_t>() == 9007199254740991);
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("9007199254740991"))).parse().get<int64_t>() == 9007199254740991);
                 }
 
                 SECTION("over the edge cases")  // issue #178 - Integer conversion to unsigned (incorrect handling of 64 bit integers)
@@ -247,11 +247,11 @@ TEST_CASE("parser class")
                     // i.e. -(2**63) -> (2**64)-1.
 
                     // -(2**63)    ** Note: compilers see negative literals as negated positive numbers (hence the -1))
-                    CHECK(json::parser(json::input_adapter::create(std::string("-9223372036854775808"))).parse().get<int64_t>() == -9223372036854775807 - 1);
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-9223372036854775808"))).parse().get<int64_t>() == -9223372036854775807 - 1);
                     // (2**63)-1
-                    CHECK(json::parser(json::input_adapter::create(std::string("9223372036854775807"))).parse().get<int64_t>() == 9223372036854775807);
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("9223372036854775807"))).parse().get<int64_t>() == 9223372036854775807);
                     // (2**64)-1
-                    CHECK(json::parser(json::input_adapter::create(std::string("18446744073709551615"))).parse().get<uint64_t>() == 18446744073709551615u);
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("18446744073709551615"))).parse().get<uint64_t>() == 18446744073709551615u);
                 }
             }
 
@@ -259,85 +259,85 @@ TEST_CASE("parser class")
             {
                 SECTION("without exponent")
                 {
-                    CHECK(json::parser(json::input_adapter::create(std::string("-128.5"))).parse() == json(-128.5));
-                    CHECK(json::parser(json::input_adapter::create(std::string("0.999"))).parse() == json(0.999));
-                    CHECK(json::parser(json::input_adapter::create(std::string("128.5"))).parse() == json(128.5));
-                    CHECK(json::parser(json::input_adapter::create(std::string("-0.0"))).parse() == json(-0.0));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-128.5"))).parse() == json(-128.5));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0.999"))).parse() == json(0.999));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("128.5"))).parse() == json(128.5));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0"))).parse() == json(-0.0));
                 }
 
                 SECTION("with exponent")
                 {
-                    CHECK(json::parser(json::input_adapter::create(std::string("-128.5E3"))).parse() == json(-128.5E3));
-                    CHECK(json::parser(json::input_adapter::create(std::string("-128.5E-3"))).parse() == json(-128.5E-3));
-                    CHECK(json::parser(json::input_adapter::create(std::string("-0.0e1"))).parse() == json(-0.0e1));
-                    CHECK(json::parser(json::input_adapter::create(std::string("-0.0E1"))).parse() == json(-0.0e1));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-128.5E3"))).parse() == json(-128.5E3));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-128.5E-3"))).parse() == json(-128.5E-3));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0e1"))).parse() == json(-0.0e1));
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0E1"))).parse() == json(-0.0e1));
                 }
             }
 
             SECTION("overflow")
             {
                 // overflows during parsing yield an exception
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1.18973e+4932"))).parse() == json(), json::out_of_range&);
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1.18973e+4932"))).parse() == json(),
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1.18973e+4932"))).parse() == json(), json::out_of_range&);
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1.18973e+4932"))).parse() == json(),
                                   "[json.exception.out_of_range.406] number overflow parsing '1.18973e+4932'");
             }
 
             SECTION("invalid numbers")
             {
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("01"))).parse(),      json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("--1"))).parse(),     json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1."))).parse(),      json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1E"))).parse(),      json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1E-"))).parse(),     json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1.E1"))).parse(),    json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-1E"))).parse(),     json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-0E#"))).parse(),    json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-0E-#"))).parse(),   json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-0#"))).parse(),     json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-0.0:"))).parse(),   json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-0.0Z"))).parse(),   json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-0E123:"))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-0e0-:"))).parse(),  json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-0e-:"))).parse(),   json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-0f"))).parse(),     json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("01"))).parse(),      json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("--1"))).parse(),     json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1."))).parse(),      json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E"))).parse(),      json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E-"))).parse(),     json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1.E1"))).parse(),    json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-1E"))).parse(),     json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E#"))).parse(),    json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E-#"))).parse(),   json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0#"))).parse(),     json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0:"))).parse(),   json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0Z"))).parse(),   json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E123:"))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0e0-:"))).parse(),  json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0e-:"))).parse(),   json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0f"))).parse(),     json::parse_error&);
 
                 // numbers must not begin with "+"
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("+1"))).parse(), json::parse_error&);
-                CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("+0"))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("+1"))).parse(), json::parse_error&);
+                CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("+0"))).parse(), json::parse_error&);
 
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("01"))).parse(),
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("01"))).parse(),
                                   "[json.exception.parse_error.101] parse error at 2: syntax error - unexpected number literal; expected end of input");
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-01"))).parse(),
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-01"))).parse(),
                                   "[json.exception.parse_error.101] parse error at 3: syntax error - unexpected number literal; expected end of input");
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("--1"))).parse(),
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("--1"))).parse(),
                                   "[json.exception.parse_error.101] parse error at 2: syntax error - invalid number; expected digit after '-'; last read: '--'");
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1."))).parse(),
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1."))).parse(),
                                   "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected digit after '.'; last read: '1.'");
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1E"))).parse(),
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E"))).parse(),
                                   "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected '+', '-', or digit after exponent; last read: '1E'");
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1E-"))).parse(),
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E-"))).parse(),
                                   "[json.exception.parse_error.101] parse error at 4: syntax error - invalid number; expected digit after exponent sign; last read: '1E-'");
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1.E1"))).parse(),
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1.E1"))).parse(),
                                   "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected digit after '.'; last read: '1.E'");
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-1E"))).parse(),
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-1E"))).parse(),
                                   "[json.exception.parse_error.101] parse error at 4: syntax error - invalid number; expected '+', '-', or digit after exponent; last read: '-1E'");
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0E#"))).parse(),
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E#"))).parse(),
                                   "[json.exception.parse_error.101] parse error at 4: syntax error - invalid number; expected '+', '-', or digit after exponent; last read: '-0E#'");
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0E-#"))).parse(),
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E-#"))).parse(),
                                   "[json.exception.parse_error.101] parse error at 5: syntax error - invalid number; expected digit after exponent sign; last read: '-0E-#'");
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0#"))).parse(),
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0#"))).parse(),
                                   "[json.exception.parse_error.101] parse error at 3: syntax error - invalid literal; last read: '-0#'; expected end of input");
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0.0:"))).parse(),
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0:"))).parse(),
                                   "[json.exception.parse_error.101] parse error at 5: syntax error - unexpected ':'; expected end of input");
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0.0Z"))).parse(),
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0Z"))).parse(),
                                   "[json.exception.parse_error.101] parse error at 5: syntax error - invalid literal; last read: '-0.0Z'; expected end of input");
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0E123:"))).parse(),
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E123:"))).parse(),
                                   "[json.exception.parse_error.101] parse error at 7: syntax error - unexpected ':'; expected end of input");
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0e0-:"))).parse(),
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0e0-:"))).parse(),
                                   "[json.exception.parse_error.101] parse error at 6: syntax error - invalid number; expected digit after '-'; last read: '-:'; expected end of input");
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0e-:"))).parse(),
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0e-:"))).parse(),
                                   "[json.exception.parse_error.101] parse error at 5: syntax error - invalid number; expected digit after exponent sign; last read: '-0e-:'");
-                CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0f"))).parse(),
+                CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0f"))).parse(),
                                   "[json.exception.parse_error.101] parse error at 4: syntax error - invalid literal; last read: '-0f'; expected end of input");
             }
         }
@@ -347,30 +347,30 @@ TEST_CASE("parser class")
     {
         SECTION("null")
         {
-            CHECK(json::parser(json::input_adapter::create(std::string("null"))).accept());
+            CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("null"))).accept());
         }
 
         SECTION("true")
         {
-            CHECK(json::parser(json::input_adapter::create(std::string("true"))).accept());
+            CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("true"))).accept());
         }
 
         SECTION("false")
         {
-            CHECK(json::parser(json::input_adapter::create(std::string("false"))).accept());
+            CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("false"))).accept());
         }
 
         SECTION("array")
         {
             SECTION("empty array")
             {
-                CHECK(json::parser(json::input_adapter::create(std::string("[]"))).accept());
-                CHECK(json::parser(json::input_adapter::create(std::string("[ ]"))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[]"))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[ ]"))).accept());
             }
 
             SECTION("nonempty array")
             {
-                CHECK(json::parser(json::input_adapter::create(std::string("[true, false, null]"))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[true, false, null]"))).accept());
             }
         }
 
@@ -378,105 +378,105 @@ TEST_CASE("parser class")
         {
             SECTION("empty object")
             {
-                CHECK(json::parser(json::input_adapter::create(std::string("{}"))).accept());
-                CHECK(json::parser(json::input_adapter::create(std::string("{ }"))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{}"))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{ }"))).accept());
             }
 
             SECTION("nonempty object")
             {
-                CHECK(json::parser(json::input_adapter::create(std::string("{\"\": true, \"one\": 1, \"two\": null}"))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"\": true, \"one\": 1, \"two\": null}"))).accept());
             }
         }
 
         SECTION("string")
         {
             // empty string
-            CHECK(json::parser(json::input_adapter::create(std::string("\"\""))).accept());
+            CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\""))).accept());
 
             SECTION("errors")
             {
                 // error: tab in string
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\t\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\t\""))).accept() == false);
                 // error: newline in string
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\n\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\r\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\n\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\r\""))).accept() == false);
                 // error: backspace in string
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\b\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\b\""))).accept() == false);
                 // improve code coverage
-                CHECK(json::parser(json::input_adapter::create(std::string("\uFF01"))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("[-4:1,]"))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\uFF01"))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[-4:1,]"))).accept() == false);
                 // unescaped control characters
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x00\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x01\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x02\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x03\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x04\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x05\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x06\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x07\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x08\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x09\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x0a\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x0b\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x0c\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x0d\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x0e\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x0f\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x10\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x11\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x12\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x13\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x14\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x15\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x16\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x17\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x18\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x19\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x1a\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x1b\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x1c\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x1d\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x1e\""))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\x1f\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x00\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x01\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x02\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x03\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x04\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x05\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x06\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x07\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x08\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x09\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0a\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0b\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0c\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0d\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0e\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x0f\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x10\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x11\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x12\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x13\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x14\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x15\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x16\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x17\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x18\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x19\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1a\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1b\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1c\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1d\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1e\""))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\x1f\""))).accept() == false);
             }
 
             SECTION("escaped")
             {
                 // quotation mark "\""
                 auto r1 = R"("\"")"_json;
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\\"\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\\"\""))).accept());
                 // reverse solidus "\\"
                 auto r2 = R"("\\")"_json;
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\\\\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\\\\""))).accept());
                 // solidus
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\/\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\/\""))).accept());
                 // backspace
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\b\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\b\""))).accept());
                 // formfeed
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\f\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\f\""))).accept());
                 // newline
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\n\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\n\""))).accept());
                 // carriage return
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\r\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\r\""))).accept());
                 // horizontal tab
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\t\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\t\""))).accept());
 
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\u0001\""))).accept());
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\u000a\""))).accept());
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\u00b0\""))).accept());
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\u0c00\""))).accept());
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\ud000\""))).accept());
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\u000E\""))).accept());
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\u00F0\""))).accept());
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\u0100\""))).accept());
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\u2000\""))).accept());
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\uFFFF\""))).accept());
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\u20AC\""))).accept());
-                CHECK(json::parser(json::input_adapter::create(std::string("\"€\""))).accept());
-                CHECK(json::parser(json::input_adapter::create(std::string("\"🎈\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0001\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u000a\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u00b0\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0c00\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\ud000\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u000E\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u00F0\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0100\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u2000\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\uFFFF\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u20AC\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"€\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"🎈\""))).accept());
 
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\ud80c\\udc60\""))).accept());
-                CHECK(json::parser(json::input_adapter::create(std::string("\"\\ud83c\\udf1e\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\ud80c\\udc60\""))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\ud83c\\udf1e\""))).accept());
             }
         }
 
@@ -486,40 +486,40 @@ TEST_CASE("parser class")
             {
                 SECTION("without exponent")
                 {
-                    CHECK(json::parser(json::input_adapter::create(std::string("-128"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("-0"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("0"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("128"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-128"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("128"))).accept());
                 }
 
                 SECTION("with exponent")
                 {
-                    CHECK(json::parser(json::input_adapter::create(std::string("0e1"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("0E1"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0e1"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0E1"))).accept());
 
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000E-4"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000E-3"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000E-2"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000E-1"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000E0"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000E1"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000E2"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000E3"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000E4"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E-4"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E-3"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E-2"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E-1"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E0"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E1"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E2"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E3"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000E4"))).accept());
 
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000e-4"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000e-3"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000e-2"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000e-1"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000e0"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000e1"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000e2"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000e3"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("10000e4"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e-4"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e-3"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e-2"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e-1"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e0"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e1"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e2"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e3"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("10000e4"))).accept());
 
-                    CHECK(json::parser(json::input_adapter::create(std::string("-0e1"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("-0E1"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("-0E123"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0e1"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E1"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E123"))).accept());
                 }
 
                 SECTION("edge cases")
@@ -531,9 +531,9 @@ TEST_CASE("parser class")
                     // agree exactly on their numeric values.
 
                     // -(2**53)+1
-                    CHECK(json::parser(json::input_adapter::create(std::string("-9007199254740991"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-9007199254740991"))).accept());
                     // (2**53)-1
-                    CHECK(json::parser(json::input_adapter::create(std::string("9007199254740991"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("9007199254740991"))).accept());
                 }
 
                 SECTION("over the edge cases")  // issue #178 - Integer conversion to unsigned (incorrect handling of 64 bit integers)
@@ -546,11 +546,11 @@ TEST_CASE("parser class")
                     // i.e. -(2**63) -> (2**64)-1.
 
                     // -(2**63)    ** Note: compilers see negative literals as negated positive numbers (hence the -1))
-                    CHECK(json::parser(json::input_adapter::create(std::string("-9223372036854775808"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-9223372036854775808"))).accept());
                     // (2**63)-1
-                    CHECK(json::parser(json::input_adapter::create(std::string("9223372036854775807"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("9223372036854775807"))).accept());
                     // (2**64)-1
-                    CHECK(json::parser(json::input_adapter::create(std::string("18446744073709551615"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("18446744073709551615"))).accept());
                 }
             }
 
@@ -558,49 +558,49 @@ TEST_CASE("parser class")
             {
                 SECTION("without exponent")
                 {
-                    CHECK(json::parser(json::input_adapter::create(std::string("-128.5"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("0.999"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("128.5"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("-0.0"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-128.5"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0.999"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("128.5"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0"))).accept());
                 }
 
                 SECTION("with exponent")
                 {
-                    CHECK(json::parser(json::input_adapter::create(std::string("-128.5E3"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("-128.5E-3"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("-0.0e1"))).accept());
-                    CHECK(json::parser(json::input_adapter::create(std::string("-0.0E1"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-128.5E3"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-128.5E-3"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0e1"))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0E1"))).accept());
                 }
             }
 
             SECTION("overflow")
             {
                 // overflows during parsing yield an exception, but is accepted anyway
-                CHECK(json::parser(json::input_adapter::create(std::string("1.18973e+4932"))).accept());
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1.18973e+4932"))).accept());
             }
 
             SECTION("invalid numbers")
             {
-                CHECK(json::parser(json::input_adapter::create(std::string("01"))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("--1"))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("1."))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("1E"))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("1E-"))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("1.E1"))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("-1E"))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("-0E#"))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("-0E-#"))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("-0#"))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("-0.0:"))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("-0.0Z"))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("-0E123:"))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("-0e0-:"))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("-0e-:"))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("-0f"))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("01"))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("--1"))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1."))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E"))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E-"))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1.E1"))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-1E"))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E#"))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E-#"))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0#"))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0:"))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0.0Z"))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0E123:"))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0e0-:"))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0e-:"))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0f"))).accept() == false);
 
                 // numbers must not begin with "+"
-                CHECK(json::parser(json::input_adapter::create(std::string("+1"))).accept() == false);
-                CHECK(json::parser(json::input_adapter::create(std::string("+0"))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("+1"))).accept() == false);
+                CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("+0"))).accept() == false);
             }
         }
     }
@@ -608,152 +608,152 @@ TEST_CASE("parser class")
     SECTION("parse errors")
     {
         // unexpected end of number
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("0."))).parse(),  json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-"))).parse(),   json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("--"))).parse(),  json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-0."))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-."))).parse(),  json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("-:"))).parse(),  json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("0.:"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("e."))).parse(),  json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1e."))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1e/"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1e:"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1E."))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1E/"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("1E:"))).parse(), json::parse_error&);
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("0."))).parse(),
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0."))).parse(),  json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-"))).parse(),   json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("--"))).parse(),  json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0."))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-."))).parse(),  json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-:"))).parse(),  json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0.:"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("e."))).parse(),  json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1e."))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1e/"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1e:"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E."))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E/"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E:"))).parse(), json::parse_error&);
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0."))).parse(),
                           "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected digit after '.'; last read: '0.'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-"))).parse(),
                           "[json.exception.parse_error.101] parse error at 2: syntax error - invalid number; expected digit after '-'; last read: '-'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("--"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("--"))).parse(),
                           "[json.exception.parse_error.101] parse error at 2: syntax error - invalid number; expected digit after '-'; last read: '--'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-0."))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0."))).parse(),
                           "[json.exception.parse_error.101] parse error at 4: syntax error - invalid number; expected digit after '.'; last read: '-0.'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-."))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-."))).parse(),
                           "[json.exception.parse_error.101] parse error at 2: syntax error - invalid number; expected digit after '-'; last read: '-.'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("-:"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-:"))).parse(),
                           "[json.exception.parse_error.101] parse error at 2: syntax error - invalid number; expected digit after '-'; last read: '-:'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("0.:"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0.:"))).parse(),
                           "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected digit after '.'; last read: '0.:'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("e."))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("e."))).parse(),
                           "[json.exception.parse_error.101] parse error at 1: syntax error - invalid literal; last read: 'e'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1e."))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1e."))).parse(),
                           "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected '+', '-', or digit after exponent; last read: '1e.'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1e/"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1e/"))).parse(),
                           "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected '+', '-', or digit after exponent; last read: '1e/'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1e:"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1e:"))).parse(),
                           "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected '+', '-', or digit after exponent; last read: '1e:'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1E."))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E."))).parse(),
                           "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected '+', '-', or digit after exponent; last read: '1E.'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1E/"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E/"))).parse(),
                           "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected '+', '-', or digit after exponent; last read: '1E/'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("1E:"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E:"))).parse(),
                           "[json.exception.parse_error.101] parse error at 3: syntax error - invalid number; expected '+', '-', or digit after exponent; last read: '1E:'");
 
         // unexpected end of null
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("n"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("nu"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("nul"))).parse(), json::parse_error&);
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("n"))).parse(),
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("n"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("nu"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("nul"))).parse(), json::parse_error&);
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("n"))).parse(),
                           "[json.exception.parse_error.101] parse error at 2: syntax error - invalid literal; last read: 'n'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("nu"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("nu"))).parse(),
                           "[json.exception.parse_error.101] parse error at 3: syntax error - invalid literal; last read: 'nu'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("nul"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("nul"))).parse(),
                           "[json.exception.parse_error.101] parse error at 4: syntax error - invalid literal; last read: 'nul'");
 
         // unexpected end of true
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("t"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("tr"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("tru"))).parse(), json::parse_error&);
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("t"))).parse(),
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("t"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("tr"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("tru"))).parse(), json::parse_error&);
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("t"))).parse(),
                           "[json.exception.parse_error.101] parse error at 2: syntax error - invalid literal; last read: 't'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("tr"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("tr"))).parse(),
                           "[json.exception.parse_error.101] parse error at 3: syntax error - invalid literal; last read: 'tr'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("tru"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("tru"))).parse(),
                           "[json.exception.parse_error.101] parse error at 4: syntax error - invalid literal; last read: 'tru'");
 
         // unexpected end of false
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("f"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("fa"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("fal"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("fals"))).parse(), json::parse_error&);
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("f"))).parse(),
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("f"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("fa"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("fal"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("fals"))).parse(), json::parse_error&);
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("f"))).parse(),
                           "[json.exception.parse_error.101] parse error at 2: syntax error - invalid literal; last read: 'f'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("fa"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("fa"))).parse(),
                           "[json.exception.parse_error.101] parse error at 3: syntax error - invalid literal; last read: 'fa'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("fal"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("fal"))).parse(),
                           "[json.exception.parse_error.101] parse error at 4: syntax error - invalid literal; last read: 'fal'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("fals"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("fals"))).parse(),
                           "[json.exception.parse_error.101] parse error at 5: syntax error - invalid literal; last read: 'fals'");
 
         // missing/unexpected end of array
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("["))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("[1"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("[1,"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("[1,]"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("]"))).parse(), json::parse_error&);
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("["))).parse(),
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("["))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[1"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[1,"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[1,]"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("]"))).parse(), json::parse_error&);
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("["))).parse(),
                           "[json.exception.parse_error.101] parse error at 2: syntax error - unexpected end of input; expected '[', '{', or a literal");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("[1"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[1"))).parse(),
                           "[json.exception.parse_error.101] parse error at 3: syntax error - unexpected end of input; expected ']'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("[1,"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[1,"))).parse(),
                           "[json.exception.parse_error.101] parse error at 4: syntax error - unexpected end of input; expected '[', '{', or a literal");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("[1,]"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[1,]"))).parse(),
                           "[json.exception.parse_error.101] parse error at 4: syntax error - unexpected ']'; expected '[', '{', or a literal");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("]"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("]"))).parse(),
                           "[json.exception.parse_error.101] parse error at 1: syntax error - unexpected ']'; expected '[', '{', or a literal");
 
         // missing/unexpected end of object
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("{"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("{\"foo\""))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("{\"foo\":"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("{\"foo\":}"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("{\"foo\":1,}"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("}"))).parse(), json::parse_error&);
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("{"))).parse(),
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\""))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\":"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\":}"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\":1,}"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("}"))).parse(), json::parse_error&);
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{"))).parse(),
                           "[json.exception.parse_error.101] parse error at 2: syntax error - unexpected end of input; expected string literal");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("{\"foo\""))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\""))).parse(),
                           "[json.exception.parse_error.101] parse error at 7: syntax error - unexpected end of input; expected ':'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("{\"foo\":"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\":"))).parse(),
                           "[json.exception.parse_error.101] parse error at 8: syntax error - unexpected end of input; expected '[', '{', or a literal");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("{\"foo\":}"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\":}"))).parse(),
                           "[json.exception.parse_error.101] parse error at 8: syntax error - unexpected '}'; expected '[', '{', or a literal");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("{\"foo\":1,}"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\":1,}"))).parse(),
                           "[json.exception.parse_error.101] parse error at 10: syntax error - unexpected '}'; expected string literal");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("}"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("}"))).parse(),
                           "[json.exception.parse_error.101] parse error at 1: syntax error - unexpected '}'; expected '[', '{', or a literal");
 
         // missing/unexpected end of string
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\""))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\\\""))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\\u\""))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\\u0\""))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\\u01\""))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\\u012\""))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\\u"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\\u0"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\\u01"))).parse(), json::parse_error&);
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("\"\\u012"))).parse(), json::parse_error&);
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\""))).parse(),
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\""))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\\""))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u\""))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0\""))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u01\""))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u012\""))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u01"))).parse(), json::parse_error&);
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u012"))).parse(), json::parse_error&);
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\""))).parse(),
                           "[json.exception.parse_error.101] parse error at 2: syntax error - invalid string: missing closing quote; last read: '\"'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\\\""))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\\""))).parse(),
                           "[json.exception.parse_error.101] parse error at 4: syntax error - invalid string: missing closing quote; last read: '\"\\\"'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\\u\""))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u\""))).parse(),
                           "[json.exception.parse_error.101] parse error at 4: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '\"\\u\"'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\\u0\""))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0\""))).parse(),
                           "[json.exception.parse_error.101] parse error at 5: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '\"\\u0\"'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\\u01\""))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u01\""))).parse(),
                           "[json.exception.parse_error.101] parse error at 6: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '\"\\u01\"'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\\u012\""))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u012\""))).parse(),
                           "[json.exception.parse_error.101] parse error at 7: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '\"\\u012\"'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\\u"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u"))).parse(),
                           "[json.exception.parse_error.101] parse error at 4: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '\"\\u'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\\u0"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0"))).parse(),
                           "[json.exception.parse_error.101] parse error at 5: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '\"\\u0'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\\u01"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u01"))).parse(),
                           "[json.exception.parse_error.101] parse error at 6: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '\"\\u01'");
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("\"\\u012"))).parse(),
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u012"))).parse(),
                           "[json.exception.parse_error.101] parse error at 7: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '\"\\u012'");
 
         // invalid escapes
@@ -773,7 +773,7 @@ TEST_CASE("parser class")
                 case ('r'):
                 case ('t'):
                 {
-                    CHECK_NOTHROW(json::parser(json::input_adapter::create(std::string(s.c_str()))).parse());
+                    CHECK_NOTHROW(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s.c_str()))).parse());
                     break;
                 }
 
@@ -786,11 +786,11 @@ TEST_CASE("parser class")
                 // any other combination of backslash and character is invalid
                 default:
                 {
-                    CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string(s.c_str()))).parse(), json::parse_error&);
+                    CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s.c_str()))).parse(), json::parse_error&);
                     // only check error message if c is not a control character
                     if (c > 0x1f)
                     {
-                        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string(s.c_str()))).parse(),
+                        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s.c_str()))).parse(),
                                           "[json.exception.parse_error.101] parse error at 3: syntax error - invalid string: forbidden character after backslash; last read: '\"\\" + std::string(1, static_cast<char>(c)) + "'");
                     }
                     break;
@@ -851,49 +851,49 @@ TEST_CASE("parser class")
                 if (valid(c))
                 {
                     CAPTURE(s1);
-                    CHECK_NOTHROW(json::parser(json::input_adapter::create(std::string(s1.c_str()))).parse());
+                    CHECK_NOTHROW(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s1.c_str()))).parse());
                     CAPTURE(s2);
-                    CHECK_NOTHROW(json::parser(json::input_adapter::create(std::string(s2.c_str()))).parse());
+                    CHECK_NOTHROW(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s2.c_str()))).parse());
                     CAPTURE(s3);
-                    CHECK_NOTHROW(json::parser(json::input_adapter::create(std::string(s3.c_str()))).parse());
+                    CHECK_NOTHROW(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s3.c_str()))).parse());
                     CAPTURE(s4);
-                    CHECK_NOTHROW(json::parser(json::input_adapter::create(std::string(s4.c_str()))).parse());
+                    CHECK_NOTHROW(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s4.c_str()))).parse());
                 }
                 else
                 {
                     CAPTURE(s1);
-                    CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string(s1.c_str()))).parse(), json::parse_error&);
+                    CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s1.c_str()))).parse(), json::parse_error&);
                     // only check error message if c is not a control character
                     if (c > 0x1f)
                     {
-                        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string(s1.c_str()))).parse(),
+                        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s1.c_str()))).parse(),
                                           "[json.exception.parse_error.101] parse error at 7: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '" + s1.substr(0, 7) + "'");
                     }
 
                     CAPTURE(s2);
-                    CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string(s2.c_str()))).parse(), json::parse_error&);
+                    CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s2.c_str()))).parse(), json::parse_error&);
                     // only check error message if c is not a control character
                     if (c > 0x1f)
                     {
-                        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string(s2.c_str()))).parse(),
+                        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s2.c_str()))).parse(),
                                           "[json.exception.parse_error.101] parse error at 6: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '" + s2.substr(0, 6) + "'");
                     }
 
                     CAPTURE(s3);
-                    CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string(s3.c_str()))).parse(), json::parse_error&);
+                    CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s3.c_str()))).parse(), json::parse_error&);
                     // only check error message if c is not a control character
                     if (c > 0x1f)
                     {
-                        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string(s3.c_str()))).parse(),
+                        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s3.c_str()))).parse(),
                                           "[json.exception.parse_error.101] parse error at 5: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '" + s3.substr(0, 5) + "'");
                     }
 
                     CAPTURE(s4);
-                    CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string(s4.c_str()))).parse(), json::parse_error&);
+                    CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s4.c_str()))).parse(), json::parse_error&);
                     // only check error message if c is not a control character
                     if (c > 0x1f)
                     {
-                        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string(s4.c_str()))).parse(),
+                        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s4.c_str()))).parse(),
                                           "[json.exception.parse_error.101] parse error at 4: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '" + s4.substr(0, 4) + "'");
                     }
                 }
@@ -919,63 +919,63 @@ TEST_CASE("parser class")
     SECTION("parse errors (accept)")
     {
         // unexpected end of number
-        CHECK(json::parser(json::input_adapter::create(std::string("0."))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("-"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("--"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("-0."))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("-."))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("-:"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("0.:"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("e."))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("1e."))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("1e/"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("1e:"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("1E."))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("1E/"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("1E:"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0."))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("--"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-0."))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-."))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("-:"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("0.:"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("e."))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1e."))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1e/"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1e:"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E."))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E/"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("1E:"))).accept() == false);
 
         // unexpected end of null
-        CHECK(json::parser(json::input_adapter::create(std::string("n"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("nu"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("nul"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("n"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("nu"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("nul"))).accept() == false);
 
         // unexpected end of true
-        CHECK(json::parser(json::input_adapter::create(std::string("t"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("tr"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("tru"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("t"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("tr"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("tru"))).accept() == false);
 
         // unexpected end of false
-        CHECK(json::parser(json::input_adapter::create(std::string("f"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("fa"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("fal"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("fals"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("f"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("fa"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("fal"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("fals"))).accept() == false);
 
         // missing/unexpected end of array
-        CHECK(json::parser(json::input_adapter::create(std::string("["))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("[1"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("[1,"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("[1,]"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("]"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("["))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[1"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[1,"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[1,]"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("]"))).accept() == false);
 
         // missing/unexpected end of object
-        CHECK(json::parser(json::input_adapter::create(std::string("{"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("{\"foo\""))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("{\"foo\":"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("{\"foo\":}"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("{\"foo\":1,}"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("}"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\""))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\":"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\":}"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{\"foo\":1,}"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("}"))).accept() == false);
 
         // missing/unexpected end of string
-        CHECK(json::parser(json::input_adapter::create(std::string("\""))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("\"\\\""))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("\"\\u\""))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("\"\\u0\""))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("\"\\u01\""))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("\"\\u012\""))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("\"\\u"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("\"\\u0"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("\"\\u01"))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("\"\\u012"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\""))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\\""))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u\""))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0\""))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u01\""))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u012\""))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u0"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u01"))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\u012"))).accept() == false);
 
         // invalid escapes
         for (int c = 1; c < 128; ++c)
@@ -994,7 +994,7 @@ TEST_CASE("parser class")
                 case ('r'):
                 case ('t'):
                 {
-                    CHECK(json::parser(json::input_adapter::create(std::string(s.c_str()))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s.c_str()))).accept());
                     break;
                 }
 
@@ -1007,7 +1007,7 @@ TEST_CASE("parser class")
                 // any other combination of backslash and character is invalid
                 default:
                 {
-                    CHECK(json::parser(json::input_adapter::create(std::string(s.c_str()))).accept() == false);
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s.c_str()))).accept() == false);
                     break;
                 }
             }
@@ -1066,48 +1066,48 @@ TEST_CASE("parser class")
                 if (valid(c))
                 {
                     CAPTURE(s1);
-                    CHECK(json::parser(json::input_adapter::create(std::string(s1.c_str()))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s1.c_str()))).accept());
                     CAPTURE(s2);
-                    CHECK(json::parser(json::input_adapter::create(std::string(s2.c_str()))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s2.c_str()))).accept());
                     CAPTURE(s3);
-                    CHECK(json::parser(json::input_adapter::create(std::string(s3.c_str()))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s3.c_str()))).accept());
                     CAPTURE(s4);
-                    CHECK(json::parser(json::input_adapter::create(std::string(s4.c_str()))).accept());
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s4.c_str()))).accept());
                 }
                 else
                 {
                     CAPTURE(s1);
-                    CHECK(json::parser(json::input_adapter::create(std::string(s1.c_str()))).accept() == false);
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s1.c_str()))).accept() == false);
 
                     CAPTURE(s2);
-                    CHECK(json::parser(json::input_adapter::create(std::string(s2.c_str()))).accept() == false);
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s2.c_str()))).accept() == false);
 
                     CAPTURE(s3);
-                    CHECK(json::parser(json::input_adapter::create(std::string(s3.c_str()))).accept() == false);
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s3.c_str()))).accept() == false);
 
                     CAPTURE(s4);
-                    CHECK(json::parser(json::input_adapter::create(std::string(s4.c_str()))).accept() == false);
+                    CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string(s4.c_str()))).accept() == false);
                 }
             }
         }
 
         // missing part of a surrogate pair
-        CHECK(json::parser(json::input_adapter::create(std::string("\"\\uD80C\""))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\uD80C\""))).accept() == false);
         // invalid surrogate pair
-        CHECK(json::parser(json::input_adapter::create(std::string("\"\\uD80C\\uD80C\""))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("\"\\uD80C\\u0000\""))).accept() == false);
-        CHECK(json::parser(json::input_adapter::create(std::string("\"\\uD80C\\uFFFF\""))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\uD80C\\uD80C\""))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\uD80C\\u0000\""))).accept() == false);
+        CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("\"\\uD80C\\uFFFF\""))).accept() == false);
     }
 
     SECTION("tests found by mutate++")
     {
         // test case to make sure no comma preceeds the first key
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("{,\"key\": false}"))).parse(), json::parse_error&);
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("{,\"key\": false}"))).parse(),
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{,\"key\": false}"))).parse(), json::parse_error&);
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("{,\"key\": false}"))).parse(),
                           "[json.exception.parse_error.101] parse error at 2: syntax error - unexpected ','; expected string literal");
         // test case to make sure an object is properly closed
-        CHECK_THROWS_AS(json::parser(json::input_adapter::create(std::string("[{\"key\": false true]"))).parse(), json::parse_error&);
-        CHECK_THROWS_WITH(json::parser(json::input_adapter::create(std::string("[{\"key\": false true]"))).parse(),
+        CHECK_THROWS_AS(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[{\"key\": false true]"))).parse(), json::parse_error&);
+        CHECK_THROWS_WITH(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("[{\"key\": false true]"))).parse(),
                           "[json.exception.parse_error.101] parse error at 19: syntax error - unexpected true literal; expected '}'");
 
         // test case to make sure the callback is properly evaluated after reading a key
@@ -1295,42 +1295,42 @@ TEST_CASE("parser class")
         SECTION("from std::vector")
         {
             std::vector<uint8_t> v = {'t', 'r', 'u', 'e'};
-            CHECK(json::parser(json::input_adapter::create(std::begin(v), std::end(v))).parse() == json(true));
+            CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::begin(v), std::end(v))).parse() == json(true));
         }
 
         SECTION("from std::array")
         {
             std::array<uint8_t, 5> v { {'t', 'r', 'u', 'e'} };
-            CHECK(json::parser(json::input_adapter::create(std::begin(v), std::end(v))).parse() == json(true));
+            CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::begin(v), std::end(v))).parse() == json(true));
         }
 
         SECTION("from array")
         {
             uint8_t v[] = {'t', 'r', 'u', 'e'};
-            CHECK(json::parser(json::input_adapter::create(std::begin(v), std::end(v))).parse() == json(true));
+            CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::begin(v), std::end(v))).parse() == json(true));
         }
 
         SECTION("from char literal")
         {
-            CHECK(json::parser(json::input_adapter::create(std::string("true"))).parse() == json(true));
+            CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::string("true"))).parse() == json(true));
         }
 
         SECTION("from std::string")
         {
             std::string v = {'t', 'r', 'u', 'e'};
-            CHECK(json::parser(json::input_adapter::create(std::begin(v), std::end(v))).parse() == json(true));
+            CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::begin(v), std::end(v))).parse() == json(true));
         }
 
         SECTION("from std::initializer_list")
         {
             std::initializer_list<uint8_t> v = {'t', 'r', 'u', 'e'};
-            CHECK(json::parser(json::input_adapter::create(std::begin(v), std::end(v))).parse() == json(true));
+            CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::begin(v), std::end(v))).parse() == json(true));
         }
 
         SECTION("from std::valarray")
         {
             std::valarray<uint8_t> v = {'t', 'r', 'u', 'e'};
-            CHECK(json::parser(json::input_adapter::create(std::begin(v), std::end(v))).parse() == json(true));
+            CHECK(json::parser(nlohmann::detail::input_adapter_factory::create(std::begin(v), std::end(v))).parse() == json(true));
         }
     }
 }