diff --git a/.gitignore b/.gitignore
index 217a2c3a..4c0706d8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,7 +1,8 @@
-bin/
-bin64/
+bin
+bin64
 *.*#
+temp
 
 # Because of CMake and VS2017
-Win32/
-x64/
+Win32
+x64
diff --git a/Jamfile b/Jamfile
index 90f8ec9d..f603e4b3 100644
--- a/Jamfile
+++ b/Jamfile
@@ -7,4 +7,6 @@
 # Official repository: https://github.com/vinniefalco/json
 #
 
+path-constant LIB_DIR : . ;
+
 build-project test ;
diff --git a/README.md b/README.md
index 6f291fc3..b8bf9e64 100644
--- a/README.md
+++ b/README.md
@@ -5,8 +5,8 @@
 
 Branch          | Travis | Appveyor | Azure Pipelines | codecov.io | Docs | Matrix |
 :-------------: | ------ | -------- | --------------- | ---------- | ---- | ------ |
-[`master`](https://github.com/vinniefalco/json/tree/master) | [![Build Status](https://travis-ci.org/vinniefalco/json.svg?branch=master)](https://travis-ci.org/vinniefalco/json) | [![Build status](https://ci.appveyor.com/api/projects/status/github/vinniefalco/json?branch=master&svg=true)](https://ci.appveyor.com/project/vinniefalco/json/branch/master) | [![Build Status](https://dev.azure.com/vinniefalco/json/_apis/build/status/pipeline?branchName=master)](https://dev.azure.com/vinniefalco/json/_build/latest?definitionId=6&branchName=master) | [![codecov](https://codecov.io/gh/vinniefalco/json/branch/master/graph/badge.svg)](https://codecov.io/gh/vinniefalco/json/branch/master) | [![Documentation](https://img.shields.io/badge/docs-master-brightgreen.svg)](http://www.boost.org/doc/libs/master/doc/html/json.html) | [![Matrix](https://img.shields.io/badge/matrix-master-brightgreen.svg)](http://www.boost.org/development/tests/master/developer/json.html)
-[`develop`](https://github.com/vinniefalco/json/tree/develop) | [![Build Status](https://travis-ci.org/vinniefalco/json.svg?branch=develop)](https://travis-ci.org/vinniefalco/json) | [![Build status](https://ci.appveyor.com/api/projects/status/github/vinniefalco/json?branch=develop&svg=true)](https://ci.appveyor.com/project/vinniefalco/json/branch/develop) | [![Build Status](https://dev.azure.com/vinniefalco/json/_apis/build/status/pipeline?branchName=develop)](https://dev.azure.com/vinniefalco/json/_build/latest?definitionId=6&branchName=master) | [![codecov](https://codecov.io/gh/vinniefalco/json/branch/develop/graph/badge.svg)](https://codecov.io/gh/vinniefalco/json/branch/develop) | [![Documentation](https://img.shields.io/badge/docs-develop-brightgreen.svg)](http://www.boost.org/doc/libs/develop/doc/html/json.html) | [![Matrix](https://img.shields.io/badge/matrix-develop-brightgreen.svg)](http://www.boost.org/development/tests/develop/developer/json.html)
+[`master`](https://github.com/vinniefalco/json/tree/master) | [![Build Status](https://travis-ci.org/vinniefalco/json.svg?branch=master)](https://travis-ci.org/vinniefalco/json) | [![Build status](https://ci.appveyor.com/api/projects/status/github/vinniefalco/json?branch=master&svg=true)](https://ci.appveyor.com/project/vinniefalco/json/branch/master) | [![Build Status](https://dev.azure.com/vinniefalco/json/_apis/build/status/pipeline?branchName=master)](https://dev.azure.com/vinniefalco/json/_build/latest?definitionId=6&branchName=master) | [![codecov](https://codecov.io/gh/vinniefalco/json/branch/master/graph/badge.svg)](https://codecov.io/gh/vinniefalco/json/branch/master) | [![Documentation](https://img.shields.io/badge/docs-master-brightgreen.svg)](http://vinniefalco.github.com/doc/json/index.html) | [![Matrix](https://img.shields.io/badge/matrix-master-brightgreen.svg)](http://www.boost.org/development/tests/master/developer/json.html)
+[`develop`](https://github.com/vinniefalco/json/tree/develop) | [![Build Status](https://travis-ci.org/vinniefalco/json.svg?branch=develop)](https://travis-ci.org/vinniefalco/json) | [![Build status](https://ci.appveyor.com/api/projects/status/github/vinniefalco/json?branch=develop&svg=true)](https://ci.appveyor.com/project/vinniefalco/json/branch/develop) | [![Build Status](https://dev.azure.com/vinniefalco/json/_apis/build/status/pipeline?branchName=develop)](https://dev.azure.com/vinniefalco/json/_build/latest?definitionId=6&branchName=master) | [![codecov](https://codecov.io/gh/vinniefalco/json/branch/develop/graph/badge.svg)](https://codecov.io/gh/vinniefalco/json/branch/develop) | [![Documentation](https://img.shields.io/badge/docs-develop-brightgreen.svg)](http://vinniefalco.github.com/doc/json/index.html) | [![Matrix](https://img.shields.io/badge/matrix-develop-brightgreen.svg)](http://www.boost.org/development/tests/develop/developer/json.html)
 
 ## This is currently **NOT** an official Boost library.
 
diff --git a/doc/Jamfile b/doc/Jamfile
index ee9eb056..5839640a 100644
--- a/doc/Jamfile
+++ b/doc/Jamfile
@@ -16,6 +16,10 @@ import doxygen ;
 import modules ;
 import saxonhe ;
 
+local broot = [ os.environ BOOST_ROOT ] ;
+
+path-constant out : . ;
+
 #-------------------------------------------------------------------------------
 #
 # Build the list of header files that Doxygen will scan. We need
@@ -78,9 +82,6 @@ make index.xml
 
 rule make_doxygen_xml ( targets * : sources * : properties * )
 {
-    LIB_DIR on $(targets) =
-        [ path.native [ path.parent [ path.root
-        [ on $(sources[1]) return $(SEARCH) ] [ path.pwd ] ] ] ] ;
 }
 
 if [ os.name ] = NT
@@ -145,20 +146,40 @@ install qbk : reference.qbk ;
 # Produce the Boost.Book XML from the QuickBook
 #
 
+install stylesheets
+    :
+        $(broot)/doc/src/boostbook.css
+    :
+        <location>$(out)/html
+    ;
+
+explicit stylesheets ;
+
 install images
     :
+        [ glob $(broot)/doc/src/images/*.png ]
+        images/doc-logo.png
     :
-        <location>html/json/images
+        <location>$(out)/html/images
     ;
 
 explicit images ;
 
+install callouts
+    :
+        [ glob $(broot)/doc/src/images/callouts/*.png ]
+    :
+        <location>$(out)/html/images/callouts
+    ;
+
+explicit callout ;
+
 xml json_doc
     :
         qbk/main.qbk
     :
-        <dependency>images
         <dependency>qbk
+#        <include>$(broot)/tools/boostbook/dtd
     ;
 
 explicit json_doc ;
@@ -173,16 +194,19 @@ boostbook json
     :
         json_doc
     :
-        <xsl:param>boost.root=../../../..
-        <xsl:param>chapter.autolabel=1
-        <xsl:param>chunk.section.depth=8                # Depth to which sections should be chunked
+        <xsl:param>boost.image.src=images/doc-logo.png
+        <xsl:param>boost.image.alt="Boost.JSON Logo"
+        <xsl:param>boost.image.w=880
+        <xsl:param>boost.image.h=80
+        <xsl:param>boost.graphics.root=images/
+        <xsl:param>html.stylesheet=boostbook.css
+        <xsl:param>nav.layout=none
+        <xsl:param>chapter.autolabel=0
         <xsl:param>chunk.first.sections=1               # Chunk the first top-level section?
-        <xsl:param>toc.section.depth=8                  # How deep should recursive sections appear in the TOC?
-        <xsl:param>toc.max.depth=8                      # How many levels should be created for each TOC?
-        <xsl:param>generate.section.toc.level=8         # Control depth of TOC generation in sections
-        <xsl:param>generate.toc="chapter toc,title section nop reference nop"
-        <include>../../../tools/boostbook/dtd
+        <xsl:param>chunk.section.depth=8                # Depth to which sections should be chunked
+        <xsl:param>generate.toc="chapter nop section nop"
     :
+        <dependency>stylesheets
         <dependency>images
     ;
 
diff --git a/doc/images/doc-logo.png b/doc/images/doc-logo.png
new file mode 100644
index 00000000..929d59c4
Binary files /dev/null and b/doc/images/doc-logo.png differ
diff --git a/doc/qbk/benchmarks.qbk b/doc/qbk/benchmarks.qbk
new file mode 100644
index 00000000..284e4cce
--- /dev/null
+++ b/doc/qbk/benchmarks.qbk
@@ -0,0 +1,52 @@
+[/
+    Copyright (c) 2019 Vinnie Falco (vinnie dot falco at gmail dot com)
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    Official repository: https://github.com/vinniefalco/json
+]
+
+[section Benchmarks]
+[block'''<?dbhtml stop-chunking?>''']
+
+[/-----------------------------------------------------------------------------]
+
+[table
+[ [Small Document] [Large Document] ]
+[[
+```
+Boost.JSON parse 55952763 bytes in 234ms
+Boost.JSON parse 55952763 bytes in 232ms
+Boost.JSON parse 55952763 bytes in 231ms
+rapidjson parse 55952763 bytes in 239ms
+rapidjson parse 55952763 bytes in 240ms
+rapidjson parse 55952763 bytes in 239ms
+nlohmann parse 55952763 bytes in 495ms
+nlohmann parse 55952763 bytes in 491ms
+nlohmann parse 55952763 bytes in 494ms
+tao-json parse 55952763 bytes in 2178ms
+tao-json parse 55952763 bytes in 2069ms
+tao-json parse 55952763 bytes in 2056ms
+```
+][
+```
+Boost.JSON parse 488889121 bytes in 1820ms
+Boost.JSON parse 488889121 bytes in 1831ms
+Boost.JSON parse 488889121 bytes in 1835ms
+rapidjson parse 488889121 bytes in 1860ms
+rapidjson parse 488889121 bytes in 1886ms
+rapidjson parse 488889121 bytes in 1828ms
+nlohmann parse 488889121 bytes in 4195ms
+nlohmann parse 488889121 bytes in 4241ms
+nlohmann parse 488889121 bytes in 4320ms
+tao-json parse 488889121 bytes in 22952ms
+tao-json parse 488889121 bytes in 23265ms
+tao-json parse 488889121 bytes in 23117ms
+```
+]]
+]
+
+[/-----------------------------------------------------------------------------]
+
+[endsect]
diff --git a/doc/qbk/comparison.qbk b/doc/qbk/comparison.qbk
new file mode 100644
index 00000000..5ed80b5b
--- /dev/null
+++ b/doc/qbk/comparison.qbk
@@ -0,0 +1,214 @@
+[/
+    Copyright (c) 2019 Vinnie Falco (vinnie dot falco at gmail dot com)
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    Official repository: https://github.com/vinniefalco/json
+]
+
+[section:comparison Comparison to Other Libraries]
+[block'''<?dbhtml stop-chunking?>''']
+
+We use these criteria for evaluating a library's JSON container (the
+"value type") for suitability as a vocabulary type:
+
+* The value type declaration is completely decoupled
+  from other facilities such as parsing and serialization.
+
+* The value type is not a class template
+
+[/-----------------------------------------------------------------------------]
+
+[heading Comparison to nlohmann JSON]
+
+* Value Type: [@https://github.com/nlohmann/json/blob/00cb98a3d170161711ab912ae6acefba31f29f75/include/nlohmann/json.hpp#L165 `nlohmann::basic_json`]
+
+```
+template<
+    template<typename, typename, typename...> class ObjectType,
+    template<typename, typename...> class ArrayType,
+    class StringType,
+    class BooleanType,
+    class NumberIntegerType,
+    class NumberUnsignedType,
+    class NumberFloatType,
+    template<typename> class AllocatorType,
+    template<typename, typename = void> class JSONSerializer
+    >
+class basic_json
+{
+  private:
+    ....
+    friend ::nlohmann::detail::parser<basic_json>;
+    friend ::nlohmann::detail::serializer<basic_json>;
+...
+
+```
+
+* __bad__ `basic_json` is a class template. Libraries must agree on
+  all the template parameters to be fully interoperable.
+
+* __bad__ Too much customization. We struggle to see a use case for
+  making `BooleanType` anything other than `bool`.
+
+* __bad__ Poor separation of concerns. The `basic_json` container
+  declaration needlessly conflates parsing and serialization APIs.
+
+* __bad__ Limited allocator support. Only stateless allocators are
+  allowed, which rules out the most important type of allocator, a
+  local arena-based implementation.
+
+* __bad__ No incremental parsing, no incremental serialization.
+
+* __bad__ Mediocre parsing performance.
+
+* __good__ Full-featured, including JSON Pointer, CBOR, and others.
+
+[/-----------------------------------------------------------------------------]
+
+[heading Comparison to RapidJSON]
+
+* Value Type: [@https://github.com/Tencent/rapidjson/blob/bb5f966b9939d6cdfbac3462a0410e185099b3af/include/rapidjson/document.h#L608 `rapidjson::GenericValue`]
+
+```
+template <typename Encoding, typename Allocator = MemoryPoolAllocator<> > 
+class GenericValue;
+
+template <bool Const, typename ValueT>
+class GenericArray;
+
+template <bool Const, typename ValueT>
+class GenericObject;
+```
+
+* __bad__ The value type is a class template.
+
+* __bad__ The value type is not __CopyConstructible__
+
+* __bad__ The interface of the array and object types are considerably
+  different from their standard library equivalents, and not idiomatic.
+
+* __bad__ No incremental parsing, no incremental serialization.
+
+* __good__ Parsing performance is excellent.
+
+[/-----------------------------------------------------------------------------]
+
+[heading Comparison to TaoCPP JSON]
+
+* Value Type: [@https://github.com/taocpp/json/blob/e0944b3b2686a6b9749c16dd06f72445bf7eef0a/include/tao/json/basic_value.hpp#L38 `tao::json::basic_value`]
+
+*https://github.com/taocpp/json
+
+```
+template< template< typename... > class Traits >
+class basic_value
+{
+    ...
+public:
+    using array_t = std::vector< basic_value >;
+    using object_t = std::map< std::string, basic_value, std::less<> >;
+...
+```
+
+The `basic_value` type uses the `Traits` as a template parameter, where the
+traits provide specializations to convert each supported native or user defined
+type to and from JSON. This makes the value type unsuitable as a vocabulary
+type because the traits for a `basic_value` exported by two different
+libraries which each has added support for their own types, are not the same.
+
+* __bad__ C++17 or later is required.
+
+* __bad__ No allocator support.
+
+* __bad__ The value type is a class template.
+
+* __bad__ The array and object container interfaces change
+  depending on which version of the standard C++ library is used.
+
+* __bad__ The performance of the library changes significantly
+  depending on which version of the standard library is used.
+
+* __bad__ Parsing performance is the worst surveyed, by a large margin.
+
+* __bad__ No incremental parsing, no incremental serialization.
+
+[/-----------------------------------------------------------------------------]
+
+[heading Comparison to JSONCPP]
+
+* Value Type: [@https://github.com/open-source-parsers/jsoncpp/blob/41ffff01d39085222280791a23451d3e852b06c2/include/json/value.h#L188 `Json::Value`]
+
+[/-----------------------------------------------------------------------------]
+
+[heading Comparison to Ciere Labs json_spirit]
+
+* Value Type: [@https://github.com/cierelabs/json_spirit/blob/e885dc55054bf0e6ef250322923396aed4c3ece7/ciere/json/value.hpp#L72 `ciere::json::value`]
+
+
+```
+   typedef std::string                                  string_t;
+   typedef std::map<std::string, value>                 object_t;
+   typedef std::pair<std::string, value>                object_member_t;
+   typedef boost::container::stable_vector<value>       array_t;
+
+   class value : public boost::spirit::extended_variant<
+        null_t, bool_t, string_t, int_t, double_t, object_t, array_t>
+        { ... };
+
+```
+
+* No allocator support.
+
+[/-----------------------------------------------------------------------------]
+
+[heading Comparison to SIMD JSON]
+
+https://github.com/lemire/simdjson
+
+```
+class ParsedJson;
+```
+
+This is quite an interesting data structure, which is optimized to work well
+with the SIMD parser. It makes very good design choices for the intended
+use-case. However it is not well suited as a vocabulary type due to the
+necessary limitations.
+
+* Read-only
+* Sequential access only, via `ParsedJson::BasicIterator`
+* Can only be realistically populated by the provided SIMD JSON parser.
+
+[/-----------------------------------------------------------------------------]
+
+[heading Comparison to trial.protocol]
+
+https://github.com/breese/trial.protocol
+
+```
+template <template <typename> class Allocator>
+class basic_variable
+{
+    ....
+public:
+```
+
+* The value type is a class template.
+
+* Allocators may only be default-constructed
+
+[/-----------------------------------------------------------------------------]
+
+[heading Comparison to jbc-json]
+
+https://github.com/Julien-Blanc-tgcm/jbc-json
+
+```
+template<typename traits_>
+class basic_item
+```
+
+[/-----------------------------------------------------------------------------]
+
+[endsect]
diff --git a/doc/qbk/index.xml b/doc/qbk/index.xml
index 6bac6790..3d3e6d4d 100644
--- a/doc/qbk/index.xml
+++ b/doc/qbk/index.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN" "../../../../tools/boostbook/dtd/boostbook.dtd">
 <!--
-  Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
+  Copyright (c) 2019 Vinnie Falco (vinnie dot falco at gmail dot com)
 
   Distributed under the Boost Software License, Version 1.0. (See accompanying
   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/doc/qbk/main.qbk b/doc/qbk/main.qbk
index d2229c2f..cc1a192b 100644
--- a/doc/qbk/main.qbk
+++ b/doc/qbk/main.qbk
@@ -1,5 +1,5 @@
 [/
-    Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
+    Copyright (c) 2019 Vinnie Falco (vinnie dot falco at gmail dot com)
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -10,7 +10,7 @@
 [library Boost.JSON
     [id json]
     [quickbook 1.6]
-    [copyright 2016 - 2019 Vinnie Falco]
+    [copyright 2019 Vinnie Falco]
     [purpose JSON Library]
     [license
         Distributed under the Boost Software License, Version 1.0.
@@ -26,254 +26,80 @@
 [template indexterm1[term1] '''<indexterm><primary>'''[term1]'''</primary></indexterm>''']
 [template indexterm2[term1 term2] '''<indexterm><primary>'''[term1]'''</primary><secondary>'''[term2]'''</secondary></indexterm>''']
 
-[template path_link[path name] '''<ulink url="../../'''[path]'''">'''[name]'''</ulink>''']
-[template include_file[path][^<'''<ulink url="../../../../'''[path]'''">'''[path]'''</ulink>'''>]]
-[template issue[n] '''<ulink url="https://github.com/boostorg/beast/issues/'''[n]'''">#'''[n]'''</ulink>''']
+[template include_file[path][^<'''<ulink url="https://github.com/vinniefalco/json/blob/master/include/'''[path]'''">'''[path]'''</ulink>'''>]]
+[template issue[n] '''<ulink url="https://github.com/vinniefalco/json/issues/'''[n]'''">#'''[n]'''</ulink>''']
 
 [/ Named Requirements ]
 
 [def __Allocator__              [@https://en.cppreference.com/w/cpp/named_req/Allocator ['Allocator]]]
 [def __Hash__                   [@https://en.cppreference.com/w/cpp/named_req/Hash ['Hash]]]
 [def __InputIterator__          [@https://en.cppreference.com/w/cpp/named_req/InputIterator ['InputIterator]]]
+[def __CopyConstructible__      [@https://en.cppreference.com/w/cpp/named_req/CopyConstructible ['CopyConstructible]]]
 
-[def __ConstBufferSequence__    [@boost:/doc/html/boost_asio/reference/ConstBufferSequence.html ['ConstBufferSequence]]]
-[def __MutableBufferSequence__  [@boost:/doc/html/boost_asio/reference/MutableBufferSequence.html ['MutableBufferSequence]]]
-
-[/-----------------------------------------------------------------------------]
-
-[section Introduction]
-
-This library provides containers and algorithms which implement JSON
-("JavaScript Object Notation"), a lightweight data-interchange format.
-This format is easy for humans to read and write, and easy for machines
-to parse and generate. It is based on a subset of the Javascript Programming
-Language, Standard ECMA-262. JSON is a text format that is language-indepdent
-but uses conventions that are familiar to programmers of the C-family of
-languages, including C, C++, C#, Java, JavaScript, Perl, Python, and many
-others. These properties make JSON an ideal data-interchange language.
-
-[endsect]
-
-[/-----------------------------------------------------------------------------]
-
-[section Motivation]
-
-JSON 
-A survey of existing JSON libraries shows impressive diversity and features.
-However, no library is known to meet all of the design goals mentioned here.
-In particular, we know of no library that supports incremental parsing and
-serialization, and also supports custom allocators robustly.
-
-[endsect]
-
-[/-----------------------------------------------------------------------------]
-
-[section Design Goals]
-
-The library recognizes that
-`json::value`
-should be crafted to be generally useful as a vocabulary type.
-
-The design of the library also achieves these goals:
-
-* Robust support for custom allocators throughout.
-* Array and object interfaces closely track their
-  corresponding C++20 container equivalents.
-* Use `std::basic_string` for strings.
-* Minimize use of templates for reduced compilation times.
-* Parsers and serializers work incrementally (['online algorithms]).
-* Elements in objects may also be iterated in insertion order.
-
-[endsect]
-
-[/-----------------------------------------------------------------------------]
-
-[section Design]
-
-[heading Terminology]
-
-Lorem ipsum.
-
-[heading Allocators]
-
-Lorem ipsum.
-
-[endsect]
-
-[/-----------------------------------------------------------------------------]
-
-[section:comparison Comparison to Other Libraries]
-
-We use these criteria for evaluating a library's JSON container (the
-"value type") for suitability as a vocabulary type:
-
-* The value type declaration is completely decoupled
-  from other facilities such as parsing and serialization.
-
-* The value type is not a class template
-
-
-
-[/-----------------------------------------------------------------------------]
-
-https://github.com/cierelabs/json_spirit/blob/master/ciere/json/value.hpp
-
-
-```
-   typedef std::string                                  string_t;
-   typedef std::map<std::string, value>                 object_t;
-   typedef std::pair<std::string, value>                object_member_t;
-   typedef boost::container::stable_vector<value>       array_t;
-
-   class value : public boost::spirit::extended_variant<
-        null_t, bool_t, string_t, int_t, double_t, object_t, array_t>
-        { ... };
-
-```
-
-[/-----------------------------------------------------------------------------]
-
-https://github.com/nlohmann/json
-
-```
-template<
-    template<typename, typename, typename...> class ObjectType,
-    template<typename, typename...> class ArrayType,
-    class StringType,
-    class BooleanType,
-    class NumberIntegerType,
-    class NumberUnsignedType,
-    class NumberFloatType,
-    template<typename> class AllocatorType,
-    template<typename, typename = void> class JSONSerializer
-    >
-class basic_json
-{
-  private:
-    ....
-    friend ::nlohmann::detail::parser<basic_json>;
-    friend ::nlohmann::detail::serializer<basic_json>;
-...
-
-```
-
-* The value type is a class template.
-
-* Massive template parameter list for the value type
-
-[/-----------------------------------------------------------------------------]
-
-https://github.com/lemire/simdjson
-
-```
-class ParsedJson;
-```
-
-This is quite an interesting data structure, which is optimized to work well
-with the SIMD parser. It makes very good design choices for the intended
-use-case. However it is not well suited as a vocabulary type due to the
-necessary limitations.
-
-* Read-only
-* Sequential access only, via `ParsedJson::BasicIterator`
-* Can only be realistically populated by the provided SIMD JSON parser.
-
-[/-----------------------------------------------------------------------------]
-
-https://github.com/Tencent/rapidjson
-
-```
-template <typename Encoding, typename Allocator = MemoryPoolAllocator<> > 
-class GenericValue;
-
-template <bool Const, typename ValueT>
-class GenericArray;
-
-template <bool Const, typename ValueT>
-class GenericObject;
-```
-
-* The value type is a class template.
-
-* The value type is not copyable
-
-* The interface of the array and object types is radically different
-  from their standard library equivalents
-
-[/-----------------------------------------------------------------------------]
-
-https://github.com/taocpp/json
-
-```
-template< template< typename... > class Traits >
-class basic_value
-{
-    ...
-public:
-    using array_t = std::vector< basic_value >;
-    using object_t = std::map< std::string, basic_value, std::less<> >;
-...
-```
-
-The `basic_value` type uses the `Traits` as a template parameter, where the
-traits provide specializations to convert each supported native or user defined
-type to and from JSON. This makes the value type unsuitable as a vocabulary
-type because the traits for a `basic_value` exported by two different
-libraries which each has added support for their own types, are not the same.
-
-* The value type is a class template.
-
-* The array and object container interfaces change depending
-  on which version of the standard C++ library is used.
-
-* No allocator support
-
-[/-----------------------------------------------------------------------------]
-
-https://github.com/breese/trial.protocol
-
-```
-template <template <typename> class Allocator>
-class basic_variable
-{
-    ....
-public:
-```
-
-* The value type is a class template.
-
-* Allocators may only be default-constructed
-
-[/-----------------------------------------------------------------------------]
-
-https://github.com/Julien-Blanc-tgcm/jbc-json
-
-```
-template<typename traits_>
-class basic_item
-```
-
-[/-----------------------------------------------------------------------------]
-
-
-[/-----------------------------------------------------------------------------]
-
-
-[/-----------------------------------------------------------------------------]
-
-
-
-
-[endsect]
+[def __value__                  [link json.ref.boost__json__value `json::value`]]
+[def __storage__                [link json.ref.boost__json__storage `json::storage`]]
+[def __storage_ptr__            [link json.ref.boost__json__storage_ptr `json::storage_ptr`]]
+[def __string__                 [link json.ref.boost__json__string `json::string`]]
+
+[def __memory_resource__        [@https://en.cppreference.com/w/cpp/memory/memory_resource `std::pmr::memory_resource`]]
+[def __polymorphic_allocator__  [@https://en.cppreference.com/w/cpp/memory/polymorphic_allocator `std::pmr::polymorphic_allocator`]]
+[def __shared_ptr__             [@https://en.cppreference.com/w/cpp/memory/shared_ptr `std::shared_ptr`]]
+[def __std_string__             [@https://en.cppreference.com/w/cpp/string/basic_string `std::string`]]
+
+[/ Dingbats ]
+
+[def __good__ [role green \u2714]]
+[def __bad__  [role red   \u2718]]
 
 [/-----------------------------------------------------------------------------]
 
+Boost.JSON is a portable C++ library which implements the
+[@https://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf JSON Data Interchange Syntax],
+providing algorithms for parsing and serialization, as well as a robust
+and performant container to permit inspection and modification of JSON Text
+in memory.
+
+[variablelist
+    [[
+        [link json.overview Overview]
+    ][
+        A review of the requirements and features included in Boost.JSON,
+        rationale and design information, and answers to frequently
+        asked questions.
+    ]]
+    [[
+        [link json.usage Usage]
+    ][
+        How to use the library to perform common tasks with JSON,
+        including some examples.
+    ]]
+    [[
+        [link json.comparison Comparison]
+    ][
+        Compares the design and usage of this library against
+        many other existing libraries.
+    ]]
+    [[
+        [link json.benchmarks Benchmarks]
+    ][
+        Shows the performance of this library for typical workloads
+        against the performance of other popular existing libraries.
+    ]]
+    [[
+        [link json.quickref Reference]
+    ][
+        Detailed function and type reference.
+    ]]
+]
+
+[include overview.qbk]
+[include usage.qbk]
+[include comparison.qbk]
+[include benchmarks.qbk]
 [include quickref.qbk]
 
-[block'''<reference id="json_hidden"><title>This Page Intentionally Left Blank 1/2</title>''']
-[section:ref This Page Intentionally Left Blank 2/2]
+[section:ref Reference]
 [include reference.qbk]
 [endsect]
-[block'''</reference>''']
 
 [xinclude index.xml]
diff --git a/doc/qbk/overview.qbk b/doc/qbk/overview.qbk
new file mode 100644
index 00000000..85c28001
--- /dev/null
+++ b/doc/qbk/overview.qbk
@@ -0,0 +1,182 @@
+[/
+    Copyright (c) 2019 Vinnie Falco (vinnie dot falco at gmail dot com)
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    Official repository: https://github.com/vinniefalco/json
+]
+
+[section Overview]
+[block'''<?dbhtml stop-chunking?>''']
+
+[/-----------------------------------------------------------------------------]
+
+[section Introduction]
+
+This library provides containers and algorithms which implement JSON
+([@https://json.org/ "JavaScript Object Notation"]), a lightweight
+data-interchange format. This format is easy for humans to read and
+write, and easy for machines to parse and generate. It is based on a
+subset of the Javascript Programming Language,
+[@https://www.ecma-international.org/ecma-262/10.0/index.html Standard ECMA-262].
+JSON is a text format that is language-indepdent but uses conventions
+that are familiar to programmers of the C-family of languages, including
+C, C++, C#, Java, JavaScript, Perl, Python, and many others. These
+properties make JSON an ideal data-interchange language.
+
+[endsect]
+
+[/-----------------------------------------------------------------------------]
+
+[section Motivation]
+
+There are an overwhelming number of JSON libraries. A common theme 
+throughout is an emphasis on parsing performance or feature richness.
+This library uses a different approach: it provides a carefully
+designed JSON container, __value__, engineered from the ground up to be
+ideally suited as a vocabulary type. In particular it provides an interface
+which is stable, lightweight, and appropriate for use as parameter or
+return types in public interfaces.
+
+The design of the library also achieves these goals:
+
+* Requires only C++11
+* Support stateful allocators
+* Uniform interface on all C++ versions
+* Strict parser and serializer which work incrementally
+* Security-aware treatment of untrusted inputs
+* Fast compilation performance
+
+[endsect]
+
+[/-----------------------------------------------------------------------------]
+
+[section Requirements]
+
+Boost.JSON requires:
+
+* [*C++11]: Robust support for most language features
+
+Tested with these compilers: msvc-14+, gcc 4.8.4+, clang 3.6+.
+
+Typically a program will need to link statically or dynamically with the
+Boost.JSON library, which is either delivered with boost or built
+separately.
+Please visit the [@boost:/more/getting_started.html Boost documentation]
+for instructions on how to build and link with Boost libraries for your
+particular environment system.
+
+Alternatively, Boost.JSON may be used in a header-only configuration by
+defining the macro `BOOST_JSON_HEADER_ONLY` and simply including the
+desired header files.
+
+Boost.JSON may also be used without the rest of Boost, simply by defining
+the macro `BOOST_JSON_STANDALONE`. This configuration requires C++17 or
+later.
+
+[endsect]
+
+[/-----------------------------------------------------------------------------]
+
+[section Design]
+
+[heading Terminology]
+
+
+
+[heading Description]
+
+Avoid user-defined customizations for the value type such as template
+parameters or alternate container choices.
+
+Avoid standard library containers. Custom container types for object,
+array, and string values present the same interface in each version of C++.
+
+The parser adheres strictly to the JSON specification and avoids calling
+into external code. This facilitates security auditing and insulates from
+upstream changes.
+
+The serializer adheres strictly to the JSON specification and avoids
+calling into external code. This ensures that the serialized output is
+predictable, uniform, and insulated from upstream changes.
+
+Arrays and objects are represented by their own distinct and constructible
+types. This allows the caller to work with the native container instead of
+going through the value type.
+
+Provide a minimal API.
+
+No single parser is going to meet the needs of all JSON consumers.
+This library thus provides a straightforward parser with a narrow
+contract, it only parses strictly valid JSON according to the
+specification. Users with parsing needs that are not covered by this
+use-case can and should use other available parsers, by adapting them
+to store their results in the __value__ type.
+
+[heading Allocators]
+
+Lorem ipsum.
+
+[endsect]
+
+[/-----------------------------------------------------------------------------]
+
+[heading Frequently Asked Questions]
+
+[variablelist
+
+[[
+    "Why doesn't the parser support comments"
+][
+    The parser provided in this library adheres strictly to
+    [@https://www.ecma-international.org/ecma-262/10.0/index.html Standard ECMA-262].
+    Users who want to parse non-compliant JSON can copy the parser
+    implementation and make the necessary adjustments in their
+    derivative work.
+]]
+
+[[
+    "I want to parse directly into my own data structures"
+][
+    The purpose of this library is to enable algorithms which implement
+    JSON functionality in their public interfaces to be interoperable,
+    by providing a __value__ type that meets the bar for vocabulary
+    type suitability. Parsing directly into a user defined type offers
+    some advantages but is not the goal of the library.
+]]
+
+[[
+    "Why not use a standard __Allocator__?"
+][
+    Using standard allocators would require that __value__ be declared
+    as a class template, which would impose an additional compilation
+    burden. By avoiding the template, most of the function definitions
+    in the library can be excluded from the headers and emitted in a
+    separate static or dynamic library.
+]]
+
+
+[[
+    "Why __storage__ and __storage_ptr__ instead of `std` types?"
+][
+    The standard's __memory_resource__ is only available since C++17.
+    __polymorphic_allocator__ treats the memory resource as a reference
+    with respect to ownership. Boost.JSON uses a reference counted
+    smart pointer container to simplify the lifetime management of
+    memory  resources. The library defines its own __storage__ type
+    which defines the reference counter intrusively, allowing a 50%
+    space savings over using a __shared_ptr__.
+]]
+
+[[
+    "Why __string__ instead of __std_string__?"
+][
+    
+]]
+
+]
+
+[/-----------------------------------------------------------------------------]
+
+[endsect]
diff --git a/doc/qbk/quickref.qbk b/doc/qbk/quickref.qbk
index b09641c7..5fef93ce 100644
--- a/doc/qbk/quickref.qbk
+++ b/doc/qbk/quickref.qbk
@@ -1,5 +1,5 @@
 [/
-    Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
+    Copyright (c) 2019 Vinnie Falco (vinnie dot falco at gmail dot com)
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
diff --git a/doc/qbk/usage.qbk b/doc/qbk/usage.qbk
new file mode 100644
index 00000000..2c00460a
--- /dev/null
+++ b/doc/qbk/usage.qbk
@@ -0,0 +1,31 @@
+[/
+    Copyright (c) 2019 Vinnie Falco (vinnie dot falco at gmail dot com)
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    Official repository: https://github.com/vinniefalco/json
+]
+
+[section Usage]
+[block'''<?dbhtml stop-chunking?>''']
+
+[/-----------------------------------------------------------------------------]
+
+[heading Container]
+
+[/-----------------------------------------------------------------------------]
+
+[heading Parsing]
+
+[/-----------------------------------------------------------------------------]
+
+[heading Serialization]
+
+[/-----------------------------------------------------------------------------]
+
+[heading Value Exchange]
+
+[/-----------------------------------------------------------------------------]
+
+[endsect]
diff --git a/doc/source.dox b/doc/source.dox
index ba132d18..2b72938f 100644
--- a/doc/source.dox
+++ b/doc/source.dox
@@ -3,8 +3,8 @@
 #---------------------------------------------------------------------------
 
 INPUT = \
-        include/boost/pilfer.hpp \
-        include/boost/json
+        $(LIB_DIR)/include/boost/json/
+        $(LIB_DIR)/include/boost/pilfer.hpp
 
 #        $(LIB_DIR)/include/boost/json/allocator.hpp \
 #        $(LIB_DIR)/include/boost/json/array.hpp \
diff --git a/doc/xsl/includes_foot.xsl b/doc/xsl/includes_foot.xsl
index fdb6307e..d227e264 100644
--- a/doc/xsl/includes_foot.xsl
+++ b/doc/xsl/includes_foot.xsl
@@ -1,2 +1,7 @@
 <!-- INCLUDES_FOOT_TEMPLATE BEGIN -->
+  <xsl:choose>
+    <xsl:when test="contains($file, 'boost/json')">
+      <xsl:text>&#xd;&#xd;Convenience header [include_file boost/json.hpp]&#xd;</xsl:text>
+    </xsl:when>
+  </xsl:choose>
 <!-- INCLUDES_FOOT_TEMPLATE END -->
diff --git a/include/boost/json/basic_parser.hpp b/include/boost/json/basic_parser.hpp
index 4baf08c8..53e67d99 100644
--- a/include/boost/json/basic_parser.hpp
+++ b/include/boost/json/basic_parser.hpp
@@ -15,7 +15,7 @@
 #include <boost/json/number.hpp>
 #include <boost/json/detail/basic_parser.hpp>
 #include <boost/json/detail/stack.hpp>
-#include <boost/utility/string_view.hpp>
+#include <boost/json/detail/string.hpp>
 #include <cstdint>
 
 #include <string>
diff --git a/include/boost/json/detail/assert.hpp b/include/boost/json/detail/assert.hpp
new file mode 100644
index 00000000..90bd5235
--- /dev/null
+++ b/include/boost/json/detail/assert.hpp
@@ -0,0 +1,21 @@
+//
+// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/vinniefalco/json
+//
+
+#ifndef BOOST_JSON_DETAIL_ASSERT_HPP
+#define BOOST_JSON_DETAIL_ASSERT_HPP
+
+#ifndef BOOST_JSON_STANDALONE
+# include <boost/assert.hpp>
+# define BOOST_JSON_ASSERT BOOST_ASSERT
+#else
+# include <cassert>
+# define BOOST_JSON_ASSERT assert
+#endif
+
+#endif
diff --git a/include/boost/json/detail/buffer.hpp b/include/boost/json/detail/buffer.hpp
index 89f029e2..95fe99c9 100644
--- a/include/boost/json/detail/buffer.hpp
+++ b/include/boost/json/detail/buffer.hpp
@@ -10,7 +10,7 @@
 #ifndef BOOST_JSON_DETAIL_BUFFER_HPP
 #define BOOST_JSON_DETAIL_BUFFER_HPP
 
-#include <boost/utility/string_view.hpp>
+#include <boost/json/detail/string.hpp>
 #include <cstring>
 
 namespace boost {
diff --git a/include/boost/json/detail/config.hpp b/include/boost/json/detail/config.hpp
index 02b88448..6f71920b 100644
--- a/include/boost/json/detail/config.hpp
+++ b/include/boost/json/detail/config.hpp
@@ -12,29 +12,36 @@
 
 #include <boost/config.hpp>
 
-#if defined(GENERATING_DOCUMENTATION)
-# define BOOST_JSON_DECL
-#elif defined(BOOST_JSON_HEADER_ONLY)
-# define BOOST_JSON_DECL  inline
-#else
-# if (defined(BOOST_JSON_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)) && !defined(BOOST_JSON_STATIC_LINK)
-#  if defined(BOOST_JSON_SOURCE)
-#   define BOOST_JSON_DECL  BOOST_SYMBOL_EXPORT
-#   define BOOST_JSON_BUILD_DLL
-#  else
-#   define BOOST_JSON_DECL  BOOST_SYMBOL_IMPORT
-#  endif
-# endif // shared lib
-# ifndef  BOOST_JSON_DECL
+#ifndef BOOST_JSON_STANDALONE
+# if defined(GENERATING_DOCUMENTATION)
 #  define BOOST_JSON_DECL
-# endif
-# if !defined(BOOST_JSON_SOURCE) && !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_JSON_NO_LIB)
-#  define BOOST_LIB_NAME boost_json
-#  if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_JSON_DYN_LINK)
-#   define BOOST_DYN_LINK
+# elif defined(BOOST_JSON_HEADER_ONLY)
+#  define BOOST_JSON_DECL  inline
+# else
+#  if (defined(BOOST_JSON_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)) && !defined(BOOST_JSON_STATIC_LINK)
+#   if defined(BOOST_JSON_SOURCE)
+#    define BOOST_JSON_DECL  BOOST_SYMBOL_EXPORT
+#    define BOOST_JSON_BUILD_DLL
+#   else
+#    define BOOST_JSON_DECL  BOOST_SYMBOL_IMPORT
+#   endif
+#  endif // shared lib
+#  ifndef  BOOST_JSON_DECL
+#   define BOOST_JSON_DECL
 #  endif
-#  include <boost/config/auto_link.hpp>
-# endif  // auto-linking disabled
+#  if !defined(BOOST_JSON_SOURCE) && !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_JSON_NO_LIB)
+#   define BOOST_LIB_NAME boost_json
+#   if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_JSON_DYN_LINK)
+#    define BOOST_DYN_LINK
+#   endif
+#   include <boost/config/auto_link.hpp>
+#  endif  // auto-linking disabled
+# endif
+#else
+# define BOOST_JSON_DECL  inline
+# ifndef BOOST_JSON_HEADER_ONLY
+#  error Standalone configuration requires BOOST_JSON_HEADER_ONLY
+# endif
 #endif
 
 #ifndef BOOST_NO_EXCEPTIONS
@@ -43,15 +50,6 @@
 # define BOOST_JSON_THROW(x) do{}while(0)
 #endif
 
-namespace boost {
-namespace json {
-namespace detail {
-
-// max length of strings used as keys or values
-constexpr unsigned long max_string_length_ = 0x7ffffffe; // 2GB
-
-} // detail
-} // json
-} // boost
+#define BOOST_JSON_STATIC_ASSERT( ... ) static_assert(__VA_ARGS__, #__VA_ARGS__)
 
 #endif
diff --git a/include/boost/json/detail/exchange.hpp b/include/boost/json/detail/exchange.hpp
new file mode 100644
index 00000000..211ca1dc
--- /dev/null
+++ b/include/boost/json/detail/exchange.hpp
@@ -0,0 +1,31 @@
+//
+// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/vinniefalco/json
+//
+
+#ifndef BOOST_JSON_DETAIL_EXCHANGE_HPP
+#define BOOST_JSON_DETAIL_EXCHANGE_HPP
+
+namespace boost {
+namespace json {
+namespace detail {
+
+template<class T, class U>
+inline
+T
+exchange(T& t, U u) noexcept
+{
+    T v = t;
+    t = u;
+    return v;
+}
+
+} // detail
+} // json
+} // boost
+
+#endif
diff --git a/include/boost/json/detail/iterator.hpp b/include/boost/json/detail/iterator.hpp
index 47638503..2042f2f0 100644
--- a/include/boost/json/detail/iterator.hpp
+++ b/include/boost/json/detail/iterator.hpp
@@ -13,7 +13,7 @@
 #include <boost/json/detail/config.hpp>
 #include <boost/json/value.hpp>
 #include <boost/json/detail/stack.hpp>
-#include <boost/json/detail/static_const.hpp>
+#include <boost/json/detail/string.hpp>
 #include <iterator>
 #include <new>
 
@@ -21,12 +21,6 @@ namespace boost {
 namespace json {
 namespace detail {
 
-struct end_t
-{
-};
-
-BOOST_JSON_INLINE_VARIABLE(end, end_t)
-
 /** A generator to perform a depth-first traversal of a JSON value.
 */
 class const_iterator
@@ -80,11 +74,22 @@ public:
         }
     };
 
+    struct end_t
+    {
+    };
+
     BOOST_JSON_DECL
     explicit
     const_iterator(
         value const& jv);
 
+    static
+    end_t
+    end() noexcept
+    {
+        return {};
+    }
+
     BOOST_JSON_DECL
     value_type
     operator*() const noexcept;
diff --git a/include/boost/json/detail/iterator.ipp b/include/boost/json/detail/iterator.ipp
index 73d24273..b47feb13 100644
--- a/include/boost/json/detail/iterator.ipp
+++ b/include/boost/json/detail/iterator.ipp
@@ -44,7 +44,7 @@ node(
 {
     if(it)
     {
-        BOOST_ASSERT(
+        BOOST_JSON_ASSERT(
             v->is_structured());
         if(v->is_object())
             ::new(&obj_it)
@@ -106,9 +106,9 @@ operator*() const noexcept ->
     auto const& n = stack_.front();
     if(! n.it)
     {
-        BOOST_ASSERT(
+        BOOST_JSON_ASSERT(
             stack_.size() == 1);
-        BOOST_ASSERT(n.key.empty());
+        BOOST_JSON_ASSERT(n.key.empty());
         return {
             stack_.size() - 1,
             "",
@@ -117,7 +117,7 @@ operator*() const noexcept ->
             true,
             false };
     }
-    BOOST_ASSERT(n.v->is_structured());
+    BOOST_JSON_ASSERT(n.v->is_structured());
     if(n.v->is_object())
     {
         if(n.obj_it !=
@@ -216,14 +216,14 @@ operator++() noexcept
 bool
 operator==(
     const_iterator const& lhs,
-    end_t) noexcept
+    const_iterator::end_t) noexcept
 {
     return lhs.stack_.empty();
 }
 
 bool
 operator==(
-    end_t,
+    const_iterator::end_t,
     const_iterator const& rhs) noexcept
 {
     return rhs.stack_.empty();
@@ -232,14 +232,14 @@ operator==(
 bool
 operator!=(
     const_iterator const& lhs,
-    end_t) noexcept
+    const_iterator::end_t) noexcept
 {
     return ! lhs.stack_.empty();
 }
 
 bool
 operator!=(
-    end_t,
+    const_iterator::end_t,
     const_iterator const& rhs) noexcept
 {
     return ! rhs.stack_.empty();
diff --git a/include/boost/json/detail/make_void.hpp b/include/boost/json/detail/make_void.hpp
new file mode 100644
index 00000000..f645cd53
--- /dev/null
+++ b/include/boost/json/detail/make_void.hpp
@@ -0,0 +1,31 @@
+//
+// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/vinniefalco/json
+//
+
+#ifndef BOOST_JSON_DETAIL_MAKE_VOID_HPP
+#define BOOST_JSON_DETAIL_MAKE_VOID_HPP
+
+namespace boost {
+namespace json {
+namespace detail {
+
+template<class...>
+struct make_void
+{
+    using type =void;
+};
+
+template<class... Ts>
+using void_t = typename
+    make_void<Ts...>::type;
+
+} // detail
+} // json
+} // boost
+
+#endif
diff --git a/include/boost/json/detail/ryu/detail/common.hpp b/include/boost/json/detail/ryu/detail/common.hpp
index d777e81c..7b1a8345 100644
--- a/include/boost/json/detail/ryu/detail/common.hpp
+++ b/include/boost/json/detail/ryu/detail/common.hpp
@@ -22,7 +22,7 @@
 #ifndef BOOST_JSON_DETAIL_RYU_DETAIL_COMMON_HPP
 #define BOOST_JSON_DETAIL_RYU_DETAIL_COMMON_HPP
 
-#include <boost/assert.hpp>
+#include <boost/json/detail/assert.hpp>
 #include <cstdint>
 #include <cstring>
 
@@ -49,7 +49,7 @@ decimalLength9(
     // Function precondition: v is not a 10-digit number.
     // (f2s: 9 digits are sufficient for round-tripping.)
     // (d2fixed: We print 9-digit blocks.)
-    BOOST_ASSERT(v < 1000000000);
+    BOOST_JSON_ASSERT(v < 1000000000);
     if (v >= 100000000) { return 9; }
     if (v >= 10000000) { return 8; }
     if (v >= 1000000) { return 7; }
@@ -70,8 +70,8 @@ pow5bits(
     // This approximation works up to the point that the multiplication overflows at e = 3529.
     // If the multiplication were done in 64 bits, it would fail at 5^4004 which is just greater
     // than 2^9297.
-    BOOST_ASSERT(e >= 0);
-    BOOST_ASSERT(e <= 3528);
+    BOOST_JSON_ASSERT(e >= 0);
+    BOOST_JSON_ASSERT(e <= 3528);
     return static_cast<std::int32_t>(((
         static_cast<std::uint32_t>(e)* 1217359) >> 19) + 1);
 }
@@ -83,8 +83,8 @@ log10Pow2(
     std::int32_t const e) noexcept
 {
     // The first value this approximation fails for is 2^1651 which is just greater than 10^297.
-    BOOST_ASSERT(e >= 0);
-    BOOST_ASSERT(e <= 1650);
+    BOOST_JSON_ASSERT(e >= 0);
+    BOOST_JSON_ASSERT(e <= 1650);
     return (static_cast<std::uint32_t>(e) * 78913) >> 18;
 }
 
@@ -95,8 +95,8 @@ log10Pow5(
     std::int32_t const e) noexcept
 {
     // The first value this approximation fails for is 5^2621 which is just greater than 10^1832.
-    BOOST_ASSERT(e >= 0);
-    BOOST_ASSERT(e <= 2620);
+    BOOST_JSON_ASSERT(e >= 0);
+    BOOST_JSON_ASSERT(e <= 2620);
     return (static_cast<std::uint32_t>(e) * 732923) >> 20;
 }
 
diff --git a/include/boost/json/detail/ryu/detail/d2s.hpp b/include/boost/json/detail/ryu/detail/d2s.hpp
index 18321d3c..3b1e2968 100644
--- a/include/boost/json/detail/ryu/detail/d2s.hpp
+++ b/include/boost/json/detail/ryu/detail/d2s.hpp
@@ -22,22 +22,19 @@
 #ifndef BOOST_JSON_DETAIL_RYU_DETAIL_D2S_HPP
 #define BOOST_JSON_DETAIL_RYU_DETAIL_D2S_HPP
 
-#include <assert.h>
-#include <stdint.h>
-
 #include <boost/json/detail/ryu/detail/common.hpp>
+#include <boost/json/detail/assert.hpp>
+#include <cstdint>
 
 // Only include the full table if we're not optimizing for size.
 #if !defined(BOOST_JSON_RYU_OPTIMIZE_SIZE)
 #include <boost/json/detail/ryu/detail/d2s_full_table.hpp>
 #endif
-
 #if defined(BOOST_JSON_RYU_HAS_UINT128)
 typedef __uint128_t uint128_t;
 #else
 #include <boost/json/detail/ryu/detail/d2s_intrinsics.hpp>
 #endif
-
 namespace boost {
 namespace json {
 namespace detail {
diff --git a/include/boost/json/detail/ryu/detail/d2s_intrinsics.hpp b/include/boost/json/detail/ryu/detail/d2s_intrinsics.hpp
index aea06925..3d0bed64 100644
--- a/include/boost/json/detail/ryu/detail/d2s_intrinsics.hpp
+++ b/include/boost/json/detail/ryu/detail/d2s_intrinsics.hpp
@@ -24,7 +24,7 @@
 
 // This sets BOOST_JSON_DETAIL_RYU_32_BIT_PLATFORM as a side effect if applicable.
 #include <boost/json/detail/ryu/detail/common.hpp>
-#include <boost/assert.hpp>
+#include <boost/json/detail/assert.hpp>
 #include <cstdint>
 
 #if defined(BOOST_JSON_RYU_HAS_64_BIT_INTRINSICS)
@@ -65,7 +65,7 @@ shiftright128(
     // Otherwise in the range [2, 59].)
     // Check this here in case a future change requires larger shift
     // values. In this case this function needs to be adjusted.
-    BOOST_ASSERT(dist < 64);
+    BOOST_JSON_ASSERT(dist < 64);
     return __shiftright128(lo, hi, (unsigned char) dist);
 }
 
@@ -115,14 +115,14 @@ shiftright128(
     uint32_t const dist)
 {
     // We don't need to handle the case dist >= 64 here (see above).
-    BOOST_ASSERT(dist < 64);
+    BOOST_JSON_ASSERT(dist < 64);
     
 #if defined(BOOST_JSON_RYU_OPTIMIZE_SIZE) || !defined(BOOST_JSON_DETAIL_RYU_32_BIT_PLATFORM)
-    BOOST_ASSERT(dist > 0);
+    BOOST_JSON_ASSERT(dist > 0);
     return (hi << (64 - dist)) | (lo >> dist);
 #else
     // Avoid a 64-bit shift by taking advantage of the range of shift values.
-    BOOST_ASSERT(dist >= 32);
+    BOOST_JSON_ASSERT(dist >= 32);
     return (hi << (64 - dist)) | ((std::uint32_t)(lo >> 32) >> (dist - 32));
 #endif
 }
@@ -266,7 +266,7 @@ pow5Factor(std::uint64_t value)
     std::uint32_t count = 0;
     for (;;)
     {
-        BOOST_ASSERT(value != 0);
+        BOOST_JSON_ASSERT(value != 0);
         std::uint64_t const q = div5(value);
         uint32_t const r = ((std::uint32_t) value) - 5 * ((std::uint32_t) q);
         if (r != 0)
@@ -295,7 +295,7 @@ multipleOfPowerOf2(
     std::uint64_t const value,
     std::uint32_t const p)
 {
-    BOOST_ASSERT(value != 0);
+    BOOST_JSON_ASSERT(value != 0);
     // return __builtin_ctzll(value) >= p;
     return (value & ((1ull << p) - 1)) == 0;
 }
diff --git a/include/boost/json/detail/ryu/impl/d2fixed.ipp b/include/boost/json/detail/ryu/impl/d2fixed.ipp
index 657a0996..b109e05f 100644
--- a/include/boost/json/detail/ryu/impl/d2fixed.ipp
+++ b/include/boost/json/detail/ryu/impl/d2fixed.ipp
@@ -144,8 +144,8 @@ mulShift_mod1e9(
     if (j < 128 || j > 180)
         printf("%d\n", j);
 #endif
-    BOOST_ASSERT(j >= 128);
-    BOOST_ASSERT(j <= 180);
+    BOOST_JSON_ASSERT(j >= 128);
+    BOOST_JSON_ASSERT(j <= 180);
     // j: [128, 256)
     const uint128_t mid = b1 + (std::uint64_t) (b0 >> 64); // 64
     const uint128_t s1 = b2 + (std::uint64_t) (mid >> 64); // 128
@@ -223,8 +223,8 @@ mulShift_mod1e9(
     if (j < 128 || j > 180)
         printf("%d\n", j);
 #endif
-    BOOST_ASSERT(j >= 128);
-    BOOST_ASSERT(j <= 180);
+    BOOST_JSON_ASSERT(j >= 128);
+    BOOST_JSON_ASSERT(j <= 180);
 #if defined(BOOST_JSON_RYU_HAS_64_BIT_INTRINSICS)
     std::uint32_t const dist = (std::uint32_t) (j - 128); // dist: [0, 52]
     std::uint64_t const shiftedhigh = s1high >> dist;
diff --git a/include/boost/json/detail/ryu/impl/d2s.ipp b/include/boost/json/detail/ryu/impl/d2s.ipp
index 2134e455..65e8fa9a 100644
--- a/include/boost/json/detail/ryu/impl/d2s.ipp
+++ b/include/boost/json/detail/ryu/impl/d2s.ipp
@@ -35,7 +35,7 @@
 #define BOOST_JSON_DETAIL_RYU_IMPL_D2S_IPP
 
 #include <boost/json/detail/ryu/ryu.hpp>
-#include <boost/assert.hpp>
+#include <boost/json/detail/assert.hpp>
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
@@ -235,7 +235,7 @@ decimalLength17(
     // The average output length is 16.38 digits, so we check high-to-low.
     // Function precondition: v is not an 18, 19, or 20-digit number.
     // (17 digits are sufficient for round-tripping.)
-    BOOST_ASSERT(v < 100000000000000000L);
+    BOOST_JSON_ASSERT(v < 100000000000000000L);
     if (v >= 10000000000000000L) { return 17; }
     if (v >= 1000000000000000L) { return 16; }
     if (v >= 100000000000000L) { return 15; }
diff --git a/include/boost/json/detail/ryu/impl/f2s.ipp b/include/boost/json/detail/ryu/impl/f2s.ipp
index fa10dfaa..9c00a9aa 100644
--- a/include/boost/json/detail/ryu/impl/f2s.ipp
+++ b/include/boost/json/detail/ryu/impl/f2s.ipp
@@ -26,12 +26,7 @@
 #define BOOST_JSON_DETAIL_RYU_IMPL_F2S_IPP
 
 #include <boost/json/detail/ryu/ryu.hpp>
-
-#include <assert.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include <limits.h>
+#include <boost/json/detail/assert.hpp>
 
 #ifdef RYU_DEBUG
 #include <stdio.h>
@@ -39,6 +34,10 @@
 
 #include <boost/json/detail/ryu/detail/common.hpp>
 #include <boost/json/detail/ryu/detail/digit_table.hpp>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <limits>
 
 namespace boost {
 namespace json {
@@ -99,7 +98,7 @@ pow5Factor(uint32_t value)
     std::uint32_t count = 0;
     for (;;)
     {
-        BOOST_ASSERT(value != 0);
+        BOOST_JSON_ASSERT(value != 0);
         const std::uint32_t q = value / 5;
         const std::uint32_t r = value % 5;
         if (r != 0)
@@ -140,7 +139,7 @@ mulShift(
     const std::uint64_t factor,
     const std::int32_t shift)
 {
-    BOOST_ASSERT(shift > 32);
+    BOOST_JSON_ASSERT(shift > 32);
 
   // The casts here help MSVC to avoid calls to the __allmul library
   // function.
@@ -162,7 +161,7 @@ mulShift(
 #else // BOOST_JSON_DETAIL_RYU_32_BIT_PLATFORM
     const std::uint64_t sum = (bits0 >> 32) + bits1;
     const std::uint64_t shiftedSum = sum >> (shift - 32);
-    BOOST_ASSERT(shiftedSum <= UINT32_MAX);
+    BOOST_JSON_ASSERT(shiftedSum <= UINT32_MAX);
     return (std::uint32_t) shiftedSum;
 #endif // BOOST_JSON_DETAIL_RYU_32_BIT_PLATFORM
 }
diff --git a/include/boost/json/detail/stack.hpp b/include/boost/json/detail/stack.hpp
index c809466a..ccbde0ab 100644
--- a/include/boost/json/detail/stack.hpp
+++ b/include/boost/json/detail/stack.hpp
@@ -10,7 +10,7 @@
 #ifndef BOOST_JSON_DETAIL_STACK_HPP
 #define BOOST_JSON_DETAIL_STACK_HPP
 
-#include <boost/assert.hpp>
+#include <boost/json/detail/assert.hpp>
 #include <new>
 #include <type_traits>
 #include <utility>
@@ -69,7 +69,7 @@ public:
     T&
     operator[](std::size_t i) noexcept
     {
-        BOOST_ASSERT(i < n_);
+        BOOST_JSON_ASSERT(i < n_);
         if(v_.empty())
             return base()[n_ - (i + 1)];
         if(i < v_.size())
@@ -81,7 +81,7 @@ public:
     T const&
     operator[](std::size_t i) const noexcept
     {
-        BOOST_ASSERT(i < n_);
+        BOOST_JSON_ASSERT(i < n_);
         if(v_.empty())
             return base()[n_ - (i + 1)];
         if(i < v_.size())
@@ -172,7 +172,7 @@ public:
     void
     pop()
     {
-        BOOST_ASSERT(n_ > 0);
+        BOOST_JSON_ASSERT(n_ > 0);
         if(! v_.empty())
             v_.pop_back();
         else
diff --git a/include/boost/json/detail/static_const.hpp b/include/boost/json/detail/static_const.hpp
deleted file mode 100644
index 362639f8..00000000
--- a/include/boost/json/detail/static_const.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//
-// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// Official repository: https://github.com/vinniefalco/json
-//
-
-#ifndef BOOST_JSON_DETAIL_STATIC_CONST_HPP
-#define BOOST_JSON_DETAIL_STATIC_CONST_HPP
-
-/*  This is a derivative work, original copyright:
-
-    Copyright Eric Niebler 2013-present
-
-    Use, modification and distribution is subject to the
-    Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at
-    http://www.boost.org/LICENSE_1_0.txt)
-
-    Project home: https://github.com/ericniebler/range-v3
-*/
-
-namespace boost {
-namespace json {
-namespace detail {
-
-template<typename T>
-struct static_const
-{
-    static constexpr T value {};
-};
-
-template<typename T>
-constexpr T static_const<T>::value;
-
-#define BOOST_JSON_INLINE_VARIABLE(name, type) \
-    namespace \
-    { \
-        constexpr auto& name = \
-            ::boost::json::detail::static_const<type>::value; \
-    }
-
-} // detail
-} // json
-} // boost
-
-#endif
diff --git a/include/boost/json/detail/string.hpp b/include/boost/json/detail/string.hpp
new file mode 100644
index 00000000..f5aec657
--- /dev/null
+++ b/include/boost/json/detail/string.hpp
@@ -0,0 +1,41 @@
+//
+// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/vinniefalco/json
+//
+
+#ifndef BOOST_JSON_DETAIL_STRING_HPP
+#define BOOST_JSON_DETAIL_STRING_HPP
+
+#ifndef BOOST_JSON_STANDALONE
+# include <boost/utility/string_view.hpp>
+#else
+# include <string_view>
+#endif
+
+namespace boost {
+namespace json {
+
+namespace detail {
+
+// max length of strings used as keys or values
+constexpr unsigned long max_string_length_ = 0x7ffffffe; // 2GB
+
+} // detail
+
+#ifndef BOOST_JSON_STANDALONE
+/// The type of string view used by the library
+using string_view = boost::string_view;
+
+#else
+using string_view = std::string_view;
+
+#endif
+
+} // json
+} // boost
+
+#endif
diff --git a/include/boost/json/detail/system_error.hpp b/include/boost/json/detail/system_error.hpp
new file mode 100644
index 00000000..32b7a00a
--- /dev/null
+++ b/include/boost/json/detail/system_error.hpp
@@ -0,0 +1,47 @@
+//
+// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/vinniefalco/json
+//
+
+#ifndef BOOST_JSON_DETAIL_SYSTEM_ERROR_HPP
+#define BOOST_JSON_DETAIL_SYSTEM_ERROR_HPP
+
+#ifndef BOOST_JSON_STANDALONE
+# include <boost/system/error_code.hpp>
+# include <boost/system/system_error.hpp>
+#else
+# include <system_error>
+#endif
+
+namespace boost {
+namespace json {
+
+#ifndef BOOST_JSON_STANDALONE
+/// The type of error code used by the library
+using error_code = boost::system::error_code;
+
+/// The type of system error thrown by the library
+using system_error = boost::system::system_error;
+
+/// The type of error category used by the library
+using error_category = boost::system::error_category;
+
+/// The type of error condition used by the library
+using error_condition = boost::system::error_condition;
+
+#else
+using error_code = std::error_code;
+using system_error = std::system_error;
+using error_category = std::error_category;
+using error_condition = std::error_condition;
+
+#endif
+
+} // json
+} // boost
+
+#endif
diff --git a/include/boost/json/detail/value.hpp b/include/boost/json/detail/value.hpp
index e68b0f92..2b82c0b7 100644
--- a/include/boost/json/detail/value.hpp
+++ b/include/boost/json/detail/value.hpp
@@ -11,7 +11,7 @@
 #define BOOST_JSON_DETAIL_VALUE_HPP
 
 #include <boost/json/error.hpp>
-#include <boost/type_traits/make_void.hpp>
+#include <boost/json/detail/make_void.hpp>
 #include <type_traits>
 
 namespace boost {
@@ -29,7 +29,7 @@ struct has_adl_to_json : std::false_type
 
 template<class T>
 struct has_adl_to_json<T,
-    boost::void_t<decltype(to_json(
+    void_t<decltype(to_json(
         std::declval<T const&>(),
         std::declval<json::value&>()))>>
     : std::true_type
@@ -44,7 +44,7 @@ struct has_adl_from_json : std::false_type
 
 template<class T>
 struct has_adl_from_json<T,
-    boost::void_t<decltype(from_json(
+    void_t<decltype(from_json(
         std::declval<T&>(),
         std::declval<json::value const&>()))>>
     : std::true_type
@@ -59,7 +59,7 @@ struct has_mf_to_json : std::false_type
 
 template<class T>
 struct has_mf_to_json<T,
-    boost::void_t<decltype(
+    void_t<decltype(
         std::declval<T const&>().to_json(
             std::declval<json::value&>()))>>
     : std::true_type
@@ -74,7 +74,7 @@ struct has_mf_from_json : std::false_type
 
 template<class T>
 struct has_mf_from_json<T,
-    boost::void_t<decltype(
+    void_t<decltype(
     std::declval<T&>().from_json(
         std::declval<json::value const&>()))>>
     : std::true_type
diff --git a/include/boost/json/error.hpp b/include/boost/json/error.hpp
index 4d97549f..77cef0e0 100644
--- a/include/boost/json/error.hpp
+++ b/include/boost/json/error.hpp
@@ -11,24 +11,11 @@
 #define BOOST_JSON_ERROR_HPP
 
 #include <boost/json/detail/config.hpp>
-#include <boost/system/error_code.hpp>
-#include <boost/system/system_error.hpp>
+#include <boost/json/detail/system_error.hpp>
 
 namespace boost {
 namespace json {
 
-/// The type of error code used by the library
-using error_code = boost::system::error_code;
-
-/// The type of system error thrown by the library
-using system_error = boost::system::system_error;
-
-/// The type of error category used by the library
-using error_category = boost::system::error_category;
-
-/// The type of error condition used by the library
-using error_condition = boost::system::error_condition;
-
 /// Error codes returned by JSON operations
 enum class error
 {
diff --git a/include/boost/json/impl/array.hpp b/include/boost/json/impl/array.hpp
index 12e0a7e3..f5742746 100644
--- a/include/boost/json/impl/array.hpp
+++ b/include/boost/json/impl/array.hpp
@@ -11,7 +11,6 @@
 #define BOOST_JSON_IMPL_ARRAY_HPP
 
 #include <boost/json/value.hpp>
-#include <boost/core/exchange.hpp>
 #include <algorithm>
 #include <stdexcept>
 #include <type_traits>
diff --git a/include/boost/json/impl/array.ipp b/include/boost/json/impl/array.ipp
index 8de495ab..09b5e47c 100644
--- a/include/boost/json/impl/array.ipp
+++ b/include/boost/json/impl/array.ipp
@@ -11,9 +11,9 @@
 #define BOOST_JSON_IMPL_ARRAY_IPP
 
 #include <boost/json/array.hpp>
-#include <boost/assert.hpp>
+#include <boost/json/detail/exchange.hpp>
+#include <boost/json/detail/assert.hpp>
 #include <boost/pilfer.hpp>
-#include <boost/static_assert.hpp>
 #include <cstdlib>
 #include <limits>
 #include <new>
@@ -49,7 +49,7 @@ construct(
     if( capacity < 3)
         capacity = 3;
 
-    BOOST_STATIC_ASSERT(
+    BOOST_JSON_STATIC_ASSERT(
         sizeof(table) == sizeof(value));
     auto const p = ::new(sp->allocate(
         sizeof(table) +
@@ -131,7 +131,7 @@ undo_create(
     size_type n,
     array& self)
     : self_(self)
-    , saved_(boost::exchange(
+    , saved_(detail::exchange(
         self.tab_,
         table::construct(n, self.sp_)))
 {
@@ -249,16 +249,16 @@ array(
 
 array::
 array(pilfered<array> other) noexcept
-    : tab_(boost::exchange(
+    : tab_(detail::exchange(
         other.get().tab_, nullptr))
-    , sp_(boost::exchange(
+    , sp_(detail::exchange(
         other.get().sp_, nullptr))
 {
 }
 
 array::
 array(array&& other) noexcept
-    : tab_(boost::exchange(
+    : tab_(detail::exchange(
         other.tab_, nullptr))
     , sp_(other.sp_)
 {
@@ -299,7 +299,7 @@ operator=(array&& other)
     {
         if(tab_)
             tab_->destroy(sp_);
-        tab_ = boost::exchange(
+        tab_ = detail::exchange(
             other.tab_, nullptr);
     }
     return *this;
diff --git a/include/boost/json/impl/basic_parser.ipp b/include/boost/json/impl/basic_parser.ipp
index 2fda47dd..f60a60a6 100644
--- a/include/boost/json/impl/basic_parser.ipp
+++ b/include/boost/json/impl/basic_parser.ipp
@@ -13,7 +13,7 @@
 #include <boost/json/basic_parser.hpp>
 #include <boost/json/error.hpp>
 #include <boost/json/detail/buffer.hpp>
-#include <boost/assert.hpp>
+#include <boost/json/detail/assert.hpp>
 
 namespace boost {
 namespace json {
@@ -290,7 +290,7 @@ write_some(
         goto loop_ws;
     }
 
-    BOOST_ASSERT(st.front() != state::end);
+    BOOST_JSON_ASSERT(st.front() != state::end);
 loop:
     switch(st.front())
     {
@@ -309,7 +309,7 @@ loop_ws:
 
     case state::value:
     {
-        BOOST_ASSERT(p < p1);
+        BOOST_JSON_ASSERT(p < p1);
         switch(*p)
         {
         // object
@@ -453,7 +453,7 @@ loop_ws:
 
     // first key or end of object
     case state::object1:
-        BOOST_ASSERT(p < p1);
+        BOOST_JSON_ASSERT(p < p1);
         if(*p == '}')
         {
             ++p;
@@ -475,7 +475,7 @@ loop_ws:
         goto loop;
 
     case state::object2:
-        BOOST_ASSERT(p < p1);
+        BOOST_JSON_ASSERT(p < p1);
         if(*p == '}')
         {
             ++p;
@@ -502,7 +502,7 @@ loop_ws:
         goto loop_ws;
 
     case state::colon:
-        BOOST_ASSERT(p < p1);
+        BOOST_JSON_ASSERT(p < p1);
         if(*p != ':')
         {
             ec = error::expected_colon;
@@ -518,7 +518,7 @@ loop_ws:
     //
 
     case state::array1:
-        BOOST_ASSERT(p < p1);
+        BOOST_JSON_ASSERT(p < p1);
         if(*p == ']')
         {
             ++p;
@@ -536,7 +536,7 @@ loop_ws:
         goto loop;
 
     case state::array2:
-        BOOST_ASSERT(p < p1);
+        BOOST_JSON_ASSERT(p < p1);
         if(*p == ']')
         {
             ++p;
@@ -565,7 +565,7 @@ loop_ws:
     // double quote opening string
     case state::string1:
 loop_string:
-        BOOST_ASSERT(p < p1);
+        BOOST_JSON_ASSERT(p < p1);
         if(*p != '\"')
         {
             ec = error::expected_quotes;
@@ -629,7 +629,7 @@ loop_string:
             // TODO UTF-8?
             ++p;
         }
-        BOOST_ASSERT(p != start);
+        BOOST_JSON_ASSERT(p != start);
         if(is_key_)
             this->on_key_data({start,
                 static_cast<std::size_t>(
@@ -1138,7 +1138,7 @@ loop_frac:
         break;
 
     case state::num_exp:
-        BOOST_ASSERT(p < p1);
+        BOOST_JSON_ASSERT(p < p1);
         if(*p != 'e' && *p != 'E')
             goto loop_num_end;
         ++p;
@@ -1259,7 +1259,7 @@ write_eof(error_code& ec)
         {
             char c = 0;
             write_some(&c, 1, ec);
-            BOOST_ASSERT(ec);
+            BOOST_JSON_ASSERT(ec);
         };
 
     stack_impl st;
diff --git a/include/boost/json/impl/object.hpp b/include/boost/json/impl/object.hpp
index 2b0cf876..da141aef 100644
--- a/include/boost/json/impl/object.hpp
+++ b/include/boost/json/impl/object.hpp
@@ -11,9 +11,7 @@
 #define BOOST_JSON_IMPL_OBJECT_HPP
 
 #include <boost/json/value.hpp>
-#include <boost/core/exchange.hpp>
-#include <boost/core/ignore_unused.hpp>
-#include <boost/utility/string_view.hpp>
+#include <boost/json/detail/string.hpp>
 #include <algorithm>
 #include <cmath>
 #include <type_traits>
diff --git a/include/boost/json/impl/object.ipp b/include/boost/json/impl/object.ipp
index 7651d403..c5a687a5 100644
--- a/include/boost/json/impl/object.ipp
+++ b/include/boost/json/impl/object.ipp
@@ -11,9 +11,8 @@
 #define BOOST_JSON_IMPL_OBJECT_IPP
 
 #include <boost/json/object.hpp>
-#include <boost/core/exchange.hpp>
-#include <boost/core/ignore_unused.hpp>
-#include <boost/assert.hpp>
+#include <boost/json/detail/exchange.hpp>
+#include <boost/json/detail/assert.hpp>
 #include <algorithm>
 #include <cmath>
 #include <cstdlib>
@@ -297,7 +296,7 @@ object(
 object::
 object(object&& other) noexcept
     : sp_(other.sp_)
-    , tab_(boost::exchange(
+    , tab_(detail::exchange(
         other.tab_, nullptr))
 {
 }
@@ -310,7 +309,7 @@ object(
 {
     if(*sp_ == *other.sp_)
     {
-        tab_ = boost::exchange(
+        tab_ = detail::exchange(
             other.tab_, nullptr);
     }
     else
@@ -326,7 +325,7 @@ object(
 object::
 object(pilfered<object> other) noexcept
     : sp_(std::move(other.get().sp_))
-    , tab_(boost::exchange(
+    , tab_(detail::exchange(
         other.get().tab_, nullptr))
 {
 }
@@ -607,7 +606,7 @@ object::
 bucket(key_type key) const noexcept ->
     size_type
 {
-    BOOST_ASSERT(tab_);
+    BOOST_JSON_ASSERT(tab_);
     return constrain_hash(
         hash_function()(key),
         tab_->bucket_count);
@@ -733,11 +732,11 @@ remove(element* e) noexcept
     if(head != e)
     {
         auto it = head;
-        BOOST_ASSERT(it != tab_->end());
+        BOOST_JSON_ASSERT(it != tab_->end());
         while(it->local_next != e)
         {
             it = it->local_next;
-            BOOST_ASSERT(it != tab_->end());
+            BOOST_JSON_ASSERT(it != tab_->end());
         }
         it->local_next = e->local_next;
     }
@@ -865,7 +864,7 @@ insert(
     head = e;
     if(tab_->head == tab_->end())
     {
-        BOOST_ASSERT(
+        BOOST_JSON_ASSERT(
             before.e_ == tab_->end());
         tab_->head = e;
         tab_->end()->prev = e;
diff --git a/include/boost/json/impl/parser.ipp b/include/boost/json/impl/parser.ipp
index e45241ba..e1bca832 100644
--- a/include/boost/json/impl/parser.ipp
+++ b/include/boost/json/impl/parser.ipp
@@ -12,8 +12,7 @@
 
 #include <boost/json/parser.hpp>
 #include <boost/json/error.hpp>
-#include <boost/core/ignore_unused.hpp>
-#include <boost/assert.hpp>
+#include <boost/json/detail/assert.hpp>
 #include <stdexcept>
 #include <utility>
 
@@ -26,22 +25,22 @@ parser::
 assign(T&& t)
 {
     auto& jv = *stack_.front();
-    BOOST_ASSERT(! jv.is_object());
+    BOOST_JSON_ASSERT(! jv.is_object());
     if(obj_)
     {
-        BOOST_ASSERT(jv.is_null());
+        BOOST_JSON_ASSERT(jv.is_null());
         jv = std::forward<T>(t);
         stack_.pop();
     }
     else if(stack_.front()->is_array())
     {
-        BOOST_ASSERT(s_.empty());
+        BOOST_JSON_ASSERT(s_.empty());
         jv.as_array().emplace_back(
             std::forward<T>(t));
     }
     else
     {
-        BOOST_ASSERT(jv.is_null());
+        BOOST_JSON_ASSERT(jv.is_null());
         jv = std::forward<T>(t);
     }
 }
@@ -149,10 +148,10 @@ on_object_begin(error_code& ec)
         return;
     }
     auto& jv = *stack_.front();
-    BOOST_ASSERT(! jv.is_object());
+    BOOST_JSON_ASSERT(! jv.is_object());
     if(obj_)
     {
-        BOOST_ASSERT(jv.is_null());
+        BOOST_JSON_ASSERT(jv.is_null());
         jv.emplace_object();
     }
     else if(jv.is_array())
@@ -164,7 +163,7 @@ on_object_begin(error_code& ec)
     }
     else
     {
-        BOOST_ASSERT(jv.is_null());
+        BOOST_JSON_ASSERT(jv.is_null());
         jv.emplace_object();
     }
     obj_ = true;
@@ -174,13 +173,13 @@ void
 parser::
 on_object_end(error_code&)
 {
-    BOOST_ASSERT(
+    BOOST_JSON_ASSERT(
         stack_.front()->is_object());
     stack_.pop();
     if(! stack_.empty())
     {
         auto const& jv = stack_.front();
-        BOOST_ASSERT(
+        BOOST_JSON_ASSERT(
             jv->is_array() || jv->is_object());
         obj_ = jv->is_object();
     }
@@ -196,15 +195,15 @@ on_array_begin(error_code& ec)
         return;
     }
     auto& jv = *stack_.front();
-    BOOST_ASSERT(! jv.is_object());
+    BOOST_JSON_ASSERT(! jv.is_object());
     if(obj_)
     {
-        BOOST_ASSERT(jv.is_null());
+        BOOST_JSON_ASSERT(jv.is_null());
         jv.emplace_array();
     }
     else if(jv.is_array())
     {
-        BOOST_ASSERT(s_.empty());
+        BOOST_JSON_ASSERT(s_.empty());
         jv.as_array().emplace_back(
             kind::array);
         stack_.push(
@@ -212,7 +211,7 @@ on_array_begin(error_code& ec)
     }
     else
     {
-        BOOST_ASSERT(jv.is_null());
+        BOOST_JSON_ASSERT(jv.is_null());
         jv.emplace_array();
     }
     obj_ = false;
@@ -222,13 +221,13 @@ void
 parser::
 on_array_end(error_code&)
 {
-    BOOST_ASSERT(
+    BOOST_JSON_ASSERT(
         stack_.front()->is_array());
     stack_.pop();
     if(! stack_.empty())
     {
         auto const& jv = stack_.front();
-        BOOST_ASSERT(
+        BOOST_JSON_ASSERT(
             jv->is_array() || jv->is_object());
         obj_ = jv->is_object();
     }
@@ -270,18 +269,18 @@ on_string_data(
     string_view s, error_code&)
 {
     auto& jv = *stack_.front();
-    BOOST_ASSERT(! jv.is_object());
+    BOOST_JSON_ASSERT(! jv.is_object());
     if(! jv.is_string())
     {
         if(obj_)
         {
-            BOOST_ASSERT(jv.is_null());
+            BOOST_JSON_ASSERT(jv.is_null());
             jv.emplace_string().append(
                 s.data(), s.size());
         }
         else if(stack_.front()->is_array())
         {
-            BOOST_ASSERT(s_.empty());
+            BOOST_JSON_ASSERT(s_.empty());
             jv.as_array().emplace_back(kind::string);
             stack_.push(
                 &jv.as_array().back());
@@ -290,7 +289,7 @@ on_string_data(
         }
         else
         {
-            BOOST_ASSERT(jv.is_null());
+            BOOST_JSON_ASSERT(jv.is_null());
             jv.emplace_string().append(
                 s.data(), s.size());
         }
@@ -309,12 +308,12 @@ on_string_end(
     error_code& ec)
 {
     on_string_data(s, ec);
-    BOOST_ASSERT(stack_.front()->is_string());
+    BOOST_JSON_ASSERT(stack_.front()->is_string());
     stack_.pop();
     if(! stack_.empty())
     {
         auto const& jv = stack_.front();
-        BOOST_ASSERT(
+        BOOST_JSON_ASSERT(
             jv->is_array() || jv->is_object());
         obj_ = jv->is_object();
     }
@@ -326,22 +325,22 @@ on_number(ieee_decimal dec, error_code&)
 {
     number n(dec.mantissa, dec.exponent, dec.sign);
     auto& jv = *stack_.front();
-    BOOST_ASSERT(! jv.is_object());
+    BOOST_JSON_ASSERT(! jv.is_object());
     if(obj_)
     {
-        BOOST_ASSERT(jv.is_null());
+        BOOST_JSON_ASSERT(jv.is_null());
         jv.emplace_number() = std::move(n);
         stack_.pop();
     }
     else if(stack_.front()->is_array())
     {
-        BOOST_ASSERT(s_.empty());
+        BOOST_JSON_ASSERT(s_.empty());
         jv.as_array().emplace_back(
             std::move(n));
     }
     else
     {
-        BOOST_ASSERT(jv.is_null());
+        BOOST_JSON_ASSERT(jv.is_null());
         jv.emplace_number() = std::move(n);
     }
 }
diff --git a/include/boost/json/impl/serializer.ipp b/include/boost/json/impl/serializer.ipp
index ef8dbae5..d3307462 100644
--- a/include/boost/json/impl/serializer.ipp
+++ b/include/boost/json/impl/serializer.ipp
@@ -11,7 +11,6 @@
 #define BOOST_JSON_IMPL_SERIALIZER_IPP
 
 #include <boost/json/serializer.hpp>
-#include <boost/static_assert.hpp>
 #include <ostream>
 
 namespace boost {
@@ -47,7 +46,7 @@ serializer(
 
 {
     // ensure room for \uXXXX escape plus one
-    BOOST_STATIC_ASSERT(sizeof(buf_) >= 7);
+    BOOST_JSON_STATIC_ASSERT(sizeof(buf_) >= 7);
 }
 
 bool
@@ -70,7 +69,7 @@ loop:
     case state::inc:
     {
         ++it_;
-        if(it_ == detail::end)
+        if(it_ == detail::const_iterator::end())
         {
             state_ = state::done;
             goto loop;
@@ -84,7 +83,7 @@ loop:
                 state_ = state::lit;
                 goto loop;
             }
-            BOOST_ASSERT(e.value.is_array());
+            BOOST_JSON_ASSERT(e.value.is_array());
             str_ = {"],", e.last ? 1U : 2U};
             state_ = state::lit;
             goto loop;
@@ -169,7 +168,7 @@ loop:
         p += n;
         if(n < key_.size())
         {
-            BOOST_ASSERT(p >= p1);
+            BOOST_JSON_ASSERT(p >= p1);
             key_ = key_.substr(n);
             goto finish;
         }
@@ -319,7 +318,7 @@ loop:
             goto loop;
         }
         str_ = str_.substr(n);
-        BOOST_ASSERT(p >= p1);
+        BOOST_JSON_ASSERT(p >= p1);
         goto finish;
     }
 
diff --git a/include/boost/json/impl/storage.ipp b/include/boost/json/impl/storage.ipp
index 9685fde2..b497e5ac 100644
--- a/include/boost/json/impl/storage.ipp
+++ b/include/boost/json/impl/storage.ipp
@@ -11,7 +11,7 @@
 #define BOOST_JSON_IMPL_STORAGE_IPP
 
 #include <boost/json/storage.hpp>
-#include <boost/assert.hpp>
+#include <boost/json/detail/assert.hpp>
 #include <memory>
 
 namespace boost {
@@ -50,7 +50,8 @@ global_storage() noexcept
         is_equal(storage const& other)
             const noexcept override
         {
-            BOOST_ASSERT(dynamic_cast<
+            (void)other;
+            BOOST_JSON_ASSERT(dynamic_cast<
                 builtin const*>(&other) == nullptr);
             return false;
         }
diff --git a/include/boost/json/impl/string.hpp b/include/boost/json/impl/string.hpp
index e8335cda..93976db0 100644
--- a/include/boost/json/impl/string.hpp
+++ b/include/boost/json/impl/string.hpp
@@ -10,7 +10,6 @@
 #ifndef BOOST_JSON_IMPL_STRING_HPP
 #define BOOST_JSON_IMPL_STRING_HPP
 
-#include <boost/core/ignore_unused.hpp>
 #include <algorithm>
 #include <utility>
 #include <string>
diff --git a/include/boost/json/impl/string.ipp b/include/boost/json/impl/string.ipp
index 0b9eec10..416ce2c1 100644
--- a/include/boost/json/impl/string.ipp
+++ b/include/boost/json/impl/string.ipp
@@ -10,9 +10,7 @@
 #ifndef BOOST_JSON_IMPL_STRING_IPP
 #define BOOST_JSON_IMPL_STRING_IPP
 
-#include <boost/core/exchange.hpp>
-#include <boost/core/ignore_unused.hpp>
-#include <boost/assert.hpp>
+#include <boost/json/detail/assert.hpp>
 #include <algorithm>
 #include <new>
 #include <ostream>
@@ -188,8 +186,8 @@ string::
 impl::
 unalloc(storage_ptr const& sp) noexcept
 {
-    BOOST_ASSERT(size < sizeof(buf));
-    BOOST_ASSERT(! in_sbo());
+    BOOST_JSON_ASSERT(size < sizeof(buf));
+    BOOST_JSON_ASSERT(! in_sbo());
     auto const p_ = p;
     traits_type::copy(
         buf, data(), size + 1);
diff --git a/include/boost/json/impl/value.hpp b/include/boost/json/impl/value.hpp
index 694e6573..a2173a4b 100644
--- a/include/boost/json/impl/value.hpp
+++ b/include/boost/json/impl/value.hpp
@@ -11,6 +11,7 @@
 #define BOOST_JSON_IMPL_VALUE_HPP
 
 #include <boost/json/error.hpp>
+#include <boost/json/detail/make_void.hpp>
 #include <limits>
 #include <type_traits>
 
@@ -58,7 +59,7 @@ struct is_range : std::false_type
 };
 
 template<class T>
-struct is_range<T, boost::void_t<
+struct is_range<T, void_t<
     typename T::value_type,
     decltype(
         std::declval<T const&>().begin(),
diff --git a/include/boost/json/number.hpp b/include/boost/json/number.hpp
index 7faddfe7..fb64144f 100644
--- a/include/boost/json/number.hpp
+++ b/include/boost/json/number.hpp
@@ -11,7 +11,7 @@
 #define BOOST_JSON_NUMBER_HPP
 
 #include <boost/json/detail/config.hpp>
-#include <boost/utility/string_view.hpp>
+#include <boost/json/detail/string.hpp>
 #include <cstdint>
 #include <iosfwd>
 #include <type_traits>
diff --git a/include/boost/json/object.hpp b/include/boost/json/object.hpp
index e29df67f..23c43087 100644
--- a/include/boost/json/object.hpp
+++ b/include/boost/json/object.hpp
@@ -12,7 +12,7 @@
 
 #include <boost/json/detail/config.hpp>
 #include <boost/json/storage.hpp>
-#include <boost/utility/string_view.hpp>
+#include <boost/json/detail/string.hpp>
 #include <boost/pilfer.hpp>
 #include <cstdlib>
 #include <initializer_list>
diff --git a/include/boost/json/parser.hpp b/include/boost/json/parser.hpp
index 6e88e57c..f34b6157 100644
--- a/include/boost/json/parser.hpp
+++ b/include/boost/json/parser.hpp
@@ -11,9 +11,10 @@
 #define BOOST_JSON_PARSER_HPP
 
 #include <boost/json/detail/config.hpp>
-#include <boost/json/value.hpp>
 #include <boost/json/basic_parser.hpp>
 #include <boost/json/storage.hpp>
+#include <boost/json/value.hpp>
+#include <boost/json/detail/string.hpp>
 #include <new>
 #include <string>
 #include <type_traits>
diff --git a/include/boost/json/serializer.hpp b/include/boost/json/serializer.hpp
index 68f29ad9..ca98057e 100644
--- a/include/boost/json/serializer.hpp
+++ b/include/boost/json/serializer.hpp
@@ -14,6 +14,7 @@
 #include <boost/json/number.hpp>
 #include <boost/json/value.hpp>
 #include <boost/json/detail/iterator.hpp>
+#include <boost/json/detail/string.hpp>
 #include <iosfwd>
 
 namespace boost {
diff --git a/include/boost/json/storage.hpp b/include/boost/json/storage.hpp
index 8fb66bc5..9f1e0380 100644
--- a/include/boost/json/storage.hpp
+++ b/include/boost/json/storage.hpp
@@ -11,8 +11,6 @@
 #define BOOST_JSON_STORAGE_HPP
 
 #include <boost/json/detail/config.hpp>
-#include <boost/core/exchange.hpp>
-#include <boost/static_assert.hpp>
 #include <atomic>
 #include <cstddef>
 #include <cstdlib>
@@ -95,7 +93,7 @@ public:
 template<class T>
 class basic_storage_ptr
 {
-    BOOST_STATIC_ASSERT(
+    BOOST_JSON_STATIC_ASSERT(
         std::is_base_of<storage, T>::value);
 
     template<class U>
@@ -164,8 +162,9 @@ public:
     */
     basic_storage_ptr(
         basic_storage_ptr&& other) noexcept
-        : t_(boost::exchange(other.t_, nullptr))
+        : t_(other.t_)
     {
+        other.t_ = nullptr;
     }
 
     /** Copy construct a storage pointer.
@@ -204,8 +203,9 @@ public:
     >
     basic_storage_ptr(
         basic_storage_ptr<U>&& sp) noexcept
-        : t_(boost::exchange(sp.t_, nullptr))
+        : t_(sp.t_)
     {
+        sp.t_ = nullptr;
     }
 
     template<class U
@@ -264,7 +264,8 @@ public:
     {
         if(t_)
             t_->release();
-        t_ = boost::exchange(other.t_, nullptr);
+        t_ = other.t_;
+        other.t_ = nullptr;
         return *this;
     }
 
diff --git a/include/boost/json/string.hpp b/include/boost/json/string.hpp
index 24e1d00b..499d2053 100644
--- a/include/boost/json/string.hpp
+++ b/include/boost/json/string.hpp
@@ -12,8 +12,8 @@
 
 #include <boost/json/detail/config.hpp>
 #include <boost/json/storage.hpp>
+#include <boost/json/detail/string.hpp>
 #include <boost/pilfer.hpp>
-#include <boost/utility/string_view.hpp>
 #include <algorithm>
 #include <initializer_list>
 #include <iosfwd>
@@ -706,8 +706,10 @@ public:
         return s_.size;
     }
 
+    static
+    constexpr
     size_type
-    max_size() const noexcept
+    max_size() noexcept
     {
         return detail::max_string_length_;
     }
diff --git a/include/boost/json/value.hpp b/include/boost/json/value.hpp
index 5b2f2df5..c38f2366 100644
--- a/include/boost/json/value.hpp
+++ b/include/boost/json/value.hpp
@@ -20,7 +20,7 @@
 #include <boost/json/string.hpp>
 #include <boost/json/detail/is_specialized.hpp>
 #include <boost/json/detail/value.hpp>
-#include <boost/assert.hpp>
+#include <boost/json/detail/assert.hpp>
 #include <boost/utility/string_view.hpp>
 #include <boost/pilfer.hpp>
 #include <cstdlib>
diff --git a/include/boost/pilfer.hpp b/include/boost/pilfer.hpp
index fc62ed93..53f7cd3b 100644
--- a/include/boost/pilfer.hpp
+++ b/include/boost/pilfer.hpp
@@ -10,7 +10,6 @@
 #ifndef BOOST_PILFER_HPP
 #define BOOST_PILFER_HPP
 
-#include <boost/static_assert.hpp>
 #include <memory>
 #include <new>
 #include <type_traits>
@@ -89,7 +88,7 @@ pilfer(T&& t) noexcept ->
 {
     using U =
         typename std::remove_reference<T>::type;
-    BOOST_STATIC_ASSERT(
+    BOOST_JSON_STATIC_ASSERT(
         is_pilfer_constructible<U>::value);
     return typename std::conditional<
         std::is_nothrow_constructible<
@@ -104,7 +103,7 @@ template<class T>
 void
 relocate(T* dest, T& src) noexcept
 {
-    BOOST_STATIC_ASSERT(
+    BOOST_JSON_STATIC_ASSERT(
         is_pilfer_constructible<T>::value);
     ::new(dest) T(pilfer(src));
     src.~T();
diff --git a/test/array.cpp b/test/array.cpp
index 23111ae2..513be219 100644
--- a/test/array.cpp
+++ b/test/array.cpp
@@ -30,7 +30,7 @@ public:
     {
         // ensure this string does
         // not fit in the SBO area.
-        BOOST_ASSERT(str_.size() >
+        BOOST_JSON_ASSERT(str_.size() >
             string().capacity());
     }
 
diff --git a/test/kind.cpp b/test/kind.cpp
index c3e047cd..1a5b3ddb 100644
--- a/test/kind.cpp
+++ b/test/kind.cpp
@@ -11,7 +11,6 @@
 #include <boost/json/kind.hpp>
 
 #include <boost/beast/_experimental/unit_test/suite.hpp>
-#include <boost/static_assert.hpp>
 #include <type_traits>
 
 namespace boost {
@@ -20,7 +19,7 @@ namespace json {
 class kind_test : public beast::unit_test::suite
 {
 public:
-    BOOST_STATIC_ASSERT(
+    BOOST_JSON_STATIC_ASSERT(
         std::is_enum<kind>::value);
 
     void
diff --git a/test/object.cpp b/test/object.cpp
index bbee7411..9c209dc5 100644
--- a/test/object.cpp
+++ b/test/object.cpp
@@ -11,7 +11,7 @@
 #include <boost/json/object.hpp>
 
 #include <boost/beast/_experimental/unit_test/suite.hpp>
-#include <boost/static_assert.hpp>
+#include <boost/json/detail/make_void.hpp>
 #include <cmath>
 #include <type_traits>
 
@@ -31,7 +31,7 @@ public:
     {
         // ensure this string does
         // not fit in the SBO area.
-        BOOST_ASSERT(str_.size() >
+        BOOST_JSON_ASSERT(str_.size() >
             string().capacity());
     }
 
@@ -39,7 +39,7 @@ public:
     struct is_equal_comparable : std::false_type {};
     
     template<class T, class U>
-    struct is_equal_comparable<T, U, boost::void_t<decltype(
+    struct is_equal_comparable<T, U, detail::void_t<decltype(
         std::declval<T const&>() == std::declval<U const&>()
             )>> : std::true_type {};
 
@@ -47,33 +47,33 @@ public:
     struct is_unequal_comparable : std::false_type {};
     
     template<class T, class U>
-    struct is_unequal_comparable<T, U, boost::void_t<decltype(
+    struct is_unequal_comparable<T, U, detail::void_t<decltype(
         std::declval<T const&>() != std::declval<U const&>()
             )>> : std::true_type {};
 
-    BOOST_STATIC_ASSERT(  std::is_constructible<object::iterator, object::iterator>::value);
-    BOOST_STATIC_ASSERT(! std::is_constructible<object::iterator, object::const_iterator>::value);
+    BOOST_JSON_STATIC_ASSERT(  std::is_constructible<object::iterator, object::iterator>::value);
+    BOOST_JSON_STATIC_ASSERT(! std::is_constructible<object::iterator, object::const_iterator>::value);
 
-    BOOST_STATIC_ASSERT(  std::is_constructible<object::const_iterator, object::iterator>::value);
-    BOOST_STATIC_ASSERT(  std::is_constructible<object::const_iterator, object::const_iterator>::value);
+    BOOST_JSON_STATIC_ASSERT(  std::is_constructible<object::const_iterator, object::iterator>::value);
+    BOOST_JSON_STATIC_ASSERT(  std::is_constructible<object::const_iterator, object::const_iterator>::value);
 
-    BOOST_STATIC_ASSERT(  std::is_assignable<object::iterator, object::iterator>::value);
-    BOOST_STATIC_ASSERT(! std::is_assignable<object::iterator, object::const_iterator>::value);
+    BOOST_JSON_STATIC_ASSERT(  std::is_assignable<object::iterator, object::iterator>::value);
+    BOOST_JSON_STATIC_ASSERT(! std::is_assignable<object::iterator, object::const_iterator>::value);
 
-    BOOST_STATIC_ASSERT(  std::is_assignable<object::const_iterator, object::iterator>::value);
-    BOOST_STATIC_ASSERT(  std::is_assignable<object::const_iterator, object::const_iterator>::value);
+    BOOST_JSON_STATIC_ASSERT(  std::is_assignable<object::const_iterator, object::iterator>::value);
+    BOOST_JSON_STATIC_ASSERT(  std::is_assignable<object::const_iterator, object::const_iterator>::value);
 
-    BOOST_STATIC_ASSERT(is_equal_comparable<object::iterator, object::iterator>::value);
-    BOOST_STATIC_ASSERT(is_equal_comparable<object::iterator, object::const_iterator>::value);
+    BOOST_JSON_STATIC_ASSERT(is_equal_comparable<object::iterator, object::iterator>::value);
+    BOOST_JSON_STATIC_ASSERT(is_equal_comparable<object::iterator, object::const_iterator>::value);
 
-    BOOST_STATIC_ASSERT(is_equal_comparable<object::const_iterator, object::iterator>::value);
-    BOOST_STATIC_ASSERT(is_equal_comparable<object::const_iterator, object::const_iterator>::value);
+    BOOST_JSON_STATIC_ASSERT(is_equal_comparable<object::const_iterator, object::iterator>::value);
+    BOOST_JSON_STATIC_ASSERT(is_equal_comparable<object::const_iterator, object::const_iterator>::value);
 
-    BOOST_STATIC_ASSERT(is_unequal_comparable<object::iterator, object::iterator>::value);
-    BOOST_STATIC_ASSERT(is_unequal_comparable<object::iterator, object::const_iterator>::value);
+    BOOST_JSON_STATIC_ASSERT(is_unequal_comparable<object::iterator, object::iterator>::value);
+    BOOST_JSON_STATIC_ASSERT(is_unequal_comparable<object::iterator, object::const_iterator>::value);
 
-    BOOST_STATIC_ASSERT(is_unequal_comparable<object::const_iterator, object::iterator>::value);
-    BOOST_STATIC_ASSERT(is_unequal_comparable<object::const_iterator, object::const_iterator>::value);
+    BOOST_JSON_STATIC_ASSERT(is_unequal_comparable<object::const_iterator, object::iterator>::value);
+    BOOST_JSON_STATIC_ASSERT(is_unequal_comparable<object::const_iterator, object::const_iterator>::value);
 
     static
     void
@@ -925,8 +925,7 @@ public:
         // hash_function()
         {
             object o;
-            object::hasher h = o.hash_function();
-            boost::ignore_unused(h);
+            o.hash_function();
         }
 
         // key_eq()
diff --git a/test/parse-vectors.hpp b/test/parse-vectors.hpp
index c36b12e0..bd496a42 100644
--- a/test/parse-vectors.hpp
+++ b/test/parse-vectors.hpp
@@ -11,17 +11,20 @@
 #ifndef PARSE_VECTORS
 #define PARSE_VECTORS
 
-#include <boost/utility/string_view.hpp>
+#include <boost/json/detail/string.hpp>
 #include <cstdlib>
 #include <type_traits>
 
+namespace boost {
+namespace json {
+
 struct parse_vectors
 {
     struct item
     {
         char result;
-        ::boost::string_view name;
-        ::boost::string_view text;
+        string_view name;
+        string_view text;
     };
 
     using iterator = item const*;
@@ -1413,4 +1416,7 @@ parse_vectors() noexcept
         decltype(list)>::value - 1];
 }
 
+} // json
+} // boost
+
 #endif
diff --git a/test/ryu/d2fixed_test.cpp b/test/ryu/d2fixed_test.cpp
index ca2dbbd4..6b528c0b 100644
--- a/test/ryu/d2fixed_test.cpp
+++ b/test/ryu/d2fixed_test.cpp
@@ -15,11 +15,10 @@
 // is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.
 
-#include <assert.h>
-#include <math.h>
-#include <stdint.h>
-
 #include <boost/json/detail/ryu/ryu.hpp>
+#include <boost/json/detail/assert.hpp>
+#include <cmath>
+#include <cstdint>
 #include "gtest.hpp"
 
 namespace boost {
@@ -35634,8 +35633,8 @@ static double int64Bits2Double(uint64_t bits) {
 }
 
 static double ieeeParts2Double(const bool sign, const uint32_t ieeeExponent, const uint64_t ieeeMantissa) {
-  BOOST_ASSERT(ieeeExponent <= 2047);
-  BOOST_ASSERT(ieeeMantissa <= ((std::uint64_t)1 << 53) - 1);
+  BOOST_JSON_ASSERT(ieeeExponent <= 2047);
+  BOOST_JSON_ASSERT(ieeeMantissa <= ((std::uint64_t)1 << 53) - 1);
   return int64Bits2Double(((std::uint64_t)sign << 63) | ((std::uint64_t)ieeeExponent << 52) | ieeeMantissa);
 }
 
diff --git a/test/ryu/d2s_test.cpp b/test/ryu/d2s_test.cpp
index f79fffab..162e0fac 100644
--- a/test/ryu/d2s_test.cpp
+++ b/test/ryu/d2s_test.cpp
@@ -20,6 +20,7 @@
 */
 
 #include <boost/json/detail/ryu/ryu.hpp>
+#include <boost/json/detail/assert.hpp>
 #include <cmath>
 #include "gtest.hpp"
 
@@ -36,8 +37,8 @@ static double int64Bits2Double(uint64_t bits) {
 }
 
 static double ieeeParts2Double(const bool sign, const uint32_t ieeeExponent, const uint64_t ieeeMantissa) {
-  BOOST_ASSERT(ieeeExponent <= 2047);
-  BOOST_ASSERT(ieeeMantissa <= ((std::uint64_t)1 << 53) - 1);
+  BOOST_JSON_ASSERT(ieeeExponent <= 2047);
+  BOOST_JSON_ASSERT(ieeeMantissa <= ((std::uint64_t)1 << 53) - 1);
   return int64Bits2Double(((std::uint64_t)sign << 63) | ((std::uint64_t)ieeeExponent << 52) | ieeeMantissa);
 }
 
diff --git a/test/ryu/gtest.hpp b/test/ryu/gtest.hpp
index 3a3a75ac..1ab38385 100644
--- a/test/ryu/gtest.hpp
+++ b/test/ryu/gtest.hpp
@@ -13,19 +13,11 @@
 #include <boost/beast/_experimental/unit_test/suite.hpp>
 #include <boost/utility/string_view.hpp>
 
-#if 0
-#define TEST(s1,s2) \
-struct s2 ## s1 ## _test; \
-BEAST_DEFINE_TESTSUITE(boost,s2,s1); \
-struct s2 ## s1 ## _test : ::boost::beast::unit_test::suite { \
-  void run() override; }; void s2##s1##_test::run()
-#else
 #define TEST(s1,s2) \
 struct s2 ## s1 ## _test; \
 BEAST_DEFINE_TESTSUITE(boost,ryu,s2##s1); \
 struct s2 ## s1 ## _test : ::boost::beast::unit_test::suite { \
   void run() override; }; void s2##s1##_test::run()
-#endif
 
 #define EXPECT_STREQ(s1, s2) BEAST_EXPECT(::boost::string_view(s1) == ::boost::string_view(s2))
 #define ASSERT_STREQ(s1, s2) { auto const s1_ = (s1); auto const s2_ = (s2); \
diff --git a/test/value.cpp b/test/value.cpp
index a801df4f..a64b5546 100644
--- a/test/value.cpp
+++ b/test/value.cpp
@@ -11,7 +11,6 @@
 #include <boost/json/value.hpp>
 
 #include <boost/beast/_experimental/unit_test/suite.hpp>
-#include <boost/static_assert.hpp>
 #include <memory>
 #include <vector>
 
@@ -68,7 +67,7 @@ public:
     {
         // ensure this string does
         // not fit in the SBO area.
-        BOOST_ASSERT(str_.size() >
+        BOOST_JSON_ASSERT(str_.size() >
             string().capacity());
     }
 
@@ -92,10 +91,10 @@ public:
         }
     }
 
-    BOOST_STATIC_ASSERT(
+    BOOST_JSON_STATIC_ASSERT(
         detail::is_range<std::vector<int>>::value);
 
-    BOOST_STATIC_ASSERT(
+    BOOST_JSON_STATIC_ASSERT(
         detail::is_range<std::initializer_list<int>>::value);
 
     //------------------------------------------------------