diff --git a/deps/simdjson/simdjson.cpp b/deps/simdjson/simdjson.cpp
index 83b5b8a5b34a5a..e2e65671e0282d 100644
--- a/deps/simdjson/simdjson.cpp
+++ b/deps/simdjson/simdjson.cpp
@@ -1,4 +1,4 @@
-/* auto-generated on 2024-12-12 10:37:26 -0500. Do not edit! */
+/* auto-generated on 2025-01-08 21:29:11 -0500. Do not edit! */
 /* including simdjson.cpp:  */
 /* begin file simdjson.cpp */
 #define SIMDJSON_SRC_SIMDJSON_CPP
@@ -83,9 +83,20 @@
 #endif
 #endif
 
+#if defined(__apple_build_version__)
+#if __apple_build_version__ < 14000000
+#define SIMDJSON_CONCEPT_DISABLED 1 // apple-clang/13 doesn't support std::convertible_to
+#endif
+#endif
+
+
 #if defined(__cpp_concepts) && !defined(SIMDJSON_CONCEPT_DISABLED)
+#if __cpp_concepts >= 201907L
 #include <utility>
 #define SIMDJSON_SUPPORTS_DESERIALIZATION 1
+#else
+#define SIMDJSON_SUPPORTS_DESERIALIZATION 0
+#endif
 #else // defined(__cpp_concepts) && !defined(SIMDJSON_CONCEPT_DISABLED)
 #define SIMDJSON_SUPPORTS_DESERIALIZATION 0
 #endif // defined(__cpp_concepts) && !defined(SIMDJSON_CONCEPT_DISABLED)
@@ -102,11 +113,15 @@
 #include <cstdlib>
 #include <cfloat>
 #include <cassert>
+#include <climits>
 #ifndef _WIN32
 // strcasecmp, strncasecmp
 #include <strings.h>
 #endif
 
+static_assert(CHAR_BIT == 8, "simdjson requires 8-bit bytes");
+
+
 // We are using size_t without namespace std:: throughout the project
 using std::size_t;
 
@@ -140,6 +155,7 @@ using std::size_t;
 #elif defined(__loongarch_lp64)
 #define SIMDJSON_IS_LOONGARCH64 1
 #elif defined(__PPC64__) || defined(_M_PPC64)
+#define SIMDJSON_IS_PPC64 1
 #if defined(__ALTIVEC__)
 #define SIMDJSON_IS_PPC64_VMX 1
 #endif // defined(__ALTIVEC__)
diff --git a/deps/simdjson/simdjson.h b/deps/simdjson/simdjson.h
index c80e8cdafc47b0..b3e1265dfd453b 100644
--- a/deps/simdjson/simdjson.h
+++ b/deps/simdjson/simdjson.h
@@ -1,4 +1,4 @@
-/* auto-generated on 2024-12-12 10:37:26 -0500. Do not edit! */
+/* auto-generated on 2025-01-08 21:29:11 -0500. Do not edit! */
 /* including simdjson.h:  */
 /* begin file simdjson.h */
 #ifndef SIMDJSON_H
@@ -103,9 +103,20 @@
 #endif
 #endif
 
+#if defined(__apple_build_version__)
+#if __apple_build_version__ < 14000000
+#define SIMDJSON_CONCEPT_DISABLED 1 // apple-clang/13 doesn't support std::convertible_to
+#endif
+#endif
+
+
 #if defined(__cpp_concepts) && !defined(SIMDJSON_CONCEPT_DISABLED)
+#if __cpp_concepts >= 201907L
 #include <utility>
 #define SIMDJSON_SUPPORTS_DESERIALIZATION 1
+#else
+#define SIMDJSON_SUPPORTS_DESERIALIZATION 0
+#endif
 #else // defined(__cpp_concepts) && !defined(SIMDJSON_CONCEPT_DISABLED)
 #define SIMDJSON_SUPPORTS_DESERIALIZATION 0
 #endif // defined(__cpp_concepts) && !defined(SIMDJSON_CONCEPT_DISABLED)
@@ -122,11 +133,15 @@
 #include <cstdlib>
 #include <cfloat>
 #include <cassert>
+#include <climits>
 #ifndef _WIN32
 // strcasecmp, strncasecmp
 #include <strings.h>
 #endif
 
+static_assert(CHAR_BIT == 8, "simdjson requires 8-bit bytes");
+
+
 // We are using size_t without namespace std:: throughout the project
 using std::size_t;
 
@@ -160,6 +175,7 @@ using std::size_t;
 #elif defined(__loongarch_lp64)
 #define SIMDJSON_IS_LOONGARCH64 1
 #elif defined(__PPC64__) || defined(_M_PPC64)
+#define SIMDJSON_IS_PPC64 1
 #if defined(__ALTIVEC__)
 #define SIMDJSON_IS_PPC64_VMX 1
 #endif // defined(__ALTIVEC__)
@@ -2421,7 +2437,7 @@ namespace std {
 #define SIMDJSON_SIMDJSON_VERSION_H
 
 /** The version of simdjson being used (major.minor.revision) */
-#define SIMDJSON_VERSION "3.11.3"
+#define SIMDJSON_VERSION "3.11.5"
 
 namespace simdjson {
 enum {
@@ -2436,7 +2452,7 @@ enum {
   /**
    * The revision (major.minor.REVISION) of simdjson being used.
    */
-  SIMDJSON_VERSION_REVISION = 3
+  SIMDJSON_VERSION_REVISION = 5
 };
 } // namespace simdjson
 
@@ -40949,36 +40965,39 @@ simdjson_inline const char * raw_json_string::raw() const noexcept { return rein
 
 simdjson_inline bool raw_json_string::is_free_from_unescaped_quote(std::string_view target) noexcept {
   size_t pos{0};
-  // if the content has no escape character, just scan through it quickly!
-  for(;pos < target.size() && target[pos] != '\\';pos++) {}
-  // slow path may begin.
-  bool escaping{false};
-  for(;pos < target.size();pos++) {
-    if((target[pos] == '"') && !escaping) {
-      return false;
-    } else if(target[pos] == '\\') {
-      escaping = !escaping;
-    } else {
-      escaping = false;
+  while(pos < target.size()) {
+    pos = target.find('"', pos);
+    if(pos == std::string_view::npos) { return true; }
+    if(pos != 0 && target[pos-1] != '\\') { return false; }
+    if(pos > 1 && target[pos-2] == '\\') {
+      size_t backslash_count{2};
+      for(size_t i = 3; i <= pos; i++) {
+        if(target[pos-i] == '\\') { backslash_count++; }
+        else { break; }
+      }
+      if(backslash_count % 2 == 0) { return false; }
     }
+    pos++;
   }
   return true;
 }
 
 simdjson_inline bool raw_json_string::is_free_from_unescaped_quote(const char* target) noexcept {
   size_t pos{0};
-  // if the content has no escape character, just scan through it quickly!
-  for(;target[pos] && target[pos] != '\\';pos++) {}
-  // slow path may begin.
-  bool escaping{false};
-  for(;target[pos];pos++) {
-    if((target[pos] == '"') && !escaping) {
-      return false;
-    } else if(target[pos] == '\\') {
-      escaping = !escaping;
-    } else {
-      escaping = false;
+  while(target[pos]) {
+    const char * result = strchr(target+pos, '"');
+    if(result == nullptr) { return true; }
+    pos = result - target;
+    if(pos != 0 && target[pos-1] != '\\') { return false; }
+    if(pos > 1 && target[pos-2] == '\\') {
+      size_t backslash_count{2};
+      for(size_t i = 3; i <= pos; i++) {
+        if(target[pos-i] == '\\') { backslash_count++; }
+        else { break; }
+      }
+      if(backslash_count % 2 == 0) { return false; }
     }
+    pos++;
   }
   return true;
 }
@@ -40990,7 +41009,7 @@ simdjson_inline bool raw_json_string::unsafe_is_equal(size_t length, std::string
 }
 
 simdjson_inline bool raw_json_string::unsafe_is_equal(std::string_view target) const noexcept {
-  // Assumptions: does not contain unescaped quote characters, and
+  // Assumptions: does not contain unescaped quote characters("), and
   // the raw content is quote terminated within a valid JSON string.
   if(target.size() <= SIMDJSON_PADDING) {
     return (raw()[target.size()] == '"') && !memcmp(raw(), target.data(), target.size());
@@ -48603,74 +48622,10 @@ simdjson_warn_unused simdjson_inline simdjson_result<number> value::get_number()
   return iter.get_number();
 }
 
-simdjson_inline std::string_view value::raw_json_token() noexcept {
-  return std::string_view(reinterpret_cast<const char*>(iter.peek_start()), iter.peek_start_length());
-}
-
-simdjson_inline simdjson_result<std::string_view> value::raw_json() noexcept {
-  json_type t;
-  SIMDJSON_TRY(type().get(t));
-  switch (t)
-  {
-    case json_type::array: {
-      ondemand::array array;
-      SIMDJSON_TRY(get_array().get(array));
-      return array.raw_json();
-    }
-    case json_type::object: {
-      ondemand::object object;
-      SIMDJSON_TRY(get_object().get(object));
-      return object.raw_json();
-    }
-    default:
-      return raw_json_token();
-  }
-}
-
-simdjson_inline simdjson_result<const char *> value::current_location() noexcept {
-  return iter.json_iter().current_location();
-}
-
-simdjson_inline int32_t value::current_depth() const noexcept{
-  return iter.json_iter().depth();
-}
-
-inline bool is_pointer_well_formed(std::string_view json_pointer) noexcept {
-  if (simdjson_unlikely(json_pointer.empty())) { // can't be
-    return false;
-  }
-  if (simdjson_unlikely(json_pointer[0] != '/')) {
-    return false;
-  }
-  size_t escape = json_pointer.find('~');
-  if (escape == std::string_view::npos) {
-    return true;
-  }
-  if (escape == json_pointer.size() - 1) {
-    return false;
-  }
-  if (json_pointer[escape + 1] != '0' && json_pointer[escape + 1] != '1') {
-    return false;
-  }
-  return true;
-}
-
-simdjson_inline simdjson_result<value> value::at_pointer(std::string_view json_pointer) noexcept {
-  json_type t;
-  SIMDJSON_TRY(type().get(t));
-  switch (t)
-  {
-    case json_type::array:
-      return (*this).get_array().at_pointer(json_pointer);
-    case json_type::object:
-      return (*this).get_object().at_pointer(json_pointer);
-    default:
-      // a non-empty string can be invalid, or accessing a primitive (issue 2154)
-      if (is_pointer_well_formed(json_pointer)) {
-        return NO_SUCH_FIELD;
-      }
-      return INVALID_JSON_POINTER;
-  }
+inline simdjson_result<value> array::at_path(std::string_view json_path) noexcept {
+  auto json_pointer = json_path_to_pointer_conversion(json_path);
+  if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
+  return at_pointer(json_pointer);
 }
 
 simdjson_inline simdjson_result<value> value::at_path(std::string_view json_path) noexcept {
@@ -48938,329 +48893,278 @@ simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallb
 
 } // namespace simdjson
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_VALUE_INL_H
-/* end file simdjson/generic/ondemand/value-inl.h for fallback */
-/* including simdjson/generic/ondemand/document-inl.h for fallback: #include "simdjson/generic/ondemand/document-inl.h" */
-/* begin file simdjson/generic/ondemand/document-inl.h for fallback */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_INL_H
+#endif // SIMDJSON_GENERIC_ONDEMAND_ARRAY_ITERATOR_INL_H
+/* end file simdjson/generic/ondemand/array_iterator-inl.h for fallback */
+/* including simdjson/generic/ondemand/value-inl.h for fallback: #include "simdjson/generic/ondemand/value-inl.h" */
+/* begin file simdjson/generic/ondemand/value-inl.h for fallback */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_VALUE_INL_H
 
 /* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_INL_H */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_VALUE_INL_H */
 /* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array.h" */
 /* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array_iterator.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_iterator.h" */
 /* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_type.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/object.h" */
 /* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/raw_json_string.h" */
 /* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value-inl.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array-inl.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_iterator-inl.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/object-inl.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value_iterator-inl.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/deserialize.h" */
 /* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
 namespace simdjson {
 namespace fallback {
 namespace ondemand {
 
-simdjson_inline document::document(ondemand::json_iterator &&_iter) noexcept
-  : iter{std::forward<json_iterator>(_iter)}
+simdjson_inline value::value(const value_iterator &_iter) noexcept
+  : iter{_iter}
 {
-  logger::log_start_value(iter, "document");
 }
-
-simdjson_inline document document::start(json_iterator &&iter) noexcept {
-  return document(std::forward<json_iterator>(iter));
-}
-
-inline void document::rewind() noexcept {
-  iter.rewind();
-}
-
-inline std::string document::to_debug_string() noexcept {
-  return iter.to_string();
-}
-
-inline simdjson_result<const char *> document::current_location() const noexcept {
-  return iter.current_location();
-}
-
-inline int32_t document::current_depth() const noexcept {
-  return iter.depth();
+simdjson_inline value value::start(const value_iterator &iter) noexcept {
+  return iter;
 }
-
-inline bool document::at_end() const noexcept {
-  return iter.at_end();
+simdjson_inline value value::resume(const value_iterator &iter) noexcept {
+  return iter;
 }
 
-
-inline bool document::is_alive() noexcept {
-  return iter.is_alive();
-}
-simdjson_inline value_iterator document::resume_value_iterator() noexcept {
-  return value_iterator(&iter, 1, iter.root_position());
+simdjson_inline simdjson_result<array> value::get_array() noexcept {
+  return array::start(iter);
 }
-simdjson_inline value_iterator document::get_root_value_iterator() noexcept {
-  return resume_value_iterator();
+simdjson_inline simdjson_result<object> value::get_object() noexcept {
+  return object::start(iter);
 }
-simdjson_inline simdjson_result<object> document::start_or_resume_object() noexcept {
-  if (iter.at_root()) {
+simdjson_inline simdjson_result<object> value::start_or_resume_object() noexcept {
+  if (iter.at_start()) {
     return get_object();
   } else {
-    return object::resume(resume_value_iterator());
-  }
-}
-simdjson_inline simdjson_result<value> document::get_value() noexcept {
-  // Make sure we start any arrays or objects before returning, so that start_root_<object/array>()
-  // gets called.
-
-  // It is the convention throughout the code that  the macro `SIMDJSON_DEVELOPMENT_CHECKS` determines whether
-  // we check for OUT_OF_ORDER_ITERATION. Proper on::demand code should never trigger this error.
-#if SIMDJSON_DEVELOPMENT_CHECKS
-  if (!iter.at_root()) { return OUT_OF_ORDER_ITERATION; }
-#endif
-  // assert_at_root() serves two purposes: in Debug mode, whether or not
-  // SIMDJSON_DEVELOPMENT_CHECKS is set or not, it checks that we are at the root of
-  // the document (this will typically be redundant). In release mode, it generates
-  // SIMDJSON_ASSUME statements to allow the compiler to make assumptions.
-  iter.assert_at_root();
-  switch (*iter.peek()) {
-    case '[': {
-      // The following lines check that the document ends with ].
-      auto value_iterator = get_root_value_iterator();
-      auto error = value_iterator.check_root_array();
-      if(error) { return error; }
-      return value(get_root_value_iterator());
-    }
-    case '{': {
-      // The following lines would check that the document ends with }.
-      auto value_iterator = get_root_value_iterator();
-      auto error = value_iterator.check_root_object();
-      if(error) { return error; }
-      return value(get_root_value_iterator());
-    }
-    default:
-      // Unfortunately, scalar documents are a special case in simdjson and they cannot
-      // be safely converted to value instances.
-      return SCALAR_DOCUMENT_AS_VALUE;
+    return object::resume(iter);
   }
 }
-simdjson_inline simdjson_result<array> document::get_array() & noexcept {
-  auto value = get_root_value_iterator();
-  return array::start_root(value);
-}
-simdjson_inline simdjson_result<object> document::get_object() & noexcept {
-  auto value = get_root_value_iterator();
-  return object::start_root(value);
-}
-
-/**
- * We decided that calling 'get_double()' on the JSON document '1.233 blabla' should
- * give an error, so we check for trailing content. We want to disallow trailing
- * content.
- * Thus, in several implementations below, we pass a 'true' parameter value to
- * a get_root_value_iterator() method: this indicates that we disallow trailing content.
- */
 
-simdjson_inline simdjson_result<uint64_t> document::get_uint64() noexcept {
-  return get_root_value_iterator().get_root_uint64(true);
+simdjson_inline simdjson_result<raw_json_string> value::get_raw_json_string() noexcept {
+  return iter.get_raw_json_string();
 }
-simdjson_inline simdjson_result<uint64_t> document::get_uint64_in_string() noexcept {
-  return get_root_value_iterator().get_root_uint64_in_string(true);
+simdjson_inline simdjson_result<std::string_view> value::get_string(bool allow_replacement) noexcept {
+  return iter.get_string(allow_replacement);
 }
-simdjson_inline simdjson_result<int64_t> document::get_int64() noexcept {
-  return get_root_value_iterator().get_root_int64(true);
+template <typename string_type>
+simdjson_inline error_code value::get_string(string_type& receiver, bool allow_replacement) noexcept {
+  return iter.get_string(receiver, allow_replacement);
 }
-simdjson_inline simdjson_result<int64_t> document::get_int64_in_string() noexcept {
-  return get_root_value_iterator().get_root_int64_in_string(true);
+simdjson_inline simdjson_result<std::string_view> value::get_wobbly_string() noexcept {
+  return iter.get_wobbly_string();
 }
-simdjson_inline simdjson_result<double> document::get_double() noexcept {
-  return get_root_value_iterator().get_root_double(true);
+simdjson_inline simdjson_result<double> value::get_double() noexcept {
+  return iter.get_double();
 }
-simdjson_inline simdjson_result<double> document::get_double_in_string() noexcept {
-  return get_root_value_iterator().get_root_double_in_string(true);
+simdjson_inline simdjson_result<double> value::get_double_in_string() noexcept {
+  return iter.get_double_in_string();
 }
-simdjson_inline simdjson_result<std::string_view> document::get_string(bool allow_replacement) noexcept {
-  return get_root_value_iterator().get_root_string(true, allow_replacement);
+simdjson_inline simdjson_result<uint64_t> value::get_uint64() noexcept {
+  return iter.get_uint64();
 }
-template <typename string_type>
-simdjson_inline error_code document::get_string(string_type& receiver, bool allow_replacement) noexcept {
-  return get_root_value_iterator().get_root_string(receiver, true, allow_replacement);
+simdjson_inline simdjson_result<uint64_t> value::get_uint64_in_string() noexcept {
+  return iter.get_uint64_in_string();
 }
-simdjson_inline simdjson_result<std::string_view> document::get_wobbly_string() noexcept {
-  return get_root_value_iterator().get_root_wobbly_string(true);
+simdjson_inline simdjson_result<int64_t> value::get_int64() noexcept {
+  return iter.get_int64();
 }
-simdjson_inline simdjson_result<raw_json_string> document::get_raw_json_string() noexcept {
-  return get_root_value_iterator().get_root_raw_json_string(true);
+simdjson_inline simdjson_result<int64_t> value::get_int64_in_string() noexcept {
+  return iter.get_int64_in_string();
 }
-simdjson_inline simdjson_result<bool> document::get_bool() noexcept {
-  return get_root_value_iterator().get_root_bool(true);
+simdjson_inline simdjson_result<bool> value::get_bool() noexcept {
+  return iter.get_bool();
 }
-simdjson_inline simdjson_result<bool> document::is_null() noexcept {
-  return get_root_value_iterator().is_root_null(true);
+simdjson_inline simdjson_result<bool> value::is_null() noexcept {
+  return iter.is_null();
 }
 
-template<> simdjson_inline simdjson_result<array> document::get() & noexcept { return get_array(); }
-template<> simdjson_inline simdjson_result<object> document::get() & noexcept { return get_object(); }
-template<> simdjson_inline simdjson_result<raw_json_string> document::get() & noexcept { return get_raw_json_string(); }
-template<> simdjson_inline simdjson_result<std::string_view> document::get() & noexcept { return get_string(false); }
-template<> simdjson_inline simdjson_result<double> document::get() & noexcept { return get_double(); }
-template<> simdjson_inline simdjson_result<uint64_t> document::get() & noexcept { return get_uint64(); }
-template<> simdjson_inline simdjson_result<int64_t> document::get() & noexcept { return get_int64(); }
-template<> simdjson_inline simdjson_result<bool> document::get() & noexcept { return get_bool(); }
-template<> simdjson_inline simdjson_result<value> document::get() & noexcept { return get_value(); }
+template<> simdjson_inline simdjson_result<array> value::get() noexcept { return get_array(); }
+template<> simdjson_inline simdjson_result<object> value::get() noexcept { return get_object(); }
+template<> simdjson_inline simdjson_result<raw_json_string> value::get() noexcept { return get_raw_json_string(); }
+template<> simdjson_inline simdjson_result<std::string_view> value::get() noexcept { return get_string(false); }
+template<> simdjson_inline simdjson_result<number> value::get() noexcept { return get_number(); }
+template<> simdjson_inline simdjson_result<double> value::get() noexcept { return get_double(); }
+template<> simdjson_inline simdjson_result<uint64_t> value::get() noexcept { return get_uint64(); }
+template<> simdjson_inline simdjson_result<int64_t> value::get() noexcept { return get_int64(); }
+template<> simdjson_inline simdjson_result<bool> value::get() noexcept { return get_bool(); }
 
-template<> simdjson_inline error_code document::get(array& out) & noexcept { return get_array().get(out); }
-template<> simdjson_inline error_code document::get(object& out) & noexcept { return get_object().get(out); }
-template<> simdjson_inline error_code document::get(raw_json_string& out) & noexcept { return get_raw_json_string().get(out); }
-template<> simdjson_inline error_code document::get(std::string_view& out) & noexcept { return get_string(false).get(out); }
-template<> simdjson_inline error_code document::get(double& out) & noexcept { return get_double().get(out); }
-template<> simdjson_inline error_code document::get(uint64_t& out) & noexcept { return get_uint64().get(out); }
-template<> simdjson_inline error_code document::get(int64_t& out) & noexcept { return get_int64().get(out); }
-template<> simdjson_inline error_code document::get(bool& out) & noexcept { return get_bool().get(out); }
-template<> simdjson_inline error_code document::get(value& out) & noexcept { return get_value().get(out); }
 
-template<> simdjson_deprecated simdjson_inline simdjson_result<raw_json_string> document::get() && noexcept { return get_raw_json_string(); }
-template<> simdjson_deprecated simdjson_inline simdjson_result<std::string_view> document::get() && noexcept { return get_string(false); }
-template<> simdjson_deprecated simdjson_inline simdjson_result<double> document::get() && noexcept { return std::forward<document>(*this).get_double(); }
-template<> simdjson_deprecated simdjson_inline simdjson_result<uint64_t> document::get() && noexcept { return std::forward<document>(*this).get_uint64(); }
-template<> simdjson_deprecated simdjson_inline simdjson_result<int64_t> document::get() && noexcept { return std::forward<document>(*this).get_int64(); }
-template<> simdjson_deprecated simdjson_inline simdjson_result<bool> document::get() && noexcept { return std::forward<document>(*this).get_bool(); }
-template<> simdjson_deprecated simdjson_inline simdjson_result<value> document::get() && noexcept { return get_value(); }
+template<> simdjson_inline error_code value::get(array& out) noexcept { return get_array().get(out); }
+template<> simdjson_inline error_code value::get(object& out) noexcept { return get_object().get(out); }
+template<> simdjson_inline error_code value::get(raw_json_string& out) noexcept { return get_raw_json_string().get(out); }
+template<> simdjson_inline error_code value::get(std::string_view& out) noexcept { return get_string(false).get(out); }
+template<> simdjson_inline error_code value::get(number& out) noexcept { return get_number().get(out); }
+template<> simdjson_inline error_code value::get(double& out) noexcept { return get_double().get(out); }
+template<> simdjson_inline error_code value::get(uint64_t& out) noexcept { return get_uint64().get(out); }
+template<> simdjson_inline error_code value::get(int64_t& out) noexcept { return get_int64().get(out); }
+template<> simdjson_inline error_code value::get(bool& out) noexcept { return get_bool().get(out); }
 
 #if SIMDJSON_EXCEPTIONS
 template <class T>
-simdjson_deprecated simdjson_inline document::operator T() && noexcept(false) { return get<T>(); }
-template <class T>
-simdjson_inline document::operator T() & noexcept(false) { return get<T>(); }
-simdjson_inline document::operator array() & noexcept(false) { return get_array(); }
-simdjson_inline document::operator object() & noexcept(false) { return get_object(); }
-simdjson_inline document::operator uint64_t() noexcept(false) { return get_uint64(); }
-simdjson_inline document::operator int64_t() noexcept(false) { return get_int64(); }
-simdjson_inline document::operator double() noexcept(false) { return get_double(); }
-simdjson_inline document::operator std::string_view() noexcept(false) { return get_string(false); }
-simdjson_inline document::operator raw_json_string() noexcept(false) { return get_raw_json_string(); }
-simdjson_inline document::operator bool() noexcept(false) { return get_bool(); }
-simdjson_inline document::operator value() noexcept(false) { return get_value(); }
-
+simdjson_inline value::operator T() noexcept(false) {
+  return get<T>();
+}
+simdjson_inline value::operator array() noexcept(false) {
+  return get_array();
+}
+simdjson_inline value::operator object() noexcept(false) {
+  return get_object();
+}
+simdjson_inline value::operator uint64_t() noexcept(false) {
+  return get_uint64();
+}
+simdjson_inline value::operator int64_t() noexcept(false) {
+  return get_int64();
+}
+simdjson_inline value::operator double() noexcept(false) {
+  return get_double();
+}
+simdjson_inline value::operator std::string_view() noexcept(false) {
+  return get_string(false);
+}
+simdjson_inline value::operator raw_json_string() noexcept(false) {
+  return get_raw_json_string();
+}
+simdjson_inline value::operator bool() noexcept(false) {
+  return get_bool();
+}
 #endif
-simdjson_inline simdjson_result<size_t> document::count_elements() & noexcept {
+
+simdjson_inline simdjson_result<array_iterator> value::begin() & noexcept {
+  return get_array().begin();
+}
+simdjson_inline simdjson_result<array_iterator> value::end() & noexcept {
+  return {};
+}
+simdjson_inline simdjson_result<size_t> value::count_elements() & noexcept {
+  simdjson_result<size_t> answer;
   auto a = get_array();
-  simdjson_result<size_t> answer = a.count_elements();
-  /* If there was an array, we are now left pointing at its first element. */
-  if(answer.error() == SUCCESS) { rewind(); }
+  answer = a.count_elements();
+  // count_elements leaves you pointing inside the array, at the first element.
+  // We need to move back so that the user can create a new array (which requires that
+  // we point at '[').
+  iter.move_at_start();
   return answer;
 }
-simdjson_inline simdjson_result<size_t> document::count_fields() & noexcept {
+simdjson_inline simdjson_result<size_t> value::count_fields() & noexcept {
+  simdjson_result<size_t> answer;
   auto a = get_object();
-  simdjson_result<size_t> answer = a.count_fields();
-  /* If there was an object, we are now left pointing at its first element. */
-  if(answer.error() == SUCCESS) { rewind(); }
+  answer = a.count_fields();
+  iter.move_at_start();
   return answer;
 }
-simdjson_inline simdjson_result<value> document::at(size_t index) & noexcept {
+simdjson_inline simdjson_result<value> value::at(size_t index) noexcept {
   auto a = get_array();
   return a.at(index);
 }
-simdjson_inline simdjson_result<array_iterator> document::begin() & noexcept {
-  return get_array().begin();
-}
-simdjson_inline simdjson_result<array_iterator> document::end() & noexcept {
-  return {};
-}
 
-simdjson_inline simdjson_result<value> document::find_field(std::string_view key) & noexcept {
+simdjson_inline simdjson_result<value> value::find_field(std::string_view key) noexcept {
   return start_or_resume_object().find_field(key);
 }
-simdjson_inline simdjson_result<value> document::find_field(const char *key) & noexcept {
+simdjson_inline simdjson_result<value> value::find_field(const char *key) noexcept {
   return start_or_resume_object().find_field(key);
 }
-simdjson_inline simdjson_result<value> document::find_field_unordered(std::string_view key) & noexcept {
+
+simdjson_inline simdjson_result<value> value::find_field_unordered(std::string_view key) noexcept {
   return start_or_resume_object().find_field_unordered(key);
 }
-simdjson_inline simdjson_result<value> document::find_field_unordered(const char *key) & noexcept {
+simdjson_inline simdjson_result<value> value::find_field_unordered(const char *key) noexcept {
   return start_or_resume_object().find_field_unordered(key);
 }
-simdjson_inline simdjson_result<value> document::operator[](std::string_view key) & noexcept {
+
+simdjson_inline simdjson_result<value> value::operator[](std::string_view key) noexcept {
   return start_or_resume_object()[key];
 }
-simdjson_inline simdjson_result<value> document::operator[](const char *key) & noexcept {
+simdjson_inline simdjson_result<value> value::operator[](const char *key) noexcept {
   return start_or_resume_object()[key];
 }
 
-simdjson_inline error_code document::consume() noexcept {
-  bool scalar = false;
-  auto error = is_scalar().get(scalar);
-  if(error) { return error; }
-  if(scalar) {
-    iter.return_current_and_advance();
-    return SUCCESS;
-  }
-  error = iter.skip_child(0);
-  if(error) { iter.abandon(); }
-  return error;
-}
-
-simdjson_inline simdjson_result<std::string_view> document::raw_json() noexcept {
-  auto _iter = get_root_value_iterator();
-  const uint8_t * starting_point{_iter.peek_start()};
-  auto error = consume();
-  if(error) { return error; }
-  // After 'consume()', we could be left pointing just beyond the document, but that
-  // is ok because we are not going to dereference the final pointer position, we just
-  // use it to compute the length in bytes.
-  const uint8_t * final_point{iter.unsafe_pointer()};
-  return std::string_view(reinterpret_cast<const char*>(starting_point), size_t(final_point - starting_point));
-}
-
-simdjson_inline simdjson_result<json_type> document::type() noexcept {
-  return get_root_value_iterator().type();
+simdjson_inline simdjson_result<json_type> value::type() noexcept {
+  return iter.type();
 }
 
-simdjson_inline simdjson_result<bool> document::is_scalar() noexcept {
-  // For more speed, we could do:
-  // return iter.is_single_token();
+simdjson_inline simdjson_result<bool> value::is_scalar() noexcept {
   json_type this_type;
   auto error = type().get(this_type);
   if(error) { return error; }
   return ! ((this_type == json_type::array) || (this_type == json_type::object));
 }
 
-simdjson_inline simdjson_result<bool> document::is_string() noexcept {
+simdjson_inline simdjson_result<bool> value::is_string() noexcept {
   json_type this_type;
   auto error = type().get(this_type);
   if(error) { return error; }
   return (this_type == json_type::string);
 }
 
-simdjson_inline bool document::is_negative() noexcept {
-  return get_root_value_iterator().is_root_negative();
+
+simdjson_inline bool value::is_negative() noexcept {
+  return iter.is_negative();
 }
 
-simdjson_inline simdjson_result<bool> document::is_integer() noexcept {
-  return get_root_value_iterator().is_root_integer(true);
+simdjson_inline simdjson_result<bool> value::is_integer() noexcept {
+  return iter.is_integer();
+}
+simdjson_warn_unused simdjson_inline simdjson_result<number_type> value::get_number_type() noexcept {
+  return iter.get_number_type();
+}
+simdjson_warn_unused simdjson_inline simdjson_result<number> value::get_number() noexcept {
+  return iter.get_number();
 }
 
-simdjson_inline simdjson_result<number_type> document::get_number_type() noexcept {
-  return get_root_value_iterator().get_root_number_type(true);
+simdjson_inline std::string_view value::raw_json_token() noexcept {
+  return std::string_view(reinterpret_cast<const char*>(iter.peek_start()), iter.peek_start_length());
 }
 
-simdjson_inline simdjson_result<number> document::get_number() noexcept {
-  return get_root_value_iterator().get_root_number(true);
+simdjson_inline simdjson_result<std::string_view> value::raw_json() noexcept {
+  json_type t;
+  SIMDJSON_TRY(type().get(t));
+  switch (t)
+  {
+    case json_type::array: {
+      ondemand::array array;
+      SIMDJSON_TRY(get_array().get(array));
+      return array.raw_json();
+    }
+    case json_type::object: {
+      ondemand::object object;
+      SIMDJSON_TRY(get_object().get(object));
+      return object.raw_json();
+    }
+    default:
+      return raw_json_token();
+  }
 }
 
+simdjson_inline simdjson_result<const char *> value::current_location() noexcept {
+  return iter.json_iter().current_location();
+}
 
-simdjson_inline simdjson_result<std::string_view> document::raw_json_token() noexcept {
-  auto _iter = get_root_value_iterator();
-  return std::string_view(reinterpret_cast<const char*>(_iter.peek_start()), _iter.peek_root_length());
+simdjson_inline int32_t value::current_depth() const noexcept{
+  return iter.json_iter().depth();
 }
 
-simdjson_inline simdjson_result<value> document::at_pointer(std::string_view json_pointer) noexcept {
-  rewind(); // Rewind the document each time at_pointer is called
-  if (json_pointer.empty()) {
-    return this->get_value();
+inline bool is_pointer_well_formed(std::string_view json_pointer) noexcept {
+  if (simdjson_unlikely(json_pointer.empty())) { // can't be
+    return false;
+  }
+  if (simdjson_unlikely(json_pointer[0] != '/')) {
+    return false;
   }
+  size_t escape = json_pointer.find('~');
+  if (escape == std::string_view::npos) {
+    return true;
+  }
+  if (escape == json_pointer.size() - 1) {
+    return false;
+  }
+  if (json_pointer[escape + 1] != '0' && json_pointer[escape + 1] != '1') {
+    return false;
+  }
+  return true;
+}
+
+simdjson_inline simdjson_result<value> value::at_pointer(std::string_view json_pointer) noexcept {
   json_type t;
   SIMDJSON_TRY(type().get(t));
   switch (t)
@@ -49270,15 +49174,15 @@ simdjson_inline simdjson_result<value> document::at_pointer(std::string_view jso
     case json_type::object:
       return (*this).get_object().at_pointer(json_pointer);
     default:
-      return INVALID_JSON_POINTER;
-  }
+      // a non-empty string can be invalid, or accessing a primitive (issue 2154)
+      if (is_pointer_well_formed(json_pointer)) {
+        return NO_SUCH_FIELD;
+      }
+      return INVALID_JSON_POINTER;
+  }
 }
 
-simdjson_inline simdjson_result<value> document::at_path(std::string_view json_path) noexcept {
-  rewind(); // Rewind the document each time at_pointer is called
-  if (json_path.empty()) {
-      return this->get_value();
-  }
+simdjson_inline simdjson_result<value> value::at_path(std::string_view json_path) noexcept {
   json_type t;
   SIMDJSON_TRY(type().get(t));
   switch (t) {
@@ -49297,699 +49201,1304 @@ simdjson_inline simdjson_result<value> document::at_path(std::string_view json_p
 
 namespace simdjson {
 
-simdjson_inline simdjson_result<fallback::ondemand::document>::simdjson_result(
-  fallback::ondemand::document &&value
+simdjson_inline simdjson_result<fallback::ondemand::value>::simdjson_result(
+  fallback::ondemand::value &&value
 ) noexcept :
-    implementation_simdjson_result_base<fallback::ondemand::document>(
-      std::forward<fallback::ondemand::document>(value)
+    implementation_simdjson_result_base<fallback::ondemand::value>(
+      std::forward<fallback::ondemand::value>(value)
     )
 {
 }
-simdjson_inline simdjson_result<fallback::ondemand::document>::simdjson_result(
+simdjson_inline simdjson_result<fallback::ondemand::value>::simdjson_result(
   error_code error
 ) noexcept :
-    implementation_simdjson_result_base<fallback::ondemand::document>(
-      error
-    )
+    implementation_simdjson_result_base<fallback::ondemand::value>(error)
 {
 }
-simdjson_inline simdjson_result<size_t> simdjson_result<fallback::ondemand::document>::count_elements() & noexcept {
+simdjson_inline simdjson_result<size_t> simdjson_result<fallback::ondemand::value>::count_elements() & noexcept {
   if (error()) { return error(); }
   return first.count_elements();
 }
-simdjson_inline simdjson_result<size_t> simdjson_result<fallback::ondemand::document>::count_fields() & noexcept {
+simdjson_inline simdjson_result<size_t> simdjson_result<fallback::ondemand::value>::count_fields() & noexcept {
   if (error()) { return error(); }
   return first.count_fields();
 }
-simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document>::at(size_t index) & noexcept {
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::value>::at(size_t index) noexcept {
   if (error()) { return error(); }
   return first.at(index);
 }
-simdjson_inline error_code simdjson_result<fallback::ondemand::document>::rewind() noexcept {
-  if (error()) { return error(); }
-  first.rewind();
-  return SUCCESS;
-}
-simdjson_inline simdjson_result<fallback::ondemand::array_iterator> simdjson_result<fallback::ondemand::document>::begin() & noexcept {
+simdjson_inline simdjson_result<fallback::ondemand::array_iterator> simdjson_result<fallback::ondemand::value>::begin() & noexcept {
   if (error()) { return error(); }
   return first.begin();
 }
-simdjson_inline simdjson_result<fallback::ondemand::array_iterator> simdjson_result<fallback::ondemand::document>::end() & noexcept {
+simdjson_inline simdjson_result<fallback::ondemand::array_iterator> simdjson_result<fallback::ondemand::value>::end() & noexcept {
+  if (error()) { return error(); }
   return {};
 }
-simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document>::find_field_unordered(std::string_view key) & noexcept {
+
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::value>::find_field(std::string_view key) noexcept {
   if (error()) { return error(); }
-  return first.find_field_unordered(key);
+  return first.find_field(key);
 }
-simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document>::find_field_unordered(const char *key) & noexcept {
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::value>::find_field(const char *key) noexcept {
   if (error()) { return error(); }
-  return first.find_field_unordered(key);
+  return first.find_field(key);
 }
-simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document>::operator[](std::string_view key) & noexcept {
+
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::value>::find_field_unordered(std::string_view key) noexcept {
   if (error()) { return error(); }
-  return first[key];
+  return first.find_field_unordered(key);
 }
-simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document>::operator[](const char *key) & noexcept {
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::value>::find_field_unordered(const char *key) noexcept {
   if (error()) { return error(); }
-  return first[key];
+  return first.find_field_unordered(key);
 }
-simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document>::find_field(std::string_view key) & noexcept {
+
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::value>::operator[](std::string_view key) noexcept {
   if (error()) { return error(); }
-  return first.find_field(key);
+  return first[key];
 }
-simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document>::find_field(const char *key) & noexcept {
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::value>::operator[](const char *key) noexcept {
   if (error()) { return error(); }
-  return first.find_field(key);
+  return first[key];
 }
-simdjson_inline simdjson_result<fallback::ondemand::array> simdjson_result<fallback::ondemand::document>::get_array() & noexcept {
+
+simdjson_inline simdjson_result<fallback::ondemand::array> simdjson_result<fallback::ondemand::value>::get_array() noexcept {
   if (error()) { return error(); }
   return first.get_array();
 }
-simdjson_inline simdjson_result<fallback::ondemand::object> simdjson_result<fallback::ondemand::document>::get_object() & noexcept {
+simdjson_inline simdjson_result<fallback::ondemand::object> simdjson_result<fallback::ondemand::value>::get_object() noexcept {
   if (error()) { return error(); }
   return first.get_object();
 }
-simdjson_inline simdjson_result<uint64_t> simdjson_result<fallback::ondemand::document>::get_uint64() noexcept {
+simdjson_inline simdjson_result<uint64_t> simdjson_result<fallback::ondemand::value>::get_uint64() noexcept {
   if (error()) { return error(); }
   return first.get_uint64();
 }
-simdjson_inline simdjson_result<uint64_t> simdjson_result<fallback::ondemand::document>::get_uint64_in_string() noexcept {
+simdjson_inline simdjson_result<uint64_t> simdjson_result<fallback::ondemand::value>::get_uint64_in_string() noexcept {
   if (error()) { return error(); }
   return first.get_uint64_in_string();
 }
-simdjson_inline simdjson_result<int64_t> simdjson_result<fallback::ondemand::document>::get_int64() noexcept {
+simdjson_inline simdjson_result<int64_t> simdjson_result<fallback::ondemand::value>::get_int64() noexcept {
   if (error()) { return error(); }
   return first.get_int64();
 }
-simdjson_inline simdjson_result<int64_t> simdjson_result<fallback::ondemand::document>::get_int64_in_string() noexcept {
+simdjson_inline simdjson_result<int64_t> simdjson_result<fallback::ondemand::value>::get_int64_in_string() noexcept {
   if (error()) { return error(); }
   return first.get_int64_in_string();
 }
-simdjson_inline simdjson_result<double> simdjson_result<fallback::ondemand::document>::get_double() noexcept {
+simdjson_inline simdjson_result<double> simdjson_result<fallback::ondemand::value>::get_double() noexcept {
   if (error()) { return error(); }
   return first.get_double();
 }
-simdjson_inline simdjson_result<double> simdjson_result<fallback::ondemand::document>::get_double_in_string() noexcept {
+simdjson_inline simdjson_result<double> simdjson_result<fallback::ondemand::value>::get_double_in_string() noexcept {
   if (error()) { return error(); }
   return first.get_double_in_string();
 }
-simdjson_inline simdjson_result<std::string_view> simdjson_result<fallback::ondemand::document>::get_string(bool allow_replacement) noexcept {
+simdjson_inline simdjson_result<std::string_view> simdjson_result<fallback::ondemand::value>::get_string(bool allow_replacement) noexcept {
   if (error()) { return error(); }
   return first.get_string(allow_replacement);
 }
 template <typename string_type>
-simdjson_inline error_code simdjson_result<fallback::ondemand::document>::get_string(string_type& receiver, bool allow_replacement) noexcept {
+simdjson_inline error_code simdjson_result<fallback::ondemand::value>::get_string(string_type& receiver, bool allow_replacement) noexcept {
   if (error()) { return error(); }
   return first.get_string(receiver, allow_replacement);
 }
-simdjson_inline simdjson_result<std::string_view> simdjson_result<fallback::ondemand::document>::get_wobbly_string() noexcept {
+simdjson_inline simdjson_result<std::string_view> simdjson_result<fallback::ondemand::value>::get_wobbly_string() noexcept {
   if (error()) { return error(); }
   return first.get_wobbly_string();
 }
-simdjson_inline simdjson_result<fallback::ondemand::raw_json_string> simdjson_result<fallback::ondemand::document>::get_raw_json_string() noexcept {
+simdjson_inline simdjson_result<fallback::ondemand::raw_json_string> simdjson_result<fallback::ondemand::value>::get_raw_json_string() noexcept {
   if (error()) { return error(); }
   return first.get_raw_json_string();
 }
-simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document>::get_bool() noexcept {
+simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::value>::get_bool() noexcept {
   if (error()) { return error(); }
   return first.get_bool();
 }
-simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document>::get_value() noexcept {
-  if (error()) { return error(); }
-  return first.get_value();
-}
-simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document>::is_null() noexcept {
+simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::value>::is_null() noexcept {
   if (error()) { return error(); }
   return first.is_null();
 }
 
-template<typename T>
-simdjson_inline simdjson_result<T> simdjson_result<fallback::ondemand::document>::get() & noexcept {
+template<> simdjson_inline error_code simdjson_result<fallback::ondemand::value>::get<fallback::ondemand::value>(fallback::ondemand::value &out) noexcept {
   if (error()) { return error(); }
-  return first.get<T>();
+  out = first;
+  return SUCCESS;
 }
-template<typename T>
-simdjson_deprecated simdjson_inline simdjson_result<T> simdjson_result<fallback::ondemand::document>::get() && noexcept {
+
+template<typename T> simdjson_inline simdjson_result<T> simdjson_result<fallback::ondemand::value>::get() noexcept {
   if (error()) { return error(); }
-  return std::forward<fallback::ondemand::document>(first).get<T>();
+  return first.get<T>();
 }
-template<typename T>
-simdjson_inline error_code simdjson_result<fallback::ondemand::document>::get(T &out) & noexcept {
+template<typename T> simdjson_inline error_code simdjson_result<fallback::ondemand::value>::get(T &out) noexcept {
   if (error()) { return error(); }
   return first.get<T>(out);
 }
-template<typename T>
-simdjson_inline error_code simdjson_result<fallback::ondemand::document>::get(T &out) && noexcept {
-  if (error()) { return error(); }
-  return std::forward<fallback::ondemand::document>(first).get<T>(out);
-}
 
-template<> simdjson_inline simdjson_result<fallback::ondemand::document> simdjson_result<fallback::ondemand::document>::get<fallback::ondemand::document>() & noexcept = delete;
-template<> simdjson_deprecated simdjson_inline simdjson_result<fallback::ondemand::document> simdjson_result<fallback::ondemand::document>::get<fallback::ondemand::document>() && noexcept {
-  if (error()) { return error(); }
-  return std::forward<fallback::ondemand::document>(first);
-}
-template<> simdjson_inline error_code simdjson_result<fallback::ondemand::document>::get<fallback::ondemand::document>(fallback::ondemand::document &out) & noexcept = delete;
-template<> simdjson_inline error_code simdjson_result<fallback::ondemand::document>::get<fallback::ondemand::document>(fallback::ondemand::document &out) && noexcept {
+template<> simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::value>::get<fallback::ondemand::value>() noexcept  {
   if (error()) { return error(); }
-  out = std::forward<fallback::ondemand::document>(first);
-  return SUCCESS;
+  return std::move(first);
 }
 
-simdjson_inline simdjson_result<fallback::ondemand::json_type> simdjson_result<fallback::ondemand::document>::type() noexcept {
+simdjson_inline simdjson_result<fallback::ondemand::json_type> simdjson_result<fallback::ondemand::value>::type() noexcept {
   if (error()) { return error(); }
   return first.type();
 }
-
-simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document>::is_scalar() noexcept {
+simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::value>::is_scalar() noexcept {
   if (error()) { return error(); }
   return first.is_scalar();
 }
-
-simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document>::is_string() noexcept {
+simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::value>::is_string() noexcept {
   if (error()) { return error(); }
   return first.is_string();
 }
-
-simdjson_inline bool simdjson_result<fallback::ondemand::document>::is_negative() noexcept {
+simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::value>::is_negative() noexcept {
   if (error()) { return error(); }
   return first.is_negative();
 }
-
-simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document>::is_integer() noexcept {
+simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::value>::is_integer() noexcept {
   if (error()) { return error(); }
   return first.is_integer();
 }
-
-simdjson_inline simdjson_result<fallback::number_type> simdjson_result<fallback::ondemand::document>::get_number_type() noexcept {
+simdjson_inline simdjson_result<fallback::number_type> simdjson_result<fallback::ondemand::value>::get_number_type() noexcept {
   if (error()) { return error(); }
   return first.get_number_type();
 }
-
-simdjson_inline simdjson_result<fallback::ondemand::number> simdjson_result<fallback::ondemand::document>::get_number() noexcept {
+simdjson_inline simdjson_result<fallback::ondemand::number> simdjson_result<fallback::ondemand::value>::get_number() noexcept {
   if (error()) { return error(); }
   return first.get_number();
 }
-
-
 #if SIMDJSON_EXCEPTIONS
-template <class T, typename std::enable_if<std::is_same<T, fallback::ondemand::document>::value == false>::type>
-simdjson_inline simdjson_result<fallback::ondemand::document>::operator T() noexcept(false) {
-  if (error()) { throw simdjson_error(error()); }
-  return first;
-}
-simdjson_inline simdjson_result<fallback::ondemand::document>::operator fallback::ondemand::array() & noexcept(false) {
+template <class T>
+simdjson_inline simdjson_result<fallback::ondemand::value>::operator T() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get<T>();
 }
-simdjson_inline simdjson_result<fallback::ondemand::document>::operator fallback::ondemand::object() & noexcept(false) {
+simdjson_inline simdjson_result<fallback::ondemand::value>::operator fallback::ondemand::array() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
   return first;
 }
-simdjson_inline simdjson_result<fallback::ondemand::document>::operator uint64_t() noexcept(false) {
+simdjson_inline simdjson_result<fallback::ondemand::value>::operator fallback::ondemand::object() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
   return first;
 }
-simdjson_inline simdjson_result<fallback::ondemand::document>::operator int64_t() noexcept(false) {
+simdjson_inline simdjson_result<fallback::ondemand::value>::operator uint64_t() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
   return first;
 }
-simdjson_inline simdjson_result<fallback::ondemand::document>::operator double() noexcept(false) {
+simdjson_inline simdjson_result<fallback::ondemand::value>::operator int64_t() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
   return first;
 }
-simdjson_inline simdjson_result<fallback::ondemand::document>::operator std::string_view() noexcept(false) {
+simdjson_inline simdjson_result<fallback::ondemand::value>::operator double() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
   return first;
 }
-simdjson_inline simdjson_result<fallback::ondemand::document>::operator fallback::ondemand::raw_json_string() noexcept(false) {
+simdjson_inline simdjson_result<fallback::ondemand::value>::operator std::string_view() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
   return first;
 }
-simdjson_inline simdjson_result<fallback::ondemand::document>::operator bool() noexcept(false) {
+simdjson_inline simdjson_result<fallback::ondemand::value>::operator fallback::ondemand::raw_json_string() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
   return first;
 }
-simdjson_inline simdjson_result<fallback::ondemand::document>::operator fallback::ondemand::value() noexcept(false) {
+simdjson_inline simdjson_result<fallback::ondemand::value>::operator bool() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
   return first;
 }
 #endif
 
-
-simdjson_inline simdjson_result<const char *> simdjson_result<fallback::ondemand::document>::current_location() noexcept {
+simdjson_inline simdjson_result<std::string_view> simdjson_result<fallback::ondemand::value>::raw_json_token() noexcept {
   if (error()) { return error(); }
-  return first.current_location();
+  return first.raw_json_token();
 }
 
-simdjson_inline bool simdjson_result<fallback::ondemand::document>::at_end() const noexcept {
+simdjson_inline simdjson_result<std::string_view> simdjson_result<fallback::ondemand::value>::raw_json() noexcept {
   if (error()) { return error(); }
-  return first.at_end();
+  return first.raw_json();
 }
 
-
-simdjson_inline int32_t simdjson_result<fallback::ondemand::document>::current_depth() const noexcept {
+simdjson_inline simdjson_result<const char *> simdjson_result<fallback::ondemand::value>::current_location() noexcept {
   if (error()) { return error(); }
-  return first.current_depth();
+  return first.current_location();
 }
 
-simdjson_inline simdjson_result<std::string_view> simdjson_result<fallback::ondemand::document>::raw_json_token() noexcept {
+simdjson_inline simdjson_result<int32_t> simdjson_result<fallback::ondemand::value>::current_depth() const noexcept {
   if (error()) { return error(); }
-  return first.raw_json_token();
+  return first.current_depth();
 }
 
-simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document>::at_pointer(std::string_view json_pointer) noexcept {
-  if (error()) { return error(); }
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::value>::at_pointer(
+    std::string_view json_pointer) noexcept {
+  if (error()) {
+      return error();
+  }
   return first.at_pointer(json_pointer);
 }
 
-simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document>::at_path(std::string_view json_path) noexcept {
-  if (error()) { return error(); }
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::value>::at_path(
+      std::string_view json_path) noexcept {
+  if (error()) {
+    return error();
+  }
   return first.at_path(json_path);
 }
 
 } // namespace simdjson
 
+#endif // SIMDJSON_GENERIC_ONDEMAND_VALUE_INL_H
+/* end file simdjson/generic/ondemand/value-inl.h for fallback */
+/* including simdjson/generic/ondemand/document-inl.h for fallback: #include "simdjson/generic/ondemand/document-inl.h" */
+/* begin file simdjson/generic/ondemand/document-inl.h for fallback */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_INL_H
+
+/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_INL_H */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array_iterator.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_type.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/raw_json_string.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value-inl.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array-inl.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_iterator-inl.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/object-inl.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value_iterator-inl.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/deserialize.h" */
+/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
 namespace simdjson {
 namespace fallback {
 namespace ondemand {
 
-simdjson_inline document_reference::document_reference() noexcept : doc{nullptr} {}
-simdjson_inline document_reference::document_reference(document &d) noexcept : doc(&d) {}
-simdjson_inline void document_reference::rewind() noexcept { doc->rewind(); }
-simdjson_inline simdjson_result<array> document_reference::get_array() & noexcept { return doc->get_array(); }
-simdjson_inline simdjson_result<object> document_reference::get_object() & noexcept { return doc->get_object(); }
-/**
- * The document_reference instances are used primarily/solely for streams of JSON
- * documents.
- * We decided that calling 'get_double()' on the JSON document '1.233 blabla' should
- * give an error, so we check for trailing content.
- *
- * However, for streams of JSON documents, we want to be able to start from
- * "321" "321" "321"
- * and parse it successfully as a stream of JSON documents, calling get_uint64_in_string()
- * successfully each time.
- *
- * To achieve this result, we pass a 'false' to a get_root_value_iterator() method:
- * this indicates that we allow trailing content.
- */
-simdjson_inline simdjson_result<uint64_t> document_reference::get_uint64() noexcept { return doc->get_root_value_iterator().get_root_uint64(false); }
-simdjson_inline simdjson_result<uint64_t> document_reference::get_uint64_in_string() noexcept { return doc->get_root_value_iterator().get_root_uint64_in_string(false); }
-simdjson_inline simdjson_result<int64_t> document_reference::get_int64() noexcept { return doc->get_root_value_iterator().get_root_int64(false); }
-simdjson_inline simdjson_result<int64_t> document_reference::get_int64_in_string() noexcept { return doc->get_root_value_iterator().get_root_int64_in_string(false); }
-simdjson_inline simdjson_result<double> document_reference::get_double() noexcept { return doc->get_root_value_iterator().get_root_double(false); }
-simdjson_inline simdjson_result<double> document_reference::get_double_in_string() noexcept { return doc->get_root_value_iterator().get_root_double(false); }
-simdjson_inline simdjson_result<std::string_view> document_reference::get_string(bool allow_replacement) noexcept { return doc->get_root_value_iterator().get_root_string(false, allow_replacement); }
-template <typename string_type>
-simdjson_inline error_code document_reference::get_string(string_type& receiver, bool allow_replacement) noexcept { return doc->get_root_value_iterator().get_root_string(receiver, false, allow_replacement); }
-simdjson_inline simdjson_result<std::string_view> document_reference::get_wobbly_string() noexcept { return doc->get_root_value_iterator().get_root_wobbly_string(false); }
-simdjson_inline simdjson_result<raw_json_string> document_reference::get_raw_json_string() noexcept { return doc->get_root_value_iterator().get_root_raw_json_string(false); }
-simdjson_inline simdjson_result<bool> document_reference::get_bool() noexcept { return doc->get_root_value_iterator().get_root_bool(false); }
-simdjson_inline simdjson_result<value> document_reference::get_value() noexcept { return doc->get_value(); }
-simdjson_inline simdjson_result<bool> document_reference::is_null() noexcept { return doc->get_root_value_iterator().is_root_null(false); }
-template<> simdjson_inline simdjson_result<array> document_reference::get() & noexcept { return get_array(); }
-template<> simdjson_inline simdjson_result<object> document_reference::get() & noexcept { return get_object(); }
-template<> simdjson_inline simdjson_result<raw_json_string> document_reference::get() & noexcept { return get_raw_json_string(); }
-template<> simdjson_inline simdjson_result<std::string_view> document_reference::get() & noexcept { return get_string(false); }
-template<> simdjson_inline simdjson_result<double> document_reference::get() & noexcept { return get_double(); }
-template<> simdjson_inline simdjson_result<uint64_t> document_reference::get() & noexcept { return get_uint64(); }
-template<> simdjson_inline simdjson_result<int64_t> document_reference::get() & noexcept { return get_int64(); }
-template<> simdjson_inline simdjson_result<bool> document_reference::get() & noexcept { return get_bool(); }
-template<> simdjson_inline simdjson_result<value> document_reference::get() & noexcept { return get_value(); }
-#if SIMDJSON_EXCEPTIONS
-template <class T>
-simdjson_inline document_reference::operator T() noexcept(false) { return get<T>(); }
-simdjson_inline document_reference::operator array() & noexcept(false) { return array(*doc); }
-simdjson_inline document_reference::operator object() & noexcept(false) { return object(*doc); }
-simdjson_inline document_reference::operator uint64_t() noexcept(false) { return get_uint64(); }
-simdjson_inline document_reference::operator int64_t() noexcept(false) { return get_int64(); }
-simdjson_inline document_reference::operator double() noexcept(false) { return get_double(); }
-simdjson_inline document_reference::operator std::string_view() noexcept(false) { return std::string_view(*doc); }
-simdjson_inline document_reference::operator raw_json_string() noexcept(false) { return get_raw_json_string(); }
-simdjson_inline document_reference::operator bool() noexcept(false) { return get_bool(); }
-simdjson_inline document_reference::operator value() noexcept(false) { return value(*doc); }
-#endif
-simdjson_inline simdjson_result<size_t> document_reference::count_elements() & noexcept { return doc->count_elements(); }
-simdjson_inline simdjson_result<size_t> document_reference::count_fields() & noexcept { return doc->count_fields(); }
-simdjson_inline simdjson_result<value> document_reference::at(size_t index) & noexcept { return doc->at(index); }
-simdjson_inline simdjson_result<array_iterator> document_reference::begin() & noexcept { return doc->begin(); }
-simdjson_inline simdjson_result<array_iterator> document_reference::end() & noexcept { return doc->end(); }
-simdjson_inline simdjson_result<value> document_reference::find_field(std::string_view key) & noexcept { return doc->find_field(key); }
-simdjson_inline simdjson_result<value> document_reference::find_field(const char *key) & noexcept { return doc->find_field(key); }
-simdjson_inline simdjson_result<value> document_reference::operator[](std::string_view key) & noexcept { return (*doc)[key]; }
-simdjson_inline simdjson_result<value> document_reference::operator[](const char *key) & noexcept { return (*doc)[key]; }
-simdjson_inline simdjson_result<value> document_reference::find_field_unordered(std::string_view key) & noexcept { return doc->find_field_unordered(key); }
-simdjson_inline simdjson_result<value> document_reference::find_field_unordered(const char *key) & noexcept { return doc->find_field_unordered(key); }
-simdjson_inline simdjson_result<json_type> document_reference::type() noexcept { return doc->type(); }
-simdjson_inline simdjson_result<bool> document_reference::is_scalar() noexcept { return doc->is_scalar(); }
-simdjson_inline simdjson_result<bool> document_reference::is_string() noexcept { return doc->is_string(); }
-simdjson_inline simdjson_result<const char *> document_reference::current_location() noexcept { return doc->current_location(); }
-simdjson_inline int32_t document_reference::current_depth() const noexcept { return doc->current_depth(); }
-simdjson_inline bool document_reference::is_negative() noexcept { return doc->is_negative(); }
-simdjson_inline simdjson_result<bool> document_reference::is_integer() noexcept { return doc->get_root_value_iterator().is_root_integer(false); }
-simdjson_inline simdjson_result<number_type> document_reference::get_number_type() noexcept { return doc->get_root_value_iterator().get_root_number_type(false); }
-simdjson_inline simdjson_result<number> document_reference::get_number() noexcept { return doc->get_root_value_iterator().get_root_number(false); }
-simdjson_inline simdjson_result<std::string_view> document_reference::raw_json_token() noexcept { return doc->raw_json_token(); }
-simdjson_inline simdjson_result<value> document_reference::at_pointer(std::string_view json_pointer) noexcept { return doc->at_pointer(json_pointer); }
-simdjson_inline simdjson_result<value> document_reference::at_path(std::string_view json_path) noexcept { return doc->at_path(json_path); }
-simdjson_inline simdjson_result<std::string_view> document_reference::raw_json() noexcept { return doc->raw_json();}
-simdjson_inline document_reference::operator document&() const noexcept { return *doc; }
-
-} // namespace ondemand
-} // namespace fallback
-} // namespace simdjson
-
-
-
-namespace simdjson {
-simdjson_inline simdjson_result<fallback::ondemand::document_reference>::simdjson_result(fallback::ondemand::document_reference value, error_code error)
-  noexcept : implementation_simdjson_result_base<fallback::ondemand::document_reference>(std::forward<fallback::ondemand::document_reference>(value), error) {}
-
-
-simdjson_inline simdjson_result<size_t> simdjson_result<fallback::ondemand::document_reference>::count_elements() & noexcept {
-  if (error()) { return error(); }
-  return first.count_elements();
+simdjson_inline document::document(ondemand::json_iterator &&_iter) noexcept
+  : iter{std::forward<json_iterator>(_iter)}
+{
+  logger::log_start_value(iter, "document");
 }
-simdjson_inline simdjson_result<size_t> simdjson_result<fallback::ondemand::document_reference>::count_fields() & noexcept {
-  if (error()) { return error(); }
-  return first.count_fields();
+
+simdjson_inline document document::start(json_iterator &&iter) noexcept {
+  return document(std::forward<json_iterator>(iter));
 }
-simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document_reference>::at(size_t index) & noexcept {
-  if (error()) { return error(); }
-  return first.at(index);
+
+inline void document::rewind() noexcept {
+  iter.rewind();
 }
-simdjson_inline error_code simdjson_result<fallback::ondemand::document_reference>::rewind() noexcept {
-  if (error()) { return error(); }
-  first.rewind();
-  return SUCCESS;
+
+inline std::string document::to_debug_string() noexcept {
+  return iter.to_string();
 }
-simdjson_inline simdjson_result<fallback::ondemand::array_iterator> simdjson_result<fallback::ondemand::document_reference>::begin() & noexcept {
-  if (error()) { return error(); }
-  return first.begin();
+
+inline simdjson_result<const char *> document::current_location() const noexcept {
+  return iter.current_location();
 }
-simdjson_inline simdjson_result<fallback::ondemand::array_iterator> simdjson_result<fallback::ondemand::document_reference>::end() & noexcept {
-  return {};
+
+inline int32_t document::current_depth() const noexcept {
+  return iter.depth();
 }
-simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document_reference>::find_field_unordered(std::string_view key) & noexcept {
-  if (error()) { return error(); }
-  return first.find_field_unordered(key);
+
+inline bool document::at_end() const noexcept {
+  return iter.at_end();
 }
-simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document_reference>::find_field_unordered(const char *key) & noexcept {
-  if (error()) { return error(); }
-  return first.find_field_unordered(key);
+
+
+inline bool document::is_alive() noexcept {
+  return iter.is_alive();
 }
-simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document_reference>::operator[](std::string_view key) & noexcept {
-  if (error()) { return error(); }
-  return first[key];
+simdjson_inline value_iterator document::resume_value_iterator() noexcept {
+  return value_iterator(&iter, 1, iter.root_position());
 }
-simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document_reference>::operator[](const char *key) & noexcept {
-  if (error()) { return error(); }
-  return first[key];
+simdjson_inline value_iterator document::get_root_value_iterator() noexcept {
+  return resume_value_iterator();
 }
-simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document_reference>::find_field(std::string_view key) & noexcept {
-  if (error()) { return error(); }
-  return first.find_field(key);
+simdjson_inline simdjson_result<object> document::start_or_resume_object() noexcept {
+  if (iter.at_root()) {
+    return get_object();
+  } else {
+    return object::resume(resume_value_iterator());
+  }
 }
-simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document_reference>::find_field(const char *key) & noexcept {
-  if (error()) { return error(); }
-  return first.find_field(key);
+simdjson_inline simdjson_result<value> document::get_value() noexcept {
+  // Make sure we start any arrays or objects before returning, so that start_root_<object/array>()
+  // gets called.
+
+  // It is the convention throughout the code that  the macro `SIMDJSON_DEVELOPMENT_CHECKS` determines whether
+  // we check for OUT_OF_ORDER_ITERATION. Proper on::demand code should never trigger this error.
+#if SIMDJSON_DEVELOPMENT_CHECKS
+  if (!iter.at_root()) { return OUT_OF_ORDER_ITERATION; }
+#endif
+  // assert_at_root() serves two purposes: in Debug mode, whether or not
+  // SIMDJSON_DEVELOPMENT_CHECKS is set or not, it checks that we are at the root of
+  // the document (this will typically be redundant). In release mode, it generates
+  // SIMDJSON_ASSUME statements to allow the compiler to make assumptions.
+  iter.assert_at_root();
+  switch (*iter.peek()) {
+    case '[': {
+      // The following lines check that the document ends with ].
+      auto value_iterator = get_root_value_iterator();
+      auto error = value_iterator.check_root_array();
+      if(error) { return error; }
+      return value(get_root_value_iterator());
+    }
+    case '{': {
+      // The following lines would check that the document ends with }.
+      auto value_iterator = get_root_value_iterator();
+      auto error = value_iterator.check_root_object();
+      if(error) { return error; }
+      return value(get_root_value_iterator());
+    }
+    default:
+      // Unfortunately, scalar documents are a special case in simdjson and they cannot
+      // be safely converted to value instances.
+      return SCALAR_DOCUMENT_AS_VALUE;
+  }
 }
-simdjson_inline simdjson_result<fallback::ondemand::array> simdjson_result<fallback::ondemand::document_reference>::get_array() & noexcept {
-  if (error()) { return error(); }
-  return first.get_array();
+simdjson_inline simdjson_result<array> document::get_array() & noexcept {
+  auto value = get_root_value_iterator();
+  return array::start_root(value);
 }
-simdjson_inline simdjson_result<fallback::ondemand::object> simdjson_result<fallback::ondemand::document_reference>::get_object() & noexcept {
-  if (error()) { return error(); }
-  return first.get_object();
+simdjson_inline simdjson_result<object> document::get_object() & noexcept {
+  auto value = get_root_value_iterator();
+  return object::start_root(value);
 }
-simdjson_inline simdjson_result<uint64_t> simdjson_result<fallback::ondemand::document_reference>::get_uint64() noexcept {
-  if (error()) { return error(); }
-  return first.get_uint64();
+
+/**
+ * We decided that calling 'get_double()' on the JSON document '1.233 blabla' should
+ * give an error, so we check for trailing content. We want to disallow trailing
+ * content.
+ * Thus, in several implementations below, we pass a 'true' parameter value to
+ * a get_root_value_iterator() method: this indicates that we disallow trailing content.
+ */
+
+simdjson_inline simdjson_result<uint64_t> document::get_uint64() noexcept {
+  return get_root_value_iterator().get_root_uint64(true);
 }
-simdjson_inline simdjson_result<uint64_t> simdjson_result<fallback::ondemand::document_reference>::get_uint64_in_string() noexcept {
-  if (error()) { return error(); }
-  return first.get_uint64_in_string();
+simdjson_inline simdjson_result<uint64_t> document::get_uint64_in_string() noexcept {
+  return get_root_value_iterator().get_root_uint64_in_string(true);
 }
-simdjson_inline simdjson_result<int64_t> simdjson_result<fallback::ondemand::document_reference>::get_int64() noexcept {
-  if (error()) { return error(); }
-  return first.get_int64();
+simdjson_inline simdjson_result<int64_t> document::get_int64() noexcept {
+  return get_root_value_iterator().get_root_int64(true);
 }
-simdjson_inline simdjson_result<int64_t> simdjson_result<fallback::ondemand::document_reference>::get_int64_in_string() noexcept {
-  if (error()) { return error(); }
-  return first.get_int64_in_string();
+simdjson_inline simdjson_result<int64_t> document::get_int64_in_string() noexcept {
+  return get_root_value_iterator().get_root_int64_in_string(true);
 }
-simdjson_inline simdjson_result<double> simdjson_result<fallback::ondemand::document_reference>::get_double() noexcept {
-  if (error()) { return error(); }
-  return first.get_double();
+simdjson_inline simdjson_result<double> document::get_double() noexcept {
+  return get_root_value_iterator().get_root_double(true);
 }
-simdjson_inline simdjson_result<double> simdjson_result<fallback::ondemand::document_reference>::get_double_in_string() noexcept {
-  if (error()) { return error(); }
-  return first.get_double_in_string();
+simdjson_inline simdjson_result<double> document::get_double_in_string() noexcept {
+  return get_root_value_iterator().get_root_double_in_string(true);
 }
-simdjson_inline simdjson_result<std::string_view> simdjson_result<fallback::ondemand::document_reference>::get_string(bool allow_replacement) noexcept {
-  if (error()) { return error(); }
-  return first.get_string(allow_replacement);
+simdjson_inline simdjson_result<std::string_view> document::get_string(bool allow_replacement) noexcept {
+  return get_root_value_iterator().get_root_string(true, allow_replacement);
 }
 template <typename string_type>
-simdjson_inline error_code simdjson_result<fallback::ondemand::document_reference>::get_string(string_type& receiver, bool allow_replacement) noexcept {
-  if (error()) { return error(); }
-  return first.get_string(receiver, allow_replacement);
-}
-simdjson_inline simdjson_result<std::string_view> simdjson_result<fallback::ondemand::document_reference>::get_wobbly_string() noexcept {
-  if (error()) { return error(); }
-  return first.get_wobbly_string();
+simdjson_inline error_code document::get_string(string_type& receiver, bool allow_replacement) noexcept {
+  return get_root_value_iterator().get_root_string(receiver, true, allow_replacement);
 }
-simdjson_inline simdjson_result<fallback::ondemand::raw_json_string> simdjson_result<fallback::ondemand::document_reference>::get_raw_json_string() noexcept {
-  if (error()) { return error(); }
-  return first.get_raw_json_string();
+simdjson_inline simdjson_result<std::string_view> document::get_wobbly_string() noexcept {
+  return get_root_value_iterator().get_root_wobbly_string(true);
 }
-simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document_reference>::get_bool() noexcept {
-  if (error()) { return error(); }
-  return first.get_bool();
+simdjson_inline simdjson_result<raw_json_string> document::get_raw_json_string() noexcept {
+  return get_root_value_iterator().get_root_raw_json_string(true);
 }
-simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document_reference>::get_value() noexcept {
-  if (error()) { return error(); }
-  return first.get_value();
+simdjson_inline simdjson_result<bool> document::get_bool() noexcept {
+  return get_root_value_iterator().get_root_bool(true);
 }
-simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document_reference>::is_null() noexcept {
+simdjson_inline simdjson_result<bool> document::is_null() noexcept {
+  return get_root_value_iterator().is_root_null(true);
+}
+
+template<> simdjson_inline simdjson_result<array> document::get() & noexcept { return get_array(); }
+template<> simdjson_inline simdjson_result<object> document::get() & noexcept { return get_object(); }
+template<> simdjson_inline simdjson_result<raw_json_string> document::get() & noexcept { return get_raw_json_string(); }
+template<> simdjson_inline simdjson_result<std::string_view> document::get() & noexcept { return get_string(false); }
+template<> simdjson_inline simdjson_result<double> document::get() & noexcept { return get_double(); }
+template<> simdjson_inline simdjson_result<uint64_t> document::get() & noexcept { return get_uint64(); }
+template<> simdjson_inline simdjson_result<int64_t> document::get() & noexcept { return get_int64(); }
+template<> simdjson_inline simdjson_result<bool> document::get() & noexcept { return get_bool(); }
+template<> simdjson_inline simdjson_result<value> document::get() & noexcept { return get_value(); }
+
+template<> simdjson_inline error_code document::get(array& out) & noexcept { return get_array().get(out); }
+template<> simdjson_inline error_code document::get(object& out) & noexcept { return get_object().get(out); }
+template<> simdjson_inline error_code document::get(raw_json_string& out) & noexcept { return get_raw_json_string().get(out); }
+template<> simdjson_inline error_code document::get(std::string_view& out) & noexcept { return get_string(false).get(out); }
+template<> simdjson_inline error_code document::get(double& out) & noexcept { return get_double().get(out); }
+template<> simdjson_inline error_code document::get(uint64_t& out) & noexcept { return get_uint64().get(out); }
+template<> simdjson_inline error_code document::get(int64_t& out) & noexcept { return get_int64().get(out); }
+template<> simdjson_inline error_code document::get(bool& out) & noexcept { return get_bool().get(out); }
+template<> simdjson_inline error_code document::get(value& out) & noexcept { return get_value().get(out); }
+
+template<> simdjson_deprecated simdjson_inline simdjson_result<raw_json_string> document::get() && noexcept { return get_raw_json_string(); }
+template<> simdjson_deprecated simdjson_inline simdjson_result<std::string_view> document::get() && noexcept { return get_string(false); }
+template<> simdjson_deprecated simdjson_inline simdjson_result<double> document::get() && noexcept { return std::forward<document>(*this).get_double(); }
+template<> simdjson_deprecated simdjson_inline simdjson_result<uint64_t> document::get() && noexcept { return std::forward<document>(*this).get_uint64(); }
+template<> simdjson_deprecated simdjson_inline simdjson_result<int64_t> document::get() && noexcept { return std::forward<document>(*this).get_int64(); }
+template<> simdjson_deprecated simdjson_inline simdjson_result<bool> document::get() && noexcept { return std::forward<document>(*this).get_bool(); }
+template<> simdjson_deprecated simdjson_inline simdjson_result<value> document::get() && noexcept { return get_value(); }
+
+#if SIMDJSON_EXCEPTIONS
+template <class T>
+simdjson_deprecated simdjson_inline document::operator T() && noexcept(false) { return get<T>(); }
+template <class T>
+simdjson_inline document::operator T() & noexcept(false) { return get<T>(); }
+simdjson_inline document::operator array() & noexcept(false) { return get_array(); }
+simdjson_inline document::operator object() & noexcept(false) { return get_object(); }
+simdjson_inline document::operator uint64_t() noexcept(false) { return get_uint64(); }
+simdjson_inline document::operator int64_t() noexcept(false) { return get_int64(); }
+simdjson_inline document::operator double() noexcept(false) { return get_double(); }
+simdjson_inline document::operator std::string_view() noexcept(false) { return get_string(false); }
+simdjson_inline document::operator raw_json_string() noexcept(false) { return get_raw_json_string(); }
+simdjson_inline document::operator bool() noexcept(false) { return get_bool(); }
+simdjson_inline document::operator value() noexcept(false) { return get_value(); }
+
+#endif
+simdjson_inline simdjson_result<size_t> document::count_elements() & noexcept {
+  auto a = get_array();
+  simdjson_result<size_t> answer = a.count_elements();
+  /* If there was an array, we are now left pointing at its first element. */
+  if(answer.error() == SUCCESS) { rewind(); }
+  return answer;
+}
+simdjson_inline simdjson_result<size_t> document::count_fields() & noexcept {
+  auto a = get_object();
+  simdjson_result<size_t> answer = a.count_fields();
+  /* If there was an object, we are now left pointing at its first element. */
+  if(answer.error() == SUCCESS) { rewind(); }
+  return answer;
+}
+simdjson_inline simdjson_result<value> document::at(size_t index) & noexcept {
+  auto a = get_array();
+  return a.at(index);
+}
+simdjson_inline simdjson_result<array_iterator> document::begin() & noexcept {
+  return get_array().begin();
+}
+simdjson_inline simdjson_result<array_iterator> document::end() & noexcept {
+  return {};
+}
+
+simdjson_inline simdjson_result<value> document::find_field(std::string_view key) & noexcept {
+  return start_or_resume_object().find_field(key);
+}
+simdjson_inline simdjson_result<value> document::find_field(const char *key) & noexcept {
+  return start_or_resume_object().find_field(key);
+}
+simdjson_inline simdjson_result<value> document::find_field_unordered(std::string_view key) & noexcept {
+  return start_or_resume_object().find_field_unordered(key);
+}
+simdjson_inline simdjson_result<value> document::find_field_unordered(const char *key) & noexcept {
+  return start_or_resume_object().find_field_unordered(key);
+}
+simdjson_inline simdjson_result<value> document::operator[](std::string_view key) & noexcept {
+  return start_or_resume_object()[key];
+}
+simdjson_inline simdjson_result<value> document::operator[](const char *key) & noexcept {
+  return start_or_resume_object()[key];
+}
+
+simdjson_inline error_code document::consume() noexcept {
+  bool scalar = false;
+  auto error = is_scalar().get(scalar);
+  if(error) { return error; }
+  if(scalar) {
+    iter.return_current_and_advance();
+    return SUCCESS;
+  }
+  error = iter.skip_child(0);
+  if(error) { iter.abandon(); }
+  return error;
+}
+
+simdjson_inline simdjson_result<std::string_view> document::raw_json() noexcept {
+  auto _iter = get_root_value_iterator();
+  const uint8_t * starting_point{_iter.peek_start()};
+  auto error = consume();
+  if(error) { return error; }
+  // After 'consume()', we could be left pointing just beyond the document, but that
+  // is ok because we are not going to dereference the final pointer position, we just
+  // use it to compute the length in bytes.
+  const uint8_t * final_point{iter.unsafe_pointer()};
+  return std::string_view(reinterpret_cast<const char*>(starting_point), size_t(final_point - starting_point));
+}
+
+simdjson_inline simdjson_result<json_type> document::type() noexcept {
+  return get_root_value_iterator().type();
+}
+
+simdjson_inline simdjson_result<bool> document::is_scalar() noexcept {
+  // For more speed, we could do:
+  // return iter.is_single_token();
+  json_type this_type;
+  auto error = type().get(this_type);
+  if(error) { return error; }
+  return ! ((this_type == json_type::array) || (this_type == json_type::object));
+}
+
+simdjson_inline simdjson_result<bool> document::is_string() noexcept {
+  json_type this_type;
+  auto error = type().get(this_type);
+  if(error) { return error; }
+  return (this_type == json_type::string);
+}
+
+simdjson_inline bool document::is_negative() noexcept {
+  return get_root_value_iterator().is_root_negative();
+}
+
+simdjson_inline simdjson_result<bool> document::is_integer() noexcept {
+  return get_root_value_iterator().is_root_integer(true);
+}
+
+simdjson_inline simdjson_result<number_type> document::get_number_type() noexcept {
+  return get_root_value_iterator().get_root_number_type(true);
+}
+
+simdjson_inline simdjson_result<number> document::get_number() noexcept {
+  return get_root_value_iterator().get_root_number(true);
+}
+
+
+simdjson_inline simdjson_result<std::string_view> document::raw_json_token() noexcept {
+  auto _iter = get_root_value_iterator();
+  return std::string_view(reinterpret_cast<const char*>(_iter.peek_start()), _iter.peek_root_length());
+}
+
+simdjson_inline simdjson_result<value> document::at_pointer(std::string_view json_pointer) noexcept {
+  rewind(); // Rewind the document each time at_pointer is called
+  if (json_pointer.empty()) {
+    return this->get_value();
+  }
+  json_type t;
+  SIMDJSON_TRY(type().get(t));
+  switch (t)
+  {
+    case json_type::array:
+      return (*this).get_array().at_pointer(json_pointer);
+    case json_type::object:
+      return (*this).get_object().at_pointer(json_pointer);
+    default:
+      return INVALID_JSON_POINTER;
+  }
+}
+
+simdjson_inline simdjson_result<value> document::at_path(std::string_view json_path) noexcept {
+  rewind(); // Rewind the document each time at_pointer is called
+  if (json_path.empty()) {
+      return this->get_value();
+  }
+  json_type t;
+  SIMDJSON_TRY(type().get(t));
+  switch (t) {
+  case json_type::array:
+      return (*this).get_array().at_path(json_path);
+  case json_type::object:
+      return (*this).get_object().at_path(json_path);
+  default:
+      return INVALID_JSON_POINTER;
+  }
+}
+
+} // namespace ondemand
+} // namespace fallback
+} // namespace simdjson
+
+namespace simdjson {
+
+simdjson_inline simdjson_result<fallback::ondemand::document>::simdjson_result(
+  fallback::ondemand::document &&value
+) noexcept :
+    implementation_simdjson_result_base<fallback::ondemand::document>(
+      std::forward<fallback::ondemand::document>(value)
+    )
+{
+}
+simdjson_inline simdjson_result<fallback::ondemand::document>::simdjson_result(
+  error_code error
+) noexcept :
+    implementation_simdjson_result_base<fallback::ondemand::document>(
+      error
+    )
+{
+}
+simdjson_inline simdjson_result<size_t> simdjson_result<fallback::ondemand::document>::count_elements() & noexcept {
+  if (error()) { return error(); }
+  return first.count_elements();
+}
+simdjson_inline simdjson_result<size_t> simdjson_result<fallback::ondemand::document>::count_fields() & noexcept {
+  if (error()) { return error(); }
+  return first.count_fields();
+}
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document>::at(size_t index) & noexcept {
+  if (error()) { return error(); }
+  return first.at(index);
+}
+simdjson_inline error_code simdjson_result<fallback::ondemand::document>::rewind() noexcept {
+  if (error()) { return error(); }
+  first.rewind();
+  return SUCCESS;
+}
+simdjson_inline simdjson_result<fallback::ondemand::array_iterator> simdjson_result<fallback::ondemand::document>::begin() & noexcept {
+  if (error()) { return error(); }
+  return first.begin();
+}
+simdjson_inline simdjson_result<fallback::ondemand::array_iterator> simdjson_result<fallback::ondemand::document>::end() & noexcept {
+  return {};
+}
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document>::find_field_unordered(std::string_view key) & noexcept {
+  if (error()) { return error(); }
+  return first.find_field_unordered(key);
+}
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document>::find_field_unordered(const char *key) & noexcept {
+  if (error()) { return error(); }
+  return first.find_field_unordered(key);
+}
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document>::operator[](std::string_view key) & noexcept {
+  if (error()) { return error(); }
+  return first[key];
+}
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document>::operator[](const char *key) & noexcept {
+  if (error()) { return error(); }
+  return first[key];
+}
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document>::find_field(std::string_view key) & noexcept {
+  if (error()) { return error(); }
+  return first.find_field(key);
+}
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document>::find_field(const char *key) & noexcept {
+  if (error()) { return error(); }
+  return first.find_field(key);
+}
+simdjson_inline simdjson_result<fallback::ondemand::array> simdjson_result<fallback::ondemand::document>::get_array() & noexcept {
+  if (error()) { return error(); }
+  return first.get_array();
+}
+simdjson_inline simdjson_result<fallback::ondemand::object> simdjson_result<fallback::ondemand::document>::get_object() & noexcept {
+  if (error()) { return error(); }
+  return first.get_object();
+}
+simdjson_inline simdjson_result<uint64_t> simdjson_result<fallback::ondemand::document>::get_uint64() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint64();
+}
+simdjson_inline simdjson_result<uint64_t> simdjson_result<fallback::ondemand::document>::get_uint64_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint64_in_string();
+}
+simdjson_inline simdjson_result<int64_t> simdjson_result<fallback::ondemand::document>::get_int64() noexcept {
+  if (error()) { return error(); }
+  return first.get_int64();
+}
+simdjson_inline simdjson_result<int64_t> simdjson_result<fallback::ondemand::document>::get_int64_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_int64_in_string();
+}
+simdjson_inline simdjson_result<double> simdjson_result<fallback::ondemand::document>::get_double() noexcept {
+  if (error()) { return error(); }
+  return first.get_double();
+}
+simdjson_inline simdjson_result<double> simdjson_result<fallback::ondemand::document>::get_double_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_double_in_string();
+}
+simdjson_inline simdjson_result<std::string_view> simdjson_result<fallback::ondemand::document>::get_string(bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.get_string(allow_replacement);
+}
+template <typename string_type>
+simdjson_inline error_code simdjson_result<fallback::ondemand::document>::get_string(string_type& receiver, bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.get_string(receiver, allow_replacement);
+}
+simdjson_inline simdjson_result<std::string_view> simdjson_result<fallback::ondemand::document>::get_wobbly_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_wobbly_string();
+}
+simdjson_inline simdjson_result<fallback::ondemand::raw_json_string> simdjson_result<fallback::ondemand::document>::get_raw_json_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_raw_json_string();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document>::get_bool() noexcept {
+  if (error()) { return error(); }
+  return first.get_bool();
+}
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document>::get_value() noexcept {
+  if (error()) { return error(); }
+  return first.get_value();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document>::is_null() noexcept {
   if (error()) { return error(); }
   return first.is_null();
 }
+
 template<typename T>
-simdjson_inline simdjson_result<T> simdjson_result<fallback::ondemand::document_reference>::get() & noexcept {
+simdjson_inline simdjson_result<T> simdjson_result<fallback::ondemand::document>::get() & noexcept {
   if (error()) { return error(); }
   return first.get<T>();
 }
 template<typename T>
-simdjson_inline simdjson_result<T> simdjson_result<fallback::ondemand::document_reference>::get() && noexcept {
+simdjson_deprecated simdjson_inline simdjson_result<T> simdjson_result<fallback::ondemand::document>::get() && noexcept {
   if (error()) { return error(); }
-  return std::forward<fallback::ondemand::document_reference>(first).get<T>();
+  return std::forward<fallback::ondemand::document>(first).get<T>();
 }
-template <class T>
-simdjson_inline error_code simdjson_result<fallback::ondemand::document_reference>::get(T &out) & noexcept {
+template<typename T>
+simdjson_inline error_code simdjson_result<fallback::ondemand::document>::get(T &out) & noexcept {
   if (error()) { return error(); }
   return first.get<T>(out);
 }
-template <class T>
-simdjson_inline error_code simdjson_result<fallback::ondemand::document_reference>::get(T &out) && noexcept {
+template<typename T>
+simdjson_inline error_code simdjson_result<fallback::ondemand::document>::get(T &out) && noexcept {
   if (error()) { return error(); }
-  return std::forward<fallback::ondemand::document_reference>(first).get<T>(out);
+  return std::forward<fallback::ondemand::document>(first).get<T>(out);
 }
-simdjson_inline simdjson_result<fallback::ondemand::json_type> simdjson_result<fallback::ondemand::document_reference>::type() noexcept {
+
+template<> simdjson_inline simdjson_result<fallback::ondemand::document> simdjson_result<fallback::ondemand::document>::get<fallback::ondemand::document>() & noexcept = delete;
+template<> simdjson_deprecated simdjson_inline simdjson_result<fallback::ondemand::document> simdjson_result<fallback::ondemand::document>::get<fallback::ondemand::document>() && noexcept {
   if (error()) { return error(); }
-  return first.type();
+  return std::forward<fallback::ondemand::document>(first);
 }
-simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document_reference>::is_scalar() noexcept {
+template<> simdjson_inline error_code simdjson_result<fallback::ondemand::document>::get<fallback::ondemand::document>(fallback::ondemand::document &out) & noexcept = delete;
+template<> simdjson_inline error_code simdjson_result<fallback::ondemand::document>::get<fallback::ondemand::document>(fallback::ondemand::document &out) && noexcept {
   if (error()) { return error(); }
-  return first.is_scalar();
+  out = std::forward<fallback::ondemand::document>(first);
+  return SUCCESS;
 }
-simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document_reference>::is_string() noexcept {
+
+simdjson_inline simdjson_result<fallback::ondemand::json_type> simdjson_result<fallback::ondemand::document>::type() noexcept {
   if (error()) { return error(); }
-  return first.is_string();
+  return first.type();
 }
-template <>
-simdjson_inline error_code simdjson_result<fallback::ondemand::document_reference>::get(fallback::ondemand::document_reference &out) & noexcept {
+
+simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document>::is_scalar() noexcept {
   if (error()) { return error(); }
-  out = first;
-  return SUCCESS;
+  return first.is_scalar();
 }
-template <>
-simdjson_inline error_code simdjson_result<fallback::ondemand::document_reference>::get(fallback::ondemand::document_reference &out) && noexcept {
+
+simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document>::is_string() noexcept {
   if (error()) { return error(); }
-  out = first;
-  return SUCCESS;
+  return first.is_string();
 }
-simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document_reference>::is_negative() noexcept {
+
+simdjson_inline bool simdjson_result<fallback::ondemand::document>::is_negative() noexcept {
   if (error()) { return error(); }
   return first.is_negative();
 }
-simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document_reference>::is_integer() noexcept {
+
+simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document>::is_integer() noexcept {
   if (error()) { return error(); }
   return first.is_integer();
 }
-simdjson_inline simdjson_result<fallback::number_type> simdjson_result<fallback::ondemand::document_reference>::get_number_type() noexcept {
+
+simdjson_inline simdjson_result<fallback::number_type> simdjson_result<fallback::ondemand::document>::get_number_type() noexcept {
   if (error()) { return error(); }
   return first.get_number_type();
 }
-simdjson_inline simdjson_result<fallback::ondemand::number> simdjson_result<fallback::ondemand::document_reference>::get_number() noexcept {
+
+simdjson_inline simdjson_result<fallback::ondemand::number> simdjson_result<fallback::ondemand::document>::get_number() noexcept {
   if (error()) { return error(); }
   return first.get_number();
 }
+
+
 #if SIMDJSON_EXCEPTIONS
-template <class T>
-simdjson_inline simdjson_result<fallback::ondemand::document_reference>::operator T() noexcept(false) {
-  static_assert(std::is_same<T, fallback::ondemand::document_reference>::value == false, "You should not call get<T> when T is a document");
-  static_assert(std::is_same<T, fallback::ondemand::document>::value == false, "You should not call get<T> when T is a document");
+template <class T, typename std::enable_if<std::is_same<T, fallback::ondemand::document>::value == false>::type>
+simdjson_inline simdjson_result<fallback::ondemand::document>::operator T() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
   return first.get<T>();
 }
-simdjson_inline simdjson_result<fallback::ondemand::document_reference>::operator fallback::ondemand::array() & noexcept(false) {
+simdjson_inline simdjson_result<fallback::ondemand::document>::operator fallback::ondemand::array() & noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
   return first;
 }
-simdjson_inline simdjson_result<fallback::ondemand::document_reference>::operator fallback::ondemand::object() & noexcept(false) {
+simdjson_inline simdjson_result<fallback::ondemand::document>::operator fallback::ondemand::object() & noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
   return first;
 }
-simdjson_inline simdjson_result<fallback::ondemand::document_reference>::operator uint64_t() noexcept(false) {
+simdjson_inline simdjson_result<fallback::ondemand::document>::operator uint64_t() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
   return first;
 }
-simdjson_inline simdjson_result<fallback::ondemand::document_reference>::operator int64_t() noexcept(false) {
+simdjson_inline simdjson_result<fallback::ondemand::document>::operator int64_t() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
   return first;
 }
-simdjson_inline simdjson_result<fallback::ondemand::document_reference>::operator double() noexcept(false) {
+simdjson_inline simdjson_result<fallback::ondemand::document>::operator double() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
   return first;
 }
-simdjson_inline simdjson_result<fallback::ondemand::document_reference>::operator std::string_view() noexcept(false) {
+simdjson_inline simdjson_result<fallback::ondemand::document>::operator std::string_view() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
   return first;
 }
-simdjson_inline simdjson_result<fallback::ondemand::document_reference>::operator fallback::ondemand::raw_json_string() noexcept(false) {
+simdjson_inline simdjson_result<fallback::ondemand::document>::operator fallback::ondemand::raw_json_string() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
   return first;
 }
-simdjson_inline simdjson_result<fallback::ondemand::document_reference>::operator bool() noexcept(false) {
+simdjson_inline simdjson_result<fallback::ondemand::document>::operator bool() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
   return first;
 }
-simdjson_inline simdjson_result<fallback::ondemand::document_reference>::operator fallback::ondemand::value() noexcept(false) {
+simdjson_inline simdjson_result<fallback::ondemand::document>::operator fallback::ondemand::value() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
   return first;
 }
 #endif
 
-simdjson_inline simdjson_result<const char *> simdjson_result<fallback::ondemand::document_reference>::current_location() noexcept {
+
+simdjson_inline simdjson_result<const char *> simdjson_result<fallback::ondemand::document>::current_location() noexcept {
   if (error()) { return error(); }
   return first.current_location();
 }
 
-simdjson_inline simdjson_result<std::string_view> simdjson_result<fallback::ondemand::document_reference>::raw_json_token() noexcept {
+simdjson_inline bool simdjson_result<fallback::ondemand::document>::at_end() const noexcept {
+  if (error()) { return error(); }
+  return first.at_end();
+}
+
+
+simdjson_inline int32_t simdjson_result<fallback::ondemand::document>::current_depth() const noexcept {
+  if (error()) { return error(); }
+  return first.current_depth();
+}
+
+simdjson_inline simdjson_result<std::string_view> simdjson_result<fallback::ondemand::document>::raw_json_token() noexcept {
   if (error()) { return error(); }
   return first.raw_json_token();
 }
 
-simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document_reference>::at_pointer(std::string_view json_pointer) noexcept {
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document>::at_pointer(std::string_view json_pointer) noexcept {
   if (error()) { return error(); }
   return first.at_pointer(json_pointer);
 }
 
-simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document_reference>::at_path(std::string_view json_path) noexcept {
-  if (error()) {
-      return error();
-  }
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document>::at_path(std::string_view json_path) noexcept {
+  if (error()) { return error(); }
   return first.at_path(json_path);
 }
 
 } // namespace simdjson
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_INL_H
-/* end file simdjson/generic/ondemand/document-inl.h for fallback */
-/* including simdjson/generic/ondemand/document_stream-inl.h for fallback: #include "simdjson/generic/ondemand/document_stream-inl.h" */
-/* begin file simdjson/generic/ondemand/document_stream-inl.h for fallback */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_STREAM_INL_H
-
-/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_STREAM_INL_H */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document_stream.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document-inl.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/implementation_simdjson_result_base-inl.h" */
-/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
-
-#include <algorithm>
-#include <stdexcept>
 
 namespace simdjson {
 namespace fallback {
 namespace ondemand {
 
-#ifdef SIMDJSON_THREADS_ENABLED
-
-inline void stage1_worker::finish() {
-  // After calling "run" someone would call finish() to wait
-  // for the end of the processing.
-  // This function will wait until either the thread has done
-  // the processing or, else, the destructor has been called.
-  std::unique_lock<std::mutex> lock(locking_mutex);
-  cond_var.wait(lock, [this]{return has_work == false;});
-}
-
-inline stage1_worker::~stage1_worker() {
-  // The thread may never outlive the stage1_worker instance
-  // and will always be stopped/joined before the stage1_worker
-  // instance is gone.
-  stop_thread();
-}
-
-inline void stage1_worker::start_thread() {
-  std::unique_lock<std::mutex> lock(locking_mutex);
-  if(thread.joinable()) {
-    return; // This should never happen but we never want to create more than one thread.
-  }
-  thread = std::thread([this]{
-      while(true) {
-        std::unique_lock<std::mutex> thread_lock(locking_mutex);
-        // We wait for either "run" or "stop_thread" to be called.
-        cond_var.wait(thread_lock, [this]{return has_work || !can_work;});
-        // If, for some reason, the stop_thread() method was called (i.e., the
-        // destructor of stage1_worker is called, then we want to immediately destroy
-        // the thread (and not do any more processing).
-        if(!can_work) {
-          break;
-        }
-        this->owner->stage1_thread_error = this->owner->run_stage1(*this->stage1_thread_parser,
-              this->_next_batch_start);
-        this->has_work = false;
-        // The condition variable call should be moved after thread_lock.unlock() for performance
-        // reasons but thread sanitizers may report it as a data race if we do.
-        // See https://stackoverflow.com/questions/35775501/c-should-condition-variable-be-notified-under-lock
-        cond_var.notify_one(); // will notify "finish"
-        thread_lock.unlock();
-      }
-    }
-  );
-}
-
-
-inline void stage1_worker::stop_thread() {
-  std::unique_lock<std::mutex> lock(locking_mutex);
-  // We have to make sure that all locks can be released.
-  can_work = false;
-  has_work = false;
-  cond_var.notify_all();
-  lock.unlock();
-  if(thread.joinable()) {
-    thread.join();
-  }
-}
-
-inline void stage1_worker::run(document_stream * ds, parser * stage1, size_t next_batch_start) {
-  std::unique_lock<std::mutex> lock(locking_mutex);
-  owner = ds;
+simdjson_inline document_reference::document_reference() noexcept : doc{nullptr} {}
+simdjson_inline document_reference::document_reference(document &d) noexcept : doc(&d) {}
+simdjson_inline void document_reference::rewind() noexcept { doc->rewind(); }
+simdjson_inline simdjson_result<array> document_reference::get_array() & noexcept { return doc->get_array(); }
+simdjson_inline simdjson_result<object> document_reference::get_object() & noexcept { return doc->get_object(); }
+/**
+ * The document_reference instances are used primarily/solely for streams of JSON
+ * documents.
+ * We decided that calling 'get_double()' on the JSON document '1.233 blabla' should
+ * give an error, so we check for trailing content.
+ *
+ * However, for streams of JSON documents, we want to be able to start from
+ * "321" "321" "321"
+ * and parse it successfully as a stream of JSON documents, calling get_uint64_in_string()
+ * successfully each time.
+ *
+ * To achieve this result, we pass a 'false' to a get_root_value_iterator() method:
+ * this indicates that we allow trailing content.
+ */
+simdjson_inline simdjson_result<uint64_t> document_reference::get_uint64() noexcept { return doc->get_root_value_iterator().get_root_uint64(false); }
+simdjson_inline simdjson_result<uint64_t> document_reference::get_uint64_in_string() noexcept { return doc->get_root_value_iterator().get_root_uint64_in_string(false); }
+simdjson_inline simdjson_result<int64_t> document_reference::get_int64() noexcept { return doc->get_root_value_iterator().get_root_int64(false); }
+simdjson_inline simdjson_result<int64_t> document_reference::get_int64_in_string() noexcept { return doc->get_root_value_iterator().get_root_int64_in_string(false); }
+simdjson_inline simdjson_result<double> document_reference::get_double() noexcept { return doc->get_root_value_iterator().get_root_double(false); }
+simdjson_inline simdjson_result<double> document_reference::get_double_in_string() noexcept { return doc->get_root_value_iterator().get_root_double(false); }
+simdjson_inline simdjson_result<std::string_view> document_reference::get_string(bool allow_replacement) noexcept { return doc->get_root_value_iterator().get_root_string(false, allow_replacement); }
+template <typename string_type>
+simdjson_inline error_code document_reference::get_string(string_type& receiver, bool allow_replacement) noexcept { return doc->get_root_value_iterator().get_root_string(receiver, false, allow_replacement); }
+simdjson_inline simdjson_result<std::string_view> document_reference::get_wobbly_string() noexcept { return doc->get_root_value_iterator().get_root_wobbly_string(false); }
+simdjson_inline simdjson_result<raw_json_string> document_reference::get_raw_json_string() noexcept { return doc->get_root_value_iterator().get_root_raw_json_string(false); }
+simdjson_inline simdjson_result<bool> document_reference::get_bool() noexcept { return doc->get_root_value_iterator().get_root_bool(false); }
+simdjson_inline simdjson_result<value> document_reference::get_value() noexcept { return doc->get_value(); }
+simdjson_inline simdjson_result<bool> document_reference::is_null() noexcept { return doc->get_root_value_iterator().is_root_null(false); }
+template<> simdjson_inline simdjson_result<array> document_reference::get() & noexcept { return get_array(); }
+template<> simdjson_inline simdjson_result<object> document_reference::get() & noexcept { return get_object(); }
+template<> simdjson_inline simdjson_result<raw_json_string> document_reference::get() & noexcept { return get_raw_json_string(); }
+template<> simdjson_inline simdjson_result<std::string_view> document_reference::get() & noexcept { return get_string(false); }
+template<> simdjson_inline simdjson_result<double> document_reference::get() & noexcept { return get_double(); }
+template<> simdjson_inline simdjson_result<uint64_t> document_reference::get() & noexcept { return get_uint64(); }
+template<> simdjson_inline simdjson_result<int64_t> document_reference::get() & noexcept { return get_int64(); }
+template<> simdjson_inline simdjson_result<bool> document_reference::get() & noexcept { return get_bool(); }
+template<> simdjson_inline simdjson_result<value> document_reference::get() & noexcept { return get_value(); }
+#if SIMDJSON_EXCEPTIONS
+template <class T>
+simdjson_inline document_reference::operator T() noexcept(false) { return get<T>(); }
+simdjson_inline document_reference::operator array() & noexcept(false) { return array(*doc); }
+simdjson_inline document_reference::operator object() & noexcept(false) { return object(*doc); }
+simdjson_inline document_reference::operator uint64_t() noexcept(false) { return get_uint64(); }
+simdjson_inline document_reference::operator int64_t() noexcept(false) { return get_int64(); }
+simdjson_inline document_reference::operator double() noexcept(false) { return get_double(); }
+simdjson_inline document_reference::operator std::string_view() noexcept(false) { return std::string_view(*doc); }
+simdjson_inline document_reference::operator raw_json_string() noexcept(false) { return get_raw_json_string(); }
+simdjson_inline document_reference::operator bool() noexcept(false) { return get_bool(); }
+simdjson_inline document_reference::operator value() noexcept(false) { return value(*doc); }
+#endif
+simdjson_inline simdjson_result<size_t> document_reference::count_elements() & noexcept { return doc->count_elements(); }
+simdjson_inline simdjson_result<size_t> document_reference::count_fields() & noexcept { return doc->count_fields(); }
+simdjson_inline simdjson_result<value> document_reference::at(size_t index) & noexcept { return doc->at(index); }
+simdjson_inline simdjson_result<array_iterator> document_reference::begin() & noexcept { return doc->begin(); }
+simdjson_inline simdjson_result<array_iterator> document_reference::end() & noexcept { return doc->end(); }
+simdjson_inline simdjson_result<value> document_reference::find_field(std::string_view key) & noexcept { return doc->find_field(key); }
+simdjson_inline simdjson_result<value> document_reference::find_field(const char *key) & noexcept { return doc->find_field(key); }
+simdjson_inline simdjson_result<value> document_reference::operator[](std::string_view key) & noexcept { return (*doc)[key]; }
+simdjson_inline simdjson_result<value> document_reference::operator[](const char *key) & noexcept { return (*doc)[key]; }
+simdjson_inline simdjson_result<value> document_reference::find_field_unordered(std::string_view key) & noexcept { return doc->find_field_unordered(key); }
+simdjson_inline simdjson_result<value> document_reference::find_field_unordered(const char *key) & noexcept { return doc->find_field_unordered(key); }
+simdjson_inline simdjson_result<json_type> document_reference::type() noexcept { return doc->type(); }
+simdjson_inline simdjson_result<bool> document_reference::is_scalar() noexcept { return doc->is_scalar(); }
+simdjson_inline simdjson_result<bool> document_reference::is_string() noexcept { return doc->is_string(); }
+simdjson_inline simdjson_result<const char *> document_reference::current_location() noexcept { return doc->current_location(); }
+simdjson_inline int32_t document_reference::current_depth() const noexcept { return doc->current_depth(); }
+simdjson_inline bool document_reference::is_negative() noexcept { return doc->is_negative(); }
+simdjson_inline simdjson_result<bool> document_reference::is_integer() noexcept { return doc->get_root_value_iterator().is_root_integer(false); }
+simdjson_inline simdjson_result<number_type> document_reference::get_number_type() noexcept { return doc->get_root_value_iterator().get_root_number_type(false); }
+simdjson_inline simdjson_result<number> document_reference::get_number() noexcept { return doc->get_root_value_iterator().get_root_number(false); }
+simdjson_inline simdjson_result<std::string_view> document_reference::raw_json_token() noexcept { return doc->raw_json_token(); }
+simdjson_inline simdjson_result<value> document_reference::at_pointer(std::string_view json_pointer) noexcept { return doc->at_pointer(json_pointer); }
+simdjson_inline simdjson_result<value> document_reference::at_path(std::string_view json_path) noexcept { return doc->at_path(json_path); }
+simdjson_inline simdjson_result<std::string_view> document_reference::raw_json() noexcept { return doc->raw_json();}
+simdjson_inline document_reference::operator document&() const noexcept { return *doc; }
+
+} // namespace ondemand
+} // namespace fallback
+} // namespace simdjson
+
+
+
+namespace simdjson {
+simdjson_inline simdjson_result<fallback::ondemand::document_reference>::simdjson_result(fallback::ondemand::document_reference value, error_code error)
+  noexcept : implementation_simdjson_result_base<fallback::ondemand::document_reference>(std::forward<fallback::ondemand::document_reference>(value), error) {}
+
+
+simdjson_inline simdjson_result<size_t> simdjson_result<fallback::ondemand::document_reference>::count_elements() & noexcept {
+  if (error()) { return error(); }
+  return first.count_elements();
+}
+simdjson_inline simdjson_result<size_t> simdjson_result<fallback::ondemand::document_reference>::count_fields() & noexcept {
+  if (error()) { return error(); }
+  return first.count_fields();
+}
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document_reference>::at(size_t index) & noexcept {
+  if (error()) { return error(); }
+  return first.at(index);
+}
+simdjson_inline error_code simdjson_result<fallback::ondemand::document_reference>::rewind() noexcept {
+  if (error()) { return error(); }
+  first.rewind();
+  return SUCCESS;
+}
+simdjson_inline simdjson_result<fallback::ondemand::array_iterator> simdjson_result<fallback::ondemand::document_reference>::begin() & noexcept {
+  if (error()) { return error(); }
+  return first.begin();
+}
+simdjson_inline simdjson_result<fallback::ondemand::array_iterator> simdjson_result<fallback::ondemand::document_reference>::end() & noexcept {
+  return {};
+}
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document_reference>::find_field_unordered(std::string_view key) & noexcept {
+  if (error()) { return error(); }
+  return first.find_field_unordered(key);
+}
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document_reference>::find_field_unordered(const char *key) & noexcept {
+  if (error()) { return error(); }
+  return first.find_field_unordered(key);
+}
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document_reference>::operator[](std::string_view key) & noexcept {
+  if (error()) { return error(); }
+  return first[key];
+}
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document_reference>::operator[](const char *key) & noexcept {
+  if (error()) { return error(); }
+  return first[key];
+}
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document_reference>::find_field(std::string_view key) & noexcept {
+  if (error()) { return error(); }
+  return first.find_field(key);
+}
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document_reference>::find_field(const char *key) & noexcept {
+  if (error()) { return error(); }
+  return first.find_field(key);
+}
+simdjson_inline simdjson_result<fallback::ondemand::array> simdjson_result<fallback::ondemand::document_reference>::get_array() & noexcept {
+  if (error()) { return error(); }
+  return first.get_array();
+}
+simdjson_inline simdjson_result<fallback::ondemand::object> simdjson_result<fallback::ondemand::document_reference>::get_object() & noexcept {
+  if (error()) { return error(); }
+  return first.get_object();
+}
+simdjson_inline simdjson_result<uint64_t> simdjson_result<fallback::ondemand::document_reference>::get_uint64() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint64();
+}
+simdjson_inline simdjson_result<uint64_t> simdjson_result<fallback::ondemand::document_reference>::get_uint64_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint64_in_string();
+}
+simdjson_inline simdjson_result<int64_t> simdjson_result<fallback::ondemand::document_reference>::get_int64() noexcept {
+  if (error()) { return error(); }
+  return first.get_int64();
+}
+simdjson_inline simdjson_result<int64_t> simdjson_result<fallback::ondemand::document_reference>::get_int64_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_int64_in_string();
+}
+simdjson_inline simdjson_result<double> simdjson_result<fallback::ondemand::document_reference>::get_double() noexcept {
+  if (error()) { return error(); }
+  return first.get_double();
+}
+simdjson_inline simdjson_result<double> simdjson_result<fallback::ondemand::document_reference>::get_double_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_double_in_string();
+}
+simdjson_inline simdjson_result<std::string_view> simdjson_result<fallback::ondemand::document_reference>::get_string(bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.get_string(allow_replacement);
+}
+template <typename string_type>
+simdjson_inline error_code simdjson_result<fallback::ondemand::document_reference>::get_string(string_type& receiver, bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.get_string(receiver, allow_replacement);
+}
+simdjson_inline simdjson_result<std::string_view> simdjson_result<fallback::ondemand::document_reference>::get_wobbly_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_wobbly_string();
+}
+simdjson_inline simdjson_result<fallback::ondemand::raw_json_string> simdjson_result<fallback::ondemand::document_reference>::get_raw_json_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_raw_json_string();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document_reference>::get_bool() noexcept {
+  if (error()) { return error(); }
+  return first.get_bool();
+}
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document_reference>::get_value() noexcept {
+  if (error()) { return error(); }
+  return first.get_value();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document_reference>::is_null() noexcept {
+  if (error()) { return error(); }
+  return first.is_null();
+}
+template<typename T>
+simdjson_inline simdjson_result<T> simdjson_result<fallback::ondemand::document_reference>::get() & noexcept {
+  if (error()) { return error(); }
+  return first.get<T>();
+}
+template<typename T>
+simdjson_inline simdjson_result<T> simdjson_result<fallback::ondemand::document_reference>::get() && noexcept {
+  if (error()) { return error(); }
+  return std::forward<fallback::ondemand::document_reference>(first).get<T>();
+}
+template <class T>
+simdjson_inline error_code simdjson_result<fallback::ondemand::document_reference>::get(T &out) & noexcept {
+  if (error()) { return error(); }
+  return first.get<T>(out);
+}
+template <class T>
+simdjson_inline error_code simdjson_result<fallback::ondemand::document_reference>::get(T &out) && noexcept {
+  if (error()) { return error(); }
+  return std::forward<fallback::ondemand::document_reference>(first).get<T>(out);
+}
+simdjson_inline simdjson_result<fallback::ondemand::json_type> simdjson_result<fallback::ondemand::document_reference>::type() noexcept {
+  if (error()) { return error(); }
+  return first.type();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document_reference>::is_scalar() noexcept {
+  if (error()) { return error(); }
+  return first.is_scalar();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document_reference>::is_string() noexcept {
+  if (error()) { return error(); }
+  return first.is_string();
+}
+template <>
+simdjson_inline error_code simdjson_result<fallback::ondemand::document_reference>::get(fallback::ondemand::document_reference &out) & noexcept {
+  if (error()) { return error(); }
+  out = first;
+  return SUCCESS;
+}
+template <>
+simdjson_inline error_code simdjson_result<fallback::ondemand::document_reference>::get(fallback::ondemand::document_reference &out) && noexcept {
+  if (error()) { return error(); }
+  out = first;
+  return SUCCESS;
+}
+simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document_reference>::is_negative() noexcept {
+  if (error()) { return error(); }
+  return first.is_negative();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<fallback::ondemand::document_reference>::is_integer() noexcept {
+  if (error()) { return error(); }
+  return first.is_integer();
+}
+simdjson_inline simdjson_result<fallback::number_type> simdjson_result<fallback::ondemand::document_reference>::get_number_type() noexcept {
+  if (error()) { return error(); }
+  return first.get_number_type();
+}
+simdjson_inline simdjson_result<fallback::ondemand::number> simdjson_result<fallback::ondemand::document_reference>::get_number() noexcept {
+  if (error()) { return error(); }
+  return first.get_number();
+}
+#if SIMDJSON_EXCEPTIONS
+template <class T>
+simdjson_inline simdjson_result<fallback::ondemand::document_reference>::operator T() noexcept(false) {
+  static_assert(std::is_same<T, fallback::ondemand::document_reference>::value == false, "You should not call get<T> when T is a document");
+  static_assert(std::is_same<T, fallback::ondemand::document>::value == false, "You should not call get<T> when T is a document");
+  if (error()) { throw simdjson_error(error()); }
+  return first.get<T>();
+}
+simdjson_inline simdjson_result<fallback::ondemand::document_reference>::operator fallback::ondemand::array() & noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<fallback::ondemand::document_reference>::operator fallback::ondemand::object() & noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<fallback::ondemand::document_reference>::operator uint64_t() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<fallback::ondemand::document_reference>::operator int64_t() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<fallback::ondemand::document_reference>::operator double() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<fallback::ondemand::document_reference>::operator std::string_view() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<fallback::ondemand::document_reference>::operator fallback::ondemand::raw_json_string() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<fallback::ondemand::document_reference>::operator bool() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<fallback::ondemand::document_reference>::operator fallback::ondemand::value() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+#endif
+
+simdjson_inline simdjson_result<const char *> simdjson_result<fallback::ondemand::document_reference>::current_location() noexcept {
+  if (error()) { return error(); }
+  return first.current_location();
+}
+
+simdjson_inline simdjson_result<std::string_view> simdjson_result<fallback::ondemand::document_reference>::raw_json_token() noexcept {
+  if (error()) { return error(); }
+  return first.raw_json_token();
+}
+
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document_reference>::at_pointer(std::string_view json_pointer) noexcept {
+  if (error()) { return error(); }
+  return first.at_pointer(json_pointer);
+}
+
+simdjson_inline simdjson_result<fallback::ondemand::value> simdjson_result<fallback::ondemand::document_reference>::at_path(std::string_view json_path) noexcept {
+  if (error()) {
+      return error();
+  }
+  return first.at_path(json_path);
+}
+
+} // namespace simdjson
+
+#endif // SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_INL_H
+/* end file simdjson/generic/ondemand/document-inl.h for fallback */
+/* including simdjson/generic/ondemand/document_stream-inl.h for fallback: #include "simdjson/generic/ondemand/document_stream-inl.h" */
+/* begin file simdjson/generic/ondemand/document_stream-inl.h for fallback */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_STREAM_INL_H
+
+/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_STREAM_INL_H */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document_stream.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document-inl.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/implementation_simdjson_result_base-inl.h" */
+/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
+
+#include <algorithm>
+#include <stdexcept>
+
+namespace simdjson {
+namespace fallback {
+namespace ondemand {
+
+#ifdef SIMDJSON_THREADS_ENABLED
+
+inline void stage1_worker::finish() {
+  // After calling "run" someone would call finish() to wait
+  // for the end of the processing.
+  // This function will wait until either the thread has done
+  // the processing or, else, the destructor has been called.
+  std::unique_lock<std::mutex> lock(locking_mutex);
+  cond_var.wait(lock, [this]{return has_work == false;});
+}
+
+inline stage1_worker::~stage1_worker() {
+  // The thread may never outlive the stage1_worker instance
+  // and will always be stopped/joined before the stage1_worker
+  // instance is gone.
+  stop_thread();
+}
+
+inline void stage1_worker::start_thread() {
+  std::unique_lock<std::mutex> lock(locking_mutex);
+  if(thread.joinable()) {
+    return; // This should never happen but we never want to create more than one thread.
+  }
+  thread = std::thread([this]{
+      while(true) {
+        std::unique_lock<std::mutex> thread_lock(locking_mutex);
+        // We wait for either "run" or "stop_thread" to be called.
+        cond_var.wait(thread_lock, [this]{return has_work || !can_work;});
+        // If, for some reason, the stop_thread() method was called (i.e., the
+        // destructor of stage1_worker is called, then we want to immediately destroy
+        // the thread (and not do any more processing).
+        if(!can_work) {
+          break;
+        }
+        this->owner->stage1_thread_error = this->owner->run_stage1(*this->stage1_thread_parser,
+              this->_next_batch_start);
+        this->has_work = false;
+        // The condition variable call should be moved after thread_lock.unlock() for performance
+        // reasons but thread sanitizers may report it as a data race if we do.
+        // See https://stackoverflow.com/questions/35775501/c-should-condition-variable-be-notified-under-lock
+        cond_var.notify_one(); // will notify "finish"
+        thread_lock.unlock();
+      }
+    }
+  );
+}
+
+
+inline void stage1_worker::stop_thread() {
+  std::unique_lock<std::mutex> lock(locking_mutex);
+  // We have to make sure that all locks can be released.
+  can_work = false;
+  has_work = false;
+  cond_var.notify_all();
+  lock.unlock();
+  if(thread.joinable()) {
+    thread.join();
+  }
+}
+
+inline void stage1_worker::run(document_stream * ds, parser * stage1, size_t next_batch_start) {
+  std::unique_lock<std::mutex> lock(locking_mutex);
+  owner = ds;
   _next_batch_start = next_batch_start;
   stage1_thread_parser = stage1;
   has_work = true;
@@ -51922,36 +52431,39 @@ simdjson_inline const char * raw_json_string::raw() const noexcept { return rein
 
 simdjson_inline bool raw_json_string::is_free_from_unescaped_quote(std::string_view target) noexcept {
   size_t pos{0};
-  // if the content has no escape character, just scan through it quickly!
-  for(;pos < target.size() && target[pos] != '\\';pos++) {}
-  // slow path may begin.
-  bool escaping{false};
-  for(;pos < target.size();pos++) {
-    if((target[pos] == '"') && !escaping) {
-      return false;
-    } else if(target[pos] == '\\') {
-      escaping = !escaping;
-    } else {
-      escaping = false;
+  while(pos < target.size()) {
+    pos = target.find('"', pos);
+    if(pos == std::string_view::npos) { return true; }
+    if(pos != 0 && target[pos-1] != '\\') { return false; }
+    if(pos > 1 && target[pos-2] == '\\') {
+      size_t backslash_count{2};
+      for(size_t i = 3; i <= pos; i++) {
+        if(target[pos-i] == '\\') { backslash_count++; }
+        else { break; }
+      }
+      if(backslash_count % 2 == 0) { return false; }
     }
+    pos++;
   }
   return true;
 }
 
 simdjson_inline bool raw_json_string::is_free_from_unescaped_quote(const char* target) noexcept {
   size_t pos{0};
-  // if the content has no escape character, just scan through it quickly!
-  for(;target[pos] && target[pos] != '\\';pos++) {}
-  // slow path may begin.
-  bool escaping{false};
-  for(;target[pos];pos++) {
-    if((target[pos] == '"') && !escaping) {
-      return false;
-    } else if(target[pos] == '\\') {
-      escaping = !escaping;
-    } else {
-      escaping = false;
+  while(target[pos]) {
+    const char * result = strchr(target+pos, '"');
+    if(result == nullptr) { return true; }
+    pos = result - target;
+    if(pos != 0 && target[pos-1] != '\\') { return false; }
+    if(pos > 1 && target[pos-2] == '\\') {
+      size_t backslash_count{2};
+      for(size_t i = 3; i <= pos; i++) {
+        if(target[pos-i] == '\\') { backslash_count++; }
+        else { break; }
+      }
+      if(backslash_count % 2 == 0) { return false; }
     }
+    pos++;
   }
   return true;
 }
@@ -51963,7 +52475,7 @@ simdjson_inline bool raw_json_string::unsafe_is_equal(size_t length, std::string
 }
 
 simdjson_inline bool raw_json_string::unsafe_is_equal(std::string_view target) const noexcept {
-  // Assumptions: does not contain unescaped quote characters, and
+  // Assumptions: does not contain unescaped quote characters("), and
   // the raw content is quote terminated within a valid JSON string.
   if(target.size() <= SIMDJSON_PADDING) {
     return (raw()[target.size()] == '"') && !memcmp(raw(), target.data(), target.size());
@@ -52054,28 +52566,62 @@ simdjson_unused simdjson_inline bool operator!=(std::string_view c, const raw_js
   return !(a == c);
 }
 
+SIMDJSON_PUSH_DISABLE_WARNINGS
+SIMDJSON_DISABLE_STRICT_OVERFLOW_WARNING
+simdjson_inline object_iterator &object_iterator::operator++() noexcept {
+  // TODO this is a safety rail ... users should exit loops as soon as they receive an error.
+  // Nonetheless, let's see if performance is OK with this if statement--the compiler may give it to us for free.
+  if (!iter.is_open()) { return *this; } // Iterator will be released if there is an error
 
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> raw_json_string::unescape(json_iterator &iter, bool allow_replacement) const noexcept {
-  return iter.unescape(*this, allow_replacement);
-}
+  simdjson_unused error_code error;
+  if ((error = iter.skip_child() )) { return *this; }
 
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> raw_json_string::unescape_wobbly(json_iterator &iter) const noexcept {
-  return iter.unescape_wobbly(*this);
+  simdjson_unused bool has_value;
+  if ((error = iter.has_next_field().get(has_value) )) { return *this; };
+  return *this;
 }
+SIMDJSON_POP_DISABLE_WARNINGS
 
-simdjson_unused simdjson_inline std::ostream &operator<<(std::ostream &out, const raw_json_string &str) noexcept {
-  bool in_escape = false;
-  const char *s = str.raw();
-  while (true) {
-    switch (*s) {
-      case '\\': in_escape = !in_escape; break;
-      case '"': if (in_escape) { in_escape = false; } else { return out; } break;
-      default: if (in_escape) { in_escape = false; }
-    }
-    out << *s;
-    s++;
-  }
-}
+//
+// ### Live States
+//
+// While iterating or looking up values, depth >= iter.depth. at_start may vary. Error is
+// always SUCCESS:
+//
+// - Start: This is the state when the object is first found and the iterator is just past the {.
+//   In this state, at_start == true.
+// - Next: After we hand a scalar value to the user, or an array/object which they then fully
+//   iterate over, the iterator is at the , or } before the next value. In this state,
+//   depth == iter.depth, at_start == false, and error == SUCCESS.
+// - Unfinished Business: When we hand an array/object to the user which they do not fully
+//   iterate over, we need to finish that iteration by skipping child values until we reach the
+//   Next state. In this state, depth > iter.depth, at_start == false, and error == SUCCESS.
+//
+// ## Error States
+//
+// In error states, we will yield exactly one more value before stopping. iter.depth == depth
+// and at_start is always false. We decrement after yielding the error, moving to the Finished
+// state.
+//
+// - Chained Error: When the object iterator is part of an error chain--for example, in
+//   `for (auto tweet : doc["tweets"])`, where the tweet field may be missing or not be an
+//   object--we yield that error in the loop, exactly once. In this state, error != SUCCESS and
+//   iter.depth == depth, and at_start == false. We decrement depth when we yield the error.
+// - Missing Comma Error: When the iterator ++ method discovers there is no comma between fields,
+//   we flag that as an error and treat it exactly the same as a Chained Error. In this state,
+//   error == TAPE_ERROR, iter.depth == depth, and at_start == false.
+//
+// Errors that occur while reading a field to give to the user (such as when the key is not a
+// string or the field is missing a colon) are yielded immediately. Depth is then decremented,
+// moving to the Finished state without transitioning through an Error state at all.
+//
+// ## Terminal State
+//
+// The terminal state has iter.depth < depth. at_start is always false.
+//
+// - Finished: When we have reached a }, we are finished. We signal this by decrementing depth.
+//   In this state, iter.depth < depth, at_start == false, and error == SUCCESS.
+//
 
 } // namespace ondemand
 } // namespace fallback
@@ -52083,343 +52629,235 @@ simdjson_unused simdjson_inline std::ostream &operator<<(std::ostream &out, cons
 
 namespace simdjson {
 
-simdjson_inline simdjson_result<fallback::ondemand::raw_json_string>::simdjson_result(fallback::ondemand::raw_json_string &&value) noexcept
-    : implementation_simdjson_result_base<fallback::ondemand::raw_json_string>(std::forward<fallback::ondemand::raw_json_string>(value)) {}
-simdjson_inline simdjson_result<fallback::ondemand::raw_json_string>::simdjson_result(error_code error) noexcept
-    : implementation_simdjson_result_base<fallback::ondemand::raw_json_string>(error) {}
+simdjson_inline simdjson_result<fallback::ondemand::object_iterator>::simdjson_result(
+  fallback::ondemand::object_iterator &&value
+) noexcept
+  : implementation_simdjson_result_base<fallback::ondemand::object_iterator>(std::forward<fallback::ondemand::object_iterator>(value))
+{
+  first.iter.assert_is_valid();
+}
+simdjson_inline simdjson_result<fallback::ondemand::object_iterator>::simdjson_result(error_code error) noexcept
+  : implementation_simdjson_result_base<fallback::ondemand::object_iterator>({}, error)
+{
+}
 
-simdjson_inline simdjson_result<const char *> simdjson_result<fallback::ondemand::raw_json_string>::raw() const noexcept {
+simdjson_inline simdjson_result<fallback::ondemand::field> simdjson_result<fallback::ondemand::object_iterator>::operator*() noexcept {
   if (error()) { return error(); }
-  return first.raw();
+  return *first;
 }
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> simdjson_result<fallback::ondemand::raw_json_string>::unescape(fallback::ondemand::json_iterator &iter, bool allow_replacement) const noexcept {
-  if (error()) { return error(); }
-  return first.unescape(iter, allow_replacement);
+// If we're iterating and there is an error, return the error once.
+simdjson_inline bool simdjson_result<fallback::ondemand::object_iterator>::operator==(const simdjson_result<fallback::ondemand::object_iterator> &other) const noexcept {
+  if (!first.iter.is_valid()) { return !error(); }
+  return first == other.first;
 }
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> simdjson_result<fallback::ondemand::raw_json_string>::unescape_wobbly(fallback::ondemand::json_iterator &iter) const noexcept {
-  if (error()) { return error(); }
-  return first.unescape_wobbly(iter);
+// If we're iterating and there is an error, return the error once.
+simdjson_inline bool simdjson_result<fallback::ondemand::object_iterator>::operator!=(const simdjson_result<fallback::ondemand::object_iterator> &other) const noexcept {
+  if (!first.iter.is_valid()) { return error(); }
+  return first != other.first;
 }
+// Checks for ']' and ','
+simdjson_inline simdjson_result<fallback::ondemand::object_iterator> &simdjson_result<fallback::ondemand::object_iterator>::operator++() noexcept {
+  // Clear the error if there is one, so we don't yield it twice
+  if (error()) { second = SUCCESS; return *this; }
+  ++first;
+  return *this;
+}
+
 } // namespace simdjson
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_RAW_JSON_STRING_INL_H
-/* end file simdjson/generic/ondemand/raw_json_string-inl.h for fallback */
-/* including simdjson/generic/ondemand/serialization-inl.h for fallback: #include "simdjson/generic/ondemand/serialization-inl.h" */
-/* begin file simdjson/generic/ondemand/serialization-inl.h for fallback */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H
+#endif // SIMDJSON_GENERIC_ONDEMAND_OBJECT_ITERATOR_INL_H
+/* end file simdjson/generic/ondemand/object_iterator-inl.h for fallback */
+/* including simdjson/generic/ondemand/parser-inl.h for fallback: #include "simdjson/generic/ondemand/parser-inl.h" */
+/* begin file simdjson/generic/ondemand/parser-inl.h for fallback */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_PARSER_INL_H
 
 /* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_PARSER_INL_H */
+/* amalgamation skipped (editor-only): #include "simdjson/padded_string.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/padded_string_view.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/implementation.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/internal/dom_parser_implementation.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/dom/base.h" // for MINIMAL_DOCUMENT_CAPACITY */
 /* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document-inl.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_type.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/object.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/serialization.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document_stream.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/parser.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/raw_json_string.h" */
 /* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
 namespace simdjson {
+namespace fallback {
+namespace ondemand {
 
-inline std::string_view trim(const std::string_view str) noexcept {
-  // We can almost surely do better by rolling our own find_first_not_of function.
-  size_t first = str.find_first_not_of(" \t\n\r");
-  // If we have the empty string (just white space), then no trimming is possible, and
-  // we return the empty string_view.
-  if (std::string_view::npos == first) { return std::string_view(); }
-  size_t last = str.find_last_not_of(" \t\n\r");
-  return str.substr(first, (last - first + 1));
-}
-
-
-inline simdjson_result<std::string_view> to_json_string(fallback::ondemand::document& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
+simdjson_inline parser::parser(size_t max_capacity) noexcept
+  : _max_capacity{max_capacity} {
 }
 
-inline simdjson_result<std::string_view> to_json_string(fallback::ondemand::document_reference& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
-}
+simdjson_warn_unused simdjson_inline error_code parser::allocate(size_t new_capacity, size_t new_max_depth) noexcept {
+  if (new_capacity > max_capacity()) { return CAPACITY; }
+  if (string_buf && new_capacity == capacity() && new_max_depth == max_depth()) { return SUCCESS; }
 
-inline simdjson_result<std::string_view> to_json_string(fallback::ondemand::value& x) noexcept {
-  /**
-   * If we somehow receive a value that has already been consumed,
-   * then the following code could be in trouble. E.g., we create
-   * an array as needed, but if an array was already created, then
-   * it could be bad.
-   */
-  using namespace fallback::ondemand;
-  fallback::ondemand::json_type t;
-  auto error = x.type().get(t);
-  if(error != SUCCESS) { return error; }
-  switch (t)
-  {
-    case json_type::array:
-    {
-      fallback::ondemand::array array;
-      error = x.get_array().get(array);
-      if(error) { return error; }
-      return to_json_string(array);
-    }
-    case json_type::object:
-    {
-      fallback::ondemand::object object;
-      error = x.get_object().get(object);
-      if(error) { return error; }
-      return to_json_string(object);
-    }
-    default:
-      return trim(x.raw_json_token());
+  // string_capacity copied from document::allocate
+  _capacity = 0;
+  size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * new_capacity / 3 + SIMDJSON_PADDING, 64);
+  string_buf.reset(new (std::nothrow) uint8_t[string_capacity]);
+#if SIMDJSON_DEVELOPMENT_CHECKS
+  start_positions.reset(new (std::nothrow) token_position[new_max_depth]);
+#endif
+  if (implementation) {
+    SIMDJSON_TRY( implementation->set_capacity(new_capacity) );
+    SIMDJSON_TRY( implementation->set_max_depth(new_max_depth) );
+  } else {
+    SIMDJSON_TRY( simdjson::get_active_implementation()->create_dom_parser_implementation(new_capacity, new_max_depth, implementation) );
   }
+  _capacity = new_capacity;
+  _max_depth = new_max_depth;
+  return SUCCESS;
 }
-
-inline simdjson_result<std::string_view> to_json_string(fallback::ondemand::object& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
-}
-
-inline simdjson_result<std::string_view> to_json_string(fallback::ondemand::array& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
+#if SIMDJSON_DEVELOPMENT_CHECKS
+simdjson_inline simdjson_warn_unused bool parser::string_buffer_overflow(const uint8_t *string_buf_loc) const noexcept {
+  return (string_buf_loc < string_buf.get()) || (size_t(string_buf_loc - string_buf.get()) >= capacity());
 }
+#endif
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<fallback::ondemand::document> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(padded_string_view json) & noexcept {
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<fallback::ondemand::document_reference> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
+  json.remove_utf8_bom();
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<fallback::ondemand::value> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
+  // Allocate if needed
+  if (capacity() < json.length() || !string_buf) {
+    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
+  }
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<fallback::ondemand::object> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
+  // Run stage 1.
+  SIMDJSON_TRY( implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular) );
+  return document::start({ reinterpret_cast<const uint8_t *>(json.data()), this });
 }
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<fallback::ondemand::array> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
-} // namespace simdjson
+#ifdef SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate_allow_incomplete_json(padded_string_view json) & noexcept {
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
-namespace simdjson { namespace fallback { namespace ondemand {
+  json.remove_utf8_bom();
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::fallback::ondemand::value x) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(x).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::fallback::ondemand::value> x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
-}
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::fallback::ondemand::value x) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(x).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
+  // Allocate if needed
+  if (capacity() < json.length() || !string_buf) {
+    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
   }
-}
-#endif
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::fallback::ondemand::array value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::fallback::ondemand::array> x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
-}
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::fallback::ondemand::array value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
+  // Run stage 1.
+  const simdjson::error_code err = implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular);
+  if (err) {
+    if (err != UNCLOSED_STRING)
+      return err;
   }
+  return document::start({ reinterpret_cast<const uint8_t *>(json.data()), this, true });
 }
-#endif
+#endif // SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::fallback::ondemand::document& value)  {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::fallback::ondemand::document_reference& value)  {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::fallback::ondemand::document>&& x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const char *json, size_t len, size_t allocated) & noexcept {
+  return iterate(padded_string_view(json, len, allocated));
 }
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::fallback::ondemand::document_reference>&& x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const uint8_t *json, size_t len, size_t allocated) & noexcept {
+  return iterate(padded_string_view(json, len, allocated));
 }
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::fallback::ondemand::document& value)  {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
-  }
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(std::string_view json, size_t allocated) & noexcept {
+  return iterate(padded_string_view(json, allocated));
 }
-#endif
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::fallback::ondemand::object value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(std::string &json) & noexcept {
+  if(json.capacity() - json.size() < SIMDJSON_PADDING) {
+    json.reserve(json.size() + SIMDJSON_PADDING);
   }
+  return iterate(padded_string_view(json));
 }
-inline std::ostream& operator<<(std::ostream& out,  simdjson::simdjson_result<simdjson::fallback::ondemand::object> x) {
-  if (x.error()) { throw  simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const std::string &json) & noexcept {
+  return iterate(padded_string_view(json));
 }
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::fallback::ondemand::object value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
-  }
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const simdjson_result<padded_string_view> &result) & noexcept {
+  // We don't presently have a way to temporarily get a const T& from a simdjson_result<T> without throwing an exception
+  SIMDJSON_TRY( result.error() );
+  padded_string_view json = result.value_unsafe();
+  return iterate(json);
 }
-#endif
-}}} // namespace simdjson::fallback::ondemand
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H
-/* end file simdjson/generic/ondemand/serialization-inl.h for fallback */
-/* including simdjson/generic/ondemand/token_iterator-inl.h for fallback: #include "simdjson/generic/ondemand/token_iterator-inl.h" */
-/* begin file simdjson/generic/ondemand/token_iterator-inl.h for fallback */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_TOKEN_ITERATOR_INL_H
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const simdjson_result<padded_string> &result) & noexcept {
+  // We don't presently have a way to temporarily get a const T& from a simdjson_result<T> without throwing an exception
+  SIMDJSON_TRY( result.error() );
+  const padded_string &json = result.value_unsafe();
+  return iterate(json);
+}
 
-/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_TOKEN_ITERATOR_INL_H */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/token_iterator.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/implementation_simdjson_result_base-inl.h" */
-/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
+simdjson_warn_unused simdjson_inline simdjson_result<json_iterator> parser::iterate_raw(padded_string_view json) & noexcept {
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
-namespace simdjson {
-namespace fallback {
-namespace ondemand {
+  json.remove_utf8_bom();
 
-simdjson_inline token_iterator::token_iterator(
-  const uint8_t *_buf,
-  token_position position
-) noexcept : buf{_buf}, _position{position}
-{
-}
+  // Allocate if needed
+  if (capacity() < json.length()) {
+    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
+  }
 
-simdjson_inline uint32_t token_iterator::current_offset() const noexcept {
-  return *(_position);
+  // Run stage 1.
+  SIMDJSON_TRY( implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular) );
+  return json_iterator(reinterpret_cast<const uint8_t *>(json.data()), this);
 }
 
-
-simdjson_inline const uint8_t *token_iterator::return_current_and_advance() noexcept {
-  return &buf[*(_position++)];
+inline simdjson_result<document_stream> parser::iterate_many(const uint8_t *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {
+  if(batch_size < MINIMAL_BATCH_SIZE) { batch_size = MINIMAL_BATCH_SIZE; }
+  if((len >= 3) && (std::memcmp(buf, "\xEF\xBB\xBF", 3) == 0)) {
+    buf += 3;
+    len -= 3;
+  }
+  if(allow_comma_separated && batch_size < len) { batch_size = len; }
+  return document_stream(*this, buf, len, batch_size, allow_comma_separated);
 }
-
-simdjson_inline const uint8_t *token_iterator::peek(token_position position) const noexcept {
-  return &buf[*position];
+inline simdjson_result<document_stream> parser::iterate_many(const char *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {
+  return iterate_many(reinterpret_cast<const uint8_t *>(buf), len, batch_size, allow_comma_separated);
 }
-simdjson_inline uint32_t token_iterator::peek_index(token_position position) const noexcept {
-  return *position;
+inline simdjson_result<document_stream> parser::iterate_many(const std::string &s, size_t batch_size, bool allow_comma_separated) noexcept {
+  return iterate_many(s.data(), s.length(), batch_size, allow_comma_separated);
 }
-simdjson_inline uint32_t token_iterator::peek_length(token_position position) const noexcept {
-  return *(position+1) - *position;
+inline simdjson_result<document_stream> parser::iterate_many(const padded_string &s, size_t batch_size, bool allow_comma_separated) noexcept {
+  return iterate_many(s.data(), s.length(), batch_size, allow_comma_separated);
 }
 
-simdjson_inline uint32_t token_iterator::peek_root_length(token_position position) const noexcept {
-  return *(position+2) - *(position) > *(position+1) - *(position) ?
-      *(position+1) - *(position)
-      : *(position+2) - *(position);
-}
-simdjson_inline const uint8_t *token_iterator::peek(int32_t delta) const noexcept {
-  return &buf[*(_position+delta)];
+simdjson_pure simdjson_inline size_t parser::capacity() const noexcept {
+  return _capacity;
 }
-simdjson_inline uint32_t token_iterator::peek_index(int32_t delta) const noexcept {
-  return *(_position+delta);
+simdjson_pure simdjson_inline size_t parser::max_capacity() const noexcept {
+  return _max_capacity;
 }
-simdjson_inline uint32_t token_iterator::peek_length(int32_t delta) const noexcept {
-  return *(_position+delta+1) - *(_position+delta);
+simdjson_pure simdjson_inline size_t parser::max_depth() const noexcept {
+  return _max_depth;
 }
 
-simdjson_inline token_position token_iterator::position() const noexcept {
-  return _position;
-}
-simdjson_inline void token_iterator::set_position(token_position target_position) noexcept {
-  _position = target_position;
+simdjson_inline void parser::set_max_capacity(size_t max_capacity) noexcept {
+  if(max_capacity < dom::MINIMAL_DOCUMENT_CAPACITY) {
+    _max_capacity = max_capacity;
+  } else {
+    _max_capacity = dom::MINIMAL_DOCUMENT_CAPACITY;
+  }
 }
 
-simdjson_inline bool token_iterator::operator==(const token_iterator &other) const noexcept {
-  return _position == other._position;
-}
-simdjson_inline bool token_iterator::operator!=(const token_iterator &other) const noexcept {
-  return _position != other._position;
-}
-simdjson_inline bool token_iterator::operator>(const token_iterator &other) const noexcept {
-  return _position > other._position;
-}
-simdjson_inline bool token_iterator::operator>=(const token_iterator &other) const noexcept {
-  return _position >= other._position;
-}
-simdjson_inline bool token_iterator::operator<(const token_iterator &other) const noexcept {
-  return _position < other._position;
+simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape(raw_json_string in, uint8_t *&dst, bool allow_replacement) const noexcept {
+  uint8_t *end = implementation->parse_string(in.buf, dst, allow_replacement);
+  if (!end) { return STRING_ERROR; }
+  std::string_view result(reinterpret_cast<const char *>(dst), end-dst);
+  dst = end;
+  return result;
 }
-simdjson_inline bool token_iterator::operator<=(const token_iterator &other) const noexcept {
-  return _position <= other._position;
+
+simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape_wobbly(raw_json_string in, uint8_t *&dst) const noexcept {
+  uint8_t *end = implementation->parse_wobbly_string(in.buf, dst);
+  if (!end) { return STRING_ERROR; }
+  std::string_view result(reinterpret_cast<const char *>(dst), end-dst);
+  dst = end;
+  return result;
 }
 
 } // namespace ondemand
@@ -52428,10 +52866,10 @@ simdjson_inline bool token_iterator::operator<=(const token_iterator &other) con
 
 namespace simdjson {
 
-simdjson_inline simdjson_result<fallback::ondemand::token_iterator>::simdjson_result(fallback::ondemand::token_iterator &&value) noexcept
-    : implementation_simdjson_result_base<fallback::ondemand::token_iterator>(std::forward<fallback::ondemand::token_iterator>(value)) {}
-simdjson_inline simdjson_result<fallback::ondemand::token_iterator>::simdjson_result(error_code error) noexcept
-    : implementation_simdjson_result_base<fallback::ondemand::token_iterator>(error) {}
+simdjson_inline simdjson_result<fallback::ondemand::parser>::simdjson_result(fallback::ondemand::parser &&value) noexcept
+    : implementation_simdjson_result_base<fallback::ondemand::parser>(std::forward<fallback::ondemand::parser>(value)) {}
+simdjson_inline simdjson_result<fallback::ondemand::parser>::simdjson_result(error_code error) noexcept
+    : implementation_simdjson_result_base<fallback::ondemand::parser>(error) {}
 
 } // namespace simdjson
 
@@ -52453,6 +52891,7 @@ simdjson_inline simdjson_result<fallback::ondemand::token_iterator>::simdjson_re
 /* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
 namespace simdjson {
+
 namespace fallback {
 namespace ondemand {
 
@@ -52532,6 +52971,7 @@ simdjson_warn_unused simdjson_inline error_code value_iterator::end_container()
     _json_iter->ascend_to(depth()-1);
     return SUCCESS;
 }
+} // namespace simdjson
 
 simdjson_warn_unused simdjson_inline simdjson_result<bool> value_iterator::has_next_field() noexcept {
   assert_at_next();
@@ -60054,6 +60494,496 @@ simdjson_inline simdjson_result<bool> value::is_string() noexcept {
 }
 
 
+simdjson_inline bool value::is_negative() noexcept {
+  return iter.is_negative();
+}
+
+simdjson_inline simdjson_result<bool> value::is_integer() noexcept {
+  return iter.is_integer();
+}
+simdjson_warn_unused simdjson_inline simdjson_result<number_type> value::get_number_type() noexcept {
+  return iter.get_number_type();
+}
+simdjson_warn_unused simdjson_inline simdjson_result<number> value::get_number() noexcept {
+  return iter.get_number();
+}
+
+inline simdjson_result<value> array::at_path(std::string_view json_path) noexcept {
+  auto json_pointer = json_path_to_pointer_conversion(json_path);
+  if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
+  return at_pointer(json_pointer);
+}
+
+simdjson_inline simdjson_result<value> value::at_path(std::string_view json_path) noexcept {
+  json_type t;
+  SIMDJSON_TRY(type().get(t));
+  switch (t) {
+  case json_type::array:
+      return (*this).get_array().at_path(json_path);
+  case json_type::object:
+      return (*this).get_object().at_path(json_path);
+  default:
+      return INVALID_JSON_POINTER;
+  }
+}
+
+} // namespace ondemand
+} // namespace haswell
+} // namespace simdjson
+
+namespace simdjson {
+
+simdjson_inline simdjson_result<haswell::ondemand::value>::simdjson_result(
+  haswell::ondemand::value &&value
+) noexcept :
+    implementation_simdjson_result_base<haswell::ondemand::value>(
+      std::forward<haswell::ondemand::value>(value)
+    )
+{
+}
+simdjson_inline simdjson_result<haswell::ondemand::value>::simdjson_result(
+  error_code error
+) noexcept :
+    implementation_simdjson_result_base<haswell::ondemand::value>(error)
+{
+}
+simdjson_inline simdjson_result<size_t> simdjson_result<haswell::ondemand::value>::count_elements() & noexcept {
+  if (error()) { return error(); }
+  return first.count_elements();
+}
+simdjson_inline simdjson_result<size_t> simdjson_result<haswell::ondemand::value>::count_fields() & noexcept {
+  if (error()) { return error(); }
+  return first.count_fields();
+}
+simdjson_inline simdjson_result<haswell::ondemand::value> simdjson_result<haswell::ondemand::value>::at(size_t index) noexcept {
+  if (error()) { return error(); }
+  return first.at(index);
+}
+simdjson_inline simdjson_result<haswell::ondemand::array_iterator> simdjson_result<haswell::ondemand::value>::begin() & noexcept {
+  if (error()) { return error(); }
+  return first.begin();
+}
+simdjson_inline simdjson_result<haswell::ondemand::array_iterator> simdjson_result<haswell::ondemand::value>::end() & noexcept {
+  if (error()) { return error(); }
+  return {};
+}
+
+simdjson_inline simdjson_result<haswell::ondemand::value> simdjson_result<haswell::ondemand::value>::find_field(std::string_view key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field(key);
+}
+simdjson_inline simdjson_result<haswell::ondemand::value> simdjson_result<haswell::ondemand::value>::find_field(const char *key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field(key);
+}
+
+simdjson_inline simdjson_result<haswell::ondemand::value> simdjson_result<haswell::ondemand::value>::find_field_unordered(std::string_view key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field_unordered(key);
+}
+simdjson_inline simdjson_result<haswell::ondemand::value> simdjson_result<haswell::ondemand::value>::find_field_unordered(const char *key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field_unordered(key);
+}
+
+simdjson_inline simdjson_result<haswell::ondemand::value> simdjson_result<haswell::ondemand::value>::operator[](std::string_view key) noexcept {
+  if (error()) { return error(); }
+  return first[key];
+}
+simdjson_inline simdjson_result<haswell::ondemand::value> simdjson_result<haswell::ondemand::value>::operator[](const char *key) noexcept {
+  if (error()) { return error(); }
+  return first[key];
+}
+
+simdjson_inline simdjson_result<haswell::ondemand::array> simdjson_result<haswell::ondemand::value>::get_array() noexcept {
+  if (error()) { return error(); }
+  return first.get_array();
+}
+simdjson_inline simdjson_result<haswell::ondemand::object> simdjson_result<haswell::ondemand::value>::get_object() noexcept {
+  if (error()) { return error(); }
+  return first.get_object();
+}
+simdjson_inline simdjson_result<uint64_t> simdjson_result<haswell::ondemand::value>::get_uint64() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint64();
+}
+simdjson_inline simdjson_result<uint64_t> simdjson_result<haswell::ondemand::value>::get_uint64_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint64_in_string();
+}
+simdjson_inline simdjson_result<int64_t> simdjson_result<haswell::ondemand::value>::get_int64() noexcept {
+  if (error()) { return error(); }
+  return first.get_int64();
+}
+simdjson_inline simdjson_result<int64_t> simdjson_result<haswell::ondemand::value>::get_int64_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_int64_in_string();
+}
+simdjson_inline simdjson_result<double> simdjson_result<haswell::ondemand::value>::get_double() noexcept {
+  if (error()) { return error(); }
+  return first.get_double();
+}
+simdjson_inline simdjson_result<double> simdjson_result<haswell::ondemand::value>::get_double_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_double_in_string();
+}
+simdjson_inline simdjson_result<std::string_view> simdjson_result<haswell::ondemand::value>::get_string(bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.get_string(allow_replacement);
+}
+template <typename string_type>
+simdjson_inline error_code simdjson_result<haswell::ondemand::value>::get_string(string_type& receiver, bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.get_string(receiver, allow_replacement);
+}
+simdjson_inline simdjson_result<std::string_view> simdjson_result<haswell::ondemand::value>::get_wobbly_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_wobbly_string();
+}
+simdjson_inline simdjson_result<haswell::ondemand::raw_json_string> simdjson_result<haswell::ondemand::value>::get_raw_json_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_raw_json_string();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<haswell::ondemand::value>::get_bool() noexcept {
+  if (error()) { return error(); }
+  return first.get_bool();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<haswell::ondemand::value>::is_null() noexcept {
+  if (error()) { return error(); }
+  return first.is_null();
+}
+
+template<> simdjson_inline error_code simdjson_result<haswell::ondemand::value>::get<haswell::ondemand::value>(haswell::ondemand::value &out) noexcept {
+  if (error()) { return error(); }
+  out = first;
+  return SUCCESS;
+}
+
+template<typename T> simdjson_inline simdjson_result<T> simdjson_result<haswell::ondemand::value>::get() noexcept {
+  if (error()) { return error(); }
+  return first.get<T>();
+}
+template<typename T> simdjson_inline error_code simdjson_result<haswell::ondemand::value>::get(T &out) noexcept {
+  if (error()) { return error(); }
+  return first.get<T>(out);
+}
+
+template<> simdjson_inline simdjson_result<haswell::ondemand::value> simdjson_result<haswell::ondemand::value>::get<haswell::ondemand::value>() noexcept  {
+  if (error()) { return error(); }
+  return std::move(first);
+}
+
+simdjson_inline simdjson_result<haswell::ondemand::json_type> simdjson_result<haswell::ondemand::value>::type() noexcept {
+  if (error()) { return error(); }
+  return first.type();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<haswell::ondemand::value>::is_scalar() noexcept {
+  if (error()) { return error(); }
+  return first.is_scalar();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<haswell::ondemand::value>::is_string() noexcept {
+  if (error()) { return error(); }
+  return first.is_string();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<haswell::ondemand::value>::is_negative() noexcept {
+  if (error()) { return error(); }
+  return first.is_negative();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<haswell::ondemand::value>::is_integer() noexcept {
+  if (error()) { return error(); }
+  return first.is_integer();
+}
+simdjson_inline simdjson_result<haswell::number_type> simdjson_result<haswell::ondemand::value>::get_number_type() noexcept {
+  if (error()) { return error(); }
+  return first.get_number_type();
+}
+simdjson_inline simdjson_result<haswell::ondemand::number> simdjson_result<haswell::ondemand::value>::get_number() noexcept {
+  if (error()) { return error(); }
+  return first.get_number();
+}
+#if SIMDJSON_EXCEPTIONS
+template <class T>
+simdjson_inline simdjson_result<haswell::ondemand::value>::operator T() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first.get<T>();
+}
+simdjson_inline simdjson_result<haswell::ondemand::value>::operator haswell::ondemand::array() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<haswell::ondemand::value>::operator haswell::ondemand::object() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<haswell::ondemand::value>::operator uint64_t() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<haswell::ondemand::value>::operator int64_t() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<haswell::ondemand::value>::operator double() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<haswell::ondemand::value>::operator std::string_view() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<haswell::ondemand::value>::operator haswell::ondemand::raw_json_string() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<haswell::ondemand::value>::operator bool() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+#endif
+
+simdjson_inline simdjson_result<std::string_view> simdjson_result<haswell::ondemand::value>::raw_json_token() noexcept {
+  if (error()) { return error(); }
+  return first.raw_json_token();
+}
+
+simdjson_inline simdjson_result<std::string_view> simdjson_result<haswell::ondemand::value>::raw_json() noexcept {
+  if (error()) { return error(); }
+  return first.raw_json();
+}
+
+simdjson_inline simdjson_result<const char *> simdjson_result<haswell::ondemand::value>::current_location() noexcept {
+  if (error()) { return error(); }
+  return first.current_location();
+}
+
+simdjson_inline simdjson_result<int32_t> simdjson_result<haswell::ondemand::value>::current_depth() const noexcept {
+  if (error()) { return error(); }
+  return first.current_depth();
+}
+
+simdjson_inline simdjson_result<haswell::ondemand::value> simdjson_result<haswell::ondemand::value>::at_pointer(
+    std::string_view json_pointer) noexcept {
+  if (error()) {
+      return error();
+  }
+  return first.at_pointer(json_pointer);
+}
+
+simdjson_inline simdjson_result<haswell::ondemand::value> simdjson_result<haswell::ondemand::value>::at_path(
+      std::string_view json_path) noexcept {
+  if (error()) {
+    return error();
+  }
+  return first.at_path(json_path);
+}
+
+} // namespace simdjson
+
+#endif // SIMDJSON_GENERIC_ONDEMAND_ARRAY_ITERATOR_INL_H
+/* end file simdjson/generic/ondemand/array_iterator-inl.h for haswell */
+/* including simdjson/generic/ondemand/value-inl.h for haswell: #include "simdjson/generic/ondemand/value-inl.h" */
+/* begin file simdjson/generic/ondemand/value-inl.h for haswell */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_VALUE_INL_H
+
+/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_VALUE_INL_H */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array_iterator.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_iterator.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_type.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/object.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/raw_json_string.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value.h" */
+/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
+
+namespace simdjson {
+namespace haswell {
+namespace ondemand {
+
+simdjson_inline value::value(const value_iterator &_iter) noexcept
+  : iter{_iter}
+{
+}
+simdjson_inline value value::start(const value_iterator &iter) noexcept {
+  return iter;
+}
+simdjson_inline value value::resume(const value_iterator &iter) noexcept {
+  return iter;
+}
+
+simdjson_inline simdjson_result<array> value::get_array() noexcept {
+  return array::start(iter);
+}
+simdjson_inline simdjson_result<object> value::get_object() noexcept {
+  return object::start(iter);
+}
+simdjson_inline simdjson_result<object> value::start_or_resume_object() noexcept {
+  if (iter.at_start()) {
+    return get_object();
+  } else {
+    return object::resume(iter);
+  }
+}
+
+simdjson_inline simdjson_result<raw_json_string> value::get_raw_json_string() noexcept {
+  return iter.get_raw_json_string();
+}
+simdjson_inline simdjson_result<std::string_view> value::get_string(bool allow_replacement) noexcept {
+  return iter.get_string(allow_replacement);
+}
+template <typename string_type>
+simdjson_inline error_code value::get_string(string_type& receiver, bool allow_replacement) noexcept {
+  return iter.get_string(receiver, allow_replacement);
+}
+simdjson_inline simdjson_result<std::string_view> value::get_wobbly_string() noexcept {
+  return iter.get_wobbly_string();
+}
+simdjson_inline simdjson_result<double> value::get_double() noexcept {
+  return iter.get_double();
+}
+simdjson_inline simdjson_result<double> value::get_double_in_string() noexcept {
+  return iter.get_double_in_string();
+}
+simdjson_inline simdjson_result<uint64_t> value::get_uint64() noexcept {
+  return iter.get_uint64();
+}
+simdjson_inline simdjson_result<uint64_t> value::get_uint64_in_string() noexcept {
+  return iter.get_uint64_in_string();
+}
+simdjson_inline simdjson_result<int64_t> value::get_int64() noexcept {
+  return iter.get_int64();
+}
+simdjson_inline simdjson_result<int64_t> value::get_int64_in_string() noexcept {
+  return iter.get_int64_in_string();
+}
+simdjson_inline simdjson_result<bool> value::get_bool() noexcept {
+  return iter.get_bool();
+}
+simdjson_inline simdjson_result<bool> value::is_null() noexcept {
+  return iter.is_null();
+}
+
+template<> simdjson_inline simdjson_result<array> value::get() noexcept { return get_array(); }
+template<> simdjson_inline simdjson_result<object> value::get() noexcept { return get_object(); }
+template<> simdjson_inline simdjson_result<raw_json_string> value::get() noexcept { return get_raw_json_string(); }
+template<> simdjson_inline simdjson_result<std::string_view> value::get() noexcept { return get_string(false); }
+template<> simdjson_inline simdjson_result<number> value::get() noexcept { return get_number(); }
+template<> simdjson_inline simdjson_result<double> value::get() noexcept { return get_double(); }
+template<> simdjson_inline simdjson_result<uint64_t> value::get() noexcept { return get_uint64(); }
+template<> simdjson_inline simdjson_result<int64_t> value::get() noexcept { return get_int64(); }
+template<> simdjson_inline simdjson_result<bool> value::get() noexcept { return get_bool(); }
+
+
+template<> simdjson_inline error_code value::get(array& out) noexcept { return get_array().get(out); }
+template<> simdjson_inline error_code value::get(object& out) noexcept { return get_object().get(out); }
+template<> simdjson_inline error_code value::get(raw_json_string& out) noexcept { return get_raw_json_string().get(out); }
+template<> simdjson_inline error_code value::get(std::string_view& out) noexcept { return get_string(false).get(out); }
+template<> simdjson_inline error_code value::get(number& out) noexcept { return get_number().get(out); }
+template<> simdjson_inline error_code value::get(double& out) noexcept { return get_double().get(out); }
+template<> simdjson_inline error_code value::get(uint64_t& out) noexcept { return get_uint64().get(out); }
+template<> simdjson_inline error_code value::get(int64_t& out) noexcept { return get_int64().get(out); }
+template<> simdjson_inline error_code value::get(bool& out) noexcept { return get_bool().get(out); }
+
+#if SIMDJSON_EXCEPTIONS
+template <class T>
+simdjson_inline value::operator T() noexcept(false) {
+  return get<T>();
+}
+simdjson_inline value::operator array() noexcept(false) {
+  return get_array();
+}
+simdjson_inline value::operator object() noexcept(false) {
+  return get_object();
+}
+simdjson_inline value::operator uint64_t() noexcept(false) {
+  return get_uint64();
+}
+simdjson_inline value::operator int64_t() noexcept(false) {
+  return get_int64();
+}
+simdjson_inline value::operator double() noexcept(false) {
+  return get_double();
+}
+simdjson_inline value::operator std::string_view() noexcept(false) {
+  return get_string(false);
+}
+simdjson_inline value::operator raw_json_string() noexcept(false) {
+  return get_raw_json_string();
+}
+simdjson_inline value::operator bool() noexcept(false) {
+  return get_bool();
+}
+#endif
+
+simdjson_inline simdjson_result<array_iterator> value::begin() & noexcept {
+  return get_array().begin();
+}
+simdjson_inline simdjson_result<array_iterator> value::end() & noexcept {
+  return {};
+}
+simdjson_inline simdjson_result<size_t> value::count_elements() & noexcept {
+  simdjson_result<size_t> answer;
+  auto a = get_array();
+  answer = a.count_elements();
+  // count_elements leaves you pointing inside the array, at the first element.
+  // We need to move back so that the user can create a new array (which requires that
+  // we point at '[').
+  iter.move_at_start();
+  return answer;
+}
+simdjson_inline simdjson_result<size_t> value::count_fields() & noexcept {
+  simdjson_result<size_t> answer;
+  auto a = get_object();
+  answer = a.count_fields();
+  iter.move_at_start();
+  return answer;
+}
+simdjson_inline simdjson_result<value> value::at(size_t index) noexcept {
+  auto a = get_array();
+  return a.at(index);
+}
+
+simdjson_inline simdjson_result<value> value::find_field(std::string_view key) noexcept {
+  return start_or_resume_object().find_field(key);
+}
+simdjson_inline simdjson_result<value> value::find_field(const char *key) noexcept {
+  return start_or_resume_object().find_field(key);
+}
+
+simdjson_inline simdjson_result<value> value::find_field_unordered(std::string_view key) noexcept {
+  return start_or_resume_object().find_field_unordered(key);
+}
+simdjson_inline simdjson_result<value> value::find_field_unordered(const char *key) noexcept {
+  return start_or_resume_object().find_field_unordered(key);
+}
+
+simdjson_inline simdjson_result<value> value::operator[](std::string_view key) noexcept {
+  return start_or_resume_object()[key];
+}
+simdjson_inline simdjson_result<value> value::operator[](const char *key) noexcept {
+  return start_or_resume_object()[key];
+}
+
+simdjson_inline simdjson_result<json_type> value::type() noexcept {
+  return iter.type();
+}
+
+simdjson_inline simdjson_result<bool> value::is_scalar() noexcept {
+  json_type this_type;
+  auto error = type().get(this_type);
+  if(error) { return error; }
+  return ! ((this_type == json_type::array) || (this_type == json_type::object));
+}
+
+simdjson_inline simdjson_result<bool> value::is_string() noexcept {
+  json_type this_type;
+  auto error = type().get(this_type);
+  if(error) { return error; }
+  return (this_type == json_type::string);
+}
+
+
 simdjson_inline bool value::is_negative() noexcept {
   return iter.is_negative();
 }
@@ -60961,7 +61891,7 @@ simdjson_inline simdjson_result<haswell::ondemand::number> simdjson_result<haswe
 template <class T, typename std::enable_if<std::is_same<T, haswell::ondemand::document>::value == false>::type>
 simdjson_inline simdjson_result<haswell::ondemand::document>::operator T() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get<T>();
 }
 simdjson_inline simdjson_result<haswell::ondemand::document>::operator haswell::ondemand::array() & noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
@@ -63387,36 +64317,39 @@ simdjson_inline const char * raw_json_string::raw() const noexcept { return rein
 
 simdjson_inline bool raw_json_string::is_free_from_unescaped_quote(std::string_view target) noexcept {
   size_t pos{0};
-  // if the content has no escape character, just scan through it quickly!
-  for(;pos < target.size() && target[pos] != '\\';pos++) {}
-  // slow path may begin.
-  bool escaping{false};
-  for(;pos < target.size();pos++) {
-    if((target[pos] == '"') && !escaping) {
-      return false;
-    } else if(target[pos] == '\\') {
-      escaping = !escaping;
-    } else {
-      escaping = false;
+  while(pos < target.size()) {
+    pos = target.find('"', pos);
+    if(pos == std::string_view::npos) { return true; }
+    if(pos != 0 && target[pos-1] != '\\') { return false; }
+    if(pos > 1 && target[pos-2] == '\\') {
+      size_t backslash_count{2};
+      for(size_t i = 3; i <= pos; i++) {
+        if(target[pos-i] == '\\') { backslash_count++; }
+        else { break; }
+      }
+      if(backslash_count % 2 == 0) { return false; }
     }
+    pos++;
   }
   return true;
 }
 
 simdjson_inline bool raw_json_string::is_free_from_unescaped_quote(const char* target) noexcept {
   size_t pos{0};
-  // if the content has no escape character, just scan through it quickly!
-  for(;target[pos] && target[pos] != '\\';pos++) {}
-  // slow path may begin.
-  bool escaping{false};
-  for(;target[pos];pos++) {
-    if((target[pos] == '"') && !escaping) {
-      return false;
-    } else if(target[pos] == '\\') {
-      escaping = !escaping;
-    } else {
-      escaping = false;
+  while(target[pos]) {
+    const char * result = strchr(target+pos, '"');
+    if(result == nullptr) { return true; }
+    pos = result - target;
+    if(pos != 0 && target[pos-1] != '\\') { return false; }
+    if(pos > 1 && target[pos-2] == '\\') {
+      size_t backslash_count{2};
+      for(size_t i = 3; i <= pos; i++) {
+        if(target[pos-i] == '\\') { backslash_count++; }
+        else { break; }
+      }
+      if(backslash_count % 2 == 0) { return false; }
     }
+    pos++;
   }
   return true;
 }
@@ -63428,7 +64361,7 @@ simdjson_inline bool raw_json_string::unsafe_is_equal(size_t length, std::string
 }
 
 simdjson_inline bool raw_json_string::unsafe_is_equal(std::string_view target) const noexcept {
-  // Assumptions: does not contain unescaped quote characters, and
+  // Assumptions: does not contain unescaped quote characters("), and
   // the raw content is quote terminated within a valid JSON string.
   if(target.size() <= SIMDJSON_PADDING) {
     return (raw()[target.size()] == '"') && !memcmp(raw(), target.data(), target.size());
@@ -63519,28 +64452,62 @@ simdjson_unused simdjson_inline bool operator!=(std::string_view c, const raw_js
   return !(a == c);
 }
 
+SIMDJSON_PUSH_DISABLE_WARNINGS
+SIMDJSON_DISABLE_STRICT_OVERFLOW_WARNING
+simdjson_inline object_iterator &object_iterator::operator++() noexcept {
+  // TODO this is a safety rail ... users should exit loops as soon as they receive an error.
+  // Nonetheless, let's see if performance is OK with this if statement--the compiler may give it to us for free.
+  if (!iter.is_open()) { return *this; } // Iterator will be released if there is an error
 
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> raw_json_string::unescape(json_iterator &iter, bool allow_replacement) const noexcept {
-  return iter.unescape(*this, allow_replacement);
-}
+  simdjson_unused error_code error;
+  if ((error = iter.skip_child() )) { return *this; }
 
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> raw_json_string::unescape_wobbly(json_iterator &iter) const noexcept {
-  return iter.unescape_wobbly(*this);
+  simdjson_unused bool has_value;
+  if ((error = iter.has_next_field().get(has_value) )) { return *this; };
+  return *this;
 }
+SIMDJSON_POP_DISABLE_WARNINGS
 
-simdjson_unused simdjson_inline std::ostream &operator<<(std::ostream &out, const raw_json_string &str) noexcept {
-  bool in_escape = false;
-  const char *s = str.raw();
-  while (true) {
-    switch (*s) {
-      case '\\': in_escape = !in_escape; break;
-      case '"': if (in_escape) { in_escape = false; } else { return out; } break;
-      default: if (in_escape) { in_escape = false; }
-    }
-    out << *s;
-    s++;
-  }
-}
+//
+// ### Live States
+//
+// While iterating or looking up values, depth >= iter.depth. at_start may vary. Error is
+// always SUCCESS:
+//
+// - Start: This is the state when the object is first found and the iterator is just past the {.
+//   In this state, at_start == true.
+// - Next: After we hand a scalar value to the user, or an array/object which they then fully
+//   iterate over, the iterator is at the , or } before the next value. In this state,
+//   depth == iter.depth, at_start == false, and error == SUCCESS.
+// - Unfinished Business: When we hand an array/object to the user which they do not fully
+//   iterate over, we need to finish that iteration by skipping child values until we reach the
+//   Next state. In this state, depth > iter.depth, at_start == false, and error == SUCCESS.
+//
+// ## Error States
+//
+// In error states, we will yield exactly one more value before stopping. iter.depth == depth
+// and at_start is always false. We decrement after yielding the error, moving to the Finished
+// state.
+//
+// - Chained Error: When the object iterator is part of an error chain--for example, in
+//   `for (auto tweet : doc["tweets"])`, where the tweet field may be missing or not be an
+//   object--we yield that error in the loop, exactly once. In this state, error != SUCCESS and
+//   iter.depth == depth, and at_start == false. We decrement depth when we yield the error.
+// - Missing Comma Error: When the iterator ++ method discovers there is no comma between fields,
+//   we flag that as an error and treat it exactly the same as a Chained Error. In this state,
+//   error == TAPE_ERROR, iter.depth == depth, and at_start == false.
+//
+// Errors that occur while reading a field to give to the user (such as when the key is not a
+// string or the field is missing a colon) are yielded immediately. Depth is then decremented,
+// moving to the Finished state without transitioning through an Error state at all.
+//
+// ## Terminal State
+//
+// The terminal state has iter.depth < depth. at_start is always false.
+//
+// - Finished: When we have reached a }, we are finished. We signal this by decrementing depth.
+//   In this state, iter.depth < depth, at_start == false, and error == SUCCESS.
+//
 
 } // namespace ondemand
 } // namespace haswell
@@ -63548,343 +64515,235 @@ simdjson_unused simdjson_inline std::ostream &operator<<(std::ostream &out, cons
 
 namespace simdjson {
 
-simdjson_inline simdjson_result<haswell::ondemand::raw_json_string>::simdjson_result(haswell::ondemand::raw_json_string &&value) noexcept
-    : implementation_simdjson_result_base<haswell::ondemand::raw_json_string>(std::forward<haswell::ondemand::raw_json_string>(value)) {}
-simdjson_inline simdjson_result<haswell::ondemand::raw_json_string>::simdjson_result(error_code error) noexcept
-    : implementation_simdjson_result_base<haswell::ondemand::raw_json_string>(error) {}
+simdjson_inline simdjson_result<haswell::ondemand::object_iterator>::simdjson_result(
+  haswell::ondemand::object_iterator &&value
+) noexcept
+  : implementation_simdjson_result_base<haswell::ondemand::object_iterator>(std::forward<haswell::ondemand::object_iterator>(value))
+{
+  first.iter.assert_is_valid();
+}
+simdjson_inline simdjson_result<haswell::ondemand::object_iterator>::simdjson_result(error_code error) noexcept
+  : implementation_simdjson_result_base<haswell::ondemand::object_iterator>({}, error)
+{
+}
 
-simdjson_inline simdjson_result<const char *> simdjson_result<haswell::ondemand::raw_json_string>::raw() const noexcept {
+simdjson_inline simdjson_result<haswell::ondemand::field> simdjson_result<haswell::ondemand::object_iterator>::operator*() noexcept {
   if (error()) { return error(); }
-  return first.raw();
+  return *first;
 }
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> simdjson_result<haswell::ondemand::raw_json_string>::unescape(haswell::ondemand::json_iterator &iter, bool allow_replacement) const noexcept {
-  if (error()) { return error(); }
-  return first.unescape(iter, allow_replacement);
+// If we're iterating and there is an error, return the error once.
+simdjson_inline bool simdjson_result<haswell::ondemand::object_iterator>::operator==(const simdjson_result<haswell::ondemand::object_iterator> &other) const noexcept {
+  if (!first.iter.is_valid()) { return !error(); }
+  return first == other.first;
 }
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> simdjson_result<haswell::ondemand::raw_json_string>::unescape_wobbly(haswell::ondemand::json_iterator &iter) const noexcept {
-  if (error()) { return error(); }
-  return first.unescape_wobbly(iter);
+// If we're iterating and there is an error, return the error once.
+simdjson_inline bool simdjson_result<haswell::ondemand::object_iterator>::operator!=(const simdjson_result<haswell::ondemand::object_iterator> &other) const noexcept {
+  if (!first.iter.is_valid()) { return error(); }
+  return first != other.first;
 }
+// Checks for ']' and ','
+simdjson_inline simdjson_result<haswell::ondemand::object_iterator> &simdjson_result<haswell::ondemand::object_iterator>::operator++() noexcept {
+  // Clear the error if there is one, so we don't yield it twice
+  if (error()) { second = SUCCESS; return *this; }
+  ++first;
+  return *this;
+}
+
 } // namespace simdjson
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_RAW_JSON_STRING_INL_H
-/* end file simdjson/generic/ondemand/raw_json_string-inl.h for haswell */
-/* including simdjson/generic/ondemand/serialization-inl.h for haswell: #include "simdjson/generic/ondemand/serialization-inl.h" */
-/* begin file simdjson/generic/ondemand/serialization-inl.h for haswell */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H
+#endif // SIMDJSON_GENERIC_ONDEMAND_OBJECT_ITERATOR_INL_H
+/* end file simdjson/generic/ondemand/object_iterator-inl.h for haswell */
+/* including simdjson/generic/ondemand/parser-inl.h for haswell: #include "simdjson/generic/ondemand/parser-inl.h" */
+/* begin file simdjson/generic/ondemand/parser-inl.h for haswell */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_PARSER_INL_H
 
 /* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_PARSER_INL_H */
+/* amalgamation skipped (editor-only): #include "simdjson/padded_string.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/padded_string_view.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/implementation.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/internal/dom_parser_implementation.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/dom/base.h" // for MINIMAL_DOCUMENT_CAPACITY */
 /* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document-inl.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_type.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/object.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/serialization.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document_stream.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/parser.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/raw_json_string.h" */
 /* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
 namespace simdjson {
+namespace haswell {
+namespace ondemand {
 
-inline std::string_view trim(const std::string_view str) noexcept {
-  // We can almost surely do better by rolling our own find_first_not_of function.
-  size_t first = str.find_first_not_of(" \t\n\r");
-  // If we have the empty string (just white space), then no trimming is possible, and
-  // we return the empty string_view.
-  if (std::string_view::npos == first) { return std::string_view(); }
-  size_t last = str.find_last_not_of(" \t\n\r");
-  return str.substr(first, (last - first + 1));
-}
-
-
-inline simdjson_result<std::string_view> to_json_string(haswell::ondemand::document& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
+simdjson_inline parser::parser(size_t max_capacity) noexcept
+  : _max_capacity{max_capacity} {
 }
 
-inline simdjson_result<std::string_view> to_json_string(haswell::ondemand::document_reference& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
-}
+simdjson_warn_unused simdjson_inline error_code parser::allocate(size_t new_capacity, size_t new_max_depth) noexcept {
+  if (new_capacity > max_capacity()) { return CAPACITY; }
+  if (string_buf && new_capacity == capacity() && new_max_depth == max_depth()) { return SUCCESS; }
 
-inline simdjson_result<std::string_view> to_json_string(haswell::ondemand::value& x) noexcept {
-  /**
-   * If we somehow receive a value that has already been consumed,
-   * then the following code could be in trouble. E.g., we create
-   * an array as needed, but if an array was already created, then
-   * it could be bad.
-   */
-  using namespace haswell::ondemand;
-  haswell::ondemand::json_type t;
-  auto error = x.type().get(t);
-  if(error != SUCCESS) { return error; }
-  switch (t)
-  {
-    case json_type::array:
-    {
-      haswell::ondemand::array array;
-      error = x.get_array().get(array);
-      if(error) { return error; }
-      return to_json_string(array);
-    }
-    case json_type::object:
-    {
-      haswell::ondemand::object object;
-      error = x.get_object().get(object);
-      if(error) { return error; }
-      return to_json_string(object);
-    }
-    default:
-      return trim(x.raw_json_token());
+  // string_capacity copied from document::allocate
+  _capacity = 0;
+  size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * new_capacity / 3 + SIMDJSON_PADDING, 64);
+  string_buf.reset(new (std::nothrow) uint8_t[string_capacity]);
+#if SIMDJSON_DEVELOPMENT_CHECKS
+  start_positions.reset(new (std::nothrow) token_position[new_max_depth]);
+#endif
+  if (implementation) {
+    SIMDJSON_TRY( implementation->set_capacity(new_capacity) );
+    SIMDJSON_TRY( implementation->set_max_depth(new_max_depth) );
+  } else {
+    SIMDJSON_TRY( simdjson::get_active_implementation()->create_dom_parser_implementation(new_capacity, new_max_depth, implementation) );
   }
+  _capacity = new_capacity;
+  _max_depth = new_max_depth;
+  return SUCCESS;
 }
-
-inline simdjson_result<std::string_view> to_json_string(haswell::ondemand::object& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
-}
-
-inline simdjson_result<std::string_view> to_json_string(haswell::ondemand::array& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
+#if SIMDJSON_DEVELOPMENT_CHECKS
+simdjson_inline simdjson_warn_unused bool parser::string_buffer_overflow(const uint8_t *string_buf_loc) const noexcept {
+  return (string_buf_loc < string_buf.get()) || (size_t(string_buf_loc - string_buf.get()) >= capacity());
 }
+#endif
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<haswell::ondemand::document> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(padded_string_view json) & noexcept {
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<haswell::ondemand::document_reference> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
+  json.remove_utf8_bom();
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<haswell::ondemand::value> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
+  // Allocate if needed
+  if (capacity() < json.length() || !string_buf) {
+    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
+  }
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<haswell::ondemand::object> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
+  // Run stage 1.
+  SIMDJSON_TRY( implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular) );
+  return document::start({ reinterpret_cast<const uint8_t *>(json.data()), this });
 }
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<haswell::ondemand::array> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
-} // namespace simdjson
+#ifdef SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate_allow_incomplete_json(padded_string_view json) & noexcept {
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
-namespace simdjson { namespace haswell { namespace ondemand {
+  json.remove_utf8_bom();
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::haswell::ondemand::value x) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(x).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::haswell::ondemand::value> x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
-}
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::haswell::ondemand::value x) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(x).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
+  // Allocate if needed
+  if (capacity() < json.length() || !string_buf) {
+    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
   }
-}
-#endif
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::haswell::ondemand::array value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::haswell::ondemand::array> x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
-}
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::haswell::ondemand::array value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
+  // Run stage 1.
+  const simdjson::error_code err = implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular);
+  if (err) {
+    if (err != UNCLOSED_STRING)
+      return err;
   }
+  return document::start({ reinterpret_cast<const uint8_t *>(json.data()), this, true });
 }
-#endif
+#endif // SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::haswell::ondemand::document& value)  {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::haswell::ondemand::document_reference& value)  {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::haswell::ondemand::document>&& x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const char *json, size_t len, size_t allocated) & noexcept {
+  return iterate(padded_string_view(json, len, allocated));
 }
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::haswell::ondemand::document_reference>&& x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const uint8_t *json, size_t len, size_t allocated) & noexcept {
+  return iterate(padded_string_view(json, len, allocated));
 }
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::haswell::ondemand::document& value)  {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
-  }
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(std::string_view json, size_t allocated) & noexcept {
+  return iterate(padded_string_view(json, allocated));
 }
-#endif
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::haswell::ondemand::object value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(std::string &json) & noexcept {
+  if(json.capacity() - json.size() < SIMDJSON_PADDING) {
+    json.reserve(json.size() + SIMDJSON_PADDING);
   }
+  return iterate(padded_string_view(json));
 }
-inline std::ostream& operator<<(std::ostream& out,  simdjson::simdjson_result<simdjson::haswell::ondemand::object> x) {
-  if (x.error()) { throw  simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const std::string &json) & noexcept {
+  return iterate(padded_string_view(json));
 }
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::haswell::ondemand::object value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
-  }
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const simdjson_result<padded_string_view> &result) & noexcept {
+  // We don't presently have a way to temporarily get a const T& from a simdjson_result<T> without throwing an exception
+  SIMDJSON_TRY( result.error() );
+  padded_string_view json = result.value_unsafe();
+  return iterate(json);
 }
-#endif
-}}} // namespace simdjson::haswell::ondemand
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H
-/* end file simdjson/generic/ondemand/serialization-inl.h for haswell */
-/* including simdjson/generic/ondemand/token_iterator-inl.h for haswell: #include "simdjson/generic/ondemand/token_iterator-inl.h" */
-/* begin file simdjson/generic/ondemand/token_iterator-inl.h for haswell */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_TOKEN_ITERATOR_INL_H
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const simdjson_result<padded_string> &result) & noexcept {
+  // We don't presently have a way to temporarily get a const T& from a simdjson_result<T> without throwing an exception
+  SIMDJSON_TRY( result.error() );
+  const padded_string &json = result.value_unsafe();
+  return iterate(json);
+}
 
-/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_TOKEN_ITERATOR_INL_H */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/token_iterator.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/implementation_simdjson_result_base-inl.h" */
-/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
+simdjson_warn_unused simdjson_inline simdjson_result<json_iterator> parser::iterate_raw(padded_string_view json) & noexcept {
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
-namespace simdjson {
-namespace haswell {
-namespace ondemand {
+  json.remove_utf8_bom();
 
-simdjson_inline token_iterator::token_iterator(
-  const uint8_t *_buf,
-  token_position position
-) noexcept : buf{_buf}, _position{position}
-{
-}
+  // Allocate if needed
+  if (capacity() < json.length()) {
+    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
+  }
 
-simdjson_inline uint32_t token_iterator::current_offset() const noexcept {
-  return *(_position);
+  // Run stage 1.
+  SIMDJSON_TRY( implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular) );
+  return json_iterator(reinterpret_cast<const uint8_t *>(json.data()), this);
 }
 
-
-simdjson_inline const uint8_t *token_iterator::return_current_and_advance() noexcept {
-  return &buf[*(_position++)];
+inline simdjson_result<document_stream> parser::iterate_many(const uint8_t *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {
+  if(batch_size < MINIMAL_BATCH_SIZE) { batch_size = MINIMAL_BATCH_SIZE; }
+  if((len >= 3) && (std::memcmp(buf, "\xEF\xBB\xBF", 3) == 0)) {
+    buf += 3;
+    len -= 3;
+  }
+  if(allow_comma_separated && batch_size < len) { batch_size = len; }
+  return document_stream(*this, buf, len, batch_size, allow_comma_separated);
 }
-
-simdjson_inline const uint8_t *token_iterator::peek(token_position position) const noexcept {
-  return &buf[*position];
+inline simdjson_result<document_stream> parser::iterate_many(const char *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {
+  return iterate_many(reinterpret_cast<const uint8_t *>(buf), len, batch_size, allow_comma_separated);
 }
-simdjson_inline uint32_t token_iterator::peek_index(token_position position) const noexcept {
-  return *position;
+inline simdjson_result<document_stream> parser::iterate_many(const std::string &s, size_t batch_size, bool allow_comma_separated) noexcept {
+  return iterate_many(s.data(), s.length(), batch_size, allow_comma_separated);
 }
-simdjson_inline uint32_t token_iterator::peek_length(token_position position) const noexcept {
-  return *(position+1) - *position;
+inline simdjson_result<document_stream> parser::iterate_many(const padded_string &s, size_t batch_size, bool allow_comma_separated) noexcept {
+  return iterate_many(s.data(), s.length(), batch_size, allow_comma_separated);
 }
 
-simdjson_inline uint32_t token_iterator::peek_root_length(token_position position) const noexcept {
-  return *(position+2) - *(position) > *(position+1) - *(position) ?
-      *(position+1) - *(position)
-      : *(position+2) - *(position);
-}
-simdjson_inline const uint8_t *token_iterator::peek(int32_t delta) const noexcept {
-  return &buf[*(_position+delta)];
+simdjson_pure simdjson_inline size_t parser::capacity() const noexcept {
+  return _capacity;
 }
-simdjson_inline uint32_t token_iterator::peek_index(int32_t delta) const noexcept {
-  return *(_position+delta);
+simdjson_pure simdjson_inline size_t parser::max_capacity() const noexcept {
+  return _max_capacity;
 }
-simdjson_inline uint32_t token_iterator::peek_length(int32_t delta) const noexcept {
-  return *(_position+delta+1) - *(_position+delta);
+simdjson_pure simdjson_inline size_t parser::max_depth() const noexcept {
+  return _max_depth;
 }
 
-simdjson_inline token_position token_iterator::position() const noexcept {
-  return _position;
-}
-simdjson_inline void token_iterator::set_position(token_position target_position) noexcept {
-  _position = target_position;
+simdjson_inline void parser::set_max_capacity(size_t max_capacity) noexcept {
+  if(max_capacity < dom::MINIMAL_DOCUMENT_CAPACITY) {
+    _max_capacity = max_capacity;
+  } else {
+    _max_capacity = dom::MINIMAL_DOCUMENT_CAPACITY;
+  }
 }
 
-simdjson_inline bool token_iterator::operator==(const token_iterator &other) const noexcept {
-  return _position == other._position;
-}
-simdjson_inline bool token_iterator::operator!=(const token_iterator &other) const noexcept {
-  return _position != other._position;
-}
-simdjson_inline bool token_iterator::operator>(const token_iterator &other) const noexcept {
-  return _position > other._position;
-}
-simdjson_inline bool token_iterator::operator>=(const token_iterator &other) const noexcept {
-  return _position >= other._position;
-}
-simdjson_inline bool token_iterator::operator<(const token_iterator &other) const noexcept {
-  return _position < other._position;
+simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape(raw_json_string in, uint8_t *&dst, bool allow_replacement) const noexcept {
+  uint8_t *end = implementation->parse_string(in.buf, dst, allow_replacement);
+  if (!end) { return STRING_ERROR; }
+  std::string_view result(reinterpret_cast<const char *>(dst), end-dst);
+  dst = end;
+  return result;
 }
-simdjson_inline bool token_iterator::operator<=(const token_iterator &other) const noexcept {
-  return _position <= other._position;
+
+simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape_wobbly(raw_json_string in, uint8_t *&dst) const noexcept {
+  uint8_t *end = implementation->parse_wobbly_string(in.buf, dst);
+  if (!end) { return STRING_ERROR; }
+  std::string_view result(reinterpret_cast<const char *>(dst), end-dst);
+  dst = end;
+  return result;
 }
 
 } // namespace ondemand
@@ -63893,10 +64752,10 @@ simdjson_inline bool token_iterator::operator<=(const token_iterator &other) con
 
 namespace simdjson {
 
-simdjson_inline simdjson_result<haswell::ondemand::token_iterator>::simdjson_result(haswell::ondemand::token_iterator &&value) noexcept
-    : implementation_simdjson_result_base<haswell::ondemand::token_iterator>(std::forward<haswell::ondemand::token_iterator>(value)) {}
-simdjson_inline simdjson_result<haswell::ondemand::token_iterator>::simdjson_result(error_code error) noexcept
-    : implementation_simdjson_result_base<haswell::ondemand::token_iterator>(error) {}
+simdjson_inline simdjson_result<haswell::ondemand::parser>::simdjson_result(haswell::ondemand::parser &&value) noexcept
+    : implementation_simdjson_result_base<haswell::ondemand::parser>(std::forward<haswell::ondemand::parser>(value)) {}
+simdjson_inline simdjson_result<haswell::ondemand::parser>::simdjson_result(error_code error) noexcept
+    : implementation_simdjson_result_base<haswell::ondemand::parser>(error) {}
 
 } // namespace simdjson
 
@@ -63918,6 +64777,7 @@ simdjson_inline simdjson_result<haswell::ondemand::token_iterator>::simdjson_res
 /* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
 namespace simdjson {
+
 namespace haswell {
 namespace ondemand {
 
@@ -71512,6 +72372,496 @@ simdjson_inline simdjson_result<bool> value::is_string() noexcept {
 }
 
 
+simdjson_inline bool value::is_negative() noexcept {
+  return iter.is_negative();
+}
+
+simdjson_inline simdjson_result<bool> value::is_integer() noexcept {
+  return iter.is_integer();
+}
+simdjson_warn_unused simdjson_inline simdjson_result<number_type> value::get_number_type() noexcept {
+  return iter.get_number_type();
+}
+simdjson_warn_unused simdjson_inline simdjson_result<number> value::get_number() noexcept {
+  return iter.get_number();
+}
+
+inline simdjson_result<value> array::at_path(std::string_view json_path) noexcept {
+  auto json_pointer = json_path_to_pointer_conversion(json_path);
+  if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
+  return at_pointer(json_pointer);
+}
+
+simdjson_inline simdjson_result<value> value::at_path(std::string_view json_path) noexcept {
+  json_type t;
+  SIMDJSON_TRY(type().get(t));
+  switch (t) {
+  case json_type::array:
+      return (*this).get_array().at_path(json_path);
+  case json_type::object:
+      return (*this).get_object().at_path(json_path);
+  default:
+      return INVALID_JSON_POINTER;
+  }
+}
+
+} // namespace ondemand
+} // namespace icelake
+} // namespace simdjson
+
+namespace simdjson {
+
+simdjson_inline simdjson_result<icelake::ondemand::value>::simdjson_result(
+  icelake::ondemand::value &&value
+) noexcept :
+    implementation_simdjson_result_base<icelake::ondemand::value>(
+      std::forward<icelake::ondemand::value>(value)
+    )
+{
+}
+simdjson_inline simdjson_result<icelake::ondemand::value>::simdjson_result(
+  error_code error
+) noexcept :
+    implementation_simdjson_result_base<icelake::ondemand::value>(error)
+{
+}
+simdjson_inline simdjson_result<size_t> simdjson_result<icelake::ondemand::value>::count_elements() & noexcept {
+  if (error()) { return error(); }
+  return first.count_elements();
+}
+simdjson_inline simdjson_result<size_t> simdjson_result<icelake::ondemand::value>::count_fields() & noexcept {
+  if (error()) { return error(); }
+  return first.count_fields();
+}
+simdjson_inline simdjson_result<icelake::ondemand::value> simdjson_result<icelake::ondemand::value>::at(size_t index) noexcept {
+  if (error()) { return error(); }
+  return first.at(index);
+}
+simdjson_inline simdjson_result<icelake::ondemand::array_iterator> simdjson_result<icelake::ondemand::value>::begin() & noexcept {
+  if (error()) { return error(); }
+  return first.begin();
+}
+simdjson_inline simdjson_result<icelake::ondemand::array_iterator> simdjson_result<icelake::ondemand::value>::end() & noexcept {
+  if (error()) { return error(); }
+  return {};
+}
+
+simdjson_inline simdjson_result<icelake::ondemand::value> simdjson_result<icelake::ondemand::value>::find_field(std::string_view key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field(key);
+}
+simdjson_inline simdjson_result<icelake::ondemand::value> simdjson_result<icelake::ondemand::value>::find_field(const char *key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field(key);
+}
+
+simdjson_inline simdjson_result<icelake::ondemand::value> simdjson_result<icelake::ondemand::value>::find_field_unordered(std::string_view key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field_unordered(key);
+}
+simdjson_inline simdjson_result<icelake::ondemand::value> simdjson_result<icelake::ondemand::value>::find_field_unordered(const char *key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field_unordered(key);
+}
+
+simdjson_inline simdjson_result<icelake::ondemand::value> simdjson_result<icelake::ondemand::value>::operator[](std::string_view key) noexcept {
+  if (error()) { return error(); }
+  return first[key];
+}
+simdjson_inline simdjson_result<icelake::ondemand::value> simdjson_result<icelake::ondemand::value>::operator[](const char *key) noexcept {
+  if (error()) { return error(); }
+  return first[key];
+}
+
+simdjson_inline simdjson_result<icelake::ondemand::array> simdjson_result<icelake::ondemand::value>::get_array() noexcept {
+  if (error()) { return error(); }
+  return first.get_array();
+}
+simdjson_inline simdjson_result<icelake::ondemand::object> simdjson_result<icelake::ondemand::value>::get_object() noexcept {
+  if (error()) { return error(); }
+  return first.get_object();
+}
+simdjson_inline simdjson_result<uint64_t> simdjson_result<icelake::ondemand::value>::get_uint64() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint64();
+}
+simdjson_inline simdjson_result<uint64_t> simdjson_result<icelake::ondemand::value>::get_uint64_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint64_in_string();
+}
+simdjson_inline simdjson_result<int64_t> simdjson_result<icelake::ondemand::value>::get_int64() noexcept {
+  if (error()) { return error(); }
+  return first.get_int64();
+}
+simdjson_inline simdjson_result<int64_t> simdjson_result<icelake::ondemand::value>::get_int64_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_int64_in_string();
+}
+simdjson_inline simdjson_result<double> simdjson_result<icelake::ondemand::value>::get_double() noexcept {
+  if (error()) { return error(); }
+  return first.get_double();
+}
+simdjson_inline simdjson_result<double> simdjson_result<icelake::ondemand::value>::get_double_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_double_in_string();
+}
+simdjson_inline simdjson_result<std::string_view> simdjson_result<icelake::ondemand::value>::get_string(bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.get_string(allow_replacement);
+}
+template <typename string_type>
+simdjson_inline error_code simdjson_result<icelake::ondemand::value>::get_string(string_type& receiver, bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.get_string(receiver, allow_replacement);
+}
+simdjson_inline simdjson_result<std::string_view> simdjson_result<icelake::ondemand::value>::get_wobbly_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_wobbly_string();
+}
+simdjson_inline simdjson_result<icelake::ondemand::raw_json_string> simdjson_result<icelake::ondemand::value>::get_raw_json_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_raw_json_string();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<icelake::ondemand::value>::get_bool() noexcept {
+  if (error()) { return error(); }
+  return first.get_bool();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<icelake::ondemand::value>::is_null() noexcept {
+  if (error()) { return error(); }
+  return first.is_null();
+}
+
+template<> simdjson_inline error_code simdjson_result<icelake::ondemand::value>::get<icelake::ondemand::value>(icelake::ondemand::value &out) noexcept {
+  if (error()) { return error(); }
+  out = first;
+  return SUCCESS;
+}
+
+template<typename T> simdjson_inline simdjson_result<T> simdjson_result<icelake::ondemand::value>::get() noexcept {
+  if (error()) { return error(); }
+  return first.get<T>();
+}
+template<typename T> simdjson_inline error_code simdjson_result<icelake::ondemand::value>::get(T &out) noexcept {
+  if (error()) { return error(); }
+  return first.get<T>(out);
+}
+
+template<> simdjson_inline simdjson_result<icelake::ondemand::value> simdjson_result<icelake::ondemand::value>::get<icelake::ondemand::value>() noexcept  {
+  if (error()) { return error(); }
+  return std::move(first);
+}
+
+simdjson_inline simdjson_result<icelake::ondemand::json_type> simdjson_result<icelake::ondemand::value>::type() noexcept {
+  if (error()) { return error(); }
+  return first.type();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<icelake::ondemand::value>::is_scalar() noexcept {
+  if (error()) { return error(); }
+  return first.is_scalar();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<icelake::ondemand::value>::is_string() noexcept {
+  if (error()) { return error(); }
+  return first.is_string();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<icelake::ondemand::value>::is_negative() noexcept {
+  if (error()) { return error(); }
+  return first.is_negative();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<icelake::ondemand::value>::is_integer() noexcept {
+  if (error()) { return error(); }
+  return first.is_integer();
+}
+simdjson_inline simdjson_result<icelake::number_type> simdjson_result<icelake::ondemand::value>::get_number_type() noexcept {
+  if (error()) { return error(); }
+  return first.get_number_type();
+}
+simdjson_inline simdjson_result<icelake::ondemand::number> simdjson_result<icelake::ondemand::value>::get_number() noexcept {
+  if (error()) { return error(); }
+  return first.get_number();
+}
+#if SIMDJSON_EXCEPTIONS
+template <class T>
+simdjson_inline simdjson_result<icelake::ondemand::value>::operator T() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first.get<T>();
+}
+simdjson_inline simdjson_result<icelake::ondemand::value>::operator icelake::ondemand::array() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<icelake::ondemand::value>::operator icelake::ondemand::object() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<icelake::ondemand::value>::operator uint64_t() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<icelake::ondemand::value>::operator int64_t() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<icelake::ondemand::value>::operator double() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<icelake::ondemand::value>::operator std::string_view() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<icelake::ondemand::value>::operator icelake::ondemand::raw_json_string() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<icelake::ondemand::value>::operator bool() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+#endif
+
+simdjson_inline simdjson_result<std::string_view> simdjson_result<icelake::ondemand::value>::raw_json_token() noexcept {
+  if (error()) { return error(); }
+  return first.raw_json_token();
+}
+
+simdjson_inline simdjson_result<std::string_view> simdjson_result<icelake::ondemand::value>::raw_json() noexcept {
+  if (error()) { return error(); }
+  return first.raw_json();
+}
+
+simdjson_inline simdjson_result<const char *> simdjson_result<icelake::ondemand::value>::current_location() noexcept {
+  if (error()) { return error(); }
+  return first.current_location();
+}
+
+simdjson_inline simdjson_result<int32_t> simdjson_result<icelake::ondemand::value>::current_depth() const noexcept {
+  if (error()) { return error(); }
+  return first.current_depth();
+}
+
+simdjson_inline simdjson_result<icelake::ondemand::value> simdjson_result<icelake::ondemand::value>::at_pointer(
+    std::string_view json_pointer) noexcept {
+  if (error()) {
+      return error();
+  }
+  return first.at_pointer(json_pointer);
+}
+
+simdjson_inline simdjson_result<icelake::ondemand::value> simdjson_result<icelake::ondemand::value>::at_path(
+      std::string_view json_path) noexcept {
+  if (error()) {
+    return error();
+  }
+  return first.at_path(json_path);
+}
+
+} // namespace simdjson
+
+#endif // SIMDJSON_GENERIC_ONDEMAND_ARRAY_ITERATOR_INL_H
+/* end file simdjson/generic/ondemand/array_iterator-inl.h for icelake */
+/* including simdjson/generic/ondemand/value-inl.h for icelake: #include "simdjson/generic/ondemand/value-inl.h" */
+/* begin file simdjson/generic/ondemand/value-inl.h for icelake */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_VALUE_INL_H
+
+/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_VALUE_INL_H */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array_iterator.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_iterator.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_type.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/object.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/raw_json_string.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value.h" */
+/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
+
+namespace simdjson {
+namespace icelake {
+namespace ondemand {
+
+simdjson_inline value::value(const value_iterator &_iter) noexcept
+  : iter{_iter}
+{
+}
+simdjson_inline value value::start(const value_iterator &iter) noexcept {
+  return iter;
+}
+simdjson_inline value value::resume(const value_iterator &iter) noexcept {
+  return iter;
+}
+
+simdjson_inline simdjson_result<array> value::get_array() noexcept {
+  return array::start(iter);
+}
+simdjson_inline simdjson_result<object> value::get_object() noexcept {
+  return object::start(iter);
+}
+simdjson_inline simdjson_result<object> value::start_or_resume_object() noexcept {
+  if (iter.at_start()) {
+    return get_object();
+  } else {
+    return object::resume(iter);
+  }
+}
+
+simdjson_inline simdjson_result<raw_json_string> value::get_raw_json_string() noexcept {
+  return iter.get_raw_json_string();
+}
+simdjson_inline simdjson_result<std::string_view> value::get_string(bool allow_replacement) noexcept {
+  return iter.get_string(allow_replacement);
+}
+template <typename string_type>
+simdjson_inline error_code value::get_string(string_type& receiver, bool allow_replacement) noexcept {
+  return iter.get_string(receiver, allow_replacement);
+}
+simdjson_inline simdjson_result<std::string_view> value::get_wobbly_string() noexcept {
+  return iter.get_wobbly_string();
+}
+simdjson_inline simdjson_result<double> value::get_double() noexcept {
+  return iter.get_double();
+}
+simdjson_inline simdjson_result<double> value::get_double_in_string() noexcept {
+  return iter.get_double_in_string();
+}
+simdjson_inline simdjson_result<uint64_t> value::get_uint64() noexcept {
+  return iter.get_uint64();
+}
+simdjson_inline simdjson_result<uint64_t> value::get_uint64_in_string() noexcept {
+  return iter.get_uint64_in_string();
+}
+simdjson_inline simdjson_result<int64_t> value::get_int64() noexcept {
+  return iter.get_int64();
+}
+simdjson_inline simdjson_result<int64_t> value::get_int64_in_string() noexcept {
+  return iter.get_int64_in_string();
+}
+simdjson_inline simdjson_result<bool> value::get_bool() noexcept {
+  return iter.get_bool();
+}
+simdjson_inline simdjson_result<bool> value::is_null() noexcept {
+  return iter.is_null();
+}
+
+template<> simdjson_inline simdjson_result<array> value::get() noexcept { return get_array(); }
+template<> simdjson_inline simdjson_result<object> value::get() noexcept { return get_object(); }
+template<> simdjson_inline simdjson_result<raw_json_string> value::get() noexcept { return get_raw_json_string(); }
+template<> simdjson_inline simdjson_result<std::string_view> value::get() noexcept { return get_string(false); }
+template<> simdjson_inline simdjson_result<number> value::get() noexcept { return get_number(); }
+template<> simdjson_inline simdjson_result<double> value::get() noexcept { return get_double(); }
+template<> simdjson_inline simdjson_result<uint64_t> value::get() noexcept { return get_uint64(); }
+template<> simdjson_inline simdjson_result<int64_t> value::get() noexcept { return get_int64(); }
+template<> simdjson_inline simdjson_result<bool> value::get() noexcept { return get_bool(); }
+
+
+template<> simdjson_inline error_code value::get(array& out) noexcept { return get_array().get(out); }
+template<> simdjson_inline error_code value::get(object& out) noexcept { return get_object().get(out); }
+template<> simdjson_inline error_code value::get(raw_json_string& out) noexcept { return get_raw_json_string().get(out); }
+template<> simdjson_inline error_code value::get(std::string_view& out) noexcept { return get_string(false).get(out); }
+template<> simdjson_inline error_code value::get(number& out) noexcept { return get_number().get(out); }
+template<> simdjson_inline error_code value::get(double& out) noexcept { return get_double().get(out); }
+template<> simdjson_inline error_code value::get(uint64_t& out) noexcept { return get_uint64().get(out); }
+template<> simdjson_inline error_code value::get(int64_t& out) noexcept { return get_int64().get(out); }
+template<> simdjson_inline error_code value::get(bool& out) noexcept { return get_bool().get(out); }
+
+#if SIMDJSON_EXCEPTIONS
+template <class T>
+simdjson_inline value::operator T() noexcept(false) {
+  return get<T>();
+}
+simdjson_inline value::operator array() noexcept(false) {
+  return get_array();
+}
+simdjson_inline value::operator object() noexcept(false) {
+  return get_object();
+}
+simdjson_inline value::operator uint64_t() noexcept(false) {
+  return get_uint64();
+}
+simdjson_inline value::operator int64_t() noexcept(false) {
+  return get_int64();
+}
+simdjson_inline value::operator double() noexcept(false) {
+  return get_double();
+}
+simdjson_inline value::operator std::string_view() noexcept(false) {
+  return get_string(false);
+}
+simdjson_inline value::operator raw_json_string() noexcept(false) {
+  return get_raw_json_string();
+}
+simdjson_inline value::operator bool() noexcept(false) {
+  return get_bool();
+}
+#endif
+
+simdjson_inline simdjson_result<array_iterator> value::begin() & noexcept {
+  return get_array().begin();
+}
+simdjson_inline simdjson_result<array_iterator> value::end() & noexcept {
+  return {};
+}
+simdjson_inline simdjson_result<size_t> value::count_elements() & noexcept {
+  simdjson_result<size_t> answer;
+  auto a = get_array();
+  answer = a.count_elements();
+  // count_elements leaves you pointing inside the array, at the first element.
+  // We need to move back so that the user can create a new array (which requires that
+  // we point at '[').
+  iter.move_at_start();
+  return answer;
+}
+simdjson_inline simdjson_result<size_t> value::count_fields() & noexcept {
+  simdjson_result<size_t> answer;
+  auto a = get_object();
+  answer = a.count_fields();
+  iter.move_at_start();
+  return answer;
+}
+simdjson_inline simdjson_result<value> value::at(size_t index) noexcept {
+  auto a = get_array();
+  return a.at(index);
+}
+
+simdjson_inline simdjson_result<value> value::find_field(std::string_view key) noexcept {
+  return start_or_resume_object().find_field(key);
+}
+simdjson_inline simdjson_result<value> value::find_field(const char *key) noexcept {
+  return start_or_resume_object().find_field(key);
+}
+
+simdjson_inline simdjson_result<value> value::find_field_unordered(std::string_view key) noexcept {
+  return start_or_resume_object().find_field_unordered(key);
+}
+simdjson_inline simdjson_result<value> value::find_field_unordered(const char *key) noexcept {
+  return start_or_resume_object().find_field_unordered(key);
+}
+
+simdjson_inline simdjson_result<value> value::operator[](std::string_view key) noexcept {
+  return start_or_resume_object()[key];
+}
+simdjson_inline simdjson_result<value> value::operator[](const char *key) noexcept {
+  return start_or_resume_object()[key];
+}
+
+simdjson_inline simdjson_result<json_type> value::type() noexcept {
+  return iter.type();
+}
+
+simdjson_inline simdjson_result<bool> value::is_scalar() noexcept {
+  json_type this_type;
+  auto error = type().get(this_type);
+  if(error) { return error; }
+  return ! ((this_type == json_type::array) || (this_type == json_type::object));
+}
+
+simdjson_inline simdjson_result<bool> value::is_string() noexcept {
+  json_type this_type;
+  auto error = type().get(this_type);
+  if(error) { return error; }
+  return (this_type == json_type::string);
+}
+
+
 simdjson_inline bool value::is_negative() noexcept {
   return iter.is_negative();
 }
@@ -72419,7 +73769,7 @@ simdjson_inline simdjson_result<icelake::ondemand::number> simdjson_result<icela
 template <class T, typename std::enable_if<std::is_same<T, icelake::ondemand::document>::value == false>::type>
 simdjson_inline simdjson_result<icelake::ondemand::document>::operator T() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get<T>();
 }
 simdjson_inline simdjson_result<icelake::ondemand::document>::operator icelake::ondemand::array() & noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
@@ -74845,36 +76195,39 @@ simdjson_inline const char * raw_json_string::raw() const noexcept { return rein
 
 simdjson_inline bool raw_json_string::is_free_from_unescaped_quote(std::string_view target) noexcept {
   size_t pos{0};
-  // if the content has no escape character, just scan through it quickly!
-  for(;pos < target.size() && target[pos] != '\\';pos++) {}
-  // slow path may begin.
-  bool escaping{false};
-  for(;pos < target.size();pos++) {
-    if((target[pos] == '"') && !escaping) {
-      return false;
-    } else if(target[pos] == '\\') {
-      escaping = !escaping;
-    } else {
-      escaping = false;
+  while(pos < target.size()) {
+    pos = target.find('"', pos);
+    if(pos == std::string_view::npos) { return true; }
+    if(pos != 0 && target[pos-1] != '\\') { return false; }
+    if(pos > 1 && target[pos-2] == '\\') {
+      size_t backslash_count{2};
+      for(size_t i = 3; i <= pos; i++) {
+        if(target[pos-i] == '\\') { backslash_count++; }
+        else { break; }
+      }
+      if(backslash_count % 2 == 0) { return false; }
     }
+    pos++;
   }
   return true;
 }
 
 simdjson_inline bool raw_json_string::is_free_from_unescaped_quote(const char* target) noexcept {
   size_t pos{0};
-  // if the content has no escape character, just scan through it quickly!
-  for(;target[pos] && target[pos] != '\\';pos++) {}
-  // slow path may begin.
-  bool escaping{false};
-  for(;target[pos];pos++) {
-    if((target[pos] == '"') && !escaping) {
-      return false;
-    } else if(target[pos] == '\\') {
-      escaping = !escaping;
-    } else {
-      escaping = false;
+  while(target[pos]) {
+    const char * result = strchr(target+pos, '"');
+    if(result == nullptr) { return true; }
+    pos = result - target;
+    if(pos != 0 && target[pos-1] != '\\') { return false; }
+    if(pos > 1 && target[pos-2] == '\\') {
+      size_t backslash_count{2};
+      for(size_t i = 3; i <= pos; i++) {
+        if(target[pos-i] == '\\') { backslash_count++; }
+        else { break; }
+      }
+      if(backslash_count % 2 == 0) { return false; }
     }
+    pos++;
   }
   return true;
 }
@@ -74886,7 +76239,7 @@ simdjson_inline bool raw_json_string::unsafe_is_equal(size_t length, std::string
 }
 
 simdjson_inline bool raw_json_string::unsafe_is_equal(std::string_view target) const noexcept {
-  // Assumptions: does not contain unescaped quote characters, and
+  // Assumptions: does not contain unescaped quote characters("), and
   // the raw content is quote terminated within a valid JSON string.
   if(target.size() <= SIMDJSON_PADDING) {
     return (raw()[target.size()] == '"') && !memcmp(raw(), target.data(), target.size());
@@ -74977,28 +76330,62 @@ simdjson_unused simdjson_inline bool operator!=(std::string_view c, const raw_js
   return !(a == c);
 }
 
+SIMDJSON_PUSH_DISABLE_WARNINGS
+SIMDJSON_DISABLE_STRICT_OVERFLOW_WARNING
+simdjson_inline object_iterator &object_iterator::operator++() noexcept {
+  // TODO this is a safety rail ... users should exit loops as soon as they receive an error.
+  // Nonetheless, let's see if performance is OK with this if statement--the compiler may give it to us for free.
+  if (!iter.is_open()) { return *this; } // Iterator will be released if there is an error
 
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> raw_json_string::unescape(json_iterator &iter, bool allow_replacement) const noexcept {
-  return iter.unescape(*this, allow_replacement);
-}
+  simdjson_unused error_code error;
+  if ((error = iter.skip_child() )) { return *this; }
 
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> raw_json_string::unescape_wobbly(json_iterator &iter) const noexcept {
-  return iter.unescape_wobbly(*this);
+  simdjson_unused bool has_value;
+  if ((error = iter.has_next_field().get(has_value) )) { return *this; };
+  return *this;
 }
+SIMDJSON_POP_DISABLE_WARNINGS
 
-simdjson_unused simdjson_inline std::ostream &operator<<(std::ostream &out, const raw_json_string &str) noexcept {
-  bool in_escape = false;
-  const char *s = str.raw();
-  while (true) {
-    switch (*s) {
-      case '\\': in_escape = !in_escape; break;
-      case '"': if (in_escape) { in_escape = false; } else { return out; } break;
-      default: if (in_escape) { in_escape = false; }
-    }
-    out << *s;
-    s++;
-  }
-}
+//
+// ### Live States
+//
+// While iterating or looking up values, depth >= iter.depth. at_start may vary. Error is
+// always SUCCESS:
+//
+// - Start: This is the state when the object is first found and the iterator is just past the {.
+//   In this state, at_start == true.
+// - Next: After we hand a scalar value to the user, or an array/object which they then fully
+//   iterate over, the iterator is at the , or } before the next value. In this state,
+//   depth == iter.depth, at_start == false, and error == SUCCESS.
+// - Unfinished Business: When we hand an array/object to the user which they do not fully
+//   iterate over, we need to finish that iteration by skipping child values until we reach the
+//   Next state. In this state, depth > iter.depth, at_start == false, and error == SUCCESS.
+//
+// ## Error States
+//
+// In error states, we will yield exactly one more value before stopping. iter.depth == depth
+// and at_start is always false. We decrement after yielding the error, moving to the Finished
+// state.
+//
+// - Chained Error: When the object iterator is part of an error chain--for example, in
+//   `for (auto tweet : doc["tweets"])`, where the tweet field may be missing or not be an
+//   object--we yield that error in the loop, exactly once. In this state, error != SUCCESS and
+//   iter.depth == depth, and at_start == false. We decrement depth when we yield the error.
+// - Missing Comma Error: When the iterator ++ method discovers there is no comma between fields,
+//   we flag that as an error and treat it exactly the same as a Chained Error. In this state,
+//   error == TAPE_ERROR, iter.depth == depth, and at_start == false.
+//
+// Errors that occur while reading a field to give to the user (such as when the key is not a
+// string or the field is missing a colon) are yielded immediately. Depth is then decremented,
+// moving to the Finished state without transitioning through an Error state at all.
+//
+// ## Terminal State
+//
+// The terminal state has iter.depth < depth. at_start is always false.
+//
+// - Finished: When we have reached a }, we are finished. We signal this by decrementing depth.
+//   In this state, iter.depth < depth, at_start == false, and error == SUCCESS.
+//
 
 } // namespace ondemand
 } // namespace icelake
@@ -75006,343 +76393,235 @@ simdjson_unused simdjson_inline std::ostream &operator<<(std::ostream &out, cons
 
 namespace simdjson {
 
-simdjson_inline simdjson_result<icelake::ondemand::raw_json_string>::simdjson_result(icelake::ondemand::raw_json_string &&value) noexcept
-    : implementation_simdjson_result_base<icelake::ondemand::raw_json_string>(std::forward<icelake::ondemand::raw_json_string>(value)) {}
-simdjson_inline simdjson_result<icelake::ondemand::raw_json_string>::simdjson_result(error_code error) noexcept
-    : implementation_simdjson_result_base<icelake::ondemand::raw_json_string>(error) {}
+simdjson_inline simdjson_result<icelake::ondemand::object_iterator>::simdjson_result(
+  icelake::ondemand::object_iterator &&value
+) noexcept
+  : implementation_simdjson_result_base<icelake::ondemand::object_iterator>(std::forward<icelake::ondemand::object_iterator>(value))
+{
+  first.iter.assert_is_valid();
+}
+simdjson_inline simdjson_result<icelake::ondemand::object_iterator>::simdjson_result(error_code error) noexcept
+  : implementation_simdjson_result_base<icelake::ondemand::object_iterator>({}, error)
+{
+}
 
-simdjson_inline simdjson_result<const char *> simdjson_result<icelake::ondemand::raw_json_string>::raw() const noexcept {
+simdjson_inline simdjson_result<icelake::ondemand::field> simdjson_result<icelake::ondemand::object_iterator>::operator*() noexcept {
   if (error()) { return error(); }
-  return first.raw();
+  return *first;
 }
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> simdjson_result<icelake::ondemand::raw_json_string>::unescape(icelake::ondemand::json_iterator &iter, bool allow_replacement) const noexcept {
-  if (error()) { return error(); }
-  return first.unescape(iter, allow_replacement);
+// If we're iterating and there is an error, return the error once.
+simdjson_inline bool simdjson_result<icelake::ondemand::object_iterator>::operator==(const simdjson_result<icelake::ondemand::object_iterator> &other) const noexcept {
+  if (!first.iter.is_valid()) { return !error(); }
+  return first == other.first;
 }
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> simdjson_result<icelake::ondemand::raw_json_string>::unescape_wobbly(icelake::ondemand::json_iterator &iter) const noexcept {
-  if (error()) { return error(); }
-  return first.unescape_wobbly(iter);
+// If we're iterating and there is an error, return the error once.
+simdjson_inline bool simdjson_result<icelake::ondemand::object_iterator>::operator!=(const simdjson_result<icelake::ondemand::object_iterator> &other) const noexcept {
+  if (!first.iter.is_valid()) { return error(); }
+  return first != other.first;
 }
+// Checks for ']' and ','
+simdjson_inline simdjson_result<icelake::ondemand::object_iterator> &simdjson_result<icelake::ondemand::object_iterator>::operator++() noexcept {
+  // Clear the error if there is one, so we don't yield it twice
+  if (error()) { second = SUCCESS; return *this; }
+  ++first;
+  return *this;
+}
+
 } // namespace simdjson
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_RAW_JSON_STRING_INL_H
-/* end file simdjson/generic/ondemand/raw_json_string-inl.h for icelake */
-/* including simdjson/generic/ondemand/serialization-inl.h for icelake: #include "simdjson/generic/ondemand/serialization-inl.h" */
-/* begin file simdjson/generic/ondemand/serialization-inl.h for icelake */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H
+#endif // SIMDJSON_GENERIC_ONDEMAND_OBJECT_ITERATOR_INL_H
+/* end file simdjson/generic/ondemand/object_iterator-inl.h for icelake */
+/* including simdjson/generic/ondemand/parser-inl.h for icelake: #include "simdjson/generic/ondemand/parser-inl.h" */
+/* begin file simdjson/generic/ondemand/parser-inl.h for icelake */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_PARSER_INL_H
 
 /* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_PARSER_INL_H */
+/* amalgamation skipped (editor-only): #include "simdjson/padded_string.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/padded_string_view.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/implementation.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/internal/dom_parser_implementation.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/dom/base.h" // for MINIMAL_DOCUMENT_CAPACITY */
 /* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document-inl.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_type.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/object.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/serialization.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document_stream.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/parser.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/raw_json_string.h" */
 /* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
 namespace simdjson {
+namespace icelake {
+namespace ondemand {
 
-inline std::string_view trim(const std::string_view str) noexcept {
-  // We can almost surely do better by rolling our own find_first_not_of function.
-  size_t first = str.find_first_not_of(" \t\n\r");
-  // If we have the empty string (just white space), then no trimming is possible, and
-  // we return the empty string_view.
-  if (std::string_view::npos == first) { return std::string_view(); }
-  size_t last = str.find_last_not_of(" \t\n\r");
-  return str.substr(first, (last - first + 1));
-}
-
-
-inline simdjson_result<std::string_view> to_json_string(icelake::ondemand::document& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
+simdjson_inline parser::parser(size_t max_capacity) noexcept
+  : _max_capacity{max_capacity} {
 }
 
-inline simdjson_result<std::string_view> to_json_string(icelake::ondemand::document_reference& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
-}
+simdjson_warn_unused simdjson_inline error_code parser::allocate(size_t new_capacity, size_t new_max_depth) noexcept {
+  if (new_capacity > max_capacity()) { return CAPACITY; }
+  if (string_buf && new_capacity == capacity() && new_max_depth == max_depth()) { return SUCCESS; }
 
-inline simdjson_result<std::string_view> to_json_string(icelake::ondemand::value& x) noexcept {
-  /**
-   * If we somehow receive a value that has already been consumed,
-   * then the following code could be in trouble. E.g., we create
-   * an array as needed, but if an array was already created, then
-   * it could be bad.
-   */
-  using namespace icelake::ondemand;
-  icelake::ondemand::json_type t;
-  auto error = x.type().get(t);
-  if(error != SUCCESS) { return error; }
-  switch (t)
-  {
-    case json_type::array:
-    {
-      icelake::ondemand::array array;
-      error = x.get_array().get(array);
-      if(error) { return error; }
-      return to_json_string(array);
-    }
-    case json_type::object:
-    {
-      icelake::ondemand::object object;
-      error = x.get_object().get(object);
-      if(error) { return error; }
-      return to_json_string(object);
-    }
-    default:
-      return trim(x.raw_json_token());
+  // string_capacity copied from document::allocate
+  _capacity = 0;
+  size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * new_capacity / 3 + SIMDJSON_PADDING, 64);
+  string_buf.reset(new (std::nothrow) uint8_t[string_capacity]);
+#if SIMDJSON_DEVELOPMENT_CHECKS
+  start_positions.reset(new (std::nothrow) token_position[new_max_depth]);
+#endif
+  if (implementation) {
+    SIMDJSON_TRY( implementation->set_capacity(new_capacity) );
+    SIMDJSON_TRY( implementation->set_max_depth(new_max_depth) );
+  } else {
+    SIMDJSON_TRY( simdjson::get_active_implementation()->create_dom_parser_implementation(new_capacity, new_max_depth, implementation) );
   }
+  _capacity = new_capacity;
+  _max_depth = new_max_depth;
+  return SUCCESS;
 }
-
-inline simdjson_result<std::string_view> to_json_string(icelake::ondemand::object& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
-}
-
-inline simdjson_result<std::string_view> to_json_string(icelake::ondemand::array& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
+#if SIMDJSON_DEVELOPMENT_CHECKS
+simdjson_inline simdjson_warn_unused bool parser::string_buffer_overflow(const uint8_t *string_buf_loc) const noexcept {
+  return (string_buf_loc < string_buf.get()) || (size_t(string_buf_loc - string_buf.get()) >= capacity());
 }
+#endif
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<icelake::ondemand::document> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(padded_string_view json) & noexcept {
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<icelake::ondemand::document_reference> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
+  json.remove_utf8_bom();
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<icelake::ondemand::value> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
+  // Allocate if needed
+  if (capacity() < json.length() || !string_buf) {
+    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
+  }
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<icelake::ondemand::object> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
+  // Run stage 1.
+  SIMDJSON_TRY( implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular) );
+  return document::start({ reinterpret_cast<const uint8_t *>(json.data()), this });
 }
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<icelake::ondemand::array> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
-} // namespace simdjson
+#ifdef SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate_allow_incomplete_json(padded_string_view json) & noexcept {
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
-namespace simdjson { namespace icelake { namespace ondemand {
+  json.remove_utf8_bom();
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::icelake::ondemand::value x) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(x).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::icelake::ondemand::value> x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
-}
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::icelake::ondemand::value x) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(x).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
+  // Allocate if needed
+  if (capacity() < json.length() || !string_buf) {
+    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
   }
-}
-#endif
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::icelake::ondemand::array value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::icelake::ondemand::array> x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
-}
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::icelake::ondemand::array value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
+  // Run stage 1.
+  const simdjson::error_code err = implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular);
+  if (err) {
+    if (err != UNCLOSED_STRING)
+      return err;
   }
+  return document::start({ reinterpret_cast<const uint8_t *>(json.data()), this, true });
 }
-#endif
+#endif // SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::icelake::ondemand::document& value)  {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::icelake::ondemand::document_reference& value)  {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::icelake::ondemand::document>&& x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const char *json, size_t len, size_t allocated) & noexcept {
+  return iterate(padded_string_view(json, len, allocated));
 }
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::icelake::ondemand::document_reference>&& x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const uint8_t *json, size_t len, size_t allocated) & noexcept {
+  return iterate(padded_string_view(json, len, allocated));
 }
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::icelake::ondemand::document& value)  {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
-  }
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(std::string_view json, size_t allocated) & noexcept {
+  return iterate(padded_string_view(json, allocated));
 }
-#endif
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::icelake::ondemand::object value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(std::string &json) & noexcept {
+  if(json.capacity() - json.size() < SIMDJSON_PADDING) {
+    json.reserve(json.size() + SIMDJSON_PADDING);
   }
+  return iterate(padded_string_view(json));
 }
-inline std::ostream& operator<<(std::ostream& out,  simdjson::simdjson_result<simdjson::icelake::ondemand::object> x) {
-  if (x.error()) { throw  simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const std::string &json) & noexcept {
+  return iterate(padded_string_view(json));
 }
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::icelake::ondemand::object value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
-  }
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const simdjson_result<padded_string_view> &result) & noexcept {
+  // We don't presently have a way to temporarily get a const T& from a simdjson_result<T> without throwing an exception
+  SIMDJSON_TRY( result.error() );
+  padded_string_view json = result.value_unsafe();
+  return iterate(json);
 }
-#endif
-}}} // namespace simdjson::icelake::ondemand
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H
-/* end file simdjson/generic/ondemand/serialization-inl.h for icelake */
-/* including simdjson/generic/ondemand/token_iterator-inl.h for icelake: #include "simdjson/generic/ondemand/token_iterator-inl.h" */
-/* begin file simdjson/generic/ondemand/token_iterator-inl.h for icelake */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_TOKEN_ITERATOR_INL_H
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const simdjson_result<padded_string> &result) & noexcept {
+  // We don't presently have a way to temporarily get a const T& from a simdjson_result<T> without throwing an exception
+  SIMDJSON_TRY( result.error() );
+  const padded_string &json = result.value_unsafe();
+  return iterate(json);
+}
 
-/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_TOKEN_ITERATOR_INL_H */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/token_iterator.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/implementation_simdjson_result_base-inl.h" */
-/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
+simdjson_warn_unused simdjson_inline simdjson_result<json_iterator> parser::iterate_raw(padded_string_view json) & noexcept {
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
-namespace simdjson {
-namespace icelake {
-namespace ondemand {
+  json.remove_utf8_bom();
 
-simdjson_inline token_iterator::token_iterator(
-  const uint8_t *_buf,
-  token_position position
-) noexcept : buf{_buf}, _position{position}
-{
-}
+  // Allocate if needed
+  if (capacity() < json.length()) {
+    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
+  }
 
-simdjson_inline uint32_t token_iterator::current_offset() const noexcept {
-  return *(_position);
+  // Run stage 1.
+  SIMDJSON_TRY( implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular) );
+  return json_iterator(reinterpret_cast<const uint8_t *>(json.data()), this);
 }
 
-
-simdjson_inline const uint8_t *token_iterator::return_current_and_advance() noexcept {
-  return &buf[*(_position++)];
+inline simdjson_result<document_stream> parser::iterate_many(const uint8_t *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {
+  if(batch_size < MINIMAL_BATCH_SIZE) { batch_size = MINIMAL_BATCH_SIZE; }
+  if((len >= 3) && (std::memcmp(buf, "\xEF\xBB\xBF", 3) == 0)) {
+    buf += 3;
+    len -= 3;
+  }
+  if(allow_comma_separated && batch_size < len) { batch_size = len; }
+  return document_stream(*this, buf, len, batch_size, allow_comma_separated);
 }
-
-simdjson_inline const uint8_t *token_iterator::peek(token_position position) const noexcept {
-  return &buf[*position];
+inline simdjson_result<document_stream> parser::iterate_many(const char *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {
+  return iterate_many(reinterpret_cast<const uint8_t *>(buf), len, batch_size, allow_comma_separated);
 }
-simdjson_inline uint32_t token_iterator::peek_index(token_position position) const noexcept {
-  return *position;
+inline simdjson_result<document_stream> parser::iterate_many(const std::string &s, size_t batch_size, bool allow_comma_separated) noexcept {
+  return iterate_many(s.data(), s.length(), batch_size, allow_comma_separated);
 }
-simdjson_inline uint32_t token_iterator::peek_length(token_position position) const noexcept {
-  return *(position+1) - *position;
+inline simdjson_result<document_stream> parser::iterate_many(const padded_string &s, size_t batch_size, bool allow_comma_separated) noexcept {
+  return iterate_many(s.data(), s.length(), batch_size, allow_comma_separated);
 }
 
-simdjson_inline uint32_t token_iterator::peek_root_length(token_position position) const noexcept {
-  return *(position+2) - *(position) > *(position+1) - *(position) ?
-      *(position+1) - *(position)
-      : *(position+2) - *(position);
-}
-simdjson_inline const uint8_t *token_iterator::peek(int32_t delta) const noexcept {
-  return &buf[*(_position+delta)];
+simdjson_pure simdjson_inline size_t parser::capacity() const noexcept {
+  return _capacity;
 }
-simdjson_inline uint32_t token_iterator::peek_index(int32_t delta) const noexcept {
-  return *(_position+delta);
+simdjson_pure simdjson_inline size_t parser::max_capacity() const noexcept {
+  return _max_capacity;
 }
-simdjson_inline uint32_t token_iterator::peek_length(int32_t delta) const noexcept {
-  return *(_position+delta+1) - *(_position+delta);
+simdjson_pure simdjson_inline size_t parser::max_depth() const noexcept {
+  return _max_depth;
 }
 
-simdjson_inline token_position token_iterator::position() const noexcept {
-  return _position;
-}
-simdjson_inline void token_iterator::set_position(token_position target_position) noexcept {
-  _position = target_position;
+simdjson_inline void parser::set_max_capacity(size_t max_capacity) noexcept {
+  if(max_capacity < dom::MINIMAL_DOCUMENT_CAPACITY) {
+    _max_capacity = max_capacity;
+  } else {
+    _max_capacity = dom::MINIMAL_DOCUMENT_CAPACITY;
+  }
 }
 
-simdjson_inline bool token_iterator::operator==(const token_iterator &other) const noexcept {
-  return _position == other._position;
-}
-simdjson_inline bool token_iterator::operator!=(const token_iterator &other) const noexcept {
-  return _position != other._position;
-}
-simdjson_inline bool token_iterator::operator>(const token_iterator &other) const noexcept {
-  return _position > other._position;
-}
-simdjson_inline bool token_iterator::operator>=(const token_iterator &other) const noexcept {
-  return _position >= other._position;
-}
-simdjson_inline bool token_iterator::operator<(const token_iterator &other) const noexcept {
-  return _position < other._position;
+simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape(raw_json_string in, uint8_t *&dst, bool allow_replacement) const noexcept {
+  uint8_t *end = implementation->parse_string(in.buf, dst, allow_replacement);
+  if (!end) { return STRING_ERROR; }
+  std::string_view result(reinterpret_cast<const char *>(dst), end-dst);
+  dst = end;
+  return result;
 }
-simdjson_inline bool token_iterator::operator<=(const token_iterator &other) const noexcept {
-  return _position <= other._position;
+
+simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape_wobbly(raw_json_string in, uint8_t *&dst) const noexcept {
+  uint8_t *end = implementation->parse_wobbly_string(in.buf, dst);
+  if (!end) { return STRING_ERROR; }
+  std::string_view result(reinterpret_cast<const char *>(dst), end-dst);
+  dst = end;
+  return result;
 }
 
 } // namespace ondemand
@@ -75351,10 +76630,10 @@ simdjson_inline bool token_iterator::operator<=(const token_iterator &other) con
 
 namespace simdjson {
 
-simdjson_inline simdjson_result<icelake::ondemand::token_iterator>::simdjson_result(icelake::ondemand::token_iterator &&value) noexcept
-    : implementation_simdjson_result_base<icelake::ondemand::token_iterator>(std::forward<icelake::ondemand::token_iterator>(value)) {}
-simdjson_inline simdjson_result<icelake::ondemand::token_iterator>::simdjson_result(error_code error) noexcept
-    : implementation_simdjson_result_base<icelake::ondemand::token_iterator>(error) {}
+simdjson_inline simdjson_result<icelake::ondemand::parser>::simdjson_result(icelake::ondemand::parser &&value) noexcept
+    : implementation_simdjson_result_base<icelake::ondemand::parser>(std::forward<icelake::ondemand::parser>(value)) {}
+simdjson_inline simdjson_result<icelake::ondemand::parser>::simdjson_result(error_code error) noexcept
+    : implementation_simdjson_result_base<icelake::ondemand::parser>(error) {}
 
 } // namespace simdjson
 
@@ -75376,6 +76655,7 @@ simdjson_inline simdjson_result<icelake::ondemand::token_iterator>::simdjson_res
 /* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
 namespace simdjson {
+
 namespace icelake {
 namespace ondemand {
 
@@ -75455,6 +76735,7 @@ simdjson_warn_unused simdjson_inline error_code value_iterator::end_container()
     _json_iter->ascend_to(depth()-1);
     return SUCCESS;
 }
+} // namespace simdjson
 
 simdjson_warn_unused simdjson_inline simdjson_result<bool> value_iterator::has_next_field() noexcept {
   assert_at_next();
@@ -83091,6 +84372,496 @@ simdjson_inline simdjson_result<bool> value::is_string() noexcept {
 }
 
 
+simdjson_inline bool value::is_negative() noexcept {
+  return iter.is_negative();
+}
+
+simdjson_inline simdjson_result<bool> value::is_integer() noexcept {
+  return iter.is_integer();
+}
+simdjson_warn_unused simdjson_inline simdjson_result<number_type> value::get_number_type() noexcept {
+  return iter.get_number_type();
+}
+simdjson_warn_unused simdjson_inline simdjson_result<number> value::get_number() noexcept {
+  return iter.get_number();
+}
+
+inline simdjson_result<value> array::at_path(std::string_view json_path) noexcept {
+  auto json_pointer = json_path_to_pointer_conversion(json_path);
+  if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
+  return at_pointer(json_pointer);
+}
+
+simdjson_inline simdjson_result<value> value::at_path(std::string_view json_path) noexcept {
+  json_type t;
+  SIMDJSON_TRY(type().get(t));
+  switch (t) {
+  case json_type::array:
+      return (*this).get_array().at_path(json_path);
+  case json_type::object:
+      return (*this).get_object().at_path(json_path);
+  default:
+      return INVALID_JSON_POINTER;
+  }
+}
+
+} // namespace ondemand
+} // namespace ppc64
+} // namespace simdjson
+
+namespace simdjson {
+
+simdjson_inline simdjson_result<ppc64::ondemand::value>::simdjson_result(
+  ppc64::ondemand::value &&value
+) noexcept :
+    implementation_simdjson_result_base<ppc64::ondemand::value>(
+      std::forward<ppc64::ondemand::value>(value)
+    )
+{
+}
+simdjson_inline simdjson_result<ppc64::ondemand::value>::simdjson_result(
+  error_code error
+) noexcept :
+    implementation_simdjson_result_base<ppc64::ondemand::value>(error)
+{
+}
+simdjson_inline simdjson_result<size_t> simdjson_result<ppc64::ondemand::value>::count_elements() & noexcept {
+  if (error()) { return error(); }
+  return first.count_elements();
+}
+simdjson_inline simdjson_result<size_t> simdjson_result<ppc64::ondemand::value>::count_fields() & noexcept {
+  if (error()) { return error(); }
+  return first.count_fields();
+}
+simdjson_inline simdjson_result<ppc64::ondemand::value> simdjson_result<ppc64::ondemand::value>::at(size_t index) noexcept {
+  if (error()) { return error(); }
+  return first.at(index);
+}
+simdjson_inline simdjson_result<ppc64::ondemand::array_iterator> simdjson_result<ppc64::ondemand::value>::begin() & noexcept {
+  if (error()) { return error(); }
+  return first.begin();
+}
+simdjson_inline simdjson_result<ppc64::ondemand::array_iterator> simdjson_result<ppc64::ondemand::value>::end() & noexcept {
+  if (error()) { return error(); }
+  return {};
+}
+
+simdjson_inline simdjson_result<ppc64::ondemand::value> simdjson_result<ppc64::ondemand::value>::find_field(std::string_view key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field(key);
+}
+simdjson_inline simdjson_result<ppc64::ondemand::value> simdjson_result<ppc64::ondemand::value>::find_field(const char *key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field(key);
+}
+
+simdjson_inline simdjson_result<ppc64::ondemand::value> simdjson_result<ppc64::ondemand::value>::find_field_unordered(std::string_view key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field_unordered(key);
+}
+simdjson_inline simdjson_result<ppc64::ondemand::value> simdjson_result<ppc64::ondemand::value>::find_field_unordered(const char *key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field_unordered(key);
+}
+
+simdjson_inline simdjson_result<ppc64::ondemand::value> simdjson_result<ppc64::ondemand::value>::operator[](std::string_view key) noexcept {
+  if (error()) { return error(); }
+  return first[key];
+}
+simdjson_inline simdjson_result<ppc64::ondemand::value> simdjson_result<ppc64::ondemand::value>::operator[](const char *key) noexcept {
+  if (error()) { return error(); }
+  return first[key];
+}
+
+simdjson_inline simdjson_result<ppc64::ondemand::array> simdjson_result<ppc64::ondemand::value>::get_array() noexcept {
+  if (error()) { return error(); }
+  return first.get_array();
+}
+simdjson_inline simdjson_result<ppc64::ondemand::object> simdjson_result<ppc64::ondemand::value>::get_object() noexcept {
+  if (error()) { return error(); }
+  return first.get_object();
+}
+simdjson_inline simdjson_result<uint64_t> simdjson_result<ppc64::ondemand::value>::get_uint64() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint64();
+}
+simdjson_inline simdjson_result<uint64_t> simdjson_result<ppc64::ondemand::value>::get_uint64_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint64_in_string();
+}
+simdjson_inline simdjson_result<int64_t> simdjson_result<ppc64::ondemand::value>::get_int64() noexcept {
+  if (error()) { return error(); }
+  return first.get_int64();
+}
+simdjson_inline simdjson_result<int64_t> simdjson_result<ppc64::ondemand::value>::get_int64_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_int64_in_string();
+}
+simdjson_inline simdjson_result<double> simdjson_result<ppc64::ondemand::value>::get_double() noexcept {
+  if (error()) { return error(); }
+  return first.get_double();
+}
+simdjson_inline simdjson_result<double> simdjson_result<ppc64::ondemand::value>::get_double_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_double_in_string();
+}
+simdjson_inline simdjson_result<std::string_view> simdjson_result<ppc64::ondemand::value>::get_string(bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.get_string(allow_replacement);
+}
+template <typename string_type>
+simdjson_inline error_code simdjson_result<ppc64::ondemand::value>::get_string(string_type& receiver, bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.get_string(receiver, allow_replacement);
+}
+simdjson_inline simdjson_result<std::string_view> simdjson_result<ppc64::ondemand::value>::get_wobbly_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_wobbly_string();
+}
+simdjson_inline simdjson_result<ppc64::ondemand::raw_json_string> simdjson_result<ppc64::ondemand::value>::get_raw_json_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_raw_json_string();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<ppc64::ondemand::value>::get_bool() noexcept {
+  if (error()) { return error(); }
+  return first.get_bool();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<ppc64::ondemand::value>::is_null() noexcept {
+  if (error()) { return error(); }
+  return first.is_null();
+}
+
+template<> simdjson_inline error_code simdjson_result<ppc64::ondemand::value>::get<ppc64::ondemand::value>(ppc64::ondemand::value &out) noexcept {
+  if (error()) { return error(); }
+  out = first;
+  return SUCCESS;
+}
+
+template<typename T> simdjson_inline simdjson_result<T> simdjson_result<ppc64::ondemand::value>::get() noexcept {
+  if (error()) { return error(); }
+  return first.get<T>();
+}
+template<typename T> simdjson_inline error_code simdjson_result<ppc64::ondemand::value>::get(T &out) noexcept {
+  if (error()) { return error(); }
+  return first.get<T>(out);
+}
+
+template<> simdjson_inline simdjson_result<ppc64::ondemand::value> simdjson_result<ppc64::ondemand::value>::get<ppc64::ondemand::value>() noexcept  {
+  if (error()) { return error(); }
+  return std::move(first);
+}
+
+simdjson_inline simdjson_result<ppc64::ondemand::json_type> simdjson_result<ppc64::ondemand::value>::type() noexcept {
+  if (error()) { return error(); }
+  return first.type();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<ppc64::ondemand::value>::is_scalar() noexcept {
+  if (error()) { return error(); }
+  return first.is_scalar();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<ppc64::ondemand::value>::is_string() noexcept {
+  if (error()) { return error(); }
+  return first.is_string();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<ppc64::ondemand::value>::is_negative() noexcept {
+  if (error()) { return error(); }
+  return first.is_negative();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<ppc64::ondemand::value>::is_integer() noexcept {
+  if (error()) { return error(); }
+  return first.is_integer();
+}
+simdjson_inline simdjson_result<ppc64::number_type> simdjson_result<ppc64::ondemand::value>::get_number_type() noexcept {
+  if (error()) { return error(); }
+  return first.get_number_type();
+}
+simdjson_inline simdjson_result<ppc64::ondemand::number> simdjson_result<ppc64::ondemand::value>::get_number() noexcept {
+  if (error()) { return error(); }
+  return first.get_number();
+}
+#if SIMDJSON_EXCEPTIONS
+template <class T>
+simdjson_inline simdjson_result<ppc64::ondemand::value>::operator T() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first.get<T>();
+}
+simdjson_inline simdjson_result<ppc64::ondemand::value>::operator ppc64::ondemand::array() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<ppc64::ondemand::value>::operator ppc64::ondemand::object() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<ppc64::ondemand::value>::operator uint64_t() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<ppc64::ondemand::value>::operator int64_t() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<ppc64::ondemand::value>::operator double() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<ppc64::ondemand::value>::operator std::string_view() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<ppc64::ondemand::value>::operator ppc64::ondemand::raw_json_string() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<ppc64::ondemand::value>::operator bool() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+#endif
+
+simdjson_inline simdjson_result<std::string_view> simdjson_result<ppc64::ondemand::value>::raw_json_token() noexcept {
+  if (error()) { return error(); }
+  return first.raw_json_token();
+}
+
+simdjson_inline simdjson_result<std::string_view> simdjson_result<ppc64::ondemand::value>::raw_json() noexcept {
+  if (error()) { return error(); }
+  return first.raw_json();
+}
+
+simdjson_inline simdjson_result<const char *> simdjson_result<ppc64::ondemand::value>::current_location() noexcept {
+  if (error()) { return error(); }
+  return first.current_location();
+}
+
+simdjson_inline simdjson_result<int32_t> simdjson_result<ppc64::ondemand::value>::current_depth() const noexcept {
+  if (error()) { return error(); }
+  return first.current_depth();
+}
+
+simdjson_inline simdjson_result<ppc64::ondemand::value> simdjson_result<ppc64::ondemand::value>::at_pointer(
+    std::string_view json_pointer) noexcept {
+  if (error()) {
+      return error();
+  }
+  return first.at_pointer(json_pointer);
+}
+
+simdjson_inline simdjson_result<ppc64::ondemand::value> simdjson_result<ppc64::ondemand::value>::at_path(
+      std::string_view json_path) noexcept {
+  if (error()) {
+    return error();
+  }
+  return first.at_path(json_path);
+}
+
+} // namespace simdjson
+
+#endif // SIMDJSON_GENERIC_ONDEMAND_ARRAY_ITERATOR_INL_H
+/* end file simdjson/generic/ondemand/array_iterator-inl.h for ppc64 */
+/* including simdjson/generic/ondemand/value-inl.h for ppc64: #include "simdjson/generic/ondemand/value-inl.h" */
+/* begin file simdjson/generic/ondemand/value-inl.h for ppc64 */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_VALUE_INL_H
+
+/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_VALUE_INL_H */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array_iterator.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_iterator.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_type.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/object.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/raw_json_string.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value.h" */
+/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
+
+namespace simdjson {
+namespace ppc64 {
+namespace ondemand {
+
+simdjson_inline value::value(const value_iterator &_iter) noexcept
+  : iter{_iter}
+{
+}
+simdjson_inline value value::start(const value_iterator &iter) noexcept {
+  return iter;
+}
+simdjson_inline value value::resume(const value_iterator &iter) noexcept {
+  return iter;
+}
+
+simdjson_inline simdjson_result<array> value::get_array() noexcept {
+  return array::start(iter);
+}
+simdjson_inline simdjson_result<object> value::get_object() noexcept {
+  return object::start(iter);
+}
+simdjson_inline simdjson_result<object> value::start_or_resume_object() noexcept {
+  if (iter.at_start()) {
+    return get_object();
+  } else {
+    return object::resume(iter);
+  }
+}
+
+simdjson_inline simdjson_result<raw_json_string> value::get_raw_json_string() noexcept {
+  return iter.get_raw_json_string();
+}
+simdjson_inline simdjson_result<std::string_view> value::get_string(bool allow_replacement) noexcept {
+  return iter.get_string(allow_replacement);
+}
+template <typename string_type>
+simdjson_inline error_code value::get_string(string_type& receiver, bool allow_replacement) noexcept {
+  return iter.get_string(receiver, allow_replacement);
+}
+simdjson_inline simdjson_result<std::string_view> value::get_wobbly_string() noexcept {
+  return iter.get_wobbly_string();
+}
+simdjson_inline simdjson_result<double> value::get_double() noexcept {
+  return iter.get_double();
+}
+simdjson_inline simdjson_result<double> value::get_double_in_string() noexcept {
+  return iter.get_double_in_string();
+}
+simdjson_inline simdjson_result<uint64_t> value::get_uint64() noexcept {
+  return iter.get_uint64();
+}
+simdjson_inline simdjson_result<uint64_t> value::get_uint64_in_string() noexcept {
+  return iter.get_uint64_in_string();
+}
+simdjson_inline simdjson_result<int64_t> value::get_int64() noexcept {
+  return iter.get_int64();
+}
+simdjson_inline simdjson_result<int64_t> value::get_int64_in_string() noexcept {
+  return iter.get_int64_in_string();
+}
+simdjson_inline simdjson_result<bool> value::get_bool() noexcept {
+  return iter.get_bool();
+}
+simdjson_inline simdjson_result<bool> value::is_null() noexcept {
+  return iter.is_null();
+}
+
+template<> simdjson_inline simdjson_result<array> value::get() noexcept { return get_array(); }
+template<> simdjson_inline simdjson_result<object> value::get() noexcept { return get_object(); }
+template<> simdjson_inline simdjson_result<raw_json_string> value::get() noexcept { return get_raw_json_string(); }
+template<> simdjson_inline simdjson_result<std::string_view> value::get() noexcept { return get_string(false); }
+template<> simdjson_inline simdjson_result<number> value::get() noexcept { return get_number(); }
+template<> simdjson_inline simdjson_result<double> value::get() noexcept { return get_double(); }
+template<> simdjson_inline simdjson_result<uint64_t> value::get() noexcept { return get_uint64(); }
+template<> simdjson_inline simdjson_result<int64_t> value::get() noexcept { return get_int64(); }
+template<> simdjson_inline simdjson_result<bool> value::get() noexcept { return get_bool(); }
+
+
+template<> simdjson_inline error_code value::get(array& out) noexcept { return get_array().get(out); }
+template<> simdjson_inline error_code value::get(object& out) noexcept { return get_object().get(out); }
+template<> simdjson_inline error_code value::get(raw_json_string& out) noexcept { return get_raw_json_string().get(out); }
+template<> simdjson_inline error_code value::get(std::string_view& out) noexcept { return get_string(false).get(out); }
+template<> simdjson_inline error_code value::get(number& out) noexcept { return get_number().get(out); }
+template<> simdjson_inline error_code value::get(double& out) noexcept { return get_double().get(out); }
+template<> simdjson_inline error_code value::get(uint64_t& out) noexcept { return get_uint64().get(out); }
+template<> simdjson_inline error_code value::get(int64_t& out) noexcept { return get_int64().get(out); }
+template<> simdjson_inline error_code value::get(bool& out) noexcept { return get_bool().get(out); }
+
+#if SIMDJSON_EXCEPTIONS
+template <class T>
+simdjson_inline value::operator T() noexcept(false) {
+  return get<T>();
+}
+simdjson_inline value::operator array() noexcept(false) {
+  return get_array();
+}
+simdjson_inline value::operator object() noexcept(false) {
+  return get_object();
+}
+simdjson_inline value::operator uint64_t() noexcept(false) {
+  return get_uint64();
+}
+simdjson_inline value::operator int64_t() noexcept(false) {
+  return get_int64();
+}
+simdjson_inline value::operator double() noexcept(false) {
+  return get_double();
+}
+simdjson_inline value::operator std::string_view() noexcept(false) {
+  return get_string(false);
+}
+simdjson_inline value::operator raw_json_string() noexcept(false) {
+  return get_raw_json_string();
+}
+simdjson_inline value::operator bool() noexcept(false) {
+  return get_bool();
+}
+#endif
+
+simdjson_inline simdjson_result<array_iterator> value::begin() & noexcept {
+  return get_array().begin();
+}
+simdjson_inline simdjson_result<array_iterator> value::end() & noexcept {
+  return {};
+}
+simdjson_inline simdjson_result<size_t> value::count_elements() & noexcept {
+  simdjson_result<size_t> answer;
+  auto a = get_array();
+  answer = a.count_elements();
+  // count_elements leaves you pointing inside the array, at the first element.
+  // We need to move back so that the user can create a new array (which requires that
+  // we point at '[').
+  iter.move_at_start();
+  return answer;
+}
+simdjson_inline simdjson_result<size_t> value::count_fields() & noexcept {
+  simdjson_result<size_t> answer;
+  auto a = get_object();
+  answer = a.count_fields();
+  iter.move_at_start();
+  return answer;
+}
+simdjson_inline simdjson_result<value> value::at(size_t index) noexcept {
+  auto a = get_array();
+  return a.at(index);
+}
+
+simdjson_inline simdjson_result<value> value::find_field(std::string_view key) noexcept {
+  return start_or_resume_object().find_field(key);
+}
+simdjson_inline simdjson_result<value> value::find_field(const char *key) noexcept {
+  return start_or_resume_object().find_field(key);
+}
+
+simdjson_inline simdjson_result<value> value::find_field_unordered(std::string_view key) noexcept {
+  return start_or_resume_object().find_field_unordered(key);
+}
+simdjson_inline simdjson_result<value> value::find_field_unordered(const char *key) noexcept {
+  return start_or_resume_object().find_field_unordered(key);
+}
+
+simdjson_inline simdjson_result<value> value::operator[](std::string_view key) noexcept {
+  return start_or_resume_object()[key];
+}
+simdjson_inline simdjson_result<value> value::operator[](const char *key) noexcept {
+  return start_or_resume_object()[key];
+}
+
+simdjson_inline simdjson_result<json_type> value::type() noexcept {
+  return iter.type();
+}
+
+simdjson_inline simdjson_result<bool> value::is_scalar() noexcept {
+  json_type this_type;
+  auto error = type().get(this_type);
+  if(error) { return error; }
+  return ! ((this_type == json_type::array) || (this_type == json_type::object));
+}
+
+simdjson_inline simdjson_result<bool> value::is_string() noexcept {
+  json_type this_type;
+  auto error = type().get(this_type);
+  if(error) { return error; }
+  return (this_type == json_type::string);
+}
+
+
 simdjson_inline bool value::is_negative() noexcept {
   return iter.is_negative();
 }
@@ -83998,7 +85769,7 @@ simdjson_inline simdjson_result<ppc64::ondemand::number> simdjson_result<ppc64::
 template <class T, typename std::enable_if<std::is_same<T, ppc64::ondemand::document>::value == false>::type>
 simdjson_inline simdjson_result<ppc64::ondemand::document>::operator T() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get<T>();
 }
 simdjson_inline simdjson_result<ppc64::ondemand::document>::operator ppc64::ondemand::array() & noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
@@ -86424,36 +88195,39 @@ simdjson_inline const char * raw_json_string::raw() const noexcept { return rein
 
 simdjson_inline bool raw_json_string::is_free_from_unescaped_quote(std::string_view target) noexcept {
   size_t pos{0};
-  // if the content has no escape character, just scan through it quickly!
-  for(;pos < target.size() && target[pos] != '\\';pos++) {}
-  // slow path may begin.
-  bool escaping{false};
-  for(;pos < target.size();pos++) {
-    if((target[pos] == '"') && !escaping) {
-      return false;
-    } else if(target[pos] == '\\') {
-      escaping = !escaping;
-    } else {
-      escaping = false;
+  while(pos < target.size()) {
+    pos = target.find('"', pos);
+    if(pos == std::string_view::npos) { return true; }
+    if(pos != 0 && target[pos-1] != '\\') { return false; }
+    if(pos > 1 && target[pos-2] == '\\') {
+      size_t backslash_count{2};
+      for(size_t i = 3; i <= pos; i++) {
+        if(target[pos-i] == '\\') { backslash_count++; }
+        else { break; }
+      }
+      if(backslash_count % 2 == 0) { return false; }
     }
+    pos++;
   }
   return true;
 }
 
 simdjson_inline bool raw_json_string::is_free_from_unescaped_quote(const char* target) noexcept {
   size_t pos{0};
-  // if the content has no escape character, just scan through it quickly!
-  for(;target[pos] && target[pos] != '\\';pos++) {}
-  // slow path may begin.
-  bool escaping{false};
-  for(;target[pos];pos++) {
-    if((target[pos] == '"') && !escaping) {
-      return false;
-    } else if(target[pos] == '\\') {
-      escaping = !escaping;
-    } else {
-      escaping = false;
+  while(target[pos]) {
+    const char * result = strchr(target+pos, '"');
+    if(result == nullptr) { return true; }
+    pos = result - target;
+    if(pos != 0 && target[pos-1] != '\\') { return false; }
+    if(pos > 1 && target[pos-2] == '\\') {
+      size_t backslash_count{2};
+      for(size_t i = 3; i <= pos; i++) {
+        if(target[pos-i] == '\\') { backslash_count++; }
+        else { break; }
+      }
+      if(backslash_count % 2 == 0) { return false; }
     }
+    pos++;
   }
   return true;
 }
@@ -86465,7 +88239,7 @@ simdjson_inline bool raw_json_string::unsafe_is_equal(size_t length, std::string
 }
 
 simdjson_inline bool raw_json_string::unsafe_is_equal(std::string_view target) const noexcept {
-  // Assumptions: does not contain unescaped quote characters, and
+  // Assumptions: does not contain unescaped quote characters("), and
   // the raw content is quote terminated within a valid JSON string.
   if(target.size() <= SIMDJSON_PADDING) {
     return (raw()[target.size()] == '"') && !memcmp(raw(), target.data(), target.size());
@@ -86556,28 +88330,62 @@ simdjson_unused simdjson_inline bool operator!=(std::string_view c, const raw_js
   return !(a == c);
 }
 
+SIMDJSON_PUSH_DISABLE_WARNINGS
+SIMDJSON_DISABLE_STRICT_OVERFLOW_WARNING
+simdjson_inline object_iterator &object_iterator::operator++() noexcept {
+  // TODO this is a safety rail ... users should exit loops as soon as they receive an error.
+  // Nonetheless, let's see if performance is OK with this if statement--the compiler may give it to us for free.
+  if (!iter.is_open()) { return *this; } // Iterator will be released if there is an error
 
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> raw_json_string::unescape(json_iterator &iter, bool allow_replacement) const noexcept {
-  return iter.unescape(*this, allow_replacement);
-}
+  simdjson_unused error_code error;
+  if ((error = iter.skip_child() )) { return *this; }
 
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> raw_json_string::unescape_wobbly(json_iterator &iter) const noexcept {
-  return iter.unescape_wobbly(*this);
+  simdjson_unused bool has_value;
+  if ((error = iter.has_next_field().get(has_value) )) { return *this; };
+  return *this;
 }
+SIMDJSON_POP_DISABLE_WARNINGS
 
-simdjson_unused simdjson_inline std::ostream &operator<<(std::ostream &out, const raw_json_string &str) noexcept {
-  bool in_escape = false;
-  const char *s = str.raw();
-  while (true) {
-    switch (*s) {
-      case '\\': in_escape = !in_escape; break;
-      case '"': if (in_escape) { in_escape = false; } else { return out; } break;
-      default: if (in_escape) { in_escape = false; }
-    }
-    out << *s;
-    s++;
-  }
-}
+//
+// ### Live States
+//
+// While iterating or looking up values, depth >= iter.depth. at_start may vary. Error is
+// always SUCCESS:
+//
+// - Start: This is the state when the object is first found and the iterator is just past the {.
+//   In this state, at_start == true.
+// - Next: After we hand a scalar value to the user, or an array/object which they then fully
+//   iterate over, the iterator is at the , or } before the next value. In this state,
+//   depth == iter.depth, at_start == false, and error == SUCCESS.
+// - Unfinished Business: When we hand an array/object to the user which they do not fully
+//   iterate over, we need to finish that iteration by skipping child values until we reach the
+//   Next state. In this state, depth > iter.depth, at_start == false, and error == SUCCESS.
+//
+// ## Error States
+//
+// In error states, we will yield exactly one more value before stopping. iter.depth == depth
+// and at_start is always false. We decrement after yielding the error, moving to the Finished
+// state.
+//
+// - Chained Error: When the object iterator is part of an error chain--for example, in
+//   `for (auto tweet : doc["tweets"])`, where the tweet field may be missing or not be an
+//   object--we yield that error in the loop, exactly once. In this state, error != SUCCESS and
+//   iter.depth == depth, and at_start == false. We decrement depth when we yield the error.
+// - Missing Comma Error: When the iterator ++ method discovers there is no comma between fields,
+//   we flag that as an error and treat it exactly the same as a Chained Error. In this state,
+//   error == TAPE_ERROR, iter.depth == depth, and at_start == false.
+//
+// Errors that occur while reading a field to give to the user (such as when the key is not a
+// string or the field is missing a colon) are yielded immediately. Depth is then decremented,
+// moving to the Finished state without transitioning through an Error state at all.
+//
+// ## Terminal State
+//
+// The terminal state has iter.depth < depth. at_start is always false.
+//
+// - Finished: When we have reached a }, we are finished. We signal this by decrementing depth.
+//   In this state, iter.depth < depth, at_start == false, and error == SUCCESS.
+//
 
 } // namespace ondemand
 } // namespace ppc64
@@ -86585,343 +88393,235 @@ simdjson_unused simdjson_inline std::ostream &operator<<(std::ostream &out, cons
 
 namespace simdjson {
 
-simdjson_inline simdjson_result<ppc64::ondemand::raw_json_string>::simdjson_result(ppc64::ondemand::raw_json_string &&value) noexcept
-    : implementation_simdjson_result_base<ppc64::ondemand::raw_json_string>(std::forward<ppc64::ondemand::raw_json_string>(value)) {}
-simdjson_inline simdjson_result<ppc64::ondemand::raw_json_string>::simdjson_result(error_code error) noexcept
-    : implementation_simdjson_result_base<ppc64::ondemand::raw_json_string>(error) {}
+simdjson_inline simdjson_result<ppc64::ondemand::object_iterator>::simdjson_result(
+  ppc64::ondemand::object_iterator &&value
+) noexcept
+  : implementation_simdjson_result_base<ppc64::ondemand::object_iterator>(std::forward<ppc64::ondemand::object_iterator>(value))
+{
+  first.iter.assert_is_valid();
+}
+simdjson_inline simdjson_result<ppc64::ondemand::object_iterator>::simdjson_result(error_code error) noexcept
+  : implementation_simdjson_result_base<ppc64::ondemand::object_iterator>({}, error)
+{
+}
 
-simdjson_inline simdjson_result<const char *> simdjson_result<ppc64::ondemand::raw_json_string>::raw() const noexcept {
+simdjson_inline simdjson_result<ppc64::ondemand::field> simdjson_result<ppc64::ondemand::object_iterator>::operator*() noexcept {
   if (error()) { return error(); }
-  return first.raw();
+  return *first;
 }
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> simdjson_result<ppc64::ondemand::raw_json_string>::unescape(ppc64::ondemand::json_iterator &iter, bool allow_replacement) const noexcept {
-  if (error()) { return error(); }
-  return first.unescape(iter, allow_replacement);
+// If we're iterating and there is an error, return the error once.
+simdjson_inline bool simdjson_result<ppc64::ondemand::object_iterator>::operator==(const simdjson_result<ppc64::ondemand::object_iterator> &other) const noexcept {
+  if (!first.iter.is_valid()) { return !error(); }
+  return first == other.first;
 }
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> simdjson_result<ppc64::ondemand::raw_json_string>::unescape_wobbly(ppc64::ondemand::json_iterator &iter) const noexcept {
-  if (error()) { return error(); }
-  return first.unescape_wobbly(iter);
+// If we're iterating and there is an error, return the error once.
+simdjson_inline bool simdjson_result<ppc64::ondemand::object_iterator>::operator!=(const simdjson_result<ppc64::ondemand::object_iterator> &other) const noexcept {
+  if (!first.iter.is_valid()) { return error(); }
+  return first != other.first;
 }
+// Checks for ']' and ','
+simdjson_inline simdjson_result<ppc64::ondemand::object_iterator> &simdjson_result<ppc64::ondemand::object_iterator>::operator++() noexcept {
+  // Clear the error if there is one, so we don't yield it twice
+  if (error()) { second = SUCCESS; return *this; }
+  ++first;
+  return *this;
+}
+
 } // namespace simdjson
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_RAW_JSON_STRING_INL_H
-/* end file simdjson/generic/ondemand/raw_json_string-inl.h for ppc64 */
-/* including simdjson/generic/ondemand/serialization-inl.h for ppc64: #include "simdjson/generic/ondemand/serialization-inl.h" */
-/* begin file simdjson/generic/ondemand/serialization-inl.h for ppc64 */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H
+#endif // SIMDJSON_GENERIC_ONDEMAND_OBJECT_ITERATOR_INL_H
+/* end file simdjson/generic/ondemand/object_iterator-inl.h for ppc64 */
+/* including simdjson/generic/ondemand/parser-inl.h for ppc64: #include "simdjson/generic/ondemand/parser-inl.h" */
+/* begin file simdjson/generic/ondemand/parser-inl.h for ppc64 */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_PARSER_INL_H
 
 /* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_PARSER_INL_H */
+/* amalgamation skipped (editor-only): #include "simdjson/padded_string.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/padded_string_view.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/implementation.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/internal/dom_parser_implementation.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/dom/base.h" // for MINIMAL_DOCUMENT_CAPACITY */
 /* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document-inl.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_type.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/object.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/serialization.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document_stream.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/parser.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/raw_json_string.h" */
 /* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
 namespace simdjson {
+namespace ppc64 {
+namespace ondemand {
 
-inline std::string_view trim(const std::string_view str) noexcept {
-  // We can almost surely do better by rolling our own find_first_not_of function.
-  size_t first = str.find_first_not_of(" \t\n\r");
-  // If we have the empty string (just white space), then no trimming is possible, and
-  // we return the empty string_view.
-  if (std::string_view::npos == first) { return std::string_view(); }
-  size_t last = str.find_last_not_of(" \t\n\r");
-  return str.substr(first, (last - first + 1));
-}
-
-
-inline simdjson_result<std::string_view> to_json_string(ppc64::ondemand::document& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
+simdjson_inline parser::parser(size_t max_capacity) noexcept
+  : _max_capacity{max_capacity} {
 }
 
-inline simdjson_result<std::string_view> to_json_string(ppc64::ondemand::document_reference& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
-}
+simdjson_warn_unused simdjson_inline error_code parser::allocate(size_t new_capacity, size_t new_max_depth) noexcept {
+  if (new_capacity > max_capacity()) { return CAPACITY; }
+  if (string_buf && new_capacity == capacity() && new_max_depth == max_depth()) { return SUCCESS; }
 
-inline simdjson_result<std::string_view> to_json_string(ppc64::ondemand::value& x) noexcept {
-  /**
-   * If we somehow receive a value that has already been consumed,
-   * then the following code could be in trouble. E.g., we create
-   * an array as needed, but if an array was already created, then
-   * it could be bad.
-   */
-  using namespace ppc64::ondemand;
-  ppc64::ondemand::json_type t;
-  auto error = x.type().get(t);
-  if(error != SUCCESS) { return error; }
-  switch (t)
-  {
-    case json_type::array:
-    {
-      ppc64::ondemand::array array;
-      error = x.get_array().get(array);
-      if(error) { return error; }
-      return to_json_string(array);
-    }
-    case json_type::object:
-    {
-      ppc64::ondemand::object object;
-      error = x.get_object().get(object);
-      if(error) { return error; }
-      return to_json_string(object);
-    }
-    default:
-      return trim(x.raw_json_token());
+  // string_capacity copied from document::allocate
+  _capacity = 0;
+  size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * new_capacity / 3 + SIMDJSON_PADDING, 64);
+  string_buf.reset(new (std::nothrow) uint8_t[string_capacity]);
+#if SIMDJSON_DEVELOPMENT_CHECKS
+  start_positions.reset(new (std::nothrow) token_position[new_max_depth]);
+#endif
+  if (implementation) {
+    SIMDJSON_TRY( implementation->set_capacity(new_capacity) );
+    SIMDJSON_TRY( implementation->set_max_depth(new_max_depth) );
+  } else {
+    SIMDJSON_TRY( simdjson::get_active_implementation()->create_dom_parser_implementation(new_capacity, new_max_depth, implementation) );
   }
+  _capacity = new_capacity;
+  _max_depth = new_max_depth;
+  return SUCCESS;
 }
-
-inline simdjson_result<std::string_view> to_json_string(ppc64::ondemand::object& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
-}
-
-inline simdjson_result<std::string_view> to_json_string(ppc64::ondemand::array& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
+#if SIMDJSON_DEVELOPMENT_CHECKS
+simdjson_inline simdjson_warn_unused bool parser::string_buffer_overflow(const uint8_t *string_buf_loc) const noexcept {
+  return (string_buf_loc < string_buf.get()) || (size_t(string_buf_loc - string_buf.get()) >= capacity());
 }
+#endif
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<ppc64::ondemand::document> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(padded_string_view json) & noexcept {
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<ppc64::ondemand::document_reference> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
+  json.remove_utf8_bom();
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<ppc64::ondemand::value> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
+  // Allocate if needed
+  if (capacity() < json.length() || !string_buf) {
+    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
+  }
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<ppc64::ondemand::object> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
+  // Run stage 1.
+  SIMDJSON_TRY( implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular) );
+  return document::start({ reinterpret_cast<const uint8_t *>(json.data()), this });
 }
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<ppc64::ondemand::array> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
-} // namespace simdjson
+#ifdef SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate_allow_incomplete_json(padded_string_view json) & noexcept {
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
-namespace simdjson { namespace ppc64 { namespace ondemand {
+  json.remove_utf8_bom();
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::ppc64::ondemand::value x) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(x).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::ppc64::ondemand::value> x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
-}
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::ppc64::ondemand::value x) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(x).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
+  // Allocate if needed
+  if (capacity() < json.length() || !string_buf) {
+    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
   }
-}
-#endif
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::ppc64::ondemand::array value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::ppc64::ondemand::array> x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
-}
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::ppc64::ondemand::array value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
+  // Run stage 1.
+  const simdjson::error_code err = implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular);
+  if (err) {
+    if (err != UNCLOSED_STRING)
+      return err;
   }
+  return document::start({ reinterpret_cast<const uint8_t *>(json.data()), this, true });
 }
-#endif
+#endif // SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::ppc64::ondemand::document& value)  {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::ppc64::ondemand::document_reference& value)  {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::ppc64::ondemand::document>&& x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const char *json, size_t len, size_t allocated) & noexcept {
+  return iterate(padded_string_view(json, len, allocated));
 }
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::ppc64::ondemand::document_reference>&& x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const uint8_t *json, size_t len, size_t allocated) & noexcept {
+  return iterate(padded_string_view(json, len, allocated));
 }
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::ppc64::ondemand::document& value)  {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
-  }
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(std::string_view json, size_t allocated) & noexcept {
+  return iterate(padded_string_view(json, allocated));
 }
-#endif
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::ppc64::ondemand::object value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(std::string &json) & noexcept {
+  if(json.capacity() - json.size() < SIMDJSON_PADDING) {
+    json.reserve(json.size() + SIMDJSON_PADDING);
   }
+  return iterate(padded_string_view(json));
 }
-inline std::ostream& operator<<(std::ostream& out,  simdjson::simdjson_result<simdjson::ppc64::ondemand::object> x) {
-  if (x.error()) { throw  simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const std::string &json) & noexcept {
+  return iterate(padded_string_view(json));
 }
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::ppc64::ondemand::object value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
-  }
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const simdjson_result<padded_string_view> &result) & noexcept {
+  // We don't presently have a way to temporarily get a const T& from a simdjson_result<T> without throwing an exception
+  SIMDJSON_TRY( result.error() );
+  padded_string_view json = result.value_unsafe();
+  return iterate(json);
 }
-#endif
-}}} // namespace simdjson::ppc64::ondemand
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H
-/* end file simdjson/generic/ondemand/serialization-inl.h for ppc64 */
-/* including simdjson/generic/ondemand/token_iterator-inl.h for ppc64: #include "simdjson/generic/ondemand/token_iterator-inl.h" */
-/* begin file simdjson/generic/ondemand/token_iterator-inl.h for ppc64 */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_TOKEN_ITERATOR_INL_H
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const simdjson_result<padded_string> &result) & noexcept {
+  // We don't presently have a way to temporarily get a const T& from a simdjson_result<T> without throwing an exception
+  SIMDJSON_TRY( result.error() );
+  const padded_string &json = result.value_unsafe();
+  return iterate(json);
+}
 
-/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_TOKEN_ITERATOR_INL_H */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/token_iterator.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/implementation_simdjson_result_base-inl.h" */
-/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
+simdjson_warn_unused simdjson_inline simdjson_result<json_iterator> parser::iterate_raw(padded_string_view json) & noexcept {
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
-namespace simdjson {
-namespace ppc64 {
-namespace ondemand {
+  json.remove_utf8_bom();
 
-simdjson_inline token_iterator::token_iterator(
-  const uint8_t *_buf,
-  token_position position
-) noexcept : buf{_buf}, _position{position}
-{
-}
+  // Allocate if needed
+  if (capacity() < json.length()) {
+    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
+  }
 
-simdjson_inline uint32_t token_iterator::current_offset() const noexcept {
-  return *(_position);
+  // Run stage 1.
+  SIMDJSON_TRY( implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular) );
+  return json_iterator(reinterpret_cast<const uint8_t *>(json.data()), this);
 }
 
-
-simdjson_inline const uint8_t *token_iterator::return_current_and_advance() noexcept {
-  return &buf[*(_position++)];
+inline simdjson_result<document_stream> parser::iterate_many(const uint8_t *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {
+  if(batch_size < MINIMAL_BATCH_SIZE) { batch_size = MINIMAL_BATCH_SIZE; }
+  if((len >= 3) && (std::memcmp(buf, "\xEF\xBB\xBF", 3) == 0)) {
+    buf += 3;
+    len -= 3;
+  }
+  if(allow_comma_separated && batch_size < len) { batch_size = len; }
+  return document_stream(*this, buf, len, batch_size, allow_comma_separated);
 }
-
-simdjson_inline const uint8_t *token_iterator::peek(token_position position) const noexcept {
-  return &buf[*position];
+inline simdjson_result<document_stream> parser::iterate_many(const char *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {
+  return iterate_many(reinterpret_cast<const uint8_t *>(buf), len, batch_size, allow_comma_separated);
 }
-simdjson_inline uint32_t token_iterator::peek_index(token_position position) const noexcept {
-  return *position;
+inline simdjson_result<document_stream> parser::iterate_many(const std::string &s, size_t batch_size, bool allow_comma_separated) noexcept {
+  return iterate_many(s.data(), s.length(), batch_size, allow_comma_separated);
 }
-simdjson_inline uint32_t token_iterator::peek_length(token_position position) const noexcept {
-  return *(position+1) - *position;
+inline simdjson_result<document_stream> parser::iterate_many(const padded_string &s, size_t batch_size, bool allow_comma_separated) noexcept {
+  return iterate_many(s.data(), s.length(), batch_size, allow_comma_separated);
 }
 
-simdjson_inline uint32_t token_iterator::peek_root_length(token_position position) const noexcept {
-  return *(position+2) - *(position) > *(position+1) - *(position) ?
-      *(position+1) - *(position)
-      : *(position+2) - *(position);
-}
-simdjson_inline const uint8_t *token_iterator::peek(int32_t delta) const noexcept {
-  return &buf[*(_position+delta)];
+simdjson_pure simdjson_inline size_t parser::capacity() const noexcept {
+  return _capacity;
 }
-simdjson_inline uint32_t token_iterator::peek_index(int32_t delta) const noexcept {
-  return *(_position+delta);
+simdjson_pure simdjson_inline size_t parser::max_capacity() const noexcept {
+  return _max_capacity;
 }
-simdjson_inline uint32_t token_iterator::peek_length(int32_t delta) const noexcept {
-  return *(_position+delta+1) - *(_position+delta);
+simdjson_pure simdjson_inline size_t parser::max_depth() const noexcept {
+  return _max_depth;
 }
 
-simdjson_inline token_position token_iterator::position() const noexcept {
-  return _position;
-}
-simdjson_inline void token_iterator::set_position(token_position target_position) noexcept {
-  _position = target_position;
+simdjson_inline void parser::set_max_capacity(size_t max_capacity) noexcept {
+  if(max_capacity < dom::MINIMAL_DOCUMENT_CAPACITY) {
+    _max_capacity = max_capacity;
+  } else {
+    _max_capacity = dom::MINIMAL_DOCUMENT_CAPACITY;
+  }
 }
 
-simdjson_inline bool token_iterator::operator==(const token_iterator &other) const noexcept {
-  return _position == other._position;
-}
-simdjson_inline bool token_iterator::operator!=(const token_iterator &other) const noexcept {
-  return _position != other._position;
-}
-simdjson_inline bool token_iterator::operator>(const token_iterator &other) const noexcept {
-  return _position > other._position;
-}
-simdjson_inline bool token_iterator::operator>=(const token_iterator &other) const noexcept {
-  return _position >= other._position;
-}
-simdjson_inline bool token_iterator::operator<(const token_iterator &other) const noexcept {
-  return _position < other._position;
+simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape(raw_json_string in, uint8_t *&dst, bool allow_replacement) const noexcept {
+  uint8_t *end = implementation->parse_string(in.buf, dst, allow_replacement);
+  if (!end) { return STRING_ERROR; }
+  std::string_view result(reinterpret_cast<const char *>(dst), end-dst);
+  dst = end;
+  return result;
 }
-simdjson_inline bool token_iterator::operator<=(const token_iterator &other) const noexcept {
-  return _position <= other._position;
+
+simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape_wobbly(raw_json_string in, uint8_t *&dst) const noexcept {
+  uint8_t *end = implementation->parse_wobbly_string(in.buf, dst);
+  if (!end) { return STRING_ERROR; }
+  std::string_view result(reinterpret_cast<const char *>(dst), end-dst);
+  dst = end;
+  return result;
 }
 
 } // namespace ondemand
@@ -86930,10 +88630,10 @@ simdjson_inline bool token_iterator::operator<=(const token_iterator &other) con
 
 namespace simdjson {
 
-simdjson_inline simdjson_result<ppc64::ondemand::token_iterator>::simdjson_result(ppc64::ondemand::token_iterator &&value) noexcept
-    : implementation_simdjson_result_base<ppc64::ondemand::token_iterator>(std::forward<ppc64::ondemand::token_iterator>(value)) {}
-simdjson_inline simdjson_result<ppc64::ondemand::token_iterator>::simdjson_result(error_code error) noexcept
-    : implementation_simdjson_result_base<ppc64::ondemand::token_iterator>(error) {}
+simdjson_inline simdjson_result<ppc64::ondemand::parser>::simdjson_result(ppc64::ondemand::parser &&value) noexcept
+    : implementation_simdjson_result_base<ppc64::ondemand::parser>(std::forward<ppc64::ondemand::parser>(value)) {}
+simdjson_inline simdjson_result<ppc64::ondemand::parser>::simdjson_result(error_code error) noexcept
+    : implementation_simdjson_result_base<ppc64::ondemand::parser>(error) {}
 
 } // namespace simdjson
 
@@ -86955,6 +88655,7 @@ simdjson_inline simdjson_result<ppc64::ondemand::token_iterator>::simdjson_resul
 /* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
 namespace simdjson {
+
 namespace ppc64 {
 namespace ondemand {
 
@@ -94987,6 +96688,496 @@ simdjson_inline simdjson_result<bool> value::is_string() noexcept {
 }
 
 
+simdjson_inline bool value::is_negative() noexcept {
+  return iter.is_negative();
+}
+
+simdjson_inline simdjson_result<bool> value::is_integer() noexcept {
+  return iter.is_integer();
+}
+simdjson_warn_unused simdjson_inline simdjson_result<number_type> value::get_number_type() noexcept {
+  return iter.get_number_type();
+}
+simdjson_warn_unused simdjson_inline simdjson_result<number> value::get_number() noexcept {
+  return iter.get_number();
+}
+
+inline simdjson_result<value> array::at_path(std::string_view json_path) noexcept {
+  auto json_pointer = json_path_to_pointer_conversion(json_path);
+  if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
+  return at_pointer(json_pointer);
+}
+
+simdjson_inline simdjson_result<value> value::at_path(std::string_view json_path) noexcept {
+  json_type t;
+  SIMDJSON_TRY(type().get(t));
+  switch (t) {
+  case json_type::array:
+      return (*this).get_array().at_path(json_path);
+  case json_type::object:
+      return (*this).get_object().at_path(json_path);
+  default:
+      return INVALID_JSON_POINTER;
+  }
+}
+
+} // namespace ondemand
+} // namespace westmere
+} // namespace simdjson
+
+namespace simdjson {
+
+simdjson_inline simdjson_result<westmere::ondemand::value>::simdjson_result(
+  westmere::ondemand::value &&value
+) noexcept :
+    implementation_simdjson_result_base<westmere::ondemand::value>(
+      std::forward<westmere::ondemand::value>(value)
+    )
+{
+}
+simdjson_inline simdjson_result<westmere::ondemand::value>::simdjson_result(
+  error_code error
+) noexcept :
+    implementation_simdjson_result_base<westmere::ondemand::value>(error)
+{
+}
+simdjson_inline simdjson_result<size_t> simdjson_result<westmere::ondemand::value>::count_elements() & noexcept {
+  if (error()) { return error(); }
+  return first.count_elements();
+}
+simdjson_inline simdjson_result<size_t> simdjson_result<westmere::ondemand::value>::count_fields() & noexcept {
+  if (error()) { return error(); }
+  return first.count_fields();
+}
+simdjson_inline simdjson_result<westmere::ondemand::value> simdjson_result<westmere::ondemand::value>::at(size_t index) noexcept {
+  if (error()) { return error(); }
+  return first.at(index);
+}
+simdjson_inline simdjson_result<westmere::ondemand::array_iterator> simdjson_result<westmere::ondemand::value>::begin() & noexcept {
+  if (error()) { return error(); }
+  return first.begin();
+}
+simdjson_inline simdjson_result<westmere::ondemand::array_iterator> simdjson_result<westmere::ondemand::value>::end() & noexcept {
+  if (error()) { return error(); }
+  return {};
+}
+
+simdjson_inline simdjson_result<westmere::ondemand::value> simdjson_result<westmere::ondemand::value>::find_field(std::string_view key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field(key);
+}
+simdjson_inline simdjson_result<westmere::ondemand::value> simdjson_result<westmere::ondemand::value>::find_field(const char *key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field(key);
+}
+
+simdjson_inline simdjson_result<westmere::ondemand::value> simdjson_result<westmere::ondemand::value>::find_field_unordered(std::string_view key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field_unordered(key);
+}
+simdjson_inline simdjson_result<westmere::ondemand::value> simdjson_result<westmere::ondemand::value>::find_field_unordered(const char *key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field_unordered(key);
+}
+
+simdjson_inline simdjson_result<westmere::ondemand::value> simdjson_result<westmere::ondemand::value>::operator[](std::string_view key) noexcept {
+  if (error()) { return error(); }
+  return first[key];
+}
+simdjson_inline simdjson_result<westmere::ondemand::value> simdjson_result<westmere::ondemand::value>::operator[](const char *key) noexcept {
+  if (error()) { return error(); }
+  return first[key];
+}
+
+simdjson_inline simdjson_result<westmere::ondemand::array> simdjson_result<westmere::ondemand::value>::get_array() noexcept {
+  if (error()) { return error(); }
+  return first.get_array();
+}
+simdjson_inline simdjson_result<westmere::ondemand::object> simdjson_result<westmere::ondemand::value>::get_object() noexcept {
+  if (error()) { return error(); }
+  return first.get_object();
+}
+simdjson_inline simdjson_result<uint64_t> simdjson_result<westmere::ondemand::value>::get_uint64() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint64();
+}
+simdjson_inline simdjson_result<uint64_t> simdjson_result<westmere::ondemand::value>::get_uint64_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint64_in_string();
+}
+simdjson_inline simdjson_result<int64_t> simdjson_result<westmere::ondemand::value>::get_int64() noexcept {
+  if (error()) { return error(); }
+  return first.get_int64();
+}
+simdjson_inline simdjson_result<int64_t> simdjson_result<westmere::ondemand::value>::get_int64_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_int64_in_string();
+}
+simdjson_inline simdjson_result<double> simdjson_result<westmere::ondemand::value>::get_double() noexcept {
+  if (error()) { return error(); }
+  return first.get_double();
+}
+simdjson_inline simdjson_result<double> simdjson_result<westmere::ondemand::value>::get_double_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_double_in_string();
+}
+simdjson_inline simdjson_result<std::string_view> simdjson_result<westmere::ondemand::value>::get_string(bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.get_string(allow_replacement);
+}
+template <typename string_type>
+simdjson_inline error_code simdjson_result<westmere::ondemand::value>::get_string(string_type& receiver, bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.get_string(receiver, allow_replacement);
+}
+simdjson_inline simdjson_result<std::string_view> simdjson_result<westmere::ondemand::value>::get_wobbly_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_wobbly_string();
+}
+simdjson_inline simdjson_result<westmere::ondemand::raw_json_string> simdjson_result<westmere::ondemand::value>::get_raw_json_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_raw_json_string();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<westmere::ondemand::value>::get_bool() noexcept {
+  if (error()) { return error(); }
+  return first.get_bool();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<westmere::ondemand::value>::is_null() noexcept {
+  if (error()) { return error(); }
+  return first.is_null();
+}
+
+template<> simdjson_inline error_code simdjson_result<westmere::ondemand::value>::get<westmere::ondemand::value>(westmere::ondemand::value &out) noexcept {
+  if (error()) { return error(); }
+  out = first;
+  return SUCCESS;
+}
+
+template<typename T> simdjson_inline simdjson_result<T> simdjson_result<westmere::ondemand::value>::get() noexcept {
+  if (error()) { return error(); }
+  return first.get<T>();
+}
+template<typename T> simdjson_inline error_code simdjson_result<westmere::ondemand::value>::get(T &out) noexcept {
+  if (error()) { return error(); }
+  return first.get<T>(out);
+}
+
+template<> simdjson_inline simdjson_result<westmere::ondemand::value> simdjson_result<westmere::ondemand::value>::get<westmere::ondemand::value>() noexcept  {
+  if (error()) { return error(); }
+  return std::move(first);
+}
+
+simdjson_inline simdjson_result<westmere::ondemand::json_type> simdjson_result<westmere::ondemand::value>::type() noexcept {
+  if (error()) { return error(); }
+  return first.type();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<westmere::ondemand::value>::is_scalar() noexcept {
+  if (error()) { return error(); }
+  return first.is_scalar();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<westmere::ondemand::value>::is_string() noexcept {
+  if (error()) { return error(); }
+  return first.is_string();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<westmere::ondemand::value>::is_negative() noexcept {
+  if (error()) { return error(); }
+  return first.is_negative();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<westmere::ondemand::value>::is_integer() noexcept {
+  if (error()) { return error(); }
+  return first.is_integer();
+}
+simdjson_inline simdjson_result<westmere::number_type> simdjson_result<westmere::ondemand::value>::get_number_type() noexcept {
+  if (error()) { return error(); }
+  return first.get_number_type();
+}
+simdjson_inline simdjson_result<westmere::ondemand::number> simdjson_result<westmere::ondemand::value>::get_number() noexcept {
+  if (error()) { return error(); }
+  return first.get_number();
+}
+#if SIMDJSON_EXCEPTIONS
+template <class T>
+simdjson_inline simdjson_result<westmere::ondemand::value>::operator T() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first.get<T>();
+}
+simdjson_inline simdjson_result<westmere::ondemand::value>::operator westmere::ondemand::array() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<westmere::ondemand::value>::operator westmere::ondemand::object() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<westmere::ondemand::value>::operator uint64_t() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<westmere::ondemand::value>::operator int64_t() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<westmere::ondemand::value>::operator double() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<westmere::ondemand::value>::operator std::string_view() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<westmere::ondemand::value>::operator westmere::ondemand::raw_json_string() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<westmere::ondemand::value>::operator bool() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+#endif
+
+simdjson_inline simdjson_result<std::string_view> simdjson_result<westmere::ondemand::value>::raw_json_token() noexcept {
+  if (error()) { return error(); }
+  return first.raw_json_token();
+}
+
+simdjson_inline simdjson_result<std::string_view> simdjson_result<westmere::ondemand::value>::raw_json() noexcept {
+  if (error()) { return error(); }
+  return first.raw_json();
+}
+
+simdjson_inline simdjson_result<const char *> simdjson_result<westmere::ondemand::value>::current_location() noexcept {
+  if (error()) { return error(); }
+  return first.current_location();
+}
+
+simdjson_inline simdjson_result<int32_t> simdjson_result<westmere::ondemand::value>::current_depth() const noexcept {
+  if (error()) { return error(); }
+  return first.current_depth();
+}
+
+simdjson_inline simdjson_result<westmere::ondemand::value> simdjson_result<westmere::ondemand::value>::at_pointer(
+    std::string_view json_pointer) noexcept {
+  if (error()) {
+      return error();
+  }
+  return first.at_pointer(json_pointer);
+}
+
+simdjson_inline simdjson_result<westmere::ondemand::value> simdjson_result<westmere::ondemand::value>::at_path(
+      std::string_view json_path) noexcept {
+  if (error()) {
+    return error();
+  }
+  return first.at_path(json_path);
+}
+
+} // namespace simdjson
+
+#endif // SIMDJSON_GENERIC_ONDEMAND_ARRAY_ITERATOR_INL_H
+/* end file simdjson/generic/ondemand/array_iterator-inl.h for westmere */
+/* including simdjson/generic/ondemand/value-inl.h for westmere: #include "simdjson/generic/ondemand/value-inl.h" */
+/* begin file simdjson/generic/ondemand/value-inl.h for westmere */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_VALUE_INL_H
+
+/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_VALUE_INL_H */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array_iterator.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_iterator.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_type.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/object.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/raw_json_string.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value.h" */
+/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
+
+namespace simdjson {
+namespace westmere {
+namespace ondemand {
+
+simdjson_inline value::value(const value_iterator &_iter) noexcept
+  : iter{_iter}
+{
+}
+simdjson_inline value value::start(const value_iterator &iter) noexcept {
+  return iter;
+}
+simdjson_inline value value::resume(const value_iterator &iter) noexcept {
+  return iter;
+}
+
+simdjson_inline simdjson_result<array> value::get_array() noexcept {
+  return array::start(iter);
+}
+simdjson_inline simdjson_result<object> value::get_object() noexcept {
+  return object::start(iter);
+}
+simdjson_inline simdjson_result<object> value::start_or_resume_object() noexcept {
+  if (iter.at_start()) {
+    return get_object();
+  } else {
+    return object::resume(iter);
+  }
+}
+
+simdjson_inline simdjson_result<raw_json_string> value::get_raw_json_string() noexcept {
+  return iter.get_raw_json_string();
+}
+simdjson_inline simdjson_result<std::string_view> value::get_string(bool allow_replacement) noexcept {
+  return iter.get_string(allow_replacement);
+}
+template <typename string_type>
+simdjson_inline error_code value::get_string(string_type& receiver, bool allow_replacement) noexcept {
+  return iter.get_string(receiver, allow_replacement);
+}
+simdjson_inline simdjson_result<std::string_view> value::get_wobbly_string() noexcept {
+  return iter.get_wobbly_string();
+}
+simdjson_inline simdjson_result<double> value::get_double() noexcept {
+  return iter.get_double();
+}
+simdjson_inline simdjson_result<double> value::get_double_in_string() noexcept {
+  return iter.get_double_in_string();
+}
+simdjson_inline simdjson_result<uint64_t> value::get_uint64() noexcept {
+  return iter.get_uint64();
+}
+simdjson_inline simdjson_result<uint64_t> value::get_uint64_in_string() noexcept {
+  return iter.get_uint64_in_string();
+}
+simdjson_inline simdjson_result<int64_t> value::get_int64() noexcept {
+  return iter.get_int64();
+}
+simdjson_inline simdjson_result<int64_t> value::get_int64_in_string() noexcept {
+  return iter.get_int64_in_string();
+}
+simdjson_inline simdjson_result<bool> value::get_bool() noexcept {
+  return iter.get_bool();
+}
+simdjson_inline simdjson_result<bool> value::is_null() noexcept {
+  return iter.is_null();
+}
+
+template<> simdjson_inline simdjson_result<array> value::get() noexcept { return get_array(); }
+template<> simdjson_inline simdjson_result<object> value::get() noexcept { return get_object(); }
+template<> simdjson_inline simdjson_result<raw_json_string> value::get() noexcept { return get_raw_json_string(); }
+template<> simdjson_inline simdjson_result<std::string_view> value::get() noexcept { return get_string(false); }
+template<> simdjson_inline simdjson_result<number> value::get() noexcept { return get_number(); }
+template<> simdjson_inline simdjson_result<double> value::get() noexcept { return get_double(); }
+template<> simdjson_inline simdjson_result<uint64_t> value::get() noexcept { return get_uint64(); }
+template<> simdjson_inline simdjson_result<int64_t> value::get() noexcept { return get_int64(); }
+template<> simdjson_inline simdjson_result<bool> value::get() noexcept { return get_bool(); }
+
+
+template<> simdjson_inline error_code value::get(array& out) noexcept { return get_array().get(out); }
+template<> simdjson_inline error_code value::get(object& out) noexcept { return get_object().get(out); }
+template<> simdjson_inline error_code value::get(raw_json_string& out) noexcept { return get_raw_json_string().get(out); }
+template<> simdjson_inline error_code value::get(std::string_view& out) noexcept { return get_string(false).get(out); }
+template<> simdjson_inline error_code value::get(number& out) noexcept { return get_number().get(out); }
+template<> simdjson_inline error_code value::get(double& out) noexcept { return get_double().get(out); }
+template<> simdjson_inline error_code value::get(uint64_t& out) noexcept { return get_uint64().get(out); }
+template<> simdjson_inline error_code value::get(int64_t& out) noexcept { return get_int64().get(out); }
+template<> simdjson_inline error_code value::get(bool& out) noexcept { return get_bool().get(out); }
+
+#if SIMDJSON_EXCEPTIONS
+template <class T>
+simdjson_inline value::operator T() noexcept(false) {
+  return get<T>();
+}
+simdjson_inline value::operator array() noexcept(false) {
+  return get_array();
+}
+simdjson_inline value::operator object() noexcept(false) {
+  return get_object();
+}
+simdjson_inline value::operator uint64_t() noexcept(false) {
+  return get_uint64();
+}
+simdjson_inline value::operator int64_t() noexcept(false) {
+  return get_int64();
+}
+simdjson_inline value::operator double() noexcept(false) {
+  return get_double();
+}
+simdjson_inline value::operator std::string_view() noexcept(false) {
+  return get_string(false);
+}
+simdjson_inline value::operator raw_json_string() noexcept(false) {
+  return get_raw_json_string();
+}
+simdjson_inline value::operator bool() noexcept(false) {
+  return get_bool();
+}
+#endif
+
+simdjson_inline simdjson_result<array_iterator> value::begin() & noexcept {
+  return get_array().begin();
+}
+simdjson_inline simdjson_result<array_iterator> value::end() & noexcept {
+  return {};
+}
+simdjson_inline simdjson_result<size_t> value::count_elements() & noexcept {
+  simdjson_result<size_t> answer;
+  auto a = get_array();
+  answer = a.count_elements();
+  // count_elements leaves you pointing inside the array, at the first element.
+  // We need to move back so that the user can create a new array (which requires that
+  // we point at '[').
+  iter.move_at_start();
+  return answer;
+}
+simdjson_inline simdjson_result<size_t> value::count_fields() & noexcept {
+  simdjson_result<size_t> answer;
+  auto a = get_object();
+  answer = a.count_fields();
+  iter.move_at_start();
+  return answer;
+}
+simdjson_inline simdjson_result<value> value::at(size_t index) noexcept {
+  auto a = get_array();
+  return a.at(index);
+}
+
+simdjson_inline simdjson_result<value> value::find_field(std::string_view key) noexcept {
+  return start_or_resume_object().find_field(key);
+}
+simdjson_inline simdjson_result<value> value::find_field(const char *key) noexcept {
+  return start_or_resume_object().find_field(key);
+}
+
+simdjson_inline simdjson_result<value> value::find_field_unordered(std::string_view key) noexcept {
+  return start_or_resume_object().find_field_unordered(key);
+}
+simdjson_inline simdjson_result<value> value::find_field_unordered(const char *key) noexcept {
+  return start_or_resume_object().find_field_unordered(key);
+}
+
+simdjson_inline simdjson_result<value> value::operator[](std::string_view key) noexcept {
+  return start_or_resume_object()[key];
+}
+simdjson_inline simdjson_result<value> value::operator[](const char *key) noexcept {
+  return start_or_resume_object()[key];
+}
+
+simdjson_inline simdjson_result<json_type> value::type() noexcept {
+  return iter.type();
+}
+
+simdjson_inline simdjson_result<bool> value::is_scalar() noexcept {
+  json_type this_type;
+  auto error = type().get(this_type);
+  if(error) { return error; }
+  return ! ((this_type == json_type::array) || (this_type == json_type::object));
+}
+
+simdjson_inline simdjson_result<bool> value::is_string() noexcept {
+  json_type this_type;
+  auto error = type().get(this_type);
+  if(error) { return error; }
+  return (this_type == json_type::string);
+}
+
+
 simdjson_inline bool value::is_negative() noexcept {
   return iter.is_negative();
 }
@@ -95894,7 +98085,7 @@ simdjson_inline simdjson_result<westmere::ondemand::number> simdjson_result<west
 template <class T, typename std::enable_if<std::is_same<T, westmere::ondemand::document>::value == false>::type>
 simdjson_inline simdjson_result<westmere::ondemand::document>::operator T() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get<T>();
 }
 simdjson_inline simdjson_result<westmere::ondemand::document>::operator westmere::ondemand::array() & noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
@@ -98320,36 +100511,39 @@ simdjson_inline const char * raw_json_string::raw() const noexcept { return rein
 
 simdjson_inline bool raw_json_string::is_free_from_unescaped_quote(std::string_view target) noexcept {
   size_t pos{0};
-  // if the content has no escape character, just scan through it quickly!
-  for(;pos < target.size() && target[pos] != '\\';pos++) {}
-  // slow path may begin.
-  bool escaping{false};
-  for(;pos < target.size();pos++) {
-    if((target[pos] == '"') && !escaping) {
-      return false;
-    } else if(target[pos] == '\\') {
-      escaping = !escaping;
-    } else {
-      escaping = false;
+  while(pos < target.size()) {
+    pos = target.find('"', pos);
+    if(pos == std::string_view::npos) { return true; }
+    if(pos != 0 && target[pos-1] != '\\') { return false; }
+    if(pos > 1 && target[pos-2] == '\\') {
+      size_t backslash_count{2};
+      for(size_t i = 3; i <= pos; i++) {
+        if(target[pos-i] == '\\') { backslash_count++; }
+        else { break; }
+      }
+      if(backslash_count % 2 == 0) { return false; }
     }
+    pos++;
   }
   return true;
 }
 
 simdjson_inline bool raw_json_string::is_free_from_unescaped_quote(const char* target) noexcept {
   size_t pos{0};
-  // if the content has no escape character, just scan through it quickly!
-  for(;target[pos] && target[pos] != '\\';pos++) {}
-  // slow path may begin.
-  bool escaping{false};
-  for(;target[pos];pos++) {
-    if((target[pos] == '"') && !escaping) {
-      return false;
-    } else if(target[pos] == '\\') {
-      escaping = !escaping;
-    } else {
-      escaping = false;
+  while(target[pos]) {
+    const char * result = strchr(target+pos, '"');
+    if(result == nullptr) { return true; }
+    pos = result - target;
+    if(pos != 0 && target[pos-1] != '\\') { return false; }
+    if(pos > 1 && target[pos-2] == '\\') {
+      size_t backslash_count{2};
+      for(size_t i = 3; i <= pos; i++) {
+        if(target[pos-i] == '\\') { backslash_count++; }
+        else { break; }
+      }
+      if(backslash_count % 2 == 0) { return false; }
     }
+    pos++;
   }
   return true;
 }
@@ -98361,7 +100555,7 @@ simdjson_inline bool raw_json_string::unsafe_is_equal(size_t length, std::string
 }
 
 simdjson_inline bool raw_json_string::unsafe_is_equal(std::string_view target) const noexcept {
-  // Assumptions: does not contain unescaped quote characters, and
+  // Assumptions: does not contain unescaped quote characters("), and
   // the raw content is quote terminated within a valid JSON string.
   if(target.size() <= SIMDJSON_PADDING) {
     return (raw()[target.size()] == '"') && !memcmp(raw(), target.data(), target.size());
@@ -98452,28 +100646,62 @@ simdjson_unused simdjson_inline bool operator!=(std::string_view c, const raw_js
   return !(a == c);
 }
 
+SIMDJSON_PUSH_DISABLE_WARNINGS
+SIMDJSON_DISABLE_STRICT_OVERFLOW_WARNING
+simdjson_inline object_iterator &object_iterator::operator++() noexcept {
+  // TODO this is a safety rail ... users should exit loops as soon as they receive an error.
+  // Nonetheless, let's see if performance is OK with this if statement--the compiler may give it to us for free.
+  if (!iter.is_open()) { return *this; } // Iterator will be released if there is an error
 
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> raw_json_string::unescape(json_iterator &iter, bool allow_replacement) const noexcept {
-  return iter.unescape(*this, allow_replacement);
-}
+  simdjson_unused error_code error;
+  if ((error = iter.skip_child() )) { return *this; }
 
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> raw_json_string::unescape_wobbly(json_iterator &iter) const noexcept {
-  return iter.unescape_wobbly(*this);
+  simdjson_unused bool has_value;
+  if ((error = iter.has_next_field().get(has_value) )) { return *this; };
+  return *this;
 }
+SIMDJSON_POP_DISABLE_WARNINGS
 
-simdjson_unused simdjson_inline std::ostream &operator<<(std::ostream &out, const raw_json_string &str) noexcept {
-  bool in_escape = false;
-  const char *s = str.raw();
-  while (true) {
-    switch (*s) {
-      case '\\': in_escape = !in_escape; break;
-      case '"': if (in_escape) { in_escape = false; } else { return out; } break;
-      default: if (in_escape) { in_escape = false; }
-    }
-    out << *s;
-    s++;
-  }
-}
+//
+// ### Live States
+//
+// While iterating or looking up values, depth >= iter.depth. at_start may vary. Error is
+// always SUCCESS:
+//
+// - Start: This is the state when the object is first found and the iterator is just past the {.
+//   In this state, at_start == true.
+// - Next: After we hand a scalar value to the user, or an array/object which they then fully
+//   iterate over, the iterator is at the , or } before the next value. In this state,
+//   depth == iter.depth, at_start == false, and error == SUCCESS.
+// - Unfinished Business: When we hand an array/object to the user which they do not fully
+//   iterate over, we need to finish that iteration by skipping child values until we reach the
+//   Next state. In this state, depth > iter.depth, at_start == false, and error == SUCCESS.
+//
+// ## Error States
+//
+// In error states, we will yield exactly one more value before stopping. iter.depth == depth
+// and at_start is always false. We decrement after yielding the error, moving to the Finished
+// state.
+//
+// - Chained Error: When the object iterator is part of an error chain--for example, in
+//   `for (auto tweet : doc["tweets"])`, where the tweet field may be missing or not be an
+//   object--we yield that error in the loop, exactly once. In this state, error != SUCCESS and
+//   iter.depth == depth, and at_start == false. We decrement depth when we yield the error.
+// - Missing Comma Error: When the iterator ++ method discovers there is no comma between fields,
+//   we flag that as an error and treat it exactly the same as a Chained Error. In this state,
+//   error == TAPE_ERROR, iter.depth == depth, and at_start == false.
+//
+// Errors that occur while reading a field to give to the user (such as when the key is not a
+// string or the field is missing a colon) are yielded immediately. Depth is then decremented,
+// moving to the Finished state without transitioning through an Error state at all.
+//
+// ## Terminal State
+//
+// The terminal state has iter.depth < depth. at_start is always false.
+//
+// - Finished: When we have reached a }, we are finished. We signal this by decrementing depth.
+//   In this state, iter.depth < depth, at_start == false, and error == SUCCESS.
+//
 
 } // namespace ondemand
 } // namespace westmere
@@ -98481,343 +100709,235 @@ simdjson_unused simdjson_inline std::ostream &operator<<(std::ostream &out, cons
 
 namespace simdjson {
 
-simdjson_inline simdjson_result<westmere::ondemand::raw_json_string>::simdjson_result(westmere::ondemand::raw_json_string &&value) noexcept
-    : implementation_simdjson_result_base<westmere::ondemand::raw_json_string>(std::forward<westmere::ondemand::raw_json_string>(value)) {}
-simdjson_inline simdjson_result<westmere::ondemand::raw_json_string>::simdjson_result(error_code error) noexcept
-    : implementation_simdjson_result_base<westmere::ondemand::raw_json_string>(error) {}
+simdjson_inline simdjson_result<westmere::ondemand::object_iterator>::simdjson_result(
+  westmere::ondemand::object_iterator &&value
+) noexcept
+  : implementation_simdjson_result_base<westmere::ondemand::object_iterator>(std::forward<westmere::ondemand::object_iterator>(value))
+{
+  first.iter.assert_is_valid();
+}
+simdjson_inline simdjson_result<westmere::ondemand::object_iterator>::simdjson_result(error_code error) noexcept
+  : implementation_simdjson_result_base<westmere::ondemand::object_iterator>({}, error)
+{
+}
 
-simdjson_inline simdjson_result<const char *> simdjson_result<westmere::ondemand::raw_json_string>::raw() const noexcept {
+simdjson_inline simdjson_result<westmere::ondemand::field> simdjson_result<westmere::ondemand::object_iterator>::operator*() noexcept {
   if (error()) { return error(); }
-  return first.raw();
+  return *first;
 }
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> simdjson_result<westmere::ondemand::raw_json_string>::unescape(westmere::ondemand::json_iterator &iter, bool allow_replacement) const noexcept {
-  if (error()) { return error(); }
-  return first.unescape(iter, allow_replacement);
+// If we're iterating and there is an error, return the error once.
+simdjson_inline bool simdjson_result<westmere::ondemand::object_iterator>::operator==(const simdjson_result<westmere::ondemand::object_iterator> &other) const noexcept {
+  if (!first.iter.is_valid()) { return !error(); }
+  return first == other.first;
 }
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> simdjson_result<westmere::ondemand::raw_json_string>::unescape_wobbly(westmere::ondemand::json_iterator &iter) const noexcept {
-  if (error()) { return error(); }
-  return first.unescape_wobbly(iter);
+// If we're iterating and there is an error, return the error once.
+simdjson_inline bool simdjson_result<westmere::ondemand::object_iterator>::operator!=(const simdjson_result<westmere::ondemand::object_iterator> &other) const noexcept {
+  if (!first.iter.is_valid()) { return error(); }
+  return first != other.first;
 }
+// Checks for ']' and ','
+simdjson_inline simdjson_result<westmere::ondemand::object_iterator> &simdjson_result<westmere::ondemand::object_iterator>::operator++() noexcept {
+  // Clear the error if there is one, so we don't yield it twice
+  if (error()) { second = SUCCESS; return *this; }
+  ++first;
+  return *this;
+}
+
 } // namespace simdjson
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_RAW_JSON_STRING_INL_H
-/* end file simdjson/generic/ondemand/raw_json_string-inl.h for westmere */
-/* including simdjson/generic/ondemand/serialization-inl.h for westmere: #include "simdjson/generic/ondemand/serialization-inl.h" */
-/* begin file simdjson/generic/ondemand/serialization-inl.h for westmere */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H
+#endif // SIMDJSON_GENERIC_ONDEMAND_OBJECT_ITERATOR_INL_H
+/* end file simdjson/generic/ondemand/object_iterator-inl.h for westmere */
+/* including simdjson/generic/ondemand/parser-inl.h for westmere: #include "simdjson/generic/ondemand/parser-inl.h" */
+/* begin file simdjson/generic/ondemand/parser-inl.h for westmere */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_PARSER_INL_H
 
 /* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_PARSER_INL_H */
+/* amalgamation skipped (editor-only): #include "simdjson/padded_string.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/padded_string_view.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/implementation.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/internal/dom_parser_implementation.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/dom/base.h" // for MINIMAL_DOCUMENT_CAPACITY */
 /* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document-inl.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_type.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/object.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/serialization.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document_stream.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/parser.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/raw_json_string.h" */
 /* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
 namespace simdjson {
+namespace westmere {
+namespace ondemand {
 
-inline std::string_view trim(const std::string_view str) noexcept {
-  // We can almost surely do better by rolling our own find_first_not_of function.
-  size_t first = str.find_first_not_of(" \t\n\r");
-  // If we have the empty string (just white space), then no trimming is possible, and
-  // we return the empty string_view.
-  if (std::string_view::npos == first) { return std::string_view(); }
-  size_t last = str.find_last_not_of(" \t\n\r");
-  return str.substr(first, (last - first + 1));
-}
-
-
-inline simdjson_result<std::string_view> to_json_string(westmere::ondemand::document& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
+simdjson_inline parser::parser(size_t max_capacity) noexcept
+  : _max_capacity{max_capacity} {
 }
 
-inline simdjson_result<std::string_view> to_json_string(westmere::ondemand::document_reference& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
-}
+simdjson_warn_unused simdjson_inline error_code parser::allocate(size_t new_capacity, size_t new_max_depth) noexcept {
+  if (new_capacity > max_capacity()) { return CAPACITY; }
+  if (string_buf && new_capacity == capacity() && new_max_depth == max_depth()) { return SUCCESS; }
 
-inline simdjson_result<std::string_view> to_json_string(westmere::ondemand::value& x) noexcept {
-  /**
-   * If we somehow receive a value that has already been consumed,
-   * then the following code could be in trouble. E.g., we create
-   * an array as needed, but if an array was already created, then
-   * it could be bad.
-   */
-  using namespace westmere::ondemand;
-  westmere::ondemand::json_type t;
-  auto error = x.type().get(t);
-  if(error != SUCCESS) { return error; }
-  switch (t)
-  {
-    case json_type::array:
-    {
-      westmere::ondemand::array array;
-      error = x.get_array().get(array);
-      if(error) { return error; }
-      return to_json_string(array);
-    }
-    case json_type::object:
-    {
-      westmere::ondemand::object object;
-      error = x.get_object().get(object);
-      if(error) { return error; }
-      return to_json_string(object);
-    }
-    default:
-      return trim(x.raw_json_token());
+  // string_capacity copied from document::allocate
+  _capacity = 0;
+  size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * new_capacity / 3 + SIMDJSON_PADDING, 64);
+  string_buf.reset(new (std::nothrow) uint8_t[string_capacity]);
+#if SIMDJSON_DEVELOPMENT_CHECKS
+  start_positions.reset(new (std::nothrow) token_position[new_max_depth]);
+#endif
+  if (implementation) {
+    SIMDJSON_TRY( implementation->set_capacity(new_capacity) );
+    SIMDJSON_TRY( implementation->set_max_depth(new_max_depth) );
+  } else {
+    SIMDJSON_TRY( simdjson::get_active_implementation()->create_dom_parser_implementation(new_capacity, new_max_depth, implementation) );
   }
+  _capacity = new_capacity;
+  _max_depth = new_max_depth;
+  return SUCCESS;
 }
-
-inline simdjson_result<std::string_view> to_json_string(westmere::ondemand::object& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
-}
-
-inline simdjson_result<std::string_view> to_json_string(westmere::ondemand::array& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
+#if SIMDJSON_DEVELOPMENT_CHECKS
+simdjson_inline simdjson_warn_unused bool parser::string_buffer_overflow(const uint8_t *string_buf_loc) const noexcept {
+  return (string_buf_loc < string_buf.get()) || (size_t(string_buf_loc - string_buf.get()) >= capacity());
 }
+#endif
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<westmere::ondemand::document> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(padded_string_view json) & noexcept {
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<westmere::ondemand::document_reference> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
+  json.remove_utf8_bom();
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<westmere::ondemand::value> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
+  // Allocate if needed
+  if (capacity() < json.length() || !string_buf) {
+    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
+  }
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<westmere::ondemand::object> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
+  // Run stage 1.
+  SIMDJSON_TRY( implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular) );
+  return document::start({ reinterpret_cast<const uint8_t *>(json.data()), this });
 }
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<westmere::ondemand::array> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
-} // namespace simdjson
+#ifdef SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate_allow_incomplete_json(padded_string_view json) & noexcept {
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
-namespace simdjson { namespace westmere { namespace ondemand {
+  json.remove_utf8_bom();
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::westmere::ondemand::value x) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(x).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::westmere::ondemand::value> x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
-}
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::westmere::ondemand::value x) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(x).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
+  // Allocate if needed
+  if (capacity() < json.length() || !string_buf) {
+    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
   }
-}
-#endif
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::westmere::ondemand::array value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::westmere::ondemand::array> x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
-}
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::westmere::ondemand::array value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
+  // Run stage 1.
+  const simdjson::error_code err = implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular);
+  if (err) {
+    if (err != UNCLOSED_STRING)
+      return err;
   }
+  return document::start({ reinterpret_cast<const uint8_t *>(json.data()), this, true });
 }
-#endif
+#endif // SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::westmere::ondemand::document& value)  {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::westmere::ondemand::document_reference& value)  {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::westmere::ondemand::document>&& x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const char *json, size_t len, size_t allocated) & noexcept {
+  return iterate(padded_string_view(json, len, allocated));
 }
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::westmere::ondemand::document_reference>&& x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const uint8_t *json, size_t len, size_t allocated) & noexcept {
+  return iterate(padded_string_view(json, len, allocated));
 }
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::westmere::ondemand::document& value)  {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
-  }
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(std::string_view json, size_t allocated) & noexcept {
+  return iterate(padded_string_view(json, allocated));
 }
-#endif
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::westmere::ondemand::object value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(std::string &json) & noexcept {
+  if(json.capacity() - json.size() < SIMDJSON_PADDING) {
+    json.reserve(json.size() + SIMDJSON_PADDING);
   }
+  return iterate(padded_string_view(json));
 }
-inline std::ostream& operator<<(std::ostream& out,  simdjson::simdjson_result<simdjson::westmere::ondemand::object> x) {
-  if (x.error()) { throw  simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const std::string &json) & noexcept {
+  return iterate(padded_string_view(json));
 }
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::westmere::ondemand::object value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
-  }
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const simdjson_result<padded_string_view> &result) & noexcept {
+  // We don't presently have a way to temporarily get a const T& from a simdjson_result<T> without throwing an exception
+  SIMDJSON_TRY( result.error() );
+  padded_string_view json = result.value_unsafe();
+  return iterate(json);
 }
-#endif
-}}} // namespace simdjson::westmere::ondemand
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H
-/* end file simdjson/generic/ondemand/serialization-inl.h for westmere */
-/* including simdjson/generic/ondemand/token_iterator-inl.h for westmere: #include "simdjson/generic/ondemand/token_iterator-inl.h" */
-/* begin file simdjson/generic/ondemand/token_iterator-inl.h for westmere */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_TOKEN_ITERATOR_INL_H
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const simdjson_result<padded_string> &result) & noexcept {
+  // We don't presently have a way to temporarily get a const T& from a simdjson_result<T> without throwing an exception
+  SIMDJSON_TRY( result.error() );
+  const padded_string &json = result.value_unsafe();
+  return iterate(json);
+}
 
-/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_TOKEN_ITERATOR_INL_H */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/token_iterator.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/implementation_simdjson_result_base-inl.h" */
-/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
+simdjson_warn_unused simdjson_inline simdjson_result<json_iterator> parser::iterate_raw(padded_string_view json) & noexcept {
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
-namespace simdjson {
-namespace westmere {
-namespace ondemand {
+  json.remove_utf8_bom();
 
-simdjson_inline token_iterator::token_iterator(
-  const uint8_t *_buf,
-  token_position position
-) noexcept : buf{_buf}, _position{position}
-{
-}
+  // Allocate if needed
+  if (capacity() < json.length()) {
+    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
+  }
 
-simdjson_inline uint32_t token_iterator::current_offset() const noexcept {
-  return *(_position);
+  // Run stage 1.
+  SIMDJSON_TRY( implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular) );
+  return json_iterator(reinterpret_cast<const uint8_t *>(json.data()), this);
 }
 
-
-simdjson_inline const uint8_t *token_iterator::return_current_and_advance() noexcept {
-  return &buf[*(_position++)];
+inline simdjson_result<document_stream> parser::iterate_many(const uint8_t *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {
+  if(batch_size < MINIMAL_BATCH_SIZE) { batch_size = MINIMAL_BATCH_SIZE; }
+  if((len >= 3) && (std::memcmp(buf, "\xEF\xBB\xBF", 3) == 0)) {
+    buf += 3;
+    len -= 3;
+  }
+  if(allow_comma_separated && batch_size < len) { batch_size = len; }
+  return document_stream(*this, buf, len, batch_size, allow_comma_separated);
 }
-
-simdjson_inline const uint8_t *token_iterator::peek(token_position position) const noexcept {
-  return &buf[*position];
+inline simdjson_result<document_stream> parser::iterate_many(const char *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {
+  return iterate_many(reinterpret_cast<const uint8_t *>(buf), len, batch_size, allow_comma_separated);
 }
-simdjson_inline uint32_t token_iterator::peek_index(token_position position) const noexcept {
-  return *position;
+inline simdjson_result<document_stream> parser::iterate_many(const std::string &s, size_t batch_size, bool allow_comma_separated) noexcept {
+  return iterate_many(s.data(), s.length(), batch_size, allow_comma_separated);
 }
-simdjson_inline uint32_t token_iterator::peek_length(token_position position) const noexcept {
-  return *(position+1) - *position;
+inline simdjson_result<document_stream> parser::iterate_many(const padded_string &s, size_t batch_size, bool allow_comma_separated) noexcept {
+  return iterate_many(s.data(), s.length(), batch_size, allow_comma_separated);
 }
 
-simdjson_inline uint32_t token_iterator::peek_root_length(token_position position) const noexcept {
-  return *(position+2) - *(position) > *(position+1) - *(position) ?
-      *(position+1) - *(position)
-      : *(position+2) - *(position);
-}
-simdjson_inline const uint8_t *token_iterator::peek(int32_t delta) const noexcept {
-  return &buf[*(_position+delta)];
+simdjson_pure simdjson_inline size_t parser::capacity() const noexcept {
+  return _capacity;
 }
-simdjson_inline uint32_t token_iterator::peek_index(int32_t delta) const noexcept {
-  return *(_position+delta);
+simdjson_pure simdjson_inline size_t parser::max_capacity() const noexcept {
+  return _max_capacity;
 }
-simdjson_inline uint32_t token_iterator::peek_length(int32_t delta) const noexcept {
-  return *(_position+delta+1) - *(_position+delta);
+simdjson_pure simdjson_inline size_t parser::max_depth() const noexcept {
+  return _max_depth;
 }
 
-simdjson_inline token_position token_iterator::position() const noexcept {
-  return _position;
-}
-simdjson_inline void token_iterator::set_position(token_position target_position) noexcept {
-  _position = target_position;
+simdjson_inline void parser::set_max_capacity(size_t max_capacity) noexcept {
+  if(max_capacity < dom::MINIMAL_DOCUMENT_CAPACITY) {
+    _max_capacity = max_capacity;
+  } else {
+    _max_capacity = dom::MINIMAL_DOCUMENT_CAPACITY;
+  }
 }
 
-simdjson_inline bool token_iterator::operator==(const token_iterator &other) const noexcept {
-  return _position == other._position;
-}
-simdjson_inline bool token_iterator::operator!=(const token_iterator &other) const noexcept {
-  return _position != other._position;
-}
-simdjson_inline bool token_iterator::operator>(const token_iterator &other) const noexcept {
-  return _position > other._position;
-}
-simdjson_inline bool token_iterator::operator>=(const token_iterator &other) const noexcept {
-  return _position >= other._position;
-}
-simdjson_inline bool token_iterator::operator<(const token_iterator &other) const noexcept {
-  return _position < other._position;
+simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape(raw_json_string in, uint8_t *&dst, bool allow_replacement) const noexcept {
+  uint8_t *end = implementation->parse_string(in.buf, dst, allow_replacement);
+  if (!end) { return STRING_ERROR; }
+  std::string_view result(reinterpret_cast<const char *>(dst), end-dst);
+  dst = end;
+  return result;
 }
-simdjson_inline bool token_iterator::operator<=(const token_iterator &other) const noexcept {
-  return _position <= other._position;
+
+simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape_wobbly(raw_json_string in, uint8_t *&dst) const noexcept {
+  uint8_t *end = implementation->parse_wobbly_string(in.buf, dst);
+  if (!end) { return STRING_ERROR; }
+  std::string_view result(reinterpret_cast<const char *>(dst), end-dst);
+  dst = end;
+  return result;
 }
 
 } // namespace ondemand
@@ -98826,10 +100946,10 @@ simdjson_inline bool token_iterator::operator<=(const token_iterator &other) con
 
 namespace simdjson {
 
-simdjson_inline simdjson_result<westmere::ondemand::token_iterator>::simdjson_result(westmere::ondemand::token_iterator &&value) noexcept
-    : implementation_simdjson_result_base<westmere::ondemand::token_iterator>(std::forward<westmere::ondemand::token_iterator>(value)) {}
-simdjson_inline simdjson_result<westmere::ondemand::token_iterator>::simdjson_result(error_code error) noexcept
-    : implementation_simdjson_result_base<westmere::ondemand::token_iterator>(error) {}
+simdjson_inline simdjson_result<westmere::ondemand::parser>::simdjson_result(westmere::ondemand::parser &&value) noexcept
+    : implementation_simdjson_result_base<westmere::ondemand::parser>(std::forward<westmere::ondemand::parser>(value)) {}
+simdjson_inline simdjson_result<westmere::ondemand::parser>::simdjson_result(error_code error) noexcept
+    : implementation_simdjson_result_base<westmere::ondemand::parser>(error) {}
 
 } // namespace simdjson
 
@@ -98851,6 +100971,7 @@ simdjson_inline simdjson_result<westmere::ondemand::token_iterator>::simdjson_re
 /* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
 namespace simdjson {
+
 namespace westmere {
 namespace ondemand {
 
@@ -98930,6 +101051,7 @@ simdjson_warn_unused simdjson_inline error_code value_iterator::end_container()
     _json_iter->ascend_to(depth()-1);
     return SUCCESS;
 }
+} // namespace simdjson
 
 simdjson_warn_unused simdjson_inline simdjson_result<bool> value_iterator::has_next_field() noexcept {
   assert_at_next();
@@ -106360,6 +108482,496 @@ simdjson_inline simdjson_result<bool> value::is_string() noexcept {
 }
 
 
+simdjson_inline bool value::is_negative() noexcept {
+  return iter.is_negative();
+}
+
+simdjson_inline simdjson_result<bool> value::is_integer() noexcept {
+  return iter.is_integer();
+}
+simdjson_warn_unused simdjson_inline simdjson_result<number_type> value::get_number_type() noexcept {
+  return iter.get_number_type();
+}
+simdjson_warn_unused simdjson_inline simdjson_result<number> value::get_number() noexcept {
+  return iter.get_number();
+}
+
+inline simdjson_result<value> array::at_path(std::string_view json_path) noexcept {
+  auto json_pointer = json_path_to_pointer_conversion(json_path);
+  if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
+  return at_pointer(json_pointer);
+}
+
+simdjson_inline simdjson_result<value> value::at_path(std::string_view json_path) noexcept {
+  json_type t;
+  SIMDJSON_TRY(type().get(t));
+  switch (t) {
+  case json_type::array:
+      return (*this).get_array().at_path(json_path);
+  case json_type::object:
+      return (*this).get_object().at_path(json_path);
+  default:
+      return INVALID_JSON_POINTER;
+  }
+}
+
+} // namespace ondemand
+} // namespace lsx
+} // namespace simdjson
+
+namespace simdjson {
+
+simdjson_inline simdjson_result<lsx::ondemand::value>::simdjson_result(
+  lsx::ondemand::value &&value
+) noexcept :
+    implementation_simdjson_result_base<lsx::ondemand::value>(
+      std::forward<lsx::ondemand::value>(value)
+    )
+{
+}
+simdjson_inline simdjson_result<lsx::ondemand::value>::simdjson_result(
+  error_code error
+) noexcept :
+    implementation_simdjson_result_base<lsx::ondemand::value>(error)
+{
+}
+simdjson_inline simdjson_result<size_t> simdjson_result<lsx::ondemand::value>::count_elements() & noexcept {
+  if (error()) { return error(); }
+  return first.count_elements();
+}
+simdjson_inline simdjson_result<size_t> simdjson_result<lsx::ondemand::value>::count_fields() & noexcept {
+  if (error()) { return error(); }
+  return first.count_fields();
+}
+simdjson_inline simdjson_result<lsx::ondemand::value> simdjson_result<lsx::ondemand::value>::at(size_t index) noexcept {
+  if (error()) { return error(); }
+  return first.at(index);
+}
+simdjson_inline simdjson_result<lsx::ondemand::array_iterator> simdjson_result<lsx::ondemand::value>::begin() & noexcept {
+  if (error()) { return error(); }
+  return first.begin();
+}
+simdjson_inline simdjson_result<lsx::ondemand::array_iterator> simdjson_result<lsx::ondemand::value>::end() & noexcept {
+  if (error()) { return error(); }
+  return {};
+}
+
+simdjson_inline simdjson_result<lsx::ondemand::value> simdjson_result<lsx::ondemand::value>::find_field(std::string_view key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field(key);
+}
+simdjson_inline simdjson_result<lsx::ondemand::value> simdjson_result<lsx::ondemand::value>::find_field(const char *key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field(key);
+}
+
+simdjson_inline simdjson_result<lsx::ondemand::value> simdjson_result<lsx::ondemand::value>::find_field_unordered(std::string_view key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field_unordered(key);
+}
+simdjson_inline simdjson_result<lsx::ondemand::value> simdjson_result<lsx::ondemand::value>::find_field_unordered(const char *key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field_unordered(key);
+}
+
+simdjson_inline simdjson_result<lsx::ondemand::value> simdjson_result<lsx::ondemand::value>::operator[](std::string_view key) noexcept {
+  if (error()) { return error(); }
+  return first[key];
+}
+simdjson_inline simdjson_result<lsx::ondemand::value> simdjson_result<lsx::ondemand::value>::operator[](const char *key) noexcept {
+  if (error()) { return error(); }
+  return first[key];
+}
+
+simdjson_inline simdjson_result<lsx::ondemand::array> simdjson_result<lsx::ondemand::value>::get_array() noexcept {
+  if (error()) { return error(); }
+  return first.get_array();
+}
+simdjson_inline simdjson_result<lsx::ondemand::object> simdjson_result<lsx::ondemand::value>::get_object() noexcept {
+  if (error()) { return error(); }
+  return first.get_object();
+}
+simdjson_inline simdjson_result<uint64_t> simdjson_result<lsx::ondemand::value>::get_uint64() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint64();
+}
+simdjson_inline simdjson_result<uint64_t> simdjson_result<lsx::ondemand::value>::get_uint64_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint64_in_string();
+}
+simdjson_inline simdjson_result<int64_t> simdjson_result<lsx::ondemand::value>::get_int64() noexcept {
+  if (error()) { return error(); }
+  return first.get_int64();
+}
+simdjson_inline simdjson_result<int64_t> simdjson_result<lsx::ondemand::value>::get_int64_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_int64_in_string();
+}
+simdjson_inline simdjson_result<double> simdjson_result<lsx::ondemand::value>::get_double() noexcept {
+  if (error()) { return error(); }
+  return first.get_double();
+}
+simdjson_inline simdjson_result<double> simdjson_result<lsx::ondemand::value>::get_double_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_double_in_string();
+}
+simdjson_inline simdjson_result<std::string_view> simdjson_result<lsx::ondemand::value>::get_string(bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.get_string(allow_replacement);
+}
+template <typename string_type>
+simdjson_inline error_code simdjson_result<lsx::ondemand::value>::get_string(string_type& receiver, bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.get_string(receiver, allow_replacement);
+}
+simdjson_inline simdjson_result<std::string_view> simdjson_result<lsx::ondemand::value>::get_wobbly_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_wobbly_string();
+}
+simdjson_inline simdjson_result<lsx::ondemand::raw_json_string> simdjson_result<lsx::ondemand::value>::get_raw_json_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_raw_json_string();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<lsx::ondemand::value>::get_bool() noexcept {
+  if (error()) { return error(); }
+  return first.get_bool();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<lsx::ondemand::value>::is_null() noexcept {
+  if (error()) { return error(); }
+  return first.is_null();
+}
+
+template<> simdjson_inline error_code simdjson_result<lsx::ondemand::value>::get<lsx::ondemand::value>(lsx::ondemand::value &out) noexcept {
+  if (error()) { return error(); }
+  out = first;
+  return SUCCESS;
+}
+
+template<typename T> simdjson_inline simdjson_result<T> simdjson_result<lsx::ondemand::value>::get() noexcept {
+  if (error()) { return error(); }
+  return first.get<T>();
+}
+template<typename T> simdjson_inline error_code simdjson_result<lsx::ondemand::value>::get(T &out) noexcept {
+  if (error()) { return error(); }
+  return first.get<T>(out);
+}
+
+template<> simdjson_inline simdjson_result<lsx::ondemand::value> simdjson_result<lsx::ondemand::value>::get<lsx::ondemand::value>() noexcept  {
+  if (error()) { return error(); }
+  return std::move(first);
+}
+
+simdjson_inline simdjson_result<lsx::ondemand::json_type> simdjson_result<lsx::ondemand::value>::type() noexcept {
+  if (error()) { return error(); }
+  return first.type();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<lsx::ondemand::value>::is_scalar() noexcept {
+  if (error()) { return error(); }
+  return first.is_scalar();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<lsx::ondemand::value>::is_string() noexcept {
+  if (error()) { return error(); }
+  return first.is_string();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<lsx::ondemand::value>::is_negative() noexcept {
+  if (error()) { return error(); }
+  return first.is_negative();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<lsx::ondemand::value>::is_integer() noexcept {
+  if (error()) { return error(); }
+  return first.is_integer();
+}
+simdjson_inline simdjson_result<lsx::number_type> simdjson_result<lsx::ondemand::value>::get_number_type() noexcept {
+  if (error()) { return error(); }
+  return first.get_number_type();
+}
+simdjson_inline simdjson_result<lsx::ondemand::number> simdjson_result<lsx::ondemand::value>::get_number() noexcept {
+  if (error()) { return error(); }
+  return first.get_number();
+}
+#if SIMDJSON_EXCEPTIONS
+template <class T>
+simdjson_inline simdjson_result<lsx::ondemand::value>::operator T() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first.get<T>();
+}
+simdjson_inline simdjson_result<lsx::ondemand::value>::operator lsx::ondemand::array() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lsx::ondemand::value>::operator lsx::ondemand::object() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lsx::ondemand::value>::operator uint64_t() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lsx::ondemand::value>::operator int64_t() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lsx::ondemand::value>::operator double() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lsx::ondemand::value>::operator std::string_view() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lsx::ondemand::value>::operator lsx::ondemand::raw_json_string() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lsx::ondemand::value>::operator bool() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+#endif
+
+simdjson_inline simdjson_result<std::string_view> simdjson_result<lsx::ondemand::value>::raw_json_token() noexcept {
+  if (error()) { return error(); }
+  return first.raw_json_token();
+}
+
+simdjson_inline simdjson_result<std::string_view> simdjson_result<lsx::ondemand::value>::raw_json() noexcept {
+  if (error()) { return error(); }
+  return first.raw_json();
+}
+
+simdjson_inline simdjson_result<const char *> simdjson_result<lsx::ondemand::value>::current_location() noexcept {
+  if (error()) { return error(); }
+  return first.current_location();
+}
+
+simdjson_inline simdjson_result<int32_t> simdjson_result<lsx::ondemand::value>::current_depth() const noexcept {
+  if (error()) { return error(); }
+  return first.current_depth();
+}
+
+simdjson_inline simdjson_result<lsx::ondemand::value> simdjson_result<lsx::ondemand::value>::at_pointer(
+    std::string_view json_pointer) noexcept {
+  if (error()) {
+      return error();
+  }
+  return first.at_pointer(json_pointer);
+}
+
+simdjson_inline simdjson_result<lsx::ondemand::value> simdjson_result<lsx::ondemand::value>::at_path(
+      std::string_view json_path) noexcept {
+  if (error()) {
+    return error();
+  }
+  return first.at_path(json_path);
+}
+
+} // namespace simdjson
+
+#endif // SIMDJSON_GENERIC_ONDEMAND_ARRAY_ITERATOR_INL_H
+/* end file simdjson/generic/ondemand/array_iterator-inl.h for lsx */
+/* including simdjson/generic/ondemand/value-inl.h for lsx: #include "simdjson/generic/ondemand/value-inl.h" */
+/* begin file simdjson/generic/ondemand/value-inl.h for lsx */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_VALUE_INL_H
+
+/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_VALUE_INL_H */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array_iterator.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_iterator.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_type.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/object.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/raw_json_string.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value.h" */
+/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
+
+namespace simdjson {
+namespace lsx {
+namespace ondemand {
+
+simdjson_inline value::value(const value_iterator &_iter) noexcept
+  : iter{_iter}
+{
+}
+simdjson_inline value value::start(const value_iterator &iter) noexcept {
+  return iter;
+}
+simdjson_inline value value::resume(const value_iterator &iter) noexcept {
+  return iter;
+}
+
+simdjson_inline simdjson_result<array> value::get_array() noexcept {
+  return array::start(iter);
+}
+simdjson_inline simdjson_result<object> value::get_object() noexcept {
+  return object::start(iter);
+}
+simdjson_inline simdjson_result<object> value::start_or_resume_object() noexcept {
+  if (iter.at_start()) {
+    return get_object();
+  } else {
+    return object::resume(iter);
+  }
+}
+
+simdjson_inline simdjson_result<raw_json_string> value::get_raw_json_string() noexcept {
+  return iter.get_raw_json_string();
+}
+simdjson_inline simdjson_result<std::string_view> value::get_string(bool allow_replacement) noexcept {
+  return iter.get_string(allow_replacement);
+}
+template <typename string_type>
+simdjson_inline error_code value::get_string(string_type& receiver, bool allow_replacement) noexcept {
+  return iter.get_string(receiver, allow_replacement);
+}
+simdjson_inline simdjson_result<std::string_view> value::get_wobbly_string() noexcept {
+  return iter.get_wobbly_string();
+}
+simdjson_inline simdjson_result<double> value::get_double() noexcept {
+  return iter.get_double();
+}
+simdjson_inline simdjson_result<double> value::get_double_in_string() noexcept {
+  return iter.get_double_in_string();
+}
+simdjson_inline simdjson_result<uint64_t> value::get_uint64() noexcept {
+  return iter.get_uint64();
+}
+simdjson_inline simdjson_result<uint64_t> value::get_uint64_in_string() noexcept {
+  return iter.get_uint64_in_string();
+}
+simdjson_inline simdjson_result<int64_t> value::get_int64() noexcept {
+  return iter.get_int64();
+}
+simdjson_inline simdjson_result<int64_t> value::get_int64_in_string() noexcept {
+  return iter.get_int64_in_string();
+}
+simdjson_inline simdjson_result<bool> value::get_bool() noexcept {
+  return iter.get_bool();
+}
+simdjson_inline simdjson_result<bool> value::is_null() noexcept {
+  return iter.is_null();
+}
+
+template<> simdjson_inline simdjson_result<array> value::get() noexcept { return get_array(); }
+template<> simdjson_inline simdjson_result<object> value::get() noexcept { return get_object(); }
+template<> simdjson_inline simdjson_result<raw_json_string> value::get() noexcept { return get_raw_json_string(); }
+template<> simdjson_inline simdjson_result<std::string_view> value::get() noexcept { return get_string(false); }
+template<> simdjson_inline simdjson_result<number> value::get() noexcept { return get_number(); }
+template<> simdjson_inline simdjson_result<double> value::get() noexcept { return get_double(); }
+template<> simdjson_inline simdjson_result<uint64_t> value::get() noexcept { return get_uint64(); }
+template<> simdjson_inline simdjson_result<int64_t> value::get() noexcept { return get_int64(); }
+template<> simdjson_inline simdjson_result<bool> value::get() noexcept { return get_bool(); }
+
+
+template<> simdjson_inline error_code value::get(array& out) noexcept { return get_array().get(out); }
+template<> simdjson_inline error_code value::get(object& out) noexcept { return get_object().get(out); }
+template<> simdjson_inline error_code value::get(raw_json_string& out) noexcept { return get_raw_json_string().get(out); }
+template<> simdjson_inline error_code value::get(std::string_view& out) noexcept { return get_string(false).get(out); }
+template<> simdjson_inline error_code value::get(number& out) noexcept { return get_number().get(out); }
+template<> simdjson_inline error_code value::get(double& out) noexcept { return get_double().get(out); }
+template<> simdjson_inline error_code value::get(uint64_t& out) noexcept { return get_uint64().get(out); }
+template<> simdjson_inline error_code value::get(int64_t& out) noexcept { return get_int64().get(out); }
+template<> simdjson_inline error_code value::get(bool& out) noexcept { return get_bool().get(out); }
+
+#if SIMDJSON_EXCEPTIONS
+template <class T>
+simdjson_inline value::operator T() noexcept(false) {
+  return get<T>();
+}
+simdjson_inline value::operator array() noexcept(false) {
+  return get_array();
+}
+simdjson_inline value::operator object() noexcept(false) {
+  return get_object();
+}
+simdjson_inline value::operator uint64_t() noexcept(false) {
+  return get_uint64();
+}
+simdjson_inline value::operator int64_t() noexcept(false) {
+  return get_int64();
+}
+simdjson_inline value::operator double() noexcept(false) {
+  return get_double();
+}
+simdjson_inline value::operator std::string_view() noexcept(false) {
+  return get_string(false);
+}
+simdjson_inline value::operator raw_json_string() noexcept(false) {
+  return get_raw_json_string();
+}
+simdjson_inline value::operator bool() noexcept(false) {
+  return get_bool();
+}
+#endif
+
+simdjson_inline simdjson_result<array_iterator> value::begin() & noexcept {
+  return get_array().begin();
+}
+simdjson_inline simdjson_result<array_iterator> value::end() & noexcept {
+  return {};
+}
+simdjson_inline simdjson_result<size_t> value::count_elements() & noexcept {
+  simdjson_result<size_t> answer;
+  auto a = get_array();
+  answer = a.count_elements();
+  // count_elements leaves you pointing inside the array, at the first element.
+  // We need to move back so that the user can create a new array (which requires that
+  // we point at '[').
+  iter.move_at_start();
+  return answer;
+}
+simdjson_inline simdjson_result<size_t> value::count_fields() & noexcept {
+  simdjson_result<size_t> answer;
+  auto a = get_object();
+  answer = a.count_fields();
+  iter.move_at_start();
+  return answer;
+}
+simdjson_inline simdjson_result<value> value::at(size_t index) noexcept {
+  auto a = get_array();
+  return a.at(index);
+}
+
+simdjson_inline simdjson_result<value> value::find_field(std::string_view key) noexcept {
+  return start_or_resume_object().find_field(key);
+}
+simdjson_inline simdjson_result<value> value::find_field(const char *key) noexcept {
+  return start_or_resume_object().find_field(key);
+}
+
+simdjson_inline simdjson_result<value> value::find_field_unordered(std::string_view key) noexcept {
+  return start_or_resume_object().find_field_unordered(key);
+}
+simdjson_inline simdjson_result<value> value::find_field_unordered(const char *key) noexcept {
+  return start_or_resume_object().find_field_unordered(key);
+}
+
+simdjson_inline simdjson_result<value> value::operator[](std::string_view key) noexcept {
+  return start_or_resume_object()[key];
+}
+simdjson_inline simdjson_result<value> value::operator[](const char *key) noexcept {
+  return start_or_resume_object()[key];
+}
+
+simdjson_inline simdjson_result<json_type> value::type() noexcept {
+  return iter.type();
+}
+
+simdjson_inline simdjson_result<bool> value::is_scalar() noexcept {
+  json_type this_type;
+  auto error = type().get(this_type);
+  if(error) { return error; }
+  return ! ((this_type == json_type::array) || (this_type == json_type::object));
+}
+
+simdjson_inline simdjson_result<bool> value::is_string() noexcept {
+  json_type this_type;
+  auto error = type().get(this_type);
+  if(error) { return error; }
+  return (this_type == json_type::string);
+}
+
+
 simdjson_inline bool value::is_negative() noexcept {
   return iter.is_negative();
 }
@@ -107267,7 +109879,7 @@ simdjson_inline simdjson_result<lsx::ondemand::number> simdjson_result<lsx::onde
 template <class T, typename std::enable_if<std::is_same<T, lsx::ondemand::document>::value == false>::type>
 simdjson_inline simdjson_result<lsx::ondemand::document>::operator T() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get<T>();
 }
 simdjson_inline simdjson_result<lsx::ondemand::document>::operator lsx::ondemand::array() & noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
@@ -109693,36 +112305,39 @@ simdjson_inline const char * raw_json_string::raw() const noexcept { return rein
 
 simdjson_inline bool raw_json_string::is_free_from_unescaped_quote(std::string_view target) noexcept {
   size_t pos{0};
-  // if the content has no escape character, just scan through it quickly!
-  for(;pos < target.size() && target[pos] != '\\';pos++) {}
-  // slow path may begin.
-  bool escaping{false};
-  for(;pos < target.size();pos++) {
-    if((target[pos] == '"') && !escaping) {
-      return false;
-    } else if(target[pos] == '\\') {
-      escaping = !escaping;
-    } else {
-      escaping = false;
+  while(pos < target.size()) {
+    pos = target.find('"', pos);
+    if(pos == std::string_view::npos) { return true; }
+    if(pos != 0 && target[pos-1] != '\\') { return false; }
+    if(pos > 1 && target[pos-2] == '\\') {
+      size_t backslash_count{2};
+      for(size_t i = 3; i <= pos; i++) {
+        if(target[pos-i] == '\\') { backslash_count++; }
+        else { break; }
+      }
+      if(backslash_count % 2 == 0) { return false; }
     }
+    pos++;
   }
   return true;
 }
 
 simdjson_inline bool raw_json_string::is_free_from_unescaped_quote(const char* target) noexcept {
   size_t pos{0};
-  // if the content has no escape character, just scan through it quickly!
-  for(;target[pos] && target[pos] != '\\';pos++) {}
-  // slow path may begin.
-  bool escaping{false};
-  for(;target[pos];pos++) {
-    if((target[pos] == '"') && !escaping) {
-      return false;
-    } else if(target[pos] == '\\') {
-      escaping = !escaping;
-    } else {
-      escaping = false;
+  while(target[pos]) {
+    const char * result = strchr(target+pos, '"');
+    if(result == nullptr) { return true; }
+    pos = result - target;
+    if(pos != 0 && target[pos-1] != '\\') { return false; }
+    if(pos > 1 && target[pos-2] == '\\') {
+      size_t backslash_count{2};
+      for(size_t i = 3; i <= pos; i++) {
+        if(target[pos-i] == '\\') { backslash_count++; }
+        else { break; }
+      }
+      if(backslash_count % 2 == 0) { return false; }
     }
+    pos++;
   }
   return true;
 }
@@ -109734,7 +112349,7 @@ simdjson_inline bool raw_json_string::unsafe_is_equal(size_t length, std::string
 }
 
 simdjson_inline bool raw_json_string::unsafe_is_equal(std::string_view target) const noexcept {
-  // Assumptions: does not contain unescaped quote characters, and
+  // Assumptions: does not contain unescaped quote characters("), and
   // the raw content is quote terminated within a valid JSON string.
   if(target.size() <= SIMDJSON_PADDING) {
     return (raw()[target.size()] == '"') && !memcmp(raw(), target.data(), target.size());
@@ -109825,28 +112440,62 @@ simdjson_unused simdjson_inline bool operator!=(std::string_view c, const raw_js
   return !(a == c);
 }
 
+SIMDJSON_PUSH_DISABLE_WARNINGS
+SIMDJSON_DISABLE_STRICT_OVERFLOW_WARNING
+simdjson_inline object_iterator &object_iterator::operator++() noexcept {
+  // TODO this is a safety rail ... users should exit loops as soon as they receive an error.
+  // Nonetheless, let's see if performance is OK with this if statement--the compiler may give it to us for free.
+  if (!iter.is_open()) { return *this; } // Iterator will be released if there is an error
 
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> raw_json_string::unescape(json_iterator &iter, bool allow_replacement) const noexcept {
-  return iter.unescape(*this, allow_replacement);
-}
+  simdjson_unused error_code error;
+  if ((error = iter.skip_child() )) { return *this; }
 
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> raw_json_string::unescape_wobbly(json_iterator &iter) const noexcept {
-  return iter.unescape_wobbly(*this);
+  simdjson_unused bool has_value;
+  if ((error = iter.has_next_field().get(has_value) )) { return *this; };
+  return *this;
 }
+SIMDJSON_POP_DISABLE_WARNINGS
 
-simdjson_unused simdjson_inline std::ostream &operator<<(std::ostream &out, const raw_json_string &str) noexcept {
-  bool in_escape = false;
-  const char *s = str.raw();
-  while (true) {
-    switch (*s) {
-      case '\\': in_escape = !in_escape; break;
-      case '"': if (in_escape) { in_escape = false; } else { return out; } break;
-      default: if (in_escape) { in_escape = false; }
-    }
-    out << *s;
-    s++;
-  }
-}
+//
+// ### Live States
+//
+// While iterating or looking up values, depth >= iter.depth. at_start may vary. Error is
+// always SUCCESS:
+//
+// - Start: This is the state when the object is first found and the iterator is just past the {.
+//   In this state, at_start == true.
+// - Next: After we hand a scalar value to the user, or an array/object which they then fully
+//   iterate over, the iterator is at the , or } before the next value. In this state,
+//   depth == iter.depth, at_start == false, and error == SUCCESS.
+// - Unfinished Business: When we hand an array/object to the user which they do not fully
+//   iterate over, we need to finish that iteration by skipping child values until we reach the
+//   Next state. In this state, depth > iter.depth, at_start == false, and error == SUCCESS.
+//
+// ## Error States
+//
+// In error states, we will yield exactly one more value before stopping. iter.depth == depth
+// and at_start is always false. We decrement after yielding the error, moving to the Finished
+// state.
+//
+// - Chained Error: When the object iterator is part of an error chain--for example, in
+//   `for (auto tweet : doc["tweets"])`, where the tweet field may be missing or not be an
+//   object--we yield that error in the loop, exactly once. In this state, error != SUCCESS and
+//   iter.depth == depth, and at_start == false. We decrement depth when we yield the error.
+// - Missing Comma Error: When the iterator ++ method discovers there is no comma between fields,
+//   we flag that as an error and treat it exactly the same as a Chained Error. In this state,
+//   error == TAPE_ERROR, iter.depth == depth, and at_start == false.
+//
+// Errors that occur while reading a field to give to the user (such as when the key is not a
+// string or the field is missing a colon) are yielded immediately. Depth is then decremented,
+// moving to the Finished state without transitioning through an Error state at all.
+//
+// ## Terminal State
+//
+// The terminal state has iter.depth < depth. at_start is always false.
+//
+// - Finished: When we have reached a }, we are finished. We signal this by decrementing depth.
+//   In this state, iter.depth < depth, at_start == false, and error == SUCCESS.
+//
 
 } // namespace ondemand
 } // namespace lsx
@@ -109854,343 +112503,235 @@ simdjson_unused simdjson_inline std::ostream &operator<<(std::ostream &out, cons
 
 namespace simdjson {
 
-simdjson_inline simdjson_result<lsx::ondemand::raw_json_string>::simdjson_result(lsx::ondemand::raw_json_string &&value) noexcept
-    : implementation_simdjson_result_base<lsx::ondemand::raw_json_string>(std::forward<lsx::ondemand::raw_json_string>(value)) {}
-simdjson_inline simdjson_result<lsx::ondemand::raw_json_string>::simdjson_result(error_code error) noexcept
-    : implementation_simdjson_result_base<lsx::ondemand::raw_json_string>(error) {}
+simdjson_inline simdjson_result<lsx::ondemand::object_iterator>::simdjson_result(
+  lsx::ondemand::object_iterator &&value
+) noexcept
+  : implementation_simdjson_result_base<lsx::ondemand::object_iterator>(std::forward<lsx::ondemand::object_iterator>(value))
+{
+  first.iter.assert_is_valid();
+}
+simdjson_inline simdjson_result<lsx::ondemand::object_iterator>::simdjson_result(error_code error) noexcept
+  : implementation_simdjson_result_base<lsx::ondemand::object_iterator>({}, error)
+{
+}
 
-simdjson_inline simdjson_result<const char *> simdjson_result<lsx::ondemand::raw_json_string>::raw() const noexcept {
+simdjson_inline simdjson_result<lsx::ondemand::field> simdjson_result<lsx::ondemand::object_iterator>::operator*() noexcept {
   if (error()) { return error(); }
-  return first.raw();
+  return *first;
 }
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> simdjson_result<lsx::ondemand::raw_json_string>::unescape(lsx::ondemand::json_iterator &iter, bool allow_replacement) const noexcept {
-  if (error()) { return error(); }
-  return first.unescape(iter, allow_replacement);
+// If we're iterating and there is an error, return the error once.
+simdjson_inline bool simdjson_result<lsx::ondemand::object_iterator>::operator==(const simdjson_result<lsx::ondemand::object_iterator> &other) const noexcept {
+  if (!first.iter.is_valid()) { return !error(); }
+  return first == other.first;
 }
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> simdjson_result<lsx::ondemand::raw_json_string>::unescape_wobbly(lsx::ondemand::json_iterator &iter) const noexcept {
-  if (error()) { return error(); }
-  return first.unescape_wobbly(iter);
+// If we're iterating and there is an error, return the error once.
+simdjson_inline bool simdjson_result<lsx::ondemand::object_iterator>::operator!=(const simdjson_result<lsx::ondemand::object_iterator> &other) const noexcept {
+  if (!first.iter.is_valid()) { return error(); }
+  return first != other.first;
 }
+// Checks for ']' and ','
+simdjson_inline simdjson_result<lsx::ondemand::object_iterator> &simdjson_result<lsx::ondemand::object_iterator>::operator++() noexcept {
+  // Clear the error if there is one, so we don't yield it twice
+  if (error()) { second = SUCCESS; return *this; }
+  ++first;
+  return *this;
+}
+
 } // namespace simdjson
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_RAW_JSON_STRING_INL_H
-/* end file simdjson/generic/ondemand/raw_json_string-inl.h for lsx */
-/* including simdjson/generic/ondemand/serialization-inl.h for lsx: #include "simdjson/generic/ondemand/serialization-inl.h" */
-/* begin file simdjson/generic/ondemand/serialization-inl.h for lsx */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H
+#endif // SIMDJSON_GENERIC_ONDEMAND_OBJECT_ITERATOR_INL_H
+/* end file simdjson/generic/ondemand/object_iterator-inl.h for lsx */
+/* including simdjson/generic/ondemand/parser-inl.h for lsx: #include "simdjson/generic/ondemand/parser-inl.h" */
+/* begin file simdjson/generic/ondemand/parser-inl.h for lsx */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_PARSER_INL_H
 
 /* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_PARSER_INL_H */
+/* amalgamation skipped (editor-only): #include "simdjson/padded_string.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/padded_string_view.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/implementation.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/internal/dom_parser_implementation.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/dom/base.h" // for MINIMAL_DOCUMENT_CAPACITY */
 /* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document-inl.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_type.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/object.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/serialization.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document_stream.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/parser.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/raw_json_string.h" */
 /* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
 namespace simdjson {
+namespace lsx {
+namespace ondemand {
 
-inline std::string_view trim(const std::string_view str) noexcept {
-  // We can almost surely do better by rolling our own find_first_not_of function.
-  size_t first = str.find_first_not_of(" \t\n\r");
-  // If we have the empty string (just white space), then no trimming is possible, and
-  // we return the empty string_view.
-  if (std::string_view::npos == first) { return std::string_view(); }
-  size_t last = str.find_last_not_of(" \t\n\r");
-  return str.substr(first, (last - first + 1));
-}
-
-
-inline simdjson_result<std::string_view> to_json_string(lsx::ondemand::document& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
+simdjson_inline parser::parser(size_t max_capacity) noexcept
+  : _max_capacity{max_capacity} {
 }
 
-inline simdjson_result<std::string_view> to_json_string(lsx::ondemand::document_reference& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
-}
+simdjson_warn_unused simdjson_inline error_code parser::allocate(size_t new_capacity, size_t new_max_depth) noexcept {
+  if (new_capacity > max_capacity()) { return CAPACITY; }
+  if (string_buf && new_capacity == capacity() && new_max_depth == max_depth()) { return SUCCESS; }
 
-inline simdjson_result<std::string_view> to_json_string(lsx::ondemand::value& x) noexcept {
-  /**
-   * If we somehow receive a value that has already been consumed,
-   * then the following code could be in trouble. E.g., we create
-   * an array as needed, but if an array was already created, then
-   * it could be bad.
-   */
-  using namespace lsx::ondemand;
-  lsx::ondemand::json_type t;
-  auto error = x.type().get(t);
-  if(error != SUCCESS) { return error; }
-  switch (t)
-  {
-    case json_type::array:
-    {
-      lsx::ondemand::array array;
-      error = x.get_array().get(array);
-      if(error) { return error; }
-      return to_json_string(array);
-    }
-    case json_type::object:
-    {
-      lsx::ondemand::object object;
-      error = x.get_object().get(object);
-      if(error) { return error; }
-      return to_json_string(object);
-    }
-    default:
-      return trim(x.raw_json_token());
+  // string_capacity copied from document::allocate
+  _capacity = 0;
+  size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * new_capacity / 3 + SIMDJSON_PADDING, 64);
+  string_buf.reset(new (std::nothrow) uint8_t[string_capacity]);
+#if SIMDJSON_DEVELOPMENT_CHECKS
+  start_positions.reset(new (std::nothrow) token_position[new_max_depth]);
+#endif
+  if (implementation) {
+    SIMDJSON_TRY( implementation->set_capacity(new_capacity) );
+    SIMDJSON_TRY( implementation->set_max_depth(new_max_depth) );
+  } else {
+    SIMDJSON_TRY( simdjson::get_active_implementation()->create_dom_parser_implementation(new_capacity, new_max_depth, implementation) );
   }
+  _capacity = new_capacity;
+  _max_depth = new_max_depth;
+  return SUCCESS;
 }
-
-inline simdjson_result<std::string_view> to_json_string(lsx::ondemand::object& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
-}
-
-inline simdjson_result<std::string_view> to_json_string(lsx::ondemand::array& x) noexcept {
-  std::string_view v;
-  auto error = x.raw_json().get(v);
-  if(error) {return error; }
-  return trim(v);
+#if SIMDJSON_DEVELOPMENT_CHECKS
+simdjson_inline simdjson_warn_unused bool parser::string_buffer_overflow(const uint8_t *string_buf_loc) const noexcept {
+  return (string_buf_loc < string_buf.get()) || (size_t(string_buf_loc - string_buf.get()) >= capacity());
 }
+#endif
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<lsx::ondemand::document> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(padded_string_view json) & noexcept {
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<lsx::ondemand::document_reference> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
+  json.remove_utf8_bom();
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<lsx::ondemand::value> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
+  // Allocate if needed
+  if (capacity() < json.length() || !string_buf) {
+    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
+  }
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<lsx::ondemand::object> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
+  // Run stage 1.
+  SIMDJSON_TRY( implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular) );
+  return document::start({ reinterpret_cast<const uint8_t *>(json.data()), this });
 }
 
-inline simdjson_result<std::string_view> to_json_string(simdjson_result<lsx::ondemand::array> x) {
-  if (x.error()) { return x.error(); }
-  return to_json_string(x.value_unsafe());
-}
-} // namespace simdjson
+#ifdef SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate_allow_incomplete_json(padded_string_view json) & noexcept {
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
-namespace simdjson { namespace lsx { namespace ondemand {
+  json.remove_utf8_bom();
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::lsx::ondemand::value x) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(x).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::lsx::ondemand::value> x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
-}
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::lsx::ondemand::value x) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(x).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
+  // Allocate if needed
+  if (capacity() < json.length() || !string_buf) {
+    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
   }
-}
-#endif
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::lsx::ondemand::array value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::lsx::ondemand::array> x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
-}
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::lsx::ondemand::array value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
+  // Run stage 1.
+  const simdjson::error_code err = implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular);
+  if (err) {
+    if (err != UNCLOSED_STRING)
+      return err;
   }
+  return document::start({ reinterpret_cast<const uint8_t *>(json.data()), this, true });
 }
-#endif
+#endif // SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::lsx::ondemand::document& value)  {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::lsx::ondemand::document_reference& value)  {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
-  }
-}
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::lsx::ondemand::document>&& x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const char *json, size_t len, size_t allocated) & noexcept {
+  return iterate(padded_string_view(json, len, allocated));
 }
-inline std::ostream& operator<<(std::ostream& out, simdjson::simdjson_result<simdjson::lsx::ondemand::document_reference>&& x) {
-  if (x.error()) { throw simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const uint8_t *json, size_t len, size_t allocated) & noexcept {
+  return iterate(padded_string_view(json, len, allocated));
 }
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::lsx::ondemand::document& value)  {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
-  }
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(std::string_view json, size_t allocated) & noexcept {
+  return iterate(padded_string_view(json, allocated));
 }
-#endif
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson::lsx::ondemand::object value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    throw simdjson::simdjson_error(error);
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(std::string &json) & noexcept {
+  if(json.capacity() - json.size() < SIMDJSON_PADDING) {
+    json.reserve(json.size() + SIMDJSON_PADDING);
   }
+  return iterate(padded_string_view(json));
 }
-inline std::ostream& operator<<(std::ostream& out,  simdjson::simdjson_result<simdjson::lsx::ondemand::object> x) {
-  if (x.error()) { throw  simdjson::simdjson_error(x.error()); }
-  return (out << x.value());
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const std::string &json) & noexcept {
+  return iterate(padded_string_view(json));
 }
-#else
-inline std::ostream& operator<<(std::ostream& out, simdjson::lsx::ondemand::object value) {
-  std::string_view v;
-  auto error = simdjson::to_json_string(value).get(v);
-  if(error == simdjson::SUCCESS) {
-    return (out << v);
-  } else {
-    return (out << error);
-  }
+
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const simdjson_result<padded_string_view> &result) & noexcept {
+  // We don't presently have a way to temporarily get a const T& from a simdjson_result<T> without throwing an exception
+  SIMDJSON_TRY( result.error() );
+  padded_string_view json = result.value_unsafe();
+  return iterate(json);
 }
-#endif
-}}} // namespace simdjson::lsx::ondemand
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_SERIALIZATION_INL_H
-/* end file simdjson/generic/ondemand/serialization-inl.h for lsx */
-/* including simdjson/generic/ondemand/token_iterator-inl.h for lsx: #include "simdjson/generic/ondemand/token_iterator-inl.h" */
-/* begin file simdjson/generic/ondemand/token_iterator-inl.h for lsx */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_TOKEN_ITERATOR_INL_H
+simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const simdjson_result<padded_string> &result) & noexcept {
+  // We don't presently have a way to temporarily get a const T& from a simdjson_result<T> without throwing an exception
+  SIMDJSON_TRY( result.error() );
+  const padded_string &json = result.value_unsafe();
+  return iterate(json);
+}
 
-/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_TOKEN_ITERATOR_INL_H */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/token_iterator.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/implementation_simdjson_result_base-inl.h" */
-/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
+simdjson_warn_unused simdjson_inline simdjson_result<json_iterator> parser::iterate_raw(padded_string_view json) & noexcept {
+  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
 
-namespace simdjson {
-namespace lsx {
-namespace ondemand {
+  json.remove_utf8_bom();
 
-simdjson_inline token_iterator::token_iterator(
-  const uint8_t *_buf,
-  token_position position
-) noexcept : buf{_buf}, _position{position}
-{
-}
+  // Allocate if needed
+  if (capacity() < json.length()) {
+    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
+  }
 
-simdjson_inline uint32_t token_iterator::current_offset() const noexcept {
-  return *(_position);
+  // Run stage 1.
+  SIMDJSON_TRY( implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular) );
+  return json_iterator(reinterpret_cast<const uint8_t *>(json.data()), this);
 }
 
-
-simdjson_inline const uint8_t *token_iterator::return_current_and_advance() noexcept {
-  return &buf[*(_position++)];
+inline simdjson_result<document_stream> parser::iterate_many(const uint8_t *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {
+  if(batch_size < MINIMAL_BATCH_SIZE) { batch_size = MINIMAL_BATCH_SIZE; }
+  if((len >= 3) && (std::memcmp(buf, "\xEF\xBB\xBF", 3) == 0)) {
+    buf += 3;
+    len -= 3;
+  }
+  if(allow_comma_separated && batch_size < len) { batch_size = len; }
+  return document_stream(*this, buf, len, batch_size, allow_comma_separated);
 }
-
-simdjson_inline const uint8_t *token_iterator::peek(token_position position) const noexcept {
-  return &buf[*position];
+inline simdjson_result<document_stream> parser::iterate_many(const char *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {
+  return iterate_many(reinterpret_cast<const uint8_t *>(buf), len, batch_size, allow_comma_separated);
 }
-simdjson_inline uint32_t token_iterator::peek_index(token_position position) const noexcept {
-  return *position;
+inline simdjson_result<document_stream> parser::iterate_many(const std::string &s, size_t batch_size, bool allow_comma_separated) noexcept {
+  return iterate_many(s.data(), s.length(), batch_size, allow_comma_separated);
 }
-simdjson_inline uint32_t token_iterator::peek_length(token_position position) const noexcept {
-  return *(position+1) - *position;
+inline simdjson_result<document_stream> parser::iterate_many(const padded_string &s, size_t batch_size, bool allow_comma_separated) noexcept {
+  return iterate_many(s.data(), s.length(), batch_size, allow_comma_separated);
 }
 
-simdjson_inline uint32_t token_iterator::peek_root_length(token_position position) const noexcept {
-  return *(position+2) - *(position) > *(position+1) - *(position) ?
-      *(position+1) - *(position)
-      : *(position+2) - *(position);
-}
-simdjson_inline const uint8_t *token_iterator::peek(int32_t delta) const noexcept {
-  return &buf[*(_position+delta)];
+simdjson_pure simdjson_inline size_t parser::capacity() const noexcept {
+  return _capacity;
 }
-simdjson_inline uint32_t token_iterator::peek_index(int32_t delta) const noexcept {
-  return *(_position+delta);
+simdjson_pure simdjson_inline size_t parser::max_capacity() const noexcept {
+  return _max_capacity;
 }
-simdjson_inline uint32_t token_iterator::peek_length(int32_t delta) const noexcept {
-  return *(_position+delta+1) - *(_position+delta);
+simdjson_pure simdjson_inline size_t parser::max_depth() const noexcept {
+  return _max_depth;
 }
 
-simdjson_inline token_position token_iterator::position() const noexcept {
-  return _position;
-}
-simdjson_inline void token_iterator::set_position(token_position target_position) noexcept {
-  _position = target_position;
+simdjson_inline void parser::set_max_capacity(size_t max_capacity) noexcept {
+  if(max_capacity < dom::MINIMAL_DOCUMENT_CAPACITY) {
+    _max_capacity = max_capacity;
+  } else {
+    _max_capacity = dom::MINIMAL_DOCUMENT_CAPACITY;
+  }
 }
 
-simdjson_inline bool token_iterator::operator==(const token_iterator &other) const noexcept {
-  return _position == other._position;
-}
-simdjson_inline bool token_iterator::operator!=(const token_iterator &other) const noexcept {
-  return _position != other._position;
-}
-simdjson_inline bool token_iterator::operator>(const token_iterator &other) const noexcept {
-  return _position > other._position;
-}
-simdjson_inline bool token_iterator::operator>=(const token_iterator &other) const noexcept {
-  return _position >= other._position;
-}
-simdjson_inline bool token_iterator::operator<(const token_iterator &other) const noexcept {
-  return _position < other._position;
+simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape(raw_json_string in, uint8_t *&dst, bool allow_replacement) const noexcept {
+  uint8_t *end = implementation->parse_string(in.buf, dst, allow_replacement);
+  if (!end) { return STRING_ERROR; }
+  std::string_view result(reinterpret_cast<const char *>(dst), end-dst);
+  dst = end;
+  return result;
 }
-simdjson_inline bool token_iterator::operator<=(const token_iterator &other) const noexcept {
-  return _position <= other._position;
+
+simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape_wobbly(raw_json_string in, uint8_t *&dst) const noexcept {
+  uint8_t *end = implementation->parse_wobbly_string(in.buf, dst);
+  if (!end) { return STRING_ERROR; }
+  std::string_view result(reinterpret_cast<const char *>(dst), end-dst);
+  dst = end;
+  return result;
 }
 
 } // namespace ondemand
@@ -110199,10 +112740,10 @@ simdjson_inline bool token_iterator::operator<=(const token_iterator &other) con
 
 namespace simdjson {
 
-simdjson_inline simdjson_result<lsx::ondemand::token_iterator>::simdjson_result(lsx::ondemand::token_iterator &&value) noexcept
-    : implementation_simdjson_result_base<lsx::ondemand::token_iterator>(std::forward<lsx::ondemand::token_iterator>(value)) {}
-simdjson_inline simdjson_result<lsx::ondemand::token_iterator>::simdjson_result(error_code error) noexcept
-    : implementation_simdjson_result_base<lsx::ondemand::token_iterator>(error) {}
+simdjson_inline simdjson_result<lsx::ondemand::parser>::simdjson_result(lsx::ondemand::parser &&value) noexcept
+    : implementation_simdjson_result_base<lsx::ondemand::parser>(std::forward<lsx::ondemand::parser>(value)) {}
+simdjson_inline simdjson_result<lsx::ondemand::parser>::simdjson_result(error_code error) noexcept
+    : implementation_simdjson_result_base<lsx::ondemand::parser>(error) {}
 
 } // namespace simdjson
 
@@ -110224,6 +112765,7 @@ simdjson_inline simdjson_result<lsx::ondemand::token_iterator>::simdjson_result(
 /* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
 namespace simdjson {
+
 namespace lsx {
 namespace ondemand {
 
@@ -110303,6 +112845,7 @@ simdjson_warn_unused simdjson_inline error_code value_iterator::end_container()
     _json_iter->ascend_to(depth()-1);
     return SUCCESS;
 }
+} // namespace simdjson
 
 simdjson_warn_unused simdjson_inline simdjson_result<bool> value_iterator::has_next_field() noexcept {
   assert_at_next();
@@ -117746,6 +120289,500 @@ simdjson_inline simdjson_result<bool> value::is_string() noexcept {
 }
 
 
+simdjson_inline bool value::is_negative() noexcept {
+  return iter.is_negative();
+}
+
+simdjson_inline simdjson_result<bool> value::is_integer() noexcept {
+  return iter.is_integer();
+}
+simdjson_warn_unused simdjson_inline simdjson_result<number_type> value::get_number_type() noexcept {
+  return iter.get_number_type();
+}
+simdjson_warn_unused simdjson_inline simdjson_result<number> value::get_number() noexcept {
+  return iter.get_number();
+}
+
+simdjson_inline std::string_view value::raw_json_token() noexcept {
+  return std::string_view(reinterpret_cast<const char*>(iter.peek_start()), iter.peek_start_length());
+}
+
+inline simdjson_result<value> array::at_path(std::string_view json_path) noexcept {
+  auto json_pointer = json_path_to_pointer_conversion(json_path);
+  if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
+  return at_pointer(json_pointer);
+}
+
+simdjson_inline simdjson_result<value> value::at_path(std::string_view json_path) noexcept {
+  json_type t;
+  SIMDJSON_TRY(type().get(t));
+  switch (t) {
+  case json_type::array:
+      return (*this).get_array().at_path(json_path);
+  case json_type::object:
+      return (*this).get_object().at_path(json_path);
+  default:
+      return INVALID_JSON_POINTER;
+  }
+}
+
+} // namespace ondemand
+} // namespace lasx
+} // namespace simdjson
+
+namespace simdjson {
+
+simdjson_inline simdjson_result<lasx::ondemand::value>::simdjson_result(
+  lasx::ondemand::value &&value
+) noexcept :
+    implementation_simdjson_result_base<lasx::ondemand::value>(
+      std::forward<lasx::ondemand::value>(value)
+    )
+{
+}
+simdjson_inline simdjson_result<lasx::ondemand::value>::simdjson_result(
+  error_code error
+) noexcept :
+    implementation_simdjson_result_base<lasx::ondemand::value>(error)
+{
+}
+simdjson_inline simdjson_result<size_t> simdjson_result<lasx::ondemand::value>::count_elements() & noexcept {
+  if (error()) { return error(); }
+  return first.count_elements();
+}
+simdjson_inline simdjson_result<size_t> simdjson_result<lasx::ondemand::value>::count_fields() & noexcept {
+  if (error()) { return error(); }
+  return first.count_fields();
+}
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::value>::at(size_t index) noexcept {
+  if (error()) { return error(); }
+  return first.at(index);
+}
+simdjson_inline simdjson_result<lasx::ondemand::array_iterator> simdjson_result<lasx::ondemand::value>::begin() & noexcept {
+  if (error()) { return error(); }
+  return first.begin();
+}
+simdjson_inline simdjson_result<lasx::ondemand::array_iterator> simdjson_result<lasx::ondemand::value>::end() & noexcept {
+  if (error()) { return error(); }
+  return {};
+}
+
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::value>::find_field(std::string_view key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field(key);
+}
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::value>::find_field(const char *key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field(key);
+}
+
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::value>::find_field_unordered(std::string_view key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field_unordered(key);
+}
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::value>::find_field_unordered(const char *key) noexcept {
+  if (error()) { return error(); }
+  return first.find_field_unordered(key);
+}
+
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::value>::operator[](std::string_view key) noexcept {
+  if (error()) { return error(); }
+  return first[key];
+}
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::value>::operator[](const char *key) noexcept {
+  if (error()) { return error(); }
+  return first[key];
+}
+
+simdjson_inline simdjson_result<lasx::ondemand::array> simdjson_result<lasx::ondemand::value>::get_array() noexcept {
+  if (error()) { return error(); }
+  return first.get_array();
+}
+simdjson_inline simdjson_result<lasx::ondemand::object> simdjson_result<lasx::ondemand::value>::get_object() noexcept {
+  if (error()) { return error(); }
+  return first.get_object();
+}
+simdjson_inline simdjson_result<uint64_t> simdjson_result<lasx::ondemand::value>::get_uint64() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint64();
+}
+simdjson_inline simdjson_result<uint64_t> simdjson_result<lasx::ondemand::value>::get_uint64_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint64_in_string();
+}
+simdjson_inline simdjson_result<int64_t> simdjson_result<lasx::ondemand::value>::get_int64() noexcept {
+  if (error()) { return error(); }
+  return first.get_int64();
+}
+simdjson_inline simdjson_result<int64_t> simdjson_result<lasx::ondemand::value>::get_int64_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_int64_in_string();
+}
+simdjson_inline simdjson_result<double> simdjson_result<lasx::ondemand::value>::get_double() noexcept {
+  if (error()) { return error(); }
+  return first.get_double();
+}
+simdjson_inline simdjson_result<double> simdjson_result<lasx::ondemand::value>::get_double_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_double_in_string();
+}
+simdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::value>::get_string(bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.get_string(allow_replacement);
+}
+template <typename string_type>
+simdjson_inline error_code simdjson_result<lasx::ondemand::value>::get_string(string_type& receiver, bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.get_string(receiver, allow_replacement);
+}
+simdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::value>::get_wobbly_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_wobbly_string();
+}
+simdjson_inline simdjson_result<lasx::ondemand::raw_json_string> simdjson_result<lasx::ondemand::value>::get_raw_json_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_raw_json_string();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::value>::get_bool() noexcept {
+  if (error()) { return error(); }
+  return first.get_bool();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::value>::is_null() noexcept {
+  if (error()) { return error(); }
+  return first.is_null();
+}
+
+template<> simdjson_inline error_code simdjson_result<lasx::ondemand::value>::get<lasx::ondemand::value>(lasx::ondemand::value &out) noexcept {
+  if (error()) { return error(); }
+  out = first;
+  return SUCCESS;
+}
+
+template<typename T> simdjson_inline simdjson_result<T> simdjson_result<lasx::ondemand::value>::get() noexcept {
+  if (error()) { return error(); }
+  return first.get<T>();
+}
+template<typename T> simdjson_inline error_code simdjson_result<lasx::ondemand::value>::get(T &out) noexcept {
+  if (error()) { return error(); }
+  return first.get<T>(out);
+}
+
+template<> simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::value>::get<lasx::ondemand::value>() noexcept  {
+  if (error()) { return error(); }
+  return std::move(first);
+}
+
+simdjson_inline simdjson_result<lasx::ondemand::json_type> simdjson_result<lasx::ondemand::value>::type() noexcept {
+  if (error()) { return error(); }
+  return first.type();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::value>::is_scalar() noexcept {
+  if (error()) { return error(); }
+  return first.is_scalar();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::value>::is_string() noexcept {
+  if (error()) { return error(); }
+  return first.is_string();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::value>::is_negative() noexcept {
+  if (error()) { return error(); }
+  return first.is_negative();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::value>::is_integer() noexcept {
+  if (error()) { return error(); }
+  return first.is_integer();
+}
+simdjson_inline simdjson_result<lasx::number_type> simdjson_result<lasx::ondemand::value>::get_number_type() noexcept {
+  if (error()) { return error(); }
+  return first.get_number_type();
+}
+simdjson_inline simdjson_result<lasx::ondemand::number> simdjson_result<lasx::ondemand::value>::get_number() noexcept {
+  if (error()) { return error(); }
+  return first.get_number();
+}
+#if SIMDJSON_EXCEPTIONS
+template <class T>
+simdjson_inline simdjson_result<lasx::ondemand::value>::operator T() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first.get<T>();
+}
+simdjson_inline simdjson_result<lasx::ondemand::value>::operator lasx::ondemand::array() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::value>::operator lasx::ondemand::object() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::value>::operator uint64_t() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::value>::operator int64_t() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::value>::operator double() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::value>::operator std::string_view() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::value>::operator lasx::ondemand::raw_json_string() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::value>::operator bool() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+#endif
+
+simdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::value>::raw_json_token() noexcept {
+  if (error()) { return error(); }
+  return first.raw_json_token();
+}
+
+simdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::value>::raw_json() noexcept {
+  if (error()) { return error(); }
+  return first.raw_json();
+}
+
+simdjson_inline simdjson_result<const char *> simdjson_result<lasx::ondemand::value>::current_location() noexcept {
+  if (error()) { return error(); }
+  return first.current_location();
+}
+
+simdjson_inline simdjson_result<int32_t> simdjson_result<lasx::ondemand::value>::current_depth() const noexcept {
+  if (error()) { return error(); }
+  return first.current_depth();
+}
+
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::value>::at_pointer(
+    std::string_view json_pointer) noexcept {
+  if (error()) {
+      return error();
+  }
+  return first.at_pointer(json_pointer);
+}
+
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::value>::at_path(
+      std::string_view json_path) noexcept {
+  if (error()) {
+    return error();
+  }
+  return first.at_path(json_path);
+}
+
+} // namespace simdjson
+
+#endif // SIMDJSON_GENERIC_ONDEMAND_ARRAY_ITERATOR_INL_H
+/* end file simdjson/generic/ondemand/array_iterator-inl.h for lasx */
+/* including simdjson/generic/ondemand/value-inl.h for lasx: #include "simdjson/generic/ondemand/value-inl.h" */
+/* begin file simdjson/generic/ondemand/value-inl.h for lasx */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_VALUE_INL_H
+
+/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_VALUE_INL_H */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/array_iterator.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_iterator.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_type.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/object.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/raw_json_string.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value.h" */
+/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
+
+namespace simdjson {
+namespace lasx {
+namespace ondemand {
+
+simdjson_inline value::value(const value_iterator &_iter) noexcept
+  : iter{_iter}
+{
+}
+simdjson_inline value value::start(const value_iterator &iter) noexcept {
+  return iter;
+}
+simdjson_inline value value::resume(const value_iterator &iter) noexcept {
+  return iter;
+}
+
+simdjson_inline simdjson_result<array> value::get_array() noexcept {
+  return array::start(iter);
+}
+simdjson_inline simdjson_result<object> value::get_object() noexcept {
+  return object::start(iter);
+}
+simdjson_inline simdjson_result<object> value::start_or_resume_object() noexcept {
+  if (iter.at_start()) {
+    return get_object();
+  } else {
+    return object::resume(iter);
+  }
+}
+
+simdjson_inline simdjson_result<raw_json_string> value::get_raw_json_string() noexcept {
+  return iter.get_raw_json_string();
+}
+simdjson_inline simdjson_result<std::string_view> value::get_string(bool allow_replacement) noexcept {
+  return iter.get_string(allow_replacement);
+}
+template <typename string_type>
+simdjson_inline error_code value::get_string(string_type& receiver, bool allow_replacement) noexcept {
+  return iter.get_string(receiver, allow_replacement);
+}
+simdjson_inline simdjson_result<std::string_view> value::get_wobbly_string() noexcept {
+  return iter.get_wobbly_string();
+}
+simdjson_inline simdjson_result<double> value::get_double() noexcept {
+  return iter.get_double();
+}
+simdjson_inline simdjson_result<double> value::get_double_in_string() noexcept {
+  return iter.get_double_in_string();
+}
+simdjson_inline simdjson_result<uint64_t> value::get_uint64() noexcept {
+  return iter.get_uint64();
+}
+simdjson_inline simdjson_result<uint64_t> value::get_uint64_in_string() noexcept {
+  return iter.get_uint64_in_string();
+}
+simdjson_inline simdjson_result<int64_t> value::get_int64() noexcept {
+  return iter.get_int64();
+}
+simdjson_inline simdjson_result<int64_t> value::get_int64_in_string() noexcept {
+  return iter.get_int64_in_string();
+}
+simdjson_inline simdjson_result<bool> value::get_bool() noexcept {
+  return iter.get_bool();
+}
+simdjson_inline simdjson_result<bool> value::is_null() noexcept {
+  return iter.is_null();
+}
+
+template<> simdjson_inline simdjson_result<array> value::get() noexcept { return get_array(); }
+template<> simdjson_inline simdjson_result<object> value::get() noexcept { return get_object(); }
+template<> simdjson_inline simdjson_result<raw_json_string> value::get() noexcept { return get_raw_json_string(); }
+template<> simdjson_inline simdjson_result<std::string_view> value::get() noexcept { return get_string(false); }
+template<> simdjson_inline simdjson_result<number> value::get() noexcept { return get_number(); }
+template<> simdjson_inline simdjson_result<double> value::get() noexcept { return get_double(); }
+template<> simdjson_inline simdjson_result<uint64_t> value::get() noexcept { return get_uint64(); }
+template<> simdjson_inline simdjson_result<int64_t> value::get() noexcept { return get_int64(); }
+template<> simdjson_inline simdjson_result<bool> value::get() noexcept { return get_bool(); }
+
+
+template<> simdjson_inline error_code value::get(array& out) noexcept { return get_array().get(out); }
+template<> simdjson_inline error_code value::get(object& out) noexcept { return get_object().get(out); }
+template<> simdjson_inline error_code value::get(raw_json_string& out) noexcept { return get_raw_json_string().get(out); }
+template<> simdjson_inline error_code value::get(std::string_view& out) noexcept { return get_string(false).get(out); }
+template<> simdjson_inline error_code value::get(number& out) noexcept { return get_number().get(out); }
+template<> simdjson_inline error_code value::get(double& out) noexcept { return get_double().get(out); }
+template<> simdjson_inline error_code value::get(uint64_t& out) noexcept { return get_uint64().get(out); }
+template<> simdjson_inline error_code value::get(int64_t& out) noexcept { return get_int64().get(out); }
+template<> simdjson_inline error_code value::get(bool& out) noexcept { return get_bool().get(out); }
+
+#if SIMDJSON_EXCEPTIONS
+template <class T>
+simdjson_inline value::operator T() noexcept(false) {
+  return get<T>();
+}
+simdjson_inline value::operator array() noexcept(false) {
+  return get_array();
+}
+simdjson_inline value::operator object() noexcept(false) {
+  return get_object();
+}
+simdjson_inline value::operator uint64_t() noexcept(false) {
+  return get_uint64();
+}
+simdjson_inline value::operator int64_t() noexcept(false) {
+  return get_int64();
+}
+simdjson_inline value::operator double() noexcept(false) {
+  return get_double();
+}
+simdjson_inline value::operator std::string_view() noexcept(false) {
+  return get_string(false);
+}
+simdjson_inline value::operator raw_json_string() noexcept(false) {
+  return get_raw_json_string();
+}
+simdjson_inline value::operator bool() noexcept(false) {
+  return get_bool();
+}
+#endif
+
+simdjson_inline simdjson_result<array_iterator> value::begin() & noexcept {
+  return get_array().begin();
+}
+simdjson_inline simdjson_result<array_iterator> value::end() & noexcept {
+  return {};
+}
+simdjson_inline simdjson_result<size_t> value::count_elements() & noexcept {
+  simdjson_result<size_t> answer;
+  auto a = get_array();
+  answer = a.count_elements();
+  // count_elements leaves you pointing inside the array, at the first element.
+  // We need to move back so that the user can create a new array (which requires that
+  // we point at '[').
+  iter.move_at_start();
+  return answer;
+}
+simdjson_inline simdjson_result<size_t> value::count_fields() & noexcept {
+  simdjson_result<size_t> answer;
+  auto a = get_object();
+  answer = a.count_fields();
+  iter.move_at_start();
+  return answer;
+}
+simdjson_inline simdjson_result<value> value::at(size_t index) noexcept {
+  auto a = get_array();
+  return a.at(index);
+}
+
+simdjson_inline simdjson_result<value> value::find_field(std::string_view key) noexcept {
+  return start_or_resume_object().find_field(key);
+}
+simdjson_inline simdjson_result<value> value::find_field(const char *key) noexcept {
+  return start_or_resume_object().find_field(key);
+}
+
+simdjson_inline simdjson_result<value> value::find_field_unordered(std::string_view key) noexcept {
+  return start_or_resume_object().find_field_unordered(key);
+}
+simdjson_inline simdjson_result<value> value::find_field_unordered(const char *key) noexcept {
+  return start_or_resume_object().find_field_unordered(key);
+}
+
+simdjson_inline simdjson_result<value> value::operator[](std::string_view key) noexcept {
+  return start_or_resume_object()[key];
+}
+simdjson_inline simdjson_result<value> value::operator[](const char *key) noexcept {
+  return start_or_resume_object()[key];
+}
+
+simdjson_inline simdjson_result<json_type> value::type() noexcept {
+  return iter.type();
+}
+
+simdjson_inline simdjson_result<bool> value::is_scalar() noexcept {
+  json_type this_type;
+  auto error = type().get(this_type);
+  if(error) { return error; }
+  return ! ((this_type == json_type::array) || (this_type == json_type::object));
+}
+
+simdjson_inline simdjson_result<bool> value::is_string() noexcept {
+  json_type this_type;
+  auto error = type().get(this_type);
+  if(error) { return error; }
+  return (this_type == json_type::string);
+}
+
+
 simdjson_inline bool value::is_negative() noexcept {
   return iter.is_negative();
 }
@@ -119364,1711 +122401,1903 @@ inline void document_stream::next() noexcept {
     }
   }
 }
-
-inline void document_stream::next_document() noexcept {
-  // Go to next place where depth=0 (document depth)
-  error = doc.iter.skip_child(0);
-  if (error) { return; }
-  // Always set depth=1 at the start of document
-  doc.iter._depth = 1;
-  // consume comma if comma separated is allowed
-  if (allow_comma_separated) { doc.iter.consume_character(','); }
-  // Resets the string buffer at the beginning, thus invalidating the strings.
-  doc.iter._string_buf_loc = parser->string_buf.get();
-  doc.iter._root = doc.iter.position();
+simdjson_inline simdjson_result<double> simdjson_result<lasx::ondemand::document>::get_double_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_double_in_string();
 }
-
-inline size_t document_stream::next_batch_start() const noexcept {
-  return batch_start + parser->implementation->structural_indexes[parser->implementation->n_structural_indexes];
+simdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::document>::get_string(bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.get_string(allow_replacement);
 }
-
-inline error_code document_stream::run_stage1(ondemand::parser &p, size_t _batch_start) noexcept {
-  // This code only updates the structural index in the parser, it does not update any json_iterator
-  // instance.
-  size_t remaining = len - _batch_start;
-  if (remaining <= batch_size) {
-    return p.implementation->stage1(&buf[_batch_start], remaining, stage1_mode::streaming_final);
-  } else {
-    return p.implementation->stage1(&buf[_batch_start], batch_size, stage1_mode::streaming_partial);
-  }
+template <typename string_type>
+simdjson_inline error_code simdjson_result<lasx::ondemand::document>::get_string(string_type& receiver, bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.get_string(receiver, allow_replacement);
 }
-
-simdjson_inline size_t document_stream::iterator::current_index() const noexcept {
-  return stream->doc_index;
+simdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::document>::get_wobbly_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_wobbly_string();
 }
-
-simdjson_inline std::string_view document_stream::iterator::source() const noexcept {
-  auto depth = stream->doc.iter.depth();
-  auto cur_struct_index = stream->doc.iter._root - stream->parser->implementation->structural_indexes.get();
-
-  // If at root, process the first token to determine if scalar value
-  if (stream->doc.iter.at_root()) {
-    switch (stream->buf[stream->batch_start + stream->parser->implementation->structural_indexes[cur_struct_index]]) {
-      case '{': case '[':   // Depth=1 already at start of document
-        break;
-      case '}': case ']':
-        depth--;
-        break;
-      default:    // Scalar value document
-        // TODO: We could remove trailing whitespaces
-        // This returns a string spanning from start of value to the beginning of the next document (excluded)
-        {
-          auto next_index = stream->parser->implementation->structural_indexes[++cur_struct_index];
-          // normally the length would be next_index - current_index() - 1, except for the last document
-          size_t svlen = next_index - current_index();
-          const char *start = reinterpret_cast<const char*>(stream->buf) + current_index();
-          while(svlen > 1 && (std::isspace(start[svlen-1]) || start[svlen-1] == '\0')) {
-            svlen--;
-          }
-          return std::string_view(start, svlen);
-        }
-    }
-    cur_struct_index++;
-  }
-
-  while (cur_struct_index <= static_cast<int64_t>(stream->parser->implementation->n_structural_indexes)) {
-    switch (stream->buf[stream->batch_start + stream->parser->implementation->structural_indexes[cur_struct_index]]) {
-      case '{': case '[':
-        depth++;
-        break;
-      case '}': case ']':
-        depth--;
-        break;
-    }
-    if (depth == 0) { break; }
-    cur_struct_index++;
-  }
-
-  return std::string_view(reinterpret_cast<const char*>(stream->buf) + current_index(), stream->parser->implementation->structural_indexes[cur_struct_index] - current_index() + stream->batch_start + 1);;
+simdjson_inline simdjson_result<lasx::ondemand::raw_json_string> simdjson_result<lasx::ondemand::document>::get_raw_json_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_raw_json_string();
 }
-
-inline error_code document_stream::iterator::error() const noexcept {
-  return stream->error;
+simdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document>::get_bool() noexcept {
+  if (error()) { return error(); }
+  return first.get_bool();
 }
-
-#ifdef SIMDJSON_THREADS_ENABLED
-
-inline void document_stream::load_from_stage1_thread() noexcept {
-  worker->finish();
-  // Swap to the parser that was loaded up in the thread. Make sure the parser has
-  // enough memory to swap to, as well.
-  std::swap(stage1_thread_parser,*parser);
-  error = stage1_thread_error;
-  if (error) { return; }
-
-  // If there's anything left, start the stage 1 thread!
-  if (next_batch_start() < len) {
-    start_stage1_thread();
-  }
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document>::get_value() noexcept {
+  if (error()) { return error(); }
+  return first.get_value();
 }
-
-inline void document_stream::start_stage1_thread() noexcept {
-  // we call the thread on a lambda that will update
-  // this->stage1_thread_error
-  // there is only one thread that may write to this value
-  // TODO this is NOT exception-safe.
-  this->stage1_thread_error = UNINITIALIZED; // In case something goes wrong, make sure it's an error
-  size_t _next_batch_start = this->next_batch_start();
-
-  worker->run(this, & this->stage1_thread_parser, _next_batch_start);
+simdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document>::is_null() noexcept {
+  if (error()) { return error(); }
+  return first.is_null();
 }
 
-#endif // SIMDJSON_THREADS_ENABLED
-
-} // namespace ondemand
-} // namespace lasx
-} // namespace simdjson
-
-namespace simdjson {
-
-simdjson_inline simdjson_result<lasx::ondemand::document_stream>::simdjson_result(
-  error_code error
-) noexcept :
-    implementation_simdjson_result_base<lasx::ondemand::document_stream>(error)
-{
+template<typename T>
+simdjson_inline simdjson_result<T> simdjson_result<lasx::ondemand::document>::get() & noexcept {
+  if (error()) { return error(); }
+  return first.get<T>();
 }
-simdjson_inline simdjson_result<lasx::ondemand::document_stream>::simdjson_result(
-  lasx::ondemand::document_stream &&value
-) noexcept :
-    implementation_simdjson_result_base<lasx::ondemand::document_stream>(
-      std::forward<lasx::ondemand::document_stream>(value)
-    )
-{
+template<typename T>
+simdjson_deprecated simdjson_inline simdjson_result<T> simdjson_result<lasx::ondemand::document>::get() && noexcept {
+  if (error()) { return error(); }
+  return std::forward<lasx::ondemand::document>(first).get<T>();
 }
-
+template<typename T>
+simdjson_inline error_code simdjson_result<lasx::ondemand::document>::get(T &out) & noexcept {
+  if (error()) { return error(); }
+  return first.get<T>(out);
 }
-
-#endif // SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_STREAM_INL_H
-/* end file simdjson/generic/ondemand/document_stream-inl.h for lasx */
-/* including simdjson/generic/ondemand/field-inl.h for lasx: #include "simdjson/generic/ondemand/field-inl.h" */
-/* begin file simdjson/generic/ondemand/field-inl.h for lasx */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_FIELD_INL_H
-
-/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_FIELD_INL_H */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/field.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value-inl.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value_iterator-inl.h" */
-/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
-
-namespace simdjson {
-namespace lasx {
-namespace ondemand {
-
-// clang 6 does not think the default constructor can be noexcept, so we make it explicit
-simdjson_inline field::field() noexcept : std::pair<raw_json_string, ondemand::value>() {}
-
-simdjson_inline field::field(raw_json_string key, ondemand::value &&value) noexcept
-  : std::pair<raw_json_string, ondemand::value>(key, std::forward<ondemand::value>(value))
-{
+template<typename T>
+simdjson_inline error_code simdjson_result<lasx::ondemand::document>::get(T &out) && noexcept {
+  if (error()) { return error(); }
+  return std::forward<lasx::ondemand::document>(first).get<T>(out);
 }
 
-simdjson_inline simdjson_result<field> field::start(value_iterator &parent_iter) noexcept {
-  raw_json_string key;
-  SIMDJSON_TRY( parent_iter.field_key().get(key) );
-  SIMDJSON_TRY( parent_iter.field_value() );
-  return field::start(parent_iter, key);
+template<> simdjson_inline simdjson_result<lasx::ondemand::document> simdjson_result<lasx::ondemand::document>::get<lasx::ondemand::document>() & noexcept = delete;
+template<> simdjson_deprecated simdjson_inline simdjson_result<lasx::ondemand::document> simdjson_result<lasx::ondemand::document>::get<lasx::ondemand::document>() && noexcept {
+  if (error()) { return error(); }
+  return std::forward<lasx::ondemand::document>(first);
 }
-
-simdjson_inline simdjson_result<field> field::start(const value_iterator &parent_iter, raw_json_string key) noexcept {
-    return field(key, parent_iter.child());
+template<> simdjson_inline error_code simdjson_result<lasx::ondemand::document>::get<lasx::ondemand::document>(lasx::ondemand::document &out) & noexcept = delete;
+template<> simdjson_inline error_code simdjson_result<lasx::ondemand::document>::get<lasx::ondemand::document>(lasx::ondemand::document &out) && noexcept {
+  if (error()) { return error(); }
+  out = std::forward<lasx::ondemand::document>(first);
+  return SUCCESS;
 }
 
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> field::unescaped_key(bool allow_replacement) noexcept {
-  SIMDJSON_ASSUME(first.buf != nullptr); // We would like to call .alive() but Visual Studio won't let us.
-  simdjson_result<std::string_view> answer = first.unescape(second.iter.json_iter(), allow_replacement);
-  first.consume();
-  return answer;
+simdjson_inline simdjson_result<lasx::ondemand::json_type> simdjson_result<lasx::ondemand::document>::type() noexcept {
+  if (error()) { return error(); }
+  return first.type();
 }
 
-template <typename string_type>
-simdjson_inline simdjson_warn_unused error_code field::unescaped_key(string_type& receiver, bool allow_replacement) noexcept {
-  std::string_view key;
-  SIMDJSON_TRY( unescaped_key(allow_replacement).get(key) );
-  receiver = key;
-  return SUCCESS;
+simdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document>::is_scalar() noexcept {
+  if (error()) { return error(); }
+  return first.is_scalar();
 }
 
-simdjson_inline raw_json_string field::key() const noexcept {
-  SIMDJSON_ASSUME(first.buf != nullptr); // We would like to call .alive() by Visual Studio won't let us.
-  return first;
+simdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document>::is_string() noexcept {
+  if (error()) { return error(); }
+  return first.is_string();
 }
 
-
-simdjson_inline std::string_view field::key_raw_json_token() const noexcept {
-  SIMDJSON_ASSUME(first.buf != nullptr); // We would like to call .alive() by Visual Studio won't let us.
-  return std::string_view(reinterpret_cast<const char*>(first.buf-1), second.iter._json_iter->token.peek(-1) - first.buf + 1);
+simdjson_inline bool simdjson_result<lasx::ondemand::document>::is_negative() noexcept {
+  if (error()) { return error(); }
+  return first.is_negative();
 }
 
-simdjson_inline std::string_view field::escaped_key() const noexcept {
-  SIMDJSON_ASSUME(first.buf != nullptr); // We would like to call .alive() by Visual Studio won't let us.
-  auto end_quote = second.iter._json_iter->token.peek(-1);
-  while(*end_quote != '"') end_quote--;
-  return std::string_view(reinterpret_cast<const char*>(first.buf), end_quote - first.buf);
+simdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document>::is_integer() noexcept {
+  if (error()) { return error(); }
+  return first.is_integer();
 }
 
-simdjson_inline value &field::value() & noexcept {
-  return second;
+simdjson_inline simdjson_result<lasx::number_type> simdjson_result<lasx::ondemand::document>::get_number_type() noexcept {
+  if (error()) { return error(); }
+  return first.get_number_type();
 }
 
-simdjson_inline value field::value() && noexcept {
-  return std::forward<field>(*this).second;
+simdjson_inline simdjson_result<lasx::ondemand::number> simdjson_result<lasx::ondemand::document>::get_number() noexcept {
+  if (error()) { return error(); }
+  return first.get_number();
 }
 
-} // namespace ondemand
-} // namespace lasx
-} // namespace simdjson
-
-namespace simdjson {
 
-simdjson_inline simdjson_result<lasx::ondemand::field>::simdjson_result(
-  lasx::ondemand::field &&value
-) noexcept :
-    implementation_simdjson_result_base<lasx::ondemand::field>(
-      std::forward<lasx::ondemand::field>(value)
-    )
-{
+#if SIMDJSON_EXCEPTIONS
+template <class T, typename std::enable_if<std::is_same<T, lasx::ondemand::document>::value == false>::type>
+simdjson_inline simdjson_result<lasx::ondemand::document>::operator T() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
 }
-simdjson_inline simdjson_result<lasx::ondemand::field>::simdjson_result(
-  error_code error
-) noexcept :
-    implementation_simdjson_result_base<lasx::ondemand::field>(error)
-{
+simdjson_inline simdjson_result<lasx::ondemand::document>::operator lasx::ondemand::array() & noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::document>::operator lasx::ondemand::object() & noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::document>::operator uint64_t() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::document>::operator int64_t() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::document>::operator double() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::document>::operator std::string_view() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::document>::operator lasx::ondemand::raw_json_string() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::document>::operator bool() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::document>::operator lasx::ondemand::value() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
 }
+#endif
 
-simdjson_inline simdjson_result<lasx::ondemand::raw_json_string> simdjson_result<lasx::ondemand::field>::key() noexcept {
+
+simdjson_inline simdjson_result<const char *> simdjson_result<lasx::ondemand::document>::current_location() noexcept {
   if (error()) { return error(); }
-  return first.key();
+  return first.current_location();
 }
 
-simdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::field>::key_raw_json_token() noexcept {
+simdjson_inline bool simdjson_result<lasx::ondemand::document>::at_end() const noexcept {
   if (error()) { return error(); }
-  return first.key_raw_json_token();
+  return first.at_end();
 }
 
-simdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::field>::escaped_key() noexcept {
+
+simdjson_inline int32_t simdjson_result<lasx::ondemand::document>::current_depth() const noexcept {
   if (error()) { return error(); }
-  return first.escaped_key();
+  return first.current_depth();
 }
 
-simdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::field>::unescaped_key(bool allow_replacement) noexcept {
+simdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::document>::raw_json_token() noexcept {
   if (error()) { return error(); }
-  return first.unescaped_key(allow_replacement);
+  return first.raw_json_token();
 }
 
-template<typename string_type>
-simdjson_inline error_code simdjson_result<lasx::ondemand::field>::unescaped_key(string_type &receiver, bool allow_replacement) noexcept {
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document>::at_pointer(std::string_view json_pointer) noexcept {
   if (error()) { return error(); }
-  return first.unescaped_key(receiver, allow_replacement);
+  return first.at_pointer(json_pointer);
 }
 
-simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::field>::value() noexcept {
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document>::at_path(std::string_view json_path) noexcept {
   if (error()) { return error(); }
-  return std::move(first.value());
+  return first.at_path(json_path);
 }
 
 } // namespace simdjson
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_FIELD_INL_H
-/* end file simdjson/generic/ondemand/field-inl.h for lasx */
-/* including simdjson/generic/ondemand/json_iterator-inl.h for lasx: #include "simdjson/generic/ondemand/json_iterator-inl.h" */
-/* begin file simdjson/generic/ondemand/json_iterator-inl.h for lasx */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_JSON_ITERATOR_INL_H
-
-/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_JSON_ITERATOR_INL_H */
-/* amalgamation skipped (editor-only): #include "simdjson/internal/dom_parser_implementation.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_iterator.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/parser.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/raw_json_string.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/logger-inl.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/parser-inl.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/token_iterator-inl.h" */
-/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
 namespace simdjson {
 namespace lasx {
 namespace ondemand {
 
-simdjson_inline json_iterator::json_iterator(json_iterator &&other) noexcept
-  : token(std::forward<token_iterator>(other.token)),
-    parser{other.parser},
-    _string_buf_loc{other._string_buf_loc},
-    error{other.error},
-    _depth{other._depth},
-    _root{other._root},
-    _streaming{other._streaming}
-{
-  other.parser = nullptr;
-}
-simdjson_inline json_iterator &json_iterator::operator=(json_iterator &&other) noexcept {
-  token = other.token;
-  parser = other.parser;
-  _string_buf_loc = other._string_buf_loc;
-  error = other.error;
-  _depth = other._depth;
-  _root = other._root;
-  _streaming = other._streaming;
-  other.parser = nullptr;
-  return *this;
-}
+simdjson_inline document_reference::document_reference() noexcept : doc{nullptr} {}
+simdjson_inline document_reference::document_reference(document &d) noexcept : doc(&d) {}
+simdjson_inline void document_reference::rewind() noexcept { doc->rewind(); }
+simdjson_inline simdjson_result<array> document_reference::get_array() & noexcept { return doc->get_array(); }
+simdjson_inline simdjson_result<object> document_reference::get_object() & noexcept { return doc->get_object(); }
+/**
+ * The document_reference instances are used primarily/solely for streams of JSON
+ * documents.
+ * We decided that calling 'get_double()' on the JSON document '1.233 blabla' should
+ * give an error, so we check for trailing content.
+ *
+ * However, for streams of JSON documents, we want to be able to start from
+ * "321" "321" "321"
+ * and parse it successfully as a stream of JSON documents, calling get_uint64_in_string()
+ * successfully each time.
+ *
+ * To achieve this result, we pass a 'false' to a get_root_value_iterator() method:
+ * this indicates that we allow trailing content.
+ */
+simdjson_inline simdjson_result<uint64_t> document_reference::get_uint64() noexcept { return doc->get_root_value_iterator().get_root_uint64(false); }
+simdjson_inline simdjson_result<uint64_t> document_reference::get_uint64_in_string() noexcept { return doc->get_root_value_iterator().get_root_uint64_in_string(false); }
+simdjson_inline simdjson_result<int64_t> document_reference::get_int64() noexcept { return doc->get_root_value_iterator().get_root_int64(false); }
+simdjson_inline simdjson_result<int64_t> document_reference::get_int64_in_string() noexcept { return doc->get_root_value_iterator().get_root_int64_in_string(false); }
+simdjson_inline simdjson_result<double> document_reference::get_double() noexcept { return doc->get_root_value_iterator().get_root_double(false); }
+simdjson_inline simdjson_result<double> document_reference::get_double_in_string() noexcept { return doc->get_root_value_iterator().get_root_double(false); }
+simdjson_inline simdjson_result<std::string_view> document_reference::get_string(bool allow_replacement) noexcept { return doc->get_root_value_iterator().get_root_string(false, allow_replacement); }
+template <typename string_type>
+simdjson_inline error_code document_reference::get_string(string_type& receiver, bool allow_replacement) noexcept { return doc->get_root_value_iterator().get_root_string(receiver, false, allow_replacement); }
+simdjson_inline simdjson_result<std::string_view> document_reference::get_wobbly_string() noexcept { return doc->get_root_value_iterator().get_root_wobbly_string(false); }
+simdjson_inline simdjson_result<raw_json_string> document_reference::get_raw_json_string() noexcept { return doc->get_root_value_iterator().get_root_raw_json_string(false); }
+simdjson_inline simdjson_result<bool> document_reference::get_bool() noexcept { return doc->get_root_value_iterator().get_root_bool(false); }
+simdjson_inline simdjson_result<value> document_reference::get_value() noexcept { return doc->get_value(); }
+simdjson_inline simdjson_result<bool> document_reference::is_null() noexcept { return doc->get_root_value_iterator().is_root_null(false); }
+template<> simdjson_inline simdjson_result<array> document_reference::get() & noexcept { return get_array(); }
+template<> simdjson_inline simdjson_result<object> document_reference::get() & noexcept { return get_object(); }
+template<> simdjson_inline simdjson_result<raw_json_string> document_reference::get() & noexcept { return get_raw_json_string(); }
+template<> simdjson_inline simdjson_result<std::string_view> document_reference::get() & noexcept { return get_string(false); }
+template<> simdjson_inline simdjson_result<double> document_reference::get() & noexcept { return get_double(); }
+template<> simdjson_inline simdjson_result<uint64_t> document_reference::get() & noexcept { return get_uint64(); }
+template<> simdjson_inline simdjson_result<int64_t> document_reference::get() & noexcept { return get_int64(); }
+template<> simdjson_inline simdjson_result<bool> document_reference::get() & noexcept { return get_bool(); }
+template<> simdjson_inline simdjson_result<value> document_reference::get() & noexcept { return get_value(); }
+#if SIMDJSON_EXCEPTIONS
+template <class T>
+simdjson_inline document_reference::operator T() noexcept(false) { return get<T>(); }
+simdjson_inline document_reference::operator array() & noexcept(false) { return array(*doc); }
+simdjson_inline document_reference::operator object() & noexcept(false) { return object(*doc); }
+simdjson_inline document_reference::operator uint64_t() noexcept(false) { return get_uint64(); }
+simdjson_inline document_reference::operator int64_t() noexcept(false) { return get_int64(); }
+simdjson_inline document_reference::operator double() noexcept(false) { return get_double(); }
+simdjson_inline document_reference::operator std::string_view() noexcept(false) { return std::string_view(*doc); }
+simdjson_inline document_reference::operator raw_json_string() noexcept(false) { return get_raw_json_string(); }
+simdjson_inline document_reference::operator bool() noexcept(false) { return get_bool(); }
+simdjson_inline document_reference::operator value() noexcept(false) { return value(*doc); }
+#endif
+simdjson_inline simdjson_result<size_t> document_reference::count_elements() & noexcept { return doc->count_elements(); }
+simdjson_inline simdjson_result<size_t> document_reference::count_fields() & noexcept { return doc->count_fields(); }
+simdjson_inline simdjson_result<value> document_reference::at(size_t index) & noexcept { return doc->at(index); }
+simdjson_inline simdjson_result<array_iterator> document_reference::begin() & noexcept { return doc->begin(); }
+simdjson_inline simdjson_result<array_iterator> document_reference::end() & noexcept { return doc->end(); }
+simdjson_inline simdjson_result<value> document_reference::find_field(std::string_view key) & noexcept { return doc->find_field(key); }
+simdjson_inline simdjson_result<value> document_reference::find_field(const char *key) & noexcept { return doc->find_field(key); }
+simdjson_inline simdjson_result<value> document_reference::operator[](std::string_view key) & noexcept { return (*doc)[key]; }
+simdjson_inline simdjson_result<value> document_reference::operator[](const char *key) & noexcept { return (*doc)[key]; }
+simdjson_inline simdjson_result<value> document_reference::find_field_unordered(std::string_view key) & noexcept { return doc->find_field_unordered(key); }
+simdjson_inline simdjson_result<value> document_reference::find_field_unordered(const char *key) & noexcept { return doc->find_field_unordered(key); }
+simdjson_inline simdjson_result<json_type> document_reference::type() noexcept { return doc->type(); }
+simdjson_inline simdjson_result<bool> document_reference::is_scalar() noexcept { return doc->is_scalar(); }
+simdjson_inline simdjson_result<bool> document_reference::is_string() noexcept { return doc->is_string(); }
+simdjson_inline simdjson_result<const char *> document_reference::current_location() noexcept { return doc->current_location(); }
+simdjson_inline int32_t document_reference::current_depth() const noexcept { return doc->current_depth(); }
+simdjson_inline bool document_reference::is_negative() noexcept { return doc->is_negative(); }
+simdjson_inline simdjson_result<bool> document_reference::is_integer() noexcept { return doc->get_root_value_iterator().is_root_integer(false); }
+simdjson_inline simdjson_result<number_type> document_reference::get_number_type() noexcept { return doc->get_root_value_iterator().get_root_number_type(false); }
+simdjson_inline simdjson_result<number> document_reference::get_number() noexcept { return doc->get_root_value_iterator().get_root_number(false); }
+simdjson_inline simdjson_result<std::string_view> document_reference::raw_json_token() noexcept { return doc->raw_json_token(); }
+simdjson_inline simdjson_result<value> document_reference::at_pointer(std::string_view json_pointer) noexcept { return doc->at_pointer(json_pointer); }
+simdjson_inline simdjson_result<value> document_reference::at_path(std::string_view json_path) noexcept { return doc->at_path(json_path); }
+simdjson_inline simdjson_result<std::string_view> document_reference::raw_json() noexcept { return doc->raw_json();}
+simdjson_inline document_reference::operator document&() const noexcept { return *doc; }
 
-simdjson_inline json_iterator::json_iterator(const uint8_t *buf, ondemand::parser *_parser) noexcept
-  : token(buf, &_parser->implementation->structural_indexes[0]),
-    parser{_parser},
-    _string_buf_loc{parser->string_buf.get()},
-    _depth{1},
-    _root{parser->implementation->structural_indexes.get()},
-    _streaming{false}
+} // namespace ondemand
+} // namespace lasx
+} // namespace simdjson
 
-{
-  logger::log_headers();
-#if SIMDJSON_CHECK_EOF
-  assert_more_tokens();
-#endif
-}
 
-#ifdef SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON
-simdjson_inline json_iterator::json_iterator(const uint8_t *buf, ondemand::parser *_parser, bool streaming) noexcept
-    : token(buf, &_parser->implementation->structural_indexes[0]),
-      parser{_parser},
-      _string_buf_loc{parser->string_buf.get()},
-      _depth{1},
-      _root{parser->implementation->structural_indexes.get()},
-      _streaming{streaming}
 
-{
-  logger::log_headers();
-#if SIMDJSON_CHECK_EOF
-  assert_more_tokens();
-#endif
-}
-#endif // SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON
+namespace simdjson {
+simdjson_inline simdjson_result<lasx::ondemand::document_reference>::simdjson_result(lasx::ondemand::document_reference value, error_code error)
+  noexcept : implementation_simdjson_result_base<lasx::ondemand::document_reference>(std::forward<lasx::ondemand::document_reference>(value), error) {}
 
-inline void json_iterator::rewind() noexcept {
-  token.set_position( root_position() );
-  logger::log_headers(); // We start again
-  _string_buf_loc = parser->string_buf.get();
-  _depth = 1;
-}
 
-inline bool json_iterator::balanced() const noexcept {
-  token_iterator ti(token);
-  int32_t count{0};
-  ti.set_position( root_position() );
-  while(ti.peek() <= peek_last()) {
-    switch (*ti.return_current_and_advance())
-    {
-    case '[': case '{':
-      count++;
-      break;
-    case ']': case '}':
-      count--;
-      break;
-    default:
-      break;
-    }
-  }
-  return count == 0;
+simdjson_inline simdjson_result<size_t> simdjson_result<lasx::ondemand::document_reference>::count_elements() & noexcept {
+  if (error()) { return error(); }
+  return first.count_elements();
+}
+simdjson_inline simdjson_result<size_t> simdjson_result<lasx::ondemand::document_reference>::count_fields() & noexcept {
+  if (error()) { return error(); }
+  return first.count_fields();
+}
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document_reference>::at(size_t index) & noexcept {
+  if (error()) { return error(); }
+  return first.at(index);
+}
+simdjson_inline error_code simdjson_result<lasx::ondemand::document_reference>::rewind() noexcept {
+  if (error()) { return error(); }
+  first.rewind();
+  return SUCCESS;
+}
+simdjson_inline simdjson_result<lasx::ondemand::array_iterator> simdjson_result<lasx::ondemand::document_reference>::begin() & noexcept {
+  if (error()) { return error(); }
+  return first.begin();
+}
+simdjson_inline simdjson_result<lasx::ondemand::array_iterator> simdjson_result<lasx::ondemand::document_reference>::end() & noexcept {
+  return {};
+}
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document_reference>::find_field_unordered(std::string_view key) & noexcept {
+  if (error()) { return error(); }
+  return first.find_field_unordered(key);
+}
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document_reference>::find_field_unordered(const char *key) & noexcept {
+  if (error()) { return error(); }
+  return first.find_field_unordered(key);
+}
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document_reference>::operator[](std::string_view key) & noexcept {
+  if (error()) { return error(); }
+  return first[key];
+}
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document_reference>::operator[](const char *key) & noexcept {
+  if (error()) { return error(); }
+  return first[key];
+}
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document_reference>::find_field(std::string_view key) & noexcept {
+  if (error()) { return error(); }
+  return first.find_field(key);
+}
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document_reference>::find_field(const char *key) & noexcept {
+  if (error()) { return error(); }
+  return first.find_field(key);
+}
+simdjson_inline simdjson_result<lasx::ondemand::array> simdjson_result<lasx::ondemand::document_reference>::get_array() & noexcept {
+  if (error()) { return error(); }
+  return first.get_array();
+}
+simdjson_inline simdjson_result<lasx::ondemand::object> simdjson_result<lasx::ondemand::document_reference>::get_object() & noexcept {
+  if (error()) { return error(); }
+  return first.get_object();
+}
+simdjson_inline simdjson_result<uint64_t> simdjson_result<lasx::ondemand::document_reference>::get_uint64() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint64();
+}
+simdjson_inline simdjson_result<uint64_t> simdjson_result<lasx::ondemand::document_reference>::get_uint64_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint64_in_string();
+}
+simdjson_inline simdjson_result<int64_t> simdjson_result<lasx::ondemand::document_reference>::get_int64() noexcept {
+  if (error()) { return error(); }
+  return first.get_int64();
+}
+simdjson_inline simdjson_result<int64_t> simdjson_result<lasx::ondemand::document_reference>::get_int64_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_int64_in_string();
+}
+simdjson_inline simdjson_result<double> simdjson_result<lasx::ondemand::document_reference>::get_double() noexcept {
+  if (error()) { return error(); }
+  return first.get_double();
+}
+simdjson_inline simdjson_result<double> simdjson_result<lasx::ondemand::document_reference>::get_double_in_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_double_in_string();
+}
+simdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::document_reference>::get_string(bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.get_string(allow_replacement);
+}
+template <typename string_type>
+simdjson_inline error_code simdjson_result<lasx::ondemand::document_reference>::get_string(string_type& receiver, bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.get_string(receiver, allow_replacement);
+}
+simdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::document_reference>::get_wobbly_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_wobbly_string();
+}
+simdjson_inline simdjson_result<lasx::ondemand::raw_json_string> simdjson_result<lasx::ondemand::document_reference>::get_raw_json_string() noexcept {
+  if (error()) { return error(); }
+  return first.get_raw_json_string();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document_reference>::get_bool() noexcept {
+  if (error()) { return error(); }
+  return first.get_bool();
+}
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document_reference>::get_value() noexcept {
+  if (error()) { return error(); }
+  return first.get_value();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document_reference>::is_null() noexcept {
+  if (error()) { return error(); }
+  return first.is_null();
+}
+template<typename T>
+simdjson_inline simdjson_result<T> simdjson_result<lasx::ondemand::document_reference>::get() & noexcept {
+  if (error()) { return error(); }
+  return first.get<T>();
+}
+template<typename T>
+simdjson_inline simdjson_result<T> simdjson_result<lasx::ondemand::document_reference>::get() && noexcept {
+  if (error()) { return error(); }
+  return std::forward<lasx::ondemand::document_reference>(first).get<T>();
+}
+template <class T>
+simdjson_inline error_code simdjson_result<lasx::ondemand::document_reference>::get(T &out) & noexcept {
+  if (error()) { return error(); }
+  return first.get<T>(out);
+}
+template <class T>
+simdjson_inline error_code simdjson_result<lasx::ondemand::document_reference>::get(T &out) && noexcept {
+  if (error()) { return error(); }
+  return std::forward<lasx::ondemand::document_reference>(first).get<T>(out);
+}
+simdjson_inline simdjson_result<lasx::ondemand::json_type> simdjson_result<lasx::ondemand::document_reference>::type() noexcept {
+  if (error()) { return error(); }
+  return first.type();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document_reference>::is_scalar() noexcept {
+  if (error()) { return error(); }
+  return first.is_scalar();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document_reference>::is_string() noexcept {
+  if (error()) { return error(); }
+  return first.is_string();
+}
+template <>
+simdjson_inline error_code simdjson_result<lasx::ondemand::document_reference>::get(lasx::ondemand::document_reference &out) & noexcept {
+  if (error()) { return error(); }
+  out = first;
+  return SUCCESS;
+}
+template <>
+simdjson_inline error_code simdjson_result<lasx::ondemand::document_reference>::get(lasx::ondemand::document_reference &out) && noexcept {
+  if (error()) { return error(); }
+  out = first;
+  return SUCCESS;
 }
+simdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document_reference>::is_negative() noexcept {
+  if (error()) { return error(); }
+  return first.is_negative();
+}
+simdjson_inline simdjson_result<bool> simdjson_result<lasx::ondemand::document_reference>::is_integer() noexcept {
+  if (error()) { return error(); }
+  return first.is_integer();
+}
+simdjson_inline simdjson_result<lasx::number_type> simdjson_result<lasx::ondemand::document_reference>::get_number_type() noexcept {
+  if (error()) { return error(); }
+  return first.get_number_type();
+}
+simdjson_inline simdjson_result<lasx::ondemand::number> simdjson_result<lasx::ondemand::document_reference>::get_number() noexcept {
+  if (error()) { return error(); }
+  return first.get_number();
+}
+#if SIMDJSON_EXCEPTIONS
+template <class T>
+simdjson_inline simdjson_result<lasx::ondemand::document_reference>::operator T() noexcept(false) {
+  static_assert(std::is_same<T, lasx::ondemand::document_reference>::value == false, "You should not call get<T> when T is a document");
+  static_assert(std::is_same<T, lasx::ondemand::document>::value == false, "You should not call get<T> when T is a document");
+  if (error()) { throw simdjson_error(error()); }
+  return first.get<T>();
+}
+simdjson_inline simdjson_result<lasx::ondemand::document_reference>::operator lasx::ondemand::array() & noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::document_reference>::operator lasx::ondemand::object() & noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::document_reference>::operator uint64_t() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::document_reference>::operator int64_t() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::document_reference>::operator double() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::document_reference>::operator std::string_view() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::document_reference>::operator lasx::ondemand::raw_json_string() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::document_reference>::operator bool() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+simdjson_inline simdjson_result<lasx::ondemand::document_reference>::operator lasx::ondemand::value() noexcept(false) {
+  if (error()) { throw simdjson_error(error()); }
+  return first;
+}
+#endif
 
+simdjson_inline simdjson_result<const char *> simdjson_result<lasx::ondemand::document_reference>::current_location() noexcept {
+  if (error()) { return error(); }
+  return first.current_location();
+}
 
-// GCC 7 warns when the first line of this function is inlined away into oblivion due to the caller
-// relating depth and parent_depth, which is a desired effect. The warning does not show up if the
-// skip_child() function is not marked inline).
-SIMDJSON_PUSH_DISABLE_WARNINGS
-SIMDJSON_DISABLE_STRICT_OVERFLOW_WARNING
-simdjson_warn_unused simdjson_inline error_code json_iterator::skip_child(depth_t parent_depth) noexcept {
-  if (depth() <= parent_depth) { return SUCCESS; }
-  switch (*return_current_and_advance()) {
-    // TODO consider whether matching braces is a requirement: if non-matching braces indicates
-    // *missing* braces, then future lookups are not in the object/arrays they think they are,
-    // violating the rule "validate enough structure that the user can be confident they are
-    // looking at the right values."
-    // PERF TODO we can eliminate the switch here with a lookup of how much to add to depth
+simdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::document_reference>::raw_json_token() noexcept {
+  if (error()) { return error(); }
+  return first.raw_json_token();
+}
 
-    // For the first open array/object in a value, we've already incremented depth, so keep it the same
-    // We never stop at colon, but if we did, it wouldn't affect depth
-    case '[': case '{': case ':':
-      logger::log_start_value(*this, "skip");
-      break;
-    // If there is a comma, we have just finished a value in an array/object, and need to get back in
-    case ',':
-      logger::log_value(*this, "skip");
-      break;
-    // ] or } means we just finished a value and need to jump out of the array/object
-    case ']': case '}':
-      logger::log_end_value(*this, "skip");
-      _depth--;
-      if (depth() <= parent_depth) { return SUCCESS; }
-#if SIMDJSON_CHECK_EOF
-      // If there are no more tokens, the parent is incomplete.
-      if (at_end()) { return report_error(INCOMPLETE_ARRAY_OR_OBJECT, "Missing [ or { at start"); }
-#endif // SIMDJSON_CHECK_EOF
-      break;
-    case '"':
-      if(*peek() == ':') {
-        // We are at a key!!!
-        // This might happen if you just started an object and you skip it immediately.
-        // Performance note: it would be nice to get rid of this check as it is somewhat
-        // expensive.
-        // https://github.com/simdjson/simdjson/issues/1742
-        logger::log_value(*this, "key");
-        return_current_and_advance(); // eat up the ':'
-        break; // important!!!
-      }
-      simdjson_fallthrough;
-    // Anything else must be a scalar value
-    default:
-      // For the first scalar, we will have incremented depth already, so we decrement it here.
-      logger::log_value(*this, "skip");
-      _depth--;
-      if (depth() <= parent_depth) { return SUCCESS; }
-      break;
-  }
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document_reference>::at_pointer(std::string_view json_pointer) noexcept {
+  if (error()) { return error(); }
+  return first.at_pointer(json_pointer);
+}
 
-  // Now that we've considered the first value, we only increment/decrement for arrays/objects
-  while (position() < end_position()) {
-    switch (*return_current_and_advance()) {
-      case '[': case '{':
-        logger::log_start_value(*this, "skip");
-        _depth++;
-        break;
-      // TODO consider whether matching braces is a requirement: if non-matching braces indicates
-      // *missing* braces, then future lookups are not in the object/arrays they think they are,
-      // violating the rule "validate enough structure that the user can be confident they are
-      // looking at the right values."
-      // PERF TODO we can eliminate the switch here with a lookup of how much to add to depth
-      case ']': case '}':
-        logger::log_end_value(*this, "skip");
-        _depth--;
-        if (depth() <= parent_depth) { return SUCCESS; }
-        break;
-      default:
-        logger::log_value(*this, "skip", "");
-        break;
-    }
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::document_reference>::at_path(std::string_view json_path) noexcept {
+  if (error()) {
+      return error();
   }
-
-  return report_error(TAPE_ERROR, "not enough close braces");
+  return first.at_path(json_path);
 }
 
-SIMDJSON_POP_DISABLE_WARNINGS
+} // namespace simdjson
 
-simdjson_inline bool json_iterator::at_root() const noexcept {
-  return position() == root_position();
-}
+#endif // SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_INL_H
+/* end file simdjson/generic/ondemand/document-inl.h for lasx */
+/* including simdjson/generic/ondemand/document_stream-inl.h for lasx: #include "simdjson/generic/ondemand/document_stream-inl.h" */
+/* begin file simdjson/generic/ondemand/document_stream-inl.h for lasx */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_STREAM_INL_H
 
-simdjson_inline bool json_iterator::is_single_token() const noexcept {
-  return parser->implementation->n_structural_indexes == 1;
-}
+/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_STREAM_INL_H */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document_stream.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document-inl.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/implementation_simdjson_result_base-inl.h" */
+/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
-simdjson_inline bool json_iterator::streaming() const noexcept {
-  return _streaming;
-}
+#include <algorithm>
+#include <stdexcept>
 
-simdjson_inline token_position json_iterator::root_position() const noexcept {
-  return _root;
-}
+namespace simdjson {
+namespace lasx {
+namespace ondemand {
 
-simdjson_inline void json_iterator::assert_at_document_depth() const noexcept {
-  SIMDJSON_ASSUME( _depth == 1 );
-}
+#ifdef SIMDJSON_THREADS_ENABLED
 
-simdjson_inline void json_iterator::assert_at_root() const noexcept {
-  SIMDJSON_ASSUME( _depth == 1 );
-#ifndef SIMDJSON_CLANG_VISUAL_STUDIO
-  // Under Visual Studio, the next SIMDJSON_ASSUME fails with: the argument
-  // has side effects that will be discarded.
-  SIMDJSON_ASSUME( token.position() == _root );
-#endif
+inline void stage1_worker::finish() {
+  // After calling "run" someone would call finish() to wait
+  // for the end of the processing.
+  // This function will wait until either the thread has done
+  // the processing or, else, the destructor has been called.
+  std::unique_lock<std::mutex> lock(locking_mutex);
+  cond_var.wait(lock, [this]{return has_work == false;});
 }
 
-simdjson_inline void json_iterator::assert_more_tokens(uint32_t required_tokens) const noexcept {
-  assert_valid_position(token._position + required_tokens - 1);
+inline stage1_worker::~stage1_worker() {
+  // The thread may never outlive the stage1_worker instance
+  // and will always be stopped/joined before the stage1_worker
+  // instance is gone.
+  stop_thread();
 }
 
-simdjson_inline void json_iterator::assert_valid_position(token_position position) const noexcept {
-#ifndef SIMDJSON_CLANG_VISUAL_STUDIO
-  SIMDJSON_ASSUME( position >= &parser->implementation->structural_indexes[0] );
-  SIMDJSON_ASSUME( position < &parser->implementation->structural_indexes[parser->implementation->n_structural_indexes] );
-#endif
+inline void stage1_worker::start_thread() {
+  std::unique_lock<std::mutex> lock(locking_mutex);
+  if(thread.joinable()) {
+    return; // This should never happen but we never want to create more than one thread.
+  }
+  thread = std::thread([this]{
+      while(true) {
+        std::unique_lock<std::mutex> thread_lock(locking_mutex);
+        // We wait for either "run" or "stop_thread" to be called.
+        cond_var.wait(thread_lock, [this]{return has_work || !can_work;});
+        // If, for some reason, the stop_thread() method was called (i.e., the
+        // destructor of stage1_worker is called, then we want to immediately destroy
+        // the thread (and not do any more processing).
+        if(!can_work) {
+          break;
+        }
+        this->owner->stage1_thread_error = this->owner->run_stage1(*this->stage1_thread_parser,
+              this->_next_batch_start);
+        this->has_work = false;
+        // The condition variable call should be moved after thread_lock.unlock() for performance
+        // reasons but thread sanitizers may report it as a data race if we do.
+        // See https://stackoverflow.com/questions/35775501/c-should-condition-variable-be-notified-under-lock
+        cond_var.notify_one(); // will notify "finish"
+        thread_lock.unlock();
+      }
+    }
+  );
 }
 
-simdjson_inline bool json_iterator::at_end() const noexcept {
-  return position() == end_position();
-}
-simdjson_inline token_position json_iterator::end_position() const noexcept {
-  uint32_t n_structural_indexes{parser->implementation->n_structural_indexes};
-  return &parser->implementation->structural_indexes[n_structural_indexes];
+
+inline void stage1_worker::stop_thread() {
+  std::unique_lock<std::mutex> lock(locking_mutex);
+  // We have to make sure that all locks can be released.
+  can_work = false;
+  has_work = false;
+  cond_var.notify_all();
+  lock.unlock();
+  if(thread.joinable()) {
+    thread.join();
+  }
 }
 
-inline std::string json_iterator::to_string() const noexcept {
-  if( !is_alive() ) { return "dead json_iterator instance"; }
-  const char * current_structural = reinterpret_cast<const char *>(token.peek());
-  return std::string("json_iterator [ depth : ") + std::to_string(_depth)
-          + std::string(", structural : '") + std::string(current_structural,1)
-          + std::string("', offset : ") + std::to_string(token.current_offset())
-          + std::string("', error : ") + error_message(error)
-          + std::string(" ]");
+inline void stage1_worker::run(document_stream * ds, parser * stage1, size_t next_batch_start) {
+  std::unique_lock<std::mutex> lock(locking_mutex);
+  owner = ds;
+  _next_batch_start = next_batch_start;
+  stage1_thread_parser = stage1;
+  has_work = true;
+  // The condition variable call should be moved after thread_lock.unlock() for performance
+  // reasons but thread sanitizers may report it as a data race if we do.
+  // See https://stackoverflow.com/questions/35775501/c-should-condition-variable-be-notified-under-lock
+  cond_var.notify_one(); // will notify the thread lock that we have work
+  lock.unlock();
 }
 
-inline simdjson_result<const char *> json_iterator::current_location() const noexcept {
-  if (!is_alive()) {    // Unrecoverable error
-    if (!at_root()) {
-      return reinterpret_cast<const char *>(token.peek(-1));
-    } else {
-      return reinterpret_cast<const char *>(token.peek());
-    }
-  }
-  if (at_end()) {
-    return OUT_OF_BOUNDS;
+#endif  // SIMDJSON_THREADS_ENABLED
+
+simdjson_inline document_stream::document_stream(
+  ondemand::parser &_parser,
+  const uint8_t *_buf,
+  size_t _len,
+  size_t _batch_size,
+  bool _allow_comma_separated
+) noexcept
+  : parser{&_parser},
+    buf{_buf},
+    len{_len},
+    batch_size{_batch_size <= MINIMAL_BATCH_SIZE ? MINIMAL_BATCH_SIZE : _batch_size},
+    allow_comma_separated{_allow_comma_separated},
+    error{SUCCESS}
+    #ifdef SIMDJSON_THREADS_ENABLED
+    , use_thread(_parser.threaded) // we need to make a copy because _parser.threaded can change
+    #endif
+{
+#ifdef SIMDJSON_THREADS_ENABLED
+  if(worker.get() == nullptr) {
+    error = MEMALLOC;
   }
-  return reinterpret_cast<const char *>(token.peek());
+#endif
 }
 
-simdjson_inline bool json_iterator::is_alive() const noexcept {
-  return parser;
+simdjson_inline document_stream::document_stream() noexcept
+  : parser{nullptr},
+    buf{nullptr},
+    len{0},
+    batch_size{0},
+    allow_comma_separated{false},
+    error{UNINITIALIZED}
+    #ifdef SIMDJSON_THREADS_ENABLED
+    , use_thread(false)
+    #endif
+{
 }
 
-simdjson_inline void json_iterator::abandon() noexcept {
-  parser = nullptr;
-  _depth = 0;
+simdjson_inline document_stream::~document_stream() noexcept
+{
+  #ifdef SIMDJSON_THREADS_ENABLED
+  worker.reset();
+  #endif
 }
 
-simdjson_inline const uint8_t *json_iterator::return_current_and_advance() noexcept {
-#if SIMDJSON_CHECK_EOF
-  assert_more_tokens();
-#endif // SIMDJSON_CHECK_EOF
-  return token.return_current_and_advance();
+inline size_t document_stream::size_in_bytes() const noexcept {
+  return len;
 }
 
-simdjson_inline const uint8_t *json_iterator::unsafe_pointer() const noexcept {
-  // deliberately done without safety guard:
-  return token.peek();
+inline size_t document_stream::truncated_bytes() const noexcept {
+  if(error == CAPACITY) { return len - batch_start; }
+  return parser->implementation->structural_indexes[parser->implementation->n_structural_indexes] - parser->implementation->structural_indexes[parser->implementation->n_structural_indexes + 1];
 }
 
-simdjson_inline const uint8_t *json_iterator::peek(int32_t delta) const noexcept {
-#if SIMDJSON_CHECK_EOF
-  assert_more_tokens(delta+1);
-#endif // SIMDJSON_CHECK_EOF
-  return token.peek(delta);
+simdjson_inline document_stream::iterator::iterator() noexcept
+  : stream{nullptr}, finished{true} {
 }
 
-simdjson_inline uint32_t json_iterator::peek_length(int32_t delta) const noexcept {
-#if SIMDJSON_CHECK_EOF
-  assert_more_tokens(delta+1);
-#endif // #if SIMDJSON_CHECK_EOF
-  return token.peek_length(delta);
+simdjson_inline document_stream::iterator::iterator(document_stream* _stream, bool is_end) noexcept
+  : stream{_stream}, finished{is_end} {
 }
 
-simdjson_inline const uint8_t *json_iterator::peek(token_position position) const noexcept {
-  // todo: currently we require end-of-string buffering, but the following
-  // assert_valid_position should be turned on if/when we lift that condition.
-  // assert_valid_position(position);
-  // This is almost surely related to SIMDJSON_CHECK_EOF but given that SIMDJSON_CHECK_EOF
-  // is ON by default, we have no choice but to disable it for real with a comment.
-  return token.peek(position);
+simdjson_inline simdjson_result<ondemand::document_reference> document_stream::iterator::operator*() noexcept {
+  return simdjson_result<ondemand::document_reference>(stream->doc, stream->error);
 }
 
-simdjson_inline uint32_t json_iterator::peek_length(token_position position) const noexcept {
-#if SIMDJSON_CHECK_EOF
-  assert_valid_position(position);
-#endif // SIMDJSON_CHECK_EOF
-  return token.peek_length(position);
-}
-simdjson_inline uint32_t json_iterator::peek_root_length(token_position position) const noexcept {
-#if SIMDJSON_CHECK_EOF
-  assert_valid_position(position);
-#endif // SIMDJSON_CHECK_EOF
-  return token.peek_root_length(position);
+simdjson_inline document_stream::iterator& document_stream::iterator::operator++() noexcept {
+  // If there is an error, then we want the iterator
+  // to be finished, no matter what. (E.g., we do not
+  // keep generating documents with errors, or go beyond
+  // a document with errors.)
+  //
+  // Users do not have to call "operator*()" when they use operator++,
+  // so we need to end the stream in the operator++ function.
+  //
+  // Note that setting finished = true is essential otherwise
+  // we would enter an infinite loop.
+  if (stream->error) { finished = true; }
+  // Note that stream->error() is guarded against error conditions
+  // (it will immediately return if stream->error casts to false).
+  // In effect, this next function does nothing when (stream->error)
+  // is true (hence the risk of an infinite loop).
+  stream->next();
+  // If that was the last document, we're finished.
+  // It is the only type of error we do not want to appear
+  // in operator*.
+  if (stream->error == EMPTY) { finished = true; }
+  // If we had any other kind of error (not EMPTY) then we want
+  // to pass it along to the operator* and we cannot mark the result
+  // as "finished" just yet.
+  return *this;
 }
 
-simdjson_inline token_position json_iterator::last_position() const noexcept {
-  // The following line fails under some compilers...
-  // SIMDJSON_ASSUME(parser->implementation->n_structural_indexes > 0);
-  // since it has side-effects.
-  uint32_t n_structural_indexes{parser->implementation->n_structural_indexes};
-  SIMDJSON_ASSUME(n_structural_indexes > 0);
-  return &parser->implementation->structural_indexes[n_structural_indexes - 1];
-}
-simdjson_inline const uint8_t *json_iterator::peek_last() const noexcept {
-  return token.peek(last_position());
+simdjson_inline bool document_stream::iterator::operator!=(const document_stream::iterator &other) const noexcept {
+  return finished != other.finished;
 }
 
-simdjson_inline void json_iterator::ascend_to(depth_t parent_depth) noexcept {
-  SIMDJSON_ASSUME(parent_depth >= 0 && parent_depth < INT32_MAX - 1);
-  SIMDJSON_ASSUME(_depth == parent_depth + 1);
-  _depth = parent_depth;
+simdjson_inline document_stream::iterator document_stream::begin() noexcept {
+  start();
+  // If there are no documents, we're finished.
+  return iterator(this, error == EMPTY);
 }
 
-simdjson_inline void json_iterator::descend_to(depth_t child_depth) noexcept {
-  SIMDJSON_ASSUME(child_depth >= 1 && child_depth < INT32_MAX);
-  SIMDJSON_ASSUME(_depth == child_depth - 1);
-  _depth = child_depth;
+simdjson_inline document_stream::iterator document_stream::end() noexcept {
+  return iterator(this, true);
 }
 
-simdjson_inline depth_t json_iterator::depth() const noexcept {
-  return _depth;
-}
+inline void document_stream::start() noexcept {
+  if (error) { return; }
+  error = parser->allocate(batch_size);
+  if (error) { return; }
+  // Always run the first stage 1 parse immediately
+  batch_start = 0;
+  error = run_stage1(*parser, batch_start);
+  while(error == EMPTY) {
+    // In exceptional cases, we may start with an empty block
+    batch_start = next_batch_start();
+    if (batch_start >= len) { return; }
+    error = run_stage1(*parser, batch_start);
+  }
+  if (error) { return; }
+  doc_index = batch_start;
+  doc = document(json_iterator(&buf[batch_start], parser));
+  doc.iter._streaming = true;
 
-simdjson_inline uint8_t *&json_iterator::string_buf_loc() noexcept {
-  return _string_buf_loc;
+  #ifdef SIMDJSON_THREADS_ENABLED
+  if (use_thread && next_batch_start() < len) {
+    // Kick off the first thread on next batch if needed
+    error = stage1_thread_parser.allocate(batch_size);
+    if (error) { return; }
+    worker->start_thread();
+    start_stage1_thread();
+    if (error) { return; }
+  }
+  #endif // SIMDJSON_THREADS_ENABLED
 }
 
-simdjson_inline error_code json_iterator::report_error(error_code _error, const char *message) noexcept {
-  SIMDJSON_ASSUME(_error != SUCCESS && _error != UNINITIALIZED && _error != INCORRECT_TYPE && _error != NO_SUCH_FIELD);
-  logger::log_error(*this, message);
-  error = _error;
-  return error;
+inline void document_stream::next() noexcept {
+  // We always enter at once once in an error condition.
+  if (error) { return; }
+  next_document();
+  if (error) { return; }
+  auto cur_struct_index = doc.iter._root - parser->implementation->structural_indexes.get();
+  doc_index = batch_start + parser->implementation->structural_indexes[cur_struct_index];
+
+  // Check if at end of structural indexes (i.e. at end of batch)
+  if(cur_struct_index >= static_cast<int64_t>(parser->implementation->n_structural_indexes)) {
+    error = EMPTY;
+    // Load another batch (if available)
+    while (error == EMPTY) {
+      batch_start = next_batch_start();
+      if (batch_start >= len) { break; }
+      #ifdef SIMDJSON_THREADS_ENABLED
+      if(use_thread) {
+        load_from_stage1_thread();
+      } else {
+        error = run_stage1(*parser, batch_start);
+      }
+      #else
+      error = run_stage1(*parser, batch_start);
+      #endif
+      /**
+       * Whenever we move to another window, we need to update all pointers to make
+       * it appear as if the input buffer started at the beginning of the window.
+       *
+       * Take this input:
+       *
+       * {"z":5}  {"1":1,"2":2,"4":4} [7,  10,   9]  [15,  11,   12, 13]  [154,  110,   112, 1311]
+       *
+       * Say you process the following window...
+       *
+       * '{"z":5}  {"1":1,"2":2,"4":4} [7,  10,   9]'
+       *
+       * When you do so, the json_iterator has a pointer at the beginning of the memory region
+       * (pointing at the beginning of '{"z"...'.
+       *
+       * When you move to the window that starts at...
+       *
+       * '[7,  10,   9]  [15,  11,   12, 13] ...
+       *
+       * then it is not sufficient to just run stage 1. You also need to re-anchor the
+       * json_iterator so that it believes we are starting at '[7,  10,   9]...'.
+       *
+       * Under the DOM front-end, this gets done automatically because the parser owns
+       * the pointer the data, and when you call stage1 and then stage2 on the same
+       * parser, then stage2 will run on the pointer acquired by stage1.
+       *
+       * That is, stage1 calls "this->buf = _buf" so the parser remembers the buffer that
+       * we used. But json_iterator has no callback when stage1 is called on the parser.
+       * In fact, I think that the parser is unaware of json_iterator.
+       *
+       *
+       * So we need to re-anchor the json_iterator after each call to stage 1 so that
+       * all of the pointers are in sync.
+       */
+      doc.iter = json_iterator(&buf[batch_start], parser);
+      doc.iter._streaming = true;
+      /**
+       * End of resync.
+       */
+
+      if (error) { continue; } // If the error was EMPTY, we may want to load another batch.
+      doc_index = batch_start;
+    }
+  }
 }
 
-simdjson_inline token_position json_iterator::position() const noexcept {
-  return token.position();
+inline void document_stream::next_document() noexcept {
+  // Go to next place where depth=0 (document depth)
+  error = doc.iter.skip_child(0);
+  if (error) { return; }
+  // Always set depth=1 at the start of document
+  doc.iter._depth = 1;
+  // consume comma if comma separated is allowed
+  if (allow_comma_separated) { doc.iter.consume_character(','); }
+  // Resets the string buffer at the beginning, thus invalidating the strings.
+  doc.iter._string_buf_loc = parser->string_buf.get();
+  doc.iter._root = doc.iter.position();
 }
 
-simdjson_inline simdjson_result<std::string_view> json_iterator::unescape(raw_json_string in, bool allow_replacement) noexcept {
-#if SIMDJSON_DEVELOPMENT_CHECKS
-  auto result = parser->unescape(in, _string_buf_loc, allow_replacement);
-  SIMDJSON_ASSUME(!parser->string_buffer_overflow(_string_buf_loc));
-  return result;
-#else
-  return parser->unescape(in, _string_buf_loc, allow_replacement);
-#endif
+inline size_t document_stream::next_batch_start() const noexcept {
+  return batch_start + parser->implementation->structural_indexes[parser->implementation->n_structural_indexes];
 }
 
-simdjson_inline simdjson_result<std::string_view> json_iterator::unescape_wobbly(raw_json_string in) noexcept {
-#if SIMDJSON_DEVELOPMENT_CHECKS
-  auto result = parser->unescape_wobbly(in, _string_buf_loc);
-  SIMDJSON_ASSUME(!parser->string_buffer_overflow(_string_buf_loc));
-  return result;
-#else
-  return parser->unescape_wobbly(in, _string_buf_loc);
-#endif
+inline error_code document_stream::run_stage1(ondemand::parser &p, size_t _batch_start) noexcept {
+  // This code only updates the structural index in the parser, it does not update any json_iterator
+  // instance.
+  size_t remaining = len - _batch_start;
+  if (remaining <= batch_size) {
+    return p.implementation->stage1(&buf[_batch_start], remaining, stage1_mode::streaming_final);
+  } else {
+    return p.implementation->stage1(&buf[_batch_start], batch_size, stage1_mode::streaming_partial);
+  }
 }
 
-simdjson_inline void json_iterator::reenter_child(token_position position, depth_t child_depth) noexcept {
-  SIMDJSON_ASSUME(child_depth >= 1 && child_depth < INT32_MAX);
-  SIMDJSON_ASSUME(_depth == child_depth - 1);
-#if SIMDJSON_DEVELOPMENT_CHECKS
-#ifndef SIMDJSON_CLANG_VISUAL_STUDIO
-  SIMDJSON_ASSUME(size_t(child_depth) < parser->max_depth());
-  SIMDJSON_ASSUME(position >= parser->start_positions[child_depth]);
-#endif
-#endif
-  token.set_position(position);
-  _depth = child_depth;
+simdjson_inline size_t document_stream::iterator::current_index() const noexcept {
+  return stream->doc_index;
 }
 
-simdjson_inline error_code json_iterator::consume_character(char c) noexcept {
-  if (*peek() == c) {
-    return_current_and_advance();
-    return SUCCESS;
+simdjson_inline std::string_view document_stream::iterator::source() const noexcept {
+  auto depth = stream->doc.iter.depth();
+  auto cur_struct_index = stream->doc.iter._root - stream->parser->implementation->structural_indexes.get();
+
+  // If at root, process the first token to determine if scalar value
+  if (stream->doc.iter.at_root()) {
+    switch (stream->buf[stream->batch_start + stream->parser->implementation->structural_indexes[cur_struct_index]]) {
+      case '{': case '[':   // Depth=1 already at start of document
+        break;
+      case '}': case ']':
+        depth--;
+        break;
+      default:    // Scalar value document
+        // TODO: We could remove trailing whitespaces
+        // This returns a string spanning from start of value to the beginning of the next document (excluded)
+        {
+          auto next_index = stream->parser->implementation->structural_indexes[++cur_struct_index];
+          // normally the length would be next_index - current_index() - 1, except for the last document
+          size_t svlen = next_index - current_index();
+          const char *start = reinterpret_cast<const char*>(stream->buf) + current_index();
+          while(svlen > 1 && (std::isspace(start[svlen-1]) || start[svlen-1] == '\0')) {
+            svlen--;
+          }
+          return std::string_view(start, svlen);
+        }
+    }
+    cur_struct_index++;
   }
-  return TAPE_ERROR;
-}
 
-#if SIMDJSON_DEVELOPMENT_CHECKS
+  while (cur_struct_index <= static_cast<int64_t>(stream->parser->implementation->n_structural_indexes)) {
+    switch (stream->buf[stream->batch_start + stream->parser->implementation->structural_indexes[cur_struct_index]]) {
+      case '{': case '[':
+        depth++;
+        break;
+      case '}': case ']':
+        depth--;
+        break;
+    }
+    if (depth == 0) { break; }
+    cur_struct_index++;
+  }
 
-simdjson_inline token_position json_iterator::start_position(depth_t depth) const noexcept {
-  SIMDJSON_ASSUME(size_t(depth) < parser->max_depth());
-  return size_t(depth) < parser->max_depth() ? parser->start_positions[depth] : 0;
+  return std::string_view(reinterpret_cast<const char*>(stream->buf) + current_index(), stream->parser->implementation->structural_indexes[cur_struct_index] - current_index() + stream->batch_start + 1);;
 }
 
-simdjson_inline void json_iterator::set_start_position(depth_t depth, token_position position) noexcept {
-  SIMDJSON_ASSUME(size_t(depth) < parser->max_depth());
-  if(size_t(depth) < parser->max_depth()) { parser->start_positions[depth] = position; }
+inline error_code document_stream::iterator::error() const noexcept {
+  return stream->error;
 }
 
-#endif
+#ifdef SIMDJSON_THREADS_ENABLED
 
+inline void document_stream::load_from_stage1_thread() noexcept {
+  worker->finish();
+  // Swap to the parser that was loaded up in the thread. Make sure the parser has
+  // enough memory to swap to, as well.
+  std::swap(stage1_thread_parser,*parser);
+  error = stage1_thread_error;
+  if (error) { return; }
 
-simdjson_inline error_code json_iterator::optional_error(error_code _error, const char *message) noexcept {
-  SIMDJSON_ASSUME(_error == INCORRECT_TYPE || _error == NO_SUCH_FIELD);
-  logger::log_error(*this, message);
-  return _error;
+  // If there's anything left, start the stage 1 thread!
+  if (next_batch_start() < len) {
+    start_stage1_thread();
+  }
 }
 
+inline void document_stream::start_stage1_thread() noexcept {
+  // we call the thread on a lambda that will update
+  // this->stage1_thread_error
+  // there is only one thread that may write to this value
+  // TODO this is NOT exception-safe.
+  this->stage1_thread_error = UNINITIALIZED; // In case something goes wrong, make sure it's an error
+  size_t _next_batch_start = this->next_batch_start();
 
-simdjson_warn_unused simdjson_inline bool json_iterator::copy_to_buffer(const uint8_t *json, uint32_t max_len, uint8_t *tmpbuf, size_t N) noexcept {
-  // This function is not expected to be called in performance-sensitive settings.
-  // Let us guard against silly cases:
-  if((N < max_len) || (N == 0)) { return false; }
-  // Copy to the buffer.
-  std::memcpy(tmpbuf, json, max_len);
-  if(N > max_len) { // We pad whatever remains with ' '.
-    std::memset(tmpbuf + max_len, ' ', N - max_len);
-  }
-  return true;
+  worker->run(this, & this->stage1_thread_parser, _next_batch_start);
 }
 
+#endif // SIMDJSON_THREADS_ENABLED
+
 } // namespace ondemand
 } // namespace lasx
 } // namespace simdjson
 
 namespace simdjson {
 
-simdjson_inline simdjson_result<lasx::ondemand::json_iterator>::simdjson_result(lasx::ondemand::json_iterator &&value) noexcept
-    : implementation_simdjson_result_base<lasx::ondemand::json_iterator>(std::forward<lasx::ondemand::json_iterator>(value)) {}
-simdjson_inline simdjson_result<lasx::ondemand::json_iterator>::simdjson_result(error_code error) noexcept
-    : implementation_simdjson_result_base<lasx::ondemand::json_iterator>(error) {}
+simdjson_inline simdjson_result<lasx::ondemand::document_stream>::simdjson_result(
+  error_code error
+) noexcept :
+    implementation_simdjson_result_base<lasx::ondemand::document_stream>(error)
+{
+}
+simdjson_inline simdjson_result<lasx::ondemand::document_stream>::simdjson_result(
+  lasx::ondemand::document_stream &&value
+) noexcept :
+    implementation_simdjson_result_base<lasx::ondemand::document_stream>(
+      std::forward<lasx::ondemand::document_stream>(value)
+    )
+{
+}
 
-} // namespace simdjson
+}
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_JSON_ITERATOR_INL_H
-/* end file simdjson/generic/ondemand/json_iterator-inl.h for lasx */
-/* including simdjson/generic/ondemand/json_type-inl.h for lasx: #include "simdjson/generic/ondemand/json_type-inl.h" */
-/* begin file simdjson/generic/ondemand/json_type-inl.h for lasx */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_JSON_TYPE_INL_H
+#endif // SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_STREAM_INL_H
+/* end file simdjson/generic/ondemand/document_stream-inl.h for lasx */
+/* including simdjson/generic/ondemand/field-inl.h for lasx: #include "simdjson/generic/ondemand/field-inl.h" */
+/* begin file simdjson/generic/ondemand/field-inl.h for lasx */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_FIELD_INL_H
 
 /* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_JSON_TYPE_INL_H */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_FIELD_INL_H */
 /* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_type.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/implementation_simdjson_result_base-inl.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/field.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value-inl.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value_iterator-inl.h" */
 /* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
 namespace simdjson {
 namespace lasx {
 namespace ondemand {
 
-inline std::ostream& operator<<(std::ostream& out, json_type type) noexcept {
-    switch (type) {
-        case json_type::array: out << "array"; break;
-        case json_type::object: out << "object"; break;
-        case json_type::number: out << "number"; break;
-        case json_type::string: out << "string"; break;
-        case json_type::boolean: out << "boolean"; break;
-        case json_type::null: out << "null"; break;
-        default: SIMDJSON_UNREACHABLE();
-    }
-    return out;
-}
+// clang 6 does not think the default constructor can be noexcept, so we make it explicit
+simdjson_inline field::field() noexcept : std::pair<raw_json_string, ondemand::value>() {}
 
-#if SIMDJSON_EXCEPTIONS
-inline std::ostream& operator<<(std::ostream& out, simdjson_result<json_type> &type) noexcept(false) {
-    return out << type.value();
+simdjson_inline field::field(raw_json_string key, ondemand::value &&value) noexcept
+  : std::pair<raw_json_string, ondemand::value>(key, std::forward<ondemand::value>(value))
+{
 }
-#endif
 
-
-
-simdjson_inline number_type number::get_number_type() const noexcept {
-  return type;
+simdjson_inline simdjson_result<field> field::start(value_iterator &parent_iter) noexcept {
+  raw_json_string key;
+  SIMDJSON_TRY( parent_iter.field_key().get(key) );
+  SIMDJSON_TRY( parent_iter.field_value() );
+  return field::start(parent_iter, key);
 }
 
-simdjson_inline bool number::is_uint64() const noexcept {
-  return get_number_type() == number_type::unsigned_integer;
+simdjson_inline simdjson_result<field> field::start(const value_iterator &parent_iter, raw_json_string key) noexcept {
+    return field(key, parent_iter.child());
 }
 
-simdjson_inline uint64_t number::get_uint64() const noexcept {
-  return payload.unsigned_integer;
+simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> field::unescaped_key(bool allow_replacement) noexcept {
+  SIMDJSON_ASSUME(first.buf != nullptr); // We would like to call .alive() but Visual Studio won't let us.
+  simdjson_result<std::string_view> answer = first.unescape(second.iter.json_iter(), allow_replacement);
+  first.consume();
+  return answer;
 }
 
-simdjson_inline number::operator uint64_t() const noexcept {
-  return get_uint64();
+template <typename string_type>
+simdjson_inline simdjson_warn_unused error_code field::unescaped_key(string_type& receiver, bool allow_replacement) noexcept {
+  std::string_view key;
+  SIMDJSON_TRY( unescaped_key(allow_replacement).get(key) );
+  receiver = key;
+  return SUCCESS;
 }
 
-simdjson_inline bool number::is_int64() const noexcept {
-  return get_number_type() == number_type::signed_integer;
+simdjson_inline raw_json_string field::key() const noexcept {
+  SIMDJSON_ASSUME(first.buf != nullptr); // We would like to call .alive() by Visual Studio won't let us.
+  return first;
 }
 
-simdjson_inline int64_t number::get_int64() const noexcept {
-  return payload.signed_integer;
-}
 
-simdjson_inline number::operator int64_t() const noexcept {
-  return get_int64();
+simdjson_inline std::string_view field::key_raw_json_token() const noexcept {
+  SIMDJSON_ASSUME(first.buf != nullptr); // We would like to call .alive() by Visual Studio won't let us.
+  return std::string_view(reinterpret_cast<const char*>(first.buf-1), second.iter._json_iter->token.peek(-1) - first.buf + 1);
 }
 
-simdjson_inline bool number::is_double() const noexcept {
-    return get_number_type() == number_type::floating_point_number;
+simdjson_inline std::string_view field::escaped_key() const noexcept {
+  SIMDJSON_ASSUME(first.buf != nullptr); // We would like to call .alive() by Visual Studio won't let us.
+  auto end_quote = second.iter._json_iter->token.peek(-1);
+  while(*end_quote != '"') end_quote--;
+  return std::string_view(reinterpret_cast<const char*>(first.buf), end_quote - first.buf);
 }
 
-simdjson_inline double number::get_double() const noexcept {
-  return payload.floating_point_number;
+simdjson_inline value &field::value() & noexcept {
+  return second;
 }
 
-simdjson_inline number::operator double() const noexcept {
-  return get_double();
+simdjson_inline value field::value() && noexcept {
+  return std::forward<field>(*this).second;
 }
 
-simdjson_inline double number::as_double() const noexcept {
-  if(is_double()) {
-    return payload.floating_point_number;
-  }
-  if(is_int64()) {
-    return double(payload.signed_integer);
-  }
-  return double(payload.unsigned_integer);
-}
+} // namespace ondemand
+} // namespace lasx
+} // namespace simdjson
 
-simdjson_inline void number::append_s64(int64_t value) noexcept {
-  payload.signed_integer = value;
-  type = number_type::signed_integer;
+namespace simdjson {
+
+simdjson_inline simdjson_result<lasx::ondemand::field>::simdjson_result(
+  lasx::ondemand::field &&value
+) noexcept :
+    implementation_simdjson_result_base<lasx::ondemand::field>(
+      std::forward<lasx::ondemand::field>(value)
+    )
+{
+}
+simdjson_inline simdjson_result<lasx::ondemand::field>::simdjson_result(
+  error_code error
+) noexcept :
+    implementation_simdjson_result_base<lasx::ondemand::field>(error)
+{
 }
 
-simdjson_inline void number::append_u64(uint64_t value) noexcept {
-  payload.unsigned_integer = value;
-  type = number_type::unsigned_integer;
+simdjson_inline simdjson_result<lasx::ondemand::raw_json_string> simdjson_result<lasx::ondemand::field>::key() noexcept {
+  if (error()) { return error(); }
+  return first.key();
 }
 
-simdjson_inline void number::append_double(double value) noexcept {
-  payload.floating_point_number = value;
-  type = number_type::floating_point_number;
+simdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::field>::key_raw_json_token() noexcept {
+  if (error()) { return error(); }
+  return first.key_raw_json_token();
 }
 
-simdjson_inline void number::skip_double() noexcept {
-  type = number_type::floating_point_number;
+simdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::field>::escaped_key() noexcept {
+  if (error()) { return error(); }
+  return first.escaped_key();
 }
 
-} // namespace ondemand
-} // namespace lasx
-} // namespace simdjson
+simdjson_inline simdjson_result<std::string_view> simdjson_result<lasx::ondemand::field>::unescaped_key(bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.unescaped_key(allow_replacement);
+}
 
-namespace simdjson {
+template<typename string_type>
+simdjson_inline error_code simdjson_result<lasx::ondemand::field>::unescaped_key(string_type &receiver, bool allow_replacement) noexcept {
+  if (error()) { return error(); }
+  return first.unescaped_key(receiver, allow_replacement);
+}
 
-simdjson_inline simdjson_result<lasx::ondemand::json_type>::simdjson_result(lasx::ondemand::json_type &&value) noexcept
-    : implementation_simdjson_result_base<lasx::ondemand::json_type>(std::forward<lasx::ondemand::json_type>(value)) {}
-simdjson_inline simdjson_result<lasx::ondemand::json_type>::simdjson_result(error_code error) noexcept
-    : implementation_simdjson_result_base<lasx::ondemand::json_type>(error) {}
+simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::field>::value() noexcept {
+  if (error()) { return error(); }
+  return std::move(first.value());
+}
 
 } // namespace simdjson
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_JSON_TYPE_INL_H
-/* end file simdjson/generic/ondemand/json_type-inl.h for lasx */
-/* including simdjson/generic/ondemand/logger-inl.h for lasx: #include "simdjson/generic/ondemand/logger-inl.h" */
-/* begin file simdjson/generic/ondemand/logger-inl.h for lasx */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_LOGGER_INL_H
+#endif // SIMDJSON_GENERIC_ONDEMAND_FIELD_INL_H
+/* end file simdjson/generic/ondemand/field-inl.h for lasx */
+/* including simdjson/generic/ondemand/json_iterator-inl.h for lasx: #include "simdjson/generic/ondemand/json_iterator-inl.h" */
+/* begin file simdjson/generic/ondemand/json_iterator-inl.h for lasx */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_JSON_ITERATOR_INL_H
 
 /* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_LOGGER_INL_H */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_JSON_ITERATOR_INL_H */
+/* amalgamation skipped (editor-only): #include "simdjson/internal/dom_parser_implementation.h" */
 /* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/logger.h" */
 /* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_iterator.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value_iterator.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/parser.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/raw_json_string.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/logger-inl.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/parser-inl.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/token_iterator-inl.h" */
 /* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
-#include <memory>
-#include <cstring>
-
 namespace simdjson {
 namespace lasx {
 namespace ondemand {
-namespace logger {
-
-static constexpr const char * DASHES = "----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------";
-static constexpr const int LOG_EVENT_LEN = 20;
-static constexpr const int LOG_BUFFER_LEN = 30;
-static constexpr const int LOG_SMALL_BUFFER_LEN = 10;
-static int log_depth = 0; // Not threadsafe. Log only.
-
-// Helper to turn unprintable or newline characters into spaces
-static inline char printable_char(char c) {
-  if (c >= 0x20) {
-    return c;
-  } else {
-    return ' ';
-  }
-}
 
-template<typename... Args>
-static inline std::string string_format(const std::string& format, const Args&... args)
+simdjson_inline json_iterator::json_iterator(json_iterator &&other) noexcept
+  : token(std::forward<token_iterator>(other.token)),
+    parser{other.parser},
+    _string_buf_loc{other._string_buf_loc},
+    error{other.error},
+    _depth{other._depth},
+    _root{other._root},
+    _streaming{other._streaming}
 {
-  SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
-  int size_s = std::snprintf(nullptr, 0, format.c_str(), args...) + 1;
-  auto size = static_cast<size_t>(size_s);
-  if (size <= 0) return std::string();
-  std::unique_ptr<char[]> buf(new char[size]);
-  std::snprintf(buf.get(), size, format.c_str(), args...);
-  SIMDJSON_POP_DISABLE_WARNINGS
-  return std::string(buf.get(), buf.get() + size - 1);
+  other.parser = nullptr;
 }
-
-static inline log_level get_log_level_from_env()
-{
-  SIMDJSON_PUSH_DISABLE_WARNINGS
-  SIMDJSON_DISABLE_DEPRECATED_WARNING // Disable CRT_SECURE warning on MSVC: manually verified this is safe
-      char *lvl = getenv("SIMDJSON_LOG_LEVEL");
-  SIMDJSON_POP_DISABLE_WARNINGS
-  if (lvl && simdjson_strcasecmp(lvl, "ERROR") == 0) { return log_level::error; }
-  return log_level::info;
+simdjson_inline json_iterator &json_iterator::operator=(json_iterator &&other) noexcept {
+  token = other.token;
+  parser = other.parser;
+  _string_buf_loc = other._string_buf_loc;
+  error = other.error;
+  _depth = other._depth;
+  _root = other._root;
+  _streaming = other._streaming;
+  other.parser = nullptr;
+  return *this;
 }
 
-static inline log_level log_threshold()
+simdjson_inline json_iterator::json_iterator(const uint8_t *buf, ondemand::parser *_parser) noexcept
+  : token(buf, &_parser->implementation->structural_indexes[0]),
+    parser{_parser},
+    _string_buf_loc{parser->string_buf.get()},
+    _depth{1},
+    _root{parser->implementation->structural_indexes.get()},
+    _streaming{false}
+
 {
-  static log_level threshold = get_log_level_from_env();
-  return threshold;
+  logger::log_headers();
+#if SIMDJSON_CHECK_EOF
+  assert_more_tokens();
+#endif
 }
 
-static inline bool should_log(log_level level)
+#ifdef SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON
+simdjson_inline json_iterator::json_iterator(const uint8_t *buf, ondemand::parser *_parser, bool streaming) noexcept
+    : token(buf, &_parser->implementation->structural_indexes[0]),
+      parser{_parser},
+      _string_buf_loc{parser->string_buf.get()},
+      _depth{1},
+      _root{parser->implementation->structural_indexes.get()},
+      _streaming{streaming}
+
 {
-  return level >= log_threshold();
+  logger::log_headers();
+#if SIMDJSON_CHECK_EOF
+  assert_more_tokens();
+#endif
 }
+#endif // SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON
 
-inline void log_event(const json_iterator &iter, const char *type, std::string_view detail, int delta, int depth_delta) noexcept {
-  log_line(iter, "", type, detail, delta, depth_delta, log_level::info);
+inline void json_iterator::rewind() noexcept {
+  token.set_position( root_position() );
+  logger::log_headers(); // We start again
+  _string_buf_loc = parser->string_buf.get();
+  _depth = 1;
 }
 
-inline void log_value(const json_iterator &iter, token_position index, depth_t depth, const char *type, std::string_view detail) noexcept {
-  log_line(iter, index, depth, "", type, detail, log_level::info);
-}
-inline void log_value(const json_iterator &iter, const char *type, std::string_view detail, int delta, int depth_delta) noexcept {
-  log_line(iter, "", type, detail, delta, depth_delta, log_level::info);
+inline bool json_iterator::balanced() const noexcept {
+  token_iterator ti(token);
+  int32_t count{0};
+  ti.set_position( root_position() );
+  while(ti.peek() <= peek_last()) {
+    switch (*ti.return_current_and_advance())
+    {
+    case '[': case '{':
+      count++;
+      break;
+    case ']': case '}':
+      count--;
+      break;
+    default:
+      break;
+    }
+  }
+  return count == 0;
 }
 
-inline void log_start_value(const json_iterator &iter, token_position index, depth_t depth, const char *type, std::string_view detail) noexcept {
-  log_line(iter, index, depth, "+", type, detail, log_level::info);
-  if (LOG_ENABLED) { log_depth++; }
-}
-inline void log_start_value(const json_iterator &iter, const char *type, int delta, int depth_delta) noexcept {
-  log_line(iter, "+", type, "", delta, depth_delta, log_level::info);
-  if (LOG_ENABLED) { log_depth++; }
-}
 
-inline void log_end_value(const json_iterator &iter, const char *type, int delta, int depth_delta) noexcept {
-  if (LOG_ENABLED) { log_depth--; }
-  log_line(iter, "-", type, "", delta, depth_delta, log_level::info);
-}
+// GCC 7 warns when the first line of this function is inlined away into oblivion due to the caller
+// relating depth and parent_depth, which is a desired effect. The warning does not show up if the
+// skip_child() function is not marked inline).
+SIMDJSON_PUSH_DISABLE_WARNINGS
+SIMDJSON_DISABLE_STRICT_OVERFLOW_WARNING
+simdjson_warn_unused simdjson_inline error_code json_iterator::skip_child(depth_t parent_depth) noexcept {
+  if (depth() <= parent_depth) { return SUCCESS; }
+  switch (*return_current_and_advance()) {
+    // TODO consider whether matching braces is a requirement: if non-matching braces indicates
+    // *missing* braces, then future lookups are not in the object/arrays they think they are,
+    // violating the rule "validate enough structure that the user can be confident they are
+    // looking at the right values."
+    // PERF TODO we can eliminate the switch here with a lookup of how much to add to depth
 
-inline void log_error(const json_iterator &iter, const char *error, const char *detail, int delta, int depth_delta) noexcept {
-  log_line(iter, "ERROR: ", error, detail, delta, depth_delta, log_level::error);
-}
-inline void log_error(const json_iterator &iter, token_position index, depth_t depth, const char *error, const char *detail) noexcept {
-  log_line(iter, index, depth, "ERROR: ", error, detail, log_level::error);
-}
+    // For the first open array/object in a value, we've already incremented depth, so keep it the same
+    // We never stop at colon, but if we did, it wouldn't affect depth
+    case '[': case '{': case ':':
+      logger::log_start_value(*this, "skip");
+      break;
+    // If there is a comma, we have just finished a value in an array/object, and need to get back in
+    case ',':
+      logger::log_value(*this, "skip");
+      break;
+    // ] or } means we just finished a value and need to jump out of the array/object
+    case ']': case '}':
+      logger::log_end_value(*this, "skip");
+      _depth--;
+      if (depth() <= parent_depth) { return SUCCESS; }
+#if SIMDJSON_CHECK_EOF
+      // If there are no more tokens, the parent is incomplete.
+      if (at_end()) { return report_error(INCOMPLETE_ARRAY_OR_OBJECT, "Missing [ or { at start"); }
+#endif // SIMDJSON_CHECK_EOF
+      break;
+    case '"':
+      if(*peek() == ':') {
+        // We are at a key!!!
+        // This might happen if you just started an object and you skip it immediately.
+        // Performance note: it would be nice to get rid of this check as it is somewhat
+        // expensive.
+        // https://github.com/simdjson/simdjson/issues/1742
+        logger::log_value(*this, "key");
+        return_current_and_advance(); // eat up the ':'
+        break; // important!!!
+      }
+      simdjson_fallthrough;
+    // Anything else must be a scalar value
+    default:
+      // For the first scalar, we will have incremented depth already, so we decrement it here.
+      logger::log_value(*this, "skip");
+      _depth--;
+      if (depth() <= parent_depth) { return SUCCESS; }
+      break;
+  }
 
-inline void log_event(const value_iterator &iter, const char *type, std::string_view detail, int delta, int depth_delta) noexcept {
-  log_event(iter.json_iter(), type, detail, delta, depth_delta);
-}
+  // Now that we've considered the first value, we only increment/decrement for arrays/objects
+  while (position() < end_position()) {
+    switch (*return_current_and_advance()) {
+      case '[': case '{':
+        logger::log_start_value(*this, "skip");
+        _depth++;
+        break;
+      // TODO consider whether matching braces is a requirement: if non-matching braces indicates
+      // *missing* braces, then future lookups are not in the object/arrays they think they are,
+      // violating the rule "validate enough structure that the user can be confident they are
+      // looking at the right values."
+      // PERF TODO we can eliminate the switch here with a lookup of how much to add to depth
+      case ']': case '}':
+        logger::log_end_value(*this, "skip");
+        _depth--;
+        if (depth() <= parent_depth) { return SUCCESS; }
+        break;
+      default:
+        logger::log_value(*this, "skip", "");
+        break;
+    }
+  }
 
-inline void log_value(const value_iterator &iter, const char *type, std::string_view detail, int delta, int depth_delta) noexcept {
-  log_value(iter.json_iter(), type, detail, delta, depth_delta);
+  return report_error(TAPE_ERROR, "not enough close braces");
 }
 
-inline void log_start_value(const value_iterator &iter, const char *type, int delta, int depth_delta) noexcept {
-  log_start_value(iter.json_iter(), type, delta, depth_delta);
-}
+SIMDJSON_POP_DISABLE_WARNINGS
 
-inline void log_end_value(const value_iterator &iter, const char *type, int delta, int depth_delta) noexcept {
-  log_end_value(iter.json_iter(), type, delta, depth_delta);
+simdjson_inline bool json_iterator::at_root() const noexcept {
+  return position() == root_position();
 }
 
-inline void log_error(const value_iterator &iter, const char *error, const char *detail, int delta, int depth_delta) noexcept {
-  log_error(iter.json_iter(), error, detail, delta, depth_delta);
+simdjson_inline bool json_iterator::is_single_token() const noexcept {
+  return parser->implementation->n_structural_indexes == 1;
 }
 
-inline void log_headers() noexcept {
-  if (LOG_ENABLED) {
-    if (simdjson_unlikely(should_log(log_level::info))) {
-      // Technically a static variable is not thread-safe, but if you are using threads and logging... well...
-      static bool displayed_hint{false};
-      log_depth = 0;
-      printf("\n");
-      if (!displayed_hint) {
-        // We only print this helpful header once.
-        printf("# Logging provides the depth and position of the iterator user-visible steps:\n");
-        printf("# +array says 'this is where we were when we discovered the start array'\n");
-        printf(
-            "# -array says 'this is where we were when we ended the array'\n");
-        printf("# skip says 'this is a structural or value I am skipping'\n");
-        printf("# +/-skip says 'this is a start/end array or object I am skipping'\n");
-        printf("#\n");
-        printf("# The indentation of the terms (array, string,...) indicates the depth,\n");
-        printf("# in addition to the depth being displayed.\n");
-        printf("#\n");
-        printf("# Every token in the document has a single depth determined by the tokens before it,\n");
-        printf("# and is not affected by what the token actually is.\n");
-        printf("#\n");
-        printf("# Not all structural elements are presented as tokens in the logs.\n");
-        printf("#\n");
-        printf("# We never give control to the user within an empty array or an empty object.\n");
-        printf("#\n");
-        printf("# Inside an array, having a depth greater than the array's depth means that\n");
-        printf("# we are pointing inside a value.\n");
-        printf("# Having a depth equal to the array means that we are pointing right before a value.\n");
-        printf("# Having a depth smaller than the array means that we have moved beyond the array.\n");
-        displayed_hint = true;
-      }
-      printf("\n");
-      printf("| %-*s ", LOG_EVENT_LEN, "Event");
-      printf("| %-*s ", LOG_BUFFER_LEN, "Buffer");
-      printf("| %-*s ", LOG_SMALL_BUFFER_LEN, "Next");
-      // printf("| %-*s ", 5,                    "Next#");
-      printf("| %-*s ", 5, "Depth");
-      printf("| Detail ");
-      printf("|\n");
-
-      printf("|%.*s", LOG_EVENT_LEN + 2, DASHES);
-      printf("|%.*s", LOG_BUFFER_LEN + 2, DASHES);
-      printf("|%.*s", LOG_SMALL_BUFFER_LEN + 2, DASHES);
-      // printf("|%.*s", 5+2, DASHES);
-      printf("|%.*s", 5 + 2, DASHES);
-      printf("|--------");
-      printf("|\n");
-      fflush(stdout);
-    }
-  }
+simdjson_inline bool json_iterator::streaming() const noexcept {
+  return _streaming;
 }
 
-template <typename... Args>
-inline void log_line(const json_iterator &iter, const char *title_prefix, const char *title, std::string_view detail, int delta, int depth_delta, log_level level, Args&&... args) noexcept {
-  log_line(iter, iter.position()+delta, depth_t(iter.depth()+depth_delta), title_prefix, title, detail, level, std::forward<Args>(args)...);
+simdjson_inline token_position json_iterator::root_position() const noexcept {
+  return _root;
 }
 
-template <typename... Args>
-inline void log_line(const json_iterator &iter, token_position index, depth_t depth, const char *title_prefix, const char *title, std::string_view detail, log_level level, Args&&... args) noexcept {
-  if (LOG_ENABLED) {
-    if (simdjson_unlikely(should_log(level))) {
-      const int indent = depth * 2;
-      const auto buf = iter.token.buf;
-      auto msg = string_format(title, std::forward<Args>(args)...);
-      printf("| %*s%s%-*s ", indent, "", title_prefix,
-             LOG_EVENT_LEN - indent - int(strlen(title_prefix)), msg.c_str());
-      {
-        // Print the current structural.
-        printf("| ");
-        // Before we begin, the index might point right before the document.
-        // This could be unsafe, see https://github.com/simdjson/simdjson/discussions/1938
-        if (index < iter._root) {
-          printf("%*s", LOG_BUFFER_LEN, "");
-        } else {
-          auto current_structural = &buf[*index];
-          for (int i = 0; i < LOG_BUFFER_LEN; i++) {
-            printf("%c", printable_char(current_structural[i]));
-          }
-        }
-        printf(" ");
-      }
-      {
-        // Print the next structural.
-        printf("| ");
-        auto next_structural = &buf[*(index + 1)];
-        for (int i = 0; i < LOG_SMALL_BUFFER_LEN; i++) {
-          printf("%c", printable_char(next_structural[i]));
-        }
-        printf(" ");
-      }
-      // printf("| %5u ", *(index+1));
-      printf("| %5i ", depth);
-      printf("| %6.*s ", int(detail.size()), detail.data());
-      printf("|\n");
-      fflush(stdout);
-    }
-  }
+simdjson_inline void json_iterator::assert_at_document_depth() const noexcept {
+  SIMDJSON_ASSUME( _depth == 1 );
 }
 
-} // namespace logger
-} // namespace ondemand
-} // namespace lasx
-} // namespace simdjson
-
-#endif // SIMDJSON_GENERIC_ONDEMAND_LOGGER_INL_H
-/* end file simdjson/generic/ondemand/logger-inl.h for lasx */
-/* including simdjson/generic/ondemand/object-inl.h for lasx: #include "simdjson/generic/ondemand/object-inl.h" */
-/* begin file simdjson/generic/ondemand/object-inl.h for lasx */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_OBJECT_INL_H
-
-/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_OBJECT_INL_H */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/field.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/object.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/object_iterator.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/raw_json_string.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_iterator.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value-inl.h" */
-/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
-
-namespace simdjson {
-namespace lasx {
-namespace ondemand {
-
-simdjson_inline simdjson_result<value> object::find_field_unordered(const std::string_view key) & noexcept {
-  bool has_value;
-  SIMDJSON_TRY( iter.find_field_unordered_raw(key).get(has_value) );
-  if (!has_value) {
-    logger::log_line(iter.json_iter(), "ERROR: ", "Cannot find key %.*s", "", -1, 0, logger::log_level::error, static_cast<int>(key.size()), key.data());
-    return NO_SUCH_FIELD;
-  }
-  return value(iter.child());
-}
-simdjson_inline simdjson_result<value> object::find_field_unordered(const std::string_view key) && noexcept {
-  bool has_value;
-  SIMDJSON_TRY( iter.find_field_unordered_raw(key).get(has_value) );
-  if (!has_value) {
-    logger::log_line(iter.json_iter(), "ERROR: ", "Cannot find key %.*s", "", -1, 0, logger::log_level::error, static_cast<int>(key.size()), key.data());
-    return NO_SUCH_FIELD;
-  }
-  return value(iter.child());
+simdjson_inline void json_iterator::assert_at_root() const noexcept {
+  SIMDJSON_ASSUME( _depth == 1 );
+#ifndef SIMDJSON_CLANG_VISUAL_STUDIO
+  // Under Visual Studio, the next SIMDJSON_ASSUME fails with: the argument
+  // has side effects that will be discarded.
+  SIMDJSON_ASSUME( token.position() == _root );
+#endif
 }
-simdjson_inline simdjson_result<value> object::operator[](const std::string_view key) & noexcept {
-  return find_field_unordered(key);
+
+simdjson_inline void json_iterator::assert_more_tokens(uint32_t required_tokens) const noexcept {
+  assert_valid_position(token._position + required_tokens - 1);
 }
-simdjson_inline simdjson_result<value> object::operator[](const std::string_view key) && noexcept {
-  return std::forward<object>(*this).find_field_unordered(key);
+
+simdjson_inline void json_iterator::assert_valid_position(token_position position) const noexcept {
+#ifndef SIMDJSON_CLANG_VISUAL_STUDIO
+  SIMDJSON_ASSUME( position >= &parser->implementation->structural_indexes[0] );
+  SIMDJSON_ASSUME( position < &parser->implementation->structural_indexes[parser->implementation->n_structural_indexes] );
+#endif
 }
-simdjson_inline simdjson_result<value> object::find_field(const std::string_view key) & noexcept {
-  bool has_value;
-  SIMDJSON_TRY( iter.find_field_raw(key).get(has_value) );
-  if (!has_value) {
-    logger::log_line(iter.json_iter(), "ERROR: ", "Cannot find key %.*s", "", -1, 0, logger::log_level::error, static_cast<int>(key.size()), key.data());
-    return NO_SUCH_FIELD;
-  }
-  return value(iter.child());
+
+simdjson_inline bool json_iterator::at_end() const noexcept {
+  return position() == end_position();
 }
-simdjson_inline simdjson_result<value> object::find_field(const std::string_view key) && noexcept {
-  bool has_value;
-  SIMDJSON_TRY( iter.find_field_raw(key).get(has_value) );
-  if (!has_value) {
-    logger::log_line(iter.json_iter(), "ERROR: ", "Cannot find key %.*s", "", -1, 0, logger::log_level::error, static_cast<int>(key.size()), key.data());
-    return NO_SUCH_FIELD;
-  }
-  return value(iter.child());
+simdjson_inline token_position json_iterator::end_position() const noexcept {
+  uint32_t n_structural_indexes{parser->implementation->n_structural_indexes};
+  return &parser->implementation->structural_indexes[n_structural_indexes];
 }
 
-simdjson_inline simdjson_result<object> object::start(value_iterator &iter) noexcept {
-  SIMDJSON_TRY( iter.start_object().error() );
-  return object(iter);
-}
-simdjson_inline simdjson_result<object> object::start_root(value_iterator &iter) noexcept {
-  SIMDJSON_TRY( iter.start_root_object().error() );
-  return object(iter);
+inline std::string json_iterator::to_string() const noexcept {
+  if( !is_alive() ) { return "dead json_iterator instance"; }
+  const char * current_structural = reinterpret_cast<const char *>(token.peek());
+  return std::string("json_iterator [ depth : ") + std::to_string(_depth)
+          + std::string(", structural : '") + std::string(current_structural,1)
+          + std::string("', offset : ") + std::to_string(token.current_offset())
+          + std::string("', error : ") + error_message(error)
+          + std::string(" ]");
 }
-simdjson_inline error_code object::consume() noexcept {
-  if(iter.is_at_key()) {
-    /**
-     * whenever you are pointing at a key, calling skip_child() is
-     * unsafe because you will hit a string and you will assume that
-     * it is string value, and this mistake will lead you to make bad
-     * depth computation.
-     */
-    /**
-     * We want to 'consume' the key. We could really
-     * just do _json_iter->return_current_and_advance(); at this
-     * point, but, for clarity, we will use the high-level API to
-     * eat the key. We assume that the compiler optimizes away
-     * most of the work.
-     */
-    simdjson_unused raw_json_string actual_key;
-    auto error = iter.field_key().get(actual_key);
-    if (error) { iter.abandon(); return error; };
-    // Let us move to the value while we are at it.
-    if ((error = iter.field_value())) { iter.abandon(); return error; }
+
+inline simdjson_result<const char *> json_iterator::current_location() const noexcept {
+  if (!is_alive()) {    // Unrecoverable error
+    if (!at_root()) {
+      return reinterpret_cast<const char *>(token.peek(-1));
+    } else {
+      return reinterpret_cast<const char *>(token.peek());
+    }
+  }
+  if (at_end()) {
+    return OUT_OF_BOUNDS;
   }
-  auto error_skip = iter.json_iter().skip_child(iter.depth()-1);
-  if(error_skip) { iter.abandon(); }
-  return error_skip;
+  return reinterpret_cast<const char *>(token.peek());
 }
 
-simdjson_inline simdjson_result<std::string_view> object::raw_json() noexcept {
-  const uint8_t * starting_point{iter.peek_start()};
-  auto error = consume();
-  if(error) { return error; }
-  const uint8_t * final_point{iter._json_iter->peek()};
-  return std::string_view(reinterpret_cast<const char*>(starting_point), size_t(final_point - starting_point));
+simdjson_inline bool json_iterator::is_alive() const noexcept {
+  return parser;
 }
 
-simdjson_inline simdjson_result<object> object::started(value_iterator &iter) noexcept {
-  SIMDJSON_TRY( iter.started_object().error() );
-  return object(iter);
+simdjson_inline void json_iterator::abandon() noexcept {
+  parser = nullptr;
+  _depth = 0;
 }
 
-simdjson_inline object object::resume(const value_iterator &iter) noexcept {
-  return iter;
+simdjson_inline const uint8_t *json_iterator::return_current_and_advance() noexcept {
+#if SIMDJSON_CHECK_EOF
+  assert_more_tokens();
+#endif // SIMDJSON_CHECK_EOF
+  return token.return_current_and_advance();
 }
 
-simdjson_inline object::object(const value_iterator &_iter) noexcept
-  : iter{_iter}
-{
+simdjson_inline const uint8_t *json_iterator::unsafe_pointer() const noexcept {
+  // deliberately done without safety guard:
+  return token.peek();
 }
 
-simdjson_inline simdjson_result<object_iterator> object::begin() noexcept {
-#if SIMDJSON_DEVELOPMENT_CHECKS
-  if (!iter.is_at_iterator_start()) { return OUT_OF_ORDER_ITERATION; }
-#endif
-  return object_iterator(iter);
-}
-simdjson_inline simdjson_result<object_iterator> object::end() noexcept {
-  return object_iterator(iter);
+simdjson_inline const uint8_t *json_iterator::peek(int32_t delta) const noexcept {
+#if SIMDJSON_CHECK_EOF
+  assert_more_tokens(delta+1);
+#endif // SIMDJSON_CHECK_EOF
+  return token.peek(delta);
 }
 
-inline simdjson_result<value> object::at_pointer(std::string_view json_pointer) noexcept {
-  if (json_pointer[0] != '/') { return INVALID_JSON_POINTER; }
-  json_pointer = json_pointer.substr(1);
-  size_t slash = json_pointer.find('/');
-  std::string_view key = json_pointer.substr(0, slash);
-  // Grab the child with the given key
-  simdjson_result<value> child;
-
-  // If there is an escape character in the key, unescape it and then get the child.
-  size_t escape = key.find('~');
-  if (escape != std::string_view::npos) {
-    // Unescape the key
-    std::string unescaped(key);
-    do {
-      switch (unescaped[escape+1]) {
-        case '0':
-          unescaped.replace(escape, 2, "~");
-          break;
-        case '1':
-          unescaped.replace(escape, 2, "/");
-          break;
-        default:
-          return INVALID_JSON_POINTER; // "Unexpected ~ escape character in JSON pointer");
-      }
-      escape = unescaped.find('~', escape+1);
-    } while (escape != std::string::npos);
-    child = find_field(unescaped);  // Take note find_field does not unescape keys when matching
-  } else {
-    child = find_field(key);
-  }
-  if(child.error()) {
-    return child; // we do not continue if there was an error
-  }
-  // If there is a /, we have to recurse and look up more of the path
-  if (slash != std::string_view::npos) {
-    child = child.at_pointer(json_pointer.substr(slash));
-  }
-  return child;
+simdjson_inline uint32_t json_iterator::peek_length(int32_t delta) const noexcept {
+#if SIMDJSON_CHECK_EOF
+  assert_more_tokens(delta+1);
+#endif // #if SIMDJSON_CHECK_EOF
+  return token.peek_length(delta);
 }
 
-inline simdjson_result<value> object::at_path(std::string_view json_path) noexcept {
-  auto json_pointer = json_path_to_pointer_conversion(json_path);
-  if (json_pointer == "-1") {
-    return INVALID_JSON_POINTER;
-  }
-  return at_pointer(json_pointer);
+simdjson_inline const uint8_t *json_iterator::peek(token_position position) const noexcept {
+  // todo: currently we require end-of-string buffering, but the following
+  // assert_valid_position should be turned on if/when we lift that condition.
+  // assert_valid_position(position);
+  // This is almost surely related to SIMDJSON_CHECK_EOF but given that SIMDJSON_CHECK_EOF
+  // is ON by default, we have no choice but to disable it for real with a comment.
+  return token.peek(position);
 }
 
-simdjson_inline simdjson_result<size_t> object::count_fields() & noexcept {
-  size_t count{0};
-  // Important: we do not consume any of the values.
-  for(simdjson_unused auto v : *this) { count++; }
-  // The above loop will always succeed, but we want to report errors.
-  if(iter.error()) { return iter.error(); }
-  // We need to move back at the start because we expect users to iterate through
-  // the object after counting the number of elements.
-  iter.reset_object();
-  return count;
+simdjson_inline uint32_t json_iterator::peek_length(token_position position) const noexcept {
+#if SIMDJSON_CHECK_EOF
+  assert_valid_position(position);
+#endif // SIMDJSON_CHECK_EOF
+  return token.peek_length(position);
 }
-
-simdjson_inline simdjson_result<bool> object::is_empty() & noexcept {
-  bool is_not_empty;
-  auto error = iter.reset_object().get(is_not_empty);
-  if(error) { return error; }
-  return !is_not_empty;
+simdjson_inline uint32_t json_iterator::peek_root_length(token_position position) const noexcept {
+#if SIMDJSON_CHECK_EOF
+  assert_valid_position(position);
+#endif // SIMDJSON_CHECK_EOF
+  return token.peek_root_length(position);
 }
 
-simdjson_inline simdjson_result<bool> object::reset() & noexcept {
-  return iter.reset_object();
+simdjson_inline token_position json_iterator::last_position() const noexcept {
+  // The following line fails under some compilers...
+  // SIMDJSON_ASSUME(parser->implementation->n_structural_indexes > 0);
+  // since it has side-effects.
+  uint32_t n_structural_indexes{parser->implementation->n_structural_indexes};
+  SIMDJSON_ASSUME(n_structural_indexes > 0);
+  return &parser->implementation->structural_indexes[n_structural_indexes - 1];
+}
+simdjson_inline const uint8_t *json_iterator::peek_last() const noexcept {
+  return token.peek(last_position());
 }
 
-} // namespace ondemand
-} // namespace lasx
-} // namespace simdjson
-
-namespace simdjson {
-
-simdjson_inline simdjson_result<lasx::ondemand::object>::simdjson_result(lasx::ondemand::object &&value) noexcept
-    : implementation_simdjson_result_base<lasx::ondemand::object>(std::forward<lasx::ondemand::object>(value)) {}
-simdjson_inline simdjson_result<lasx::ondemand::object>::simdjson_result(error_code error) noexcept
-    : implementation_simdjson_result_base<lasx::ondemand::object>(error) {}
-
-simdjson_inline simdjson_result<lasx::ondemand::object_iterator> simdjson_result<lasx::ondemand::object>::begin() noexcept {
-  if (error()) { return error(); }
-  return first.begin();
+simdjson_inline void json_iterator::ascend_to(depth_t parent_depth) noexcept {
+  SIMDJSON_ASSUME(parent_depth >= 0 && parent_depth < INT32_MAX - 1);
+  SIMDJSON_ASSUME(_depth == parent_depth + 1);
+  _depth = parent_depth;
 }
-simdjson_inline simdjson_result<lasx::ondemand::object_iterator> simdjson_result<lasx::ondemand::object>::end() noexcept {
-  if (error()) { return error(); }
-  return first.end();
+
+simdjson_inline void json_iterator::descend_to(depth_t child_depth) noexcept {
+  SIMDJSON_ASSUME(child_depth >= 1 && child_depth < INT32_MAX);
+  SIMDJSON_ASSUME(_depth == child_depth - 1);
+  _depth = child_depth;
 }
-simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::object>::find_field_unordered(std::string_view key) & noexcept {
-  if (error()) { return error(); }
-  return first.find_field_unordered(key);
+
+simdjson_inline depth_t json_iterator::depth() const noexcept {
+  return _depth;
 }
-simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::object>::find_field_unordered(std::string_view key) && noexcept {
-  if (error()) { return error(); }
-  return std::forward<lasx::ondemand::object>(first).find_field_unordered(key);
+
+simdjson_inline uint8_t *&json_iterator::string_buf_loc() noexcept {
+  return _string_buf_loc;
 }
-simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::object>::operator[](std::string_view key) & noexcept {
-  if (error()) { return error(); }
-  return first[key];
+
+simdjson_inline error_code json_iterator::report_error(error_code _error, const char *message) noexcept {
+  SIMDJSON_ASSUME(_error != SUCCESS && _error != UNINITIALIZED && _error != INCORRECT_TYPE && _error != NO_SUCH_FIELD);
+  logger::log_error(*this, message);
+  error = _error;
+  return error;
 }
-simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::object>::operator[](std::string_view key) && noexcept {
-  if (error()) { return error(); }
-  return std::forward<lasx::ondemand::object>(first)[key];
+
+simdjson_inline token_position json_iterator::position() const noexcept {
+  return token.position();
 }
-simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::object>::find_field(std::string_view key) & noexcept {
-  if (error()) { return error(); }
-  return first.find_field(key);
+
+simdjson_inline simdjson_result<std::string_view> json_iterator::unescape(raw_json_string in, bool allow_replacement) noexcept {
+#if SIMDJSON_DEVELOPMENT_CHECKS
+  auto result = parser->unescape(in, _string_buf_loc, allow_replacement);
+  SIMDJSON_ASSUME(!parser->string_buffer_overflow(_string_buf_loc));
+  return result;
+#else
+  return parser->unescape(in, _string_buf_loc, allow_replacement);
+#endif
 }
-simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::object>::find_field(std::string_view key) && noexcept {
-  if (error()) { return error(); }
-  return std::forward<lasx::ondemand::object>(first).find_field(key);
+
+simdjson_inline simdjson_result<std::string_view> json_iterator::unescape_wobbly(raw_json_string in) noexcept {
+#if SIMDJSON_DEVELOPMENT_CHECKS
+  auto result = parser->unescape_wobbly(in, _string_buf_loc);
+  SIMDJSON_ASSUME(!parser->string_buffer_overflow(_string_buf_loc));
+  return result;
+#else
+  return parser->unescape_wobbly(in, _string_buf_loc);
+#endif
 }
 
-simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::object>::at_pointer(std::string_view json_pointer) noexcept {
-  if (error()) { return error(); }
-  return first.at_pointer(json_pointer);
+simdjson_inline void json_iterator::reenter_child(token_position position, depth_t child_depth) noexcept {
+  SIMDJSON_ASSUME(child_depth >= 1 && child_depth < INT32_MAX);
+  SIMDJSON_ASSUME(_depth == child_depth - 1);
+#if SIMDJSON_DEVELOPMENT_CHECKS
+#ifndef SIMDJSON_CLANG_VISUAL_STUDIO
+  SIMDJSON_ASSUME(size_t(child_depth) < parser->max_depth());
+  SIMDJSON_ASSUME(position >= parser->start_positions[child_depth]);
+#endif
+#endif
+  token.set_position(position);
+  _depth = child_depth;
 }
 
-simdjson_inline simdjson_result<lasx::ondemand::value> simdjson_result<lasx::ondemand::object>::at_path(
-    std::string_view json_path) noexcept {
-  if (error()) {
-    return error();
+simdjson_inline error_code json_iterator::consume_character(char c) noexcept {
+  if (*peek() == c) {
+    return_current_and_advance();
+    return SUCCESS;
   }
-  return first.at_path(json_path);
+  return TAPE_ERROR;
 }
 
-inline simdjson_result<bool> simdjson_result<lasx::ondemand::object>::reset() noexcept {
-  if (error()) { return error(); }
-  return first.reset();
+#if SIMDJSON_DEVELOPMENT_CHECKS
+
+simdjson_inline token_position json_iterator::start_position(depth_t depth) const noexcept {
+  SIMDJSON_ASSUME(size_t(depth) < parser->max_depth());
+  return size_t(depth) < parser->max_depth() ? parser->start_positions[depth] : 0;
 }
 
-inline simdjson_result<bool> simdjson_result<lasx::ondemand::object>::is_empty() noexcept {
-  if (error()) { return error(); }
-  return first.is_empty();
+simdjson_inline void json_iterator::set_start_position(depth_t depth, token_position position) noexcept {
+  SIMDJSON_ASSUME(size_t(depth) < parser->max_depth());
+  if(size_t(depth) < parser->max_depth()) { parser->start_positions[depth] = position; }
 }
 
-simdjson_inline  simdjson_result<size_t> simdjson_result<lasx::ondemand::object>::count_fields() & noexcept {
-  if (error()) { return error(); }
-  return first.count_fields();
+#endif
+
+
+simdjson_inline error_code json_iterator::optional_error(error_code _error, const char *message) noexcept {
+  SIMDJSON_ASSUME(_error == INCORRECT_TYPE || _error == NO_SUCH_FIELD);
+  logger::log_error(*this, message);
+  return _error;
 }
 
-simdjson_inline  simdjson_result<std::string_view> simdjson_result<lasx::ondemand::object>::raw_json() noexcept {
-  if (error()) { return error(); }
-  return first.raw_json();
+
+simdjson_warn_unused simdjson_inline bool json_iterator::copy_to_buffer(const uint8_t *json, uint32_t max_len, uint8_t *tmpbuf, size_t N) noexcept {
+  // This function is not expected to be called in performance-sensitive settings.
+  // Let us guard against silly cases:
+  if((N < max_len) || (N == 0)) { return false; }
+  // Copy to the buffer.
+  std::memcpy(tmpbuf, json, max_len);
+  if(N > max_len) { // We pad whatever remains with ' '.
+    std::memset(tmpbuf + max_len, ' ', N - max_len);
+  }
+  return true;
 }
+
+} // namespace ondemand
+} // namespace lasx
 } // namespace simdjson
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_OBJECT_INL_H
-/* end file simdjson/generic/ondemand/object-inl.h for lasx */
-/* including simdjson/generic/ondemand/object_iterator-inl.h for lasx: #include "simdjson/generic/ondemand/object_iterator-inl.h" */
-/* begin file simdjson/generic/ondemand/object_iterator-inl.h for lasx */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_OBJECT_ITERATOR_INL_H
+namespace simdjson {
+
+simdjson_inline simdjson_result<lasx::ondemand::json_iterator>::simdjson_result(lasx::ondemand::json_iterator &&value) noexcept
+    : implementation_simdjson_result_base<lasx::ondemand::json_iterator>(std::forward<lasx::ondemand::json_iterator>(value)) {}
+simdjson_inline simdjson_result<lasx::ondemand::json_iterator>::simdjson_result(error_code error) noexcept
+    : implementation_simdjson_result_base<lasx::ondemand::json_iterator>(error) {}
+
+} // namespace simdjson
+
+#endif // SIMDJSON_GENERIC_ONDEMAND_JSON_ITERATOR_INL_H
+/* end file simdjson/generic/ondemand/json_iterator-inl.h for lasx */
+/* including simdjson/generic/ondemand/json_type-inl.h for lasx: #include "simdjson/generic/ondemand/json_type-inl.h" */
+/* begin file simdjson/generic/ondemand/json_type-inl.h for lasx */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_JSON_TYPE_INL_H
 
 /* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_OBJECT_ITERATOR_INL_H */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_JSON_TYPE_INL_H */
 /* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/object_iterator.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/field-inl.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value_iterator-inl.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_type.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/implementation_simdjson_result_base-inl.h" */
 /* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
 namespace simdjson {
 namespace lasx {
 namespace ondemand {
 
-//
-// object_iterator
-//
-
-simdjson_inline object_iterator::object_iterator(const value_iterator &_iter) noexcept
-  : iter{_iter}
-{}
-
-simdjson_inline simdjson_result<field> object_iterator::operator*() noexcept {
-  error_code error = iter.error();
-  if (error) { iter.abandon(); return error; }
-  auto result = field::start(iter);
-  // TODO this is a safety rail ... users should exit loops as soon as they receive an error.
-  // Nonetheless, let's see if performance is OK with this if statement--the compiler may give it to us for free.
-  if (result.error()) { iter.abandon(); }
-  return result;
-}
-simdjson_inline bool object_iterator::operator==(const object_iterator &other) const noexcept {
-  return !(*this != other);
-}
-simdjson_inline bool object_iterator::operator!=(const object_iterator &) const noexcept {
-  return iter.is_open();
+inline std::ostream& operator<<(std::ostream& out, json_type type) noexcept {
+    switch (type) {
+        case json_type::array: out << "array"; break;
+        case json_type::object: out << "object"; break;
+        case json_type::number: out << "number"; break;
+        case json_type::string: out << "string"; break;
+        case json_type::boolean: out << "boolean"; break;
+        case json_type::null: out << "null"; break;
+        default: SIMDJSON_UNREACHABLE();
+    }
+    return out;
 }
 
-SIMDJSON_PUSH_DISABLE_WARNINGS
-SIMDJSON_DISABLE_STRICT_OVERFLOW_WARNING
-simdjson_inline object_iterator &object_iterator::operator++() noexcept {
-  // TODO this is a safety rail ... users should exit loops as soon as they receive an error.
-  // Nonetheless, let's see if performance is OK with this if statement--the compiler may give it to us for free.
-  if (!iter.is_open()) { return *this; } // Iterator will be released if there is an error
-
-  simdjson_unused error_code error;
-  if ((error = iter.skip_child() )) { return *this; }
-
-  simdjson_unused bool has_value;
-  if ((error = iter.has_next_field().get(has_value) )) { return *this; };
-  return *this;
+#if SIMDJSON_EXCEPTIONS
+inline std::ostream& operator<<(std::ostream& out, simdjson_result<json_type> &type) noexcept(false) {
+    return out << type.value();
 }
-SIMDJSON_POP_DISABLE_WARNINGS
+#endif
 
-//
-// ### Live States
-//
-// While iterating or looking up values, depth >= iter.depth. at_start may vary. Error is
-// always SUCCESS:
-//
-// - Start: This is the state when the object is first found and the iterator is just past the {.
-//   In this state, at_start == true.
-// - Next: After we hand a scalar value to the user, or an array/object which they then fully
-//   iterate over, the iterator is at the , or } before the next value. In this state,
-//   depth == iter.depth, at_start == false, and error == SUCCESS.
-// - Unfinished Business: When we hand an array/object to the user which they do not fully
-//   iterate over, we need to finish that iteration by skipping child values until we reach the
-//   Next state. In this state, depth > iter.depth, at_start == false, and error == SUCCESS.
-//
-// ## Error States
-//
-// In error states, we will yield exactly one more value before stopping. iter.depth == depth
-// and at_start is always false. We decrement after yielding the error, moving to the Finished
-// state.
-//
-// - Chained Error: When the object iterator is part of an error chain--for example, in
-//   `for (auto tweet : doc["tweets"])`, where the tweet field may be missing or not be an
-//   object--we yield that error in the loop, exactly once. In this state, error != SUCCESS and
-//   iter.depth == depth, and at_start == false. We decrement depth when we yield the error.
-// - Missing Comma Error: When the iterator ++ method discovers there is no comma between fields,
-//   we flag that as an error and treat it exactly the same as a Chained Error. In this state,
-//   error == TAPE_ERROR, iter.depth == depth, and at_start == false.
-//
-// Errors that occur while reading a field to give to the user (such as when the key is not a
-// string or the field is missing a colon) are yielded immediately. Depth is then decremented,
-// moving to the Finished state without transitioning through an Error state at all.
-//
-// ## Terminal State
-//
-// The terminal state has iter.depth < depth. at_start is always false.
-//
-// - Finished: When we have reached a }, we are finished. We signal this by decrementing depth.
-//   In this state, iter.depth < depth, at_start == false, and error == SUCCESS.
-//
 
-} // namespace ondemand
-} // namespace lasx
-} // namespace simdjson
 
-namespace simdjson {
+simdjson_inline number_type number::get_number_type() const noexcept {
+  return type;
+}
 
-simdjson_inline simdjson_result<lasx::ondemand::object_iterator>::simdjson_result(
-  lasx::ondemand::object_iterator &&value
-) noexcept
-  : implementation_simdjson_result_base<lasx::ondemand::object_iterator>(std::forward<lasx::ondemand::object_iterator>(value))
-{
-  first.iter.assert_is_valid();
+simdjson_inline bool number::is_uint64() const noexcept {
+  return get_number_type() == number_type::unsigned_integer;
 }
-simdjson_inline simdjson_result<lasx::ondemand::object_iterator>::simdjson_result(error_code error) noexcept
-  : implementation_simdjson_result_base<lasx::ondemand::object_iterator>({}, error)
-{
+
+simdjson_inline uint64_t number::get_uint64() const noexcept {
+  return payload.unsigned_integer;
 }
 
-simdjson_inline simdjson_result<lasx::ondemand::field> simdjson_result<lasx::ondemand::object_iterator>::operator*() noexcept {
-  if (error()) { return error(); }
-  return *first;
+simdjson_inline number::operator uint64_t() const noexcept {
+  return get_uint64();
 }
-// If we're iterating and there is an error, return the error once.
-simdjson_inline bool simdjson_result<lasx::ondemand::object_iterator>::operator==(const simdjson_result<lasx::ondemand::object_iterator> &other) const noexcept {
-  if (!first.iter.is_valid()) { return !error(); }
-  return first == other.first;
+
+simdjson_inline bool number::is_int64() const noexcept {
+  return get_number_type() == number_type::signed_integer;
 }
-// If we're iterating and there is an error, return the error once.
-simdjson_inline bool simdjson_result<lasx::ondemand::object_iterator>::operator!=(const simdjson_result<lasx::ondemand::object_iterator> &other) const noexcept {
-  if (!first.iter.is_valid()) { return error(); }
-  return first != other.first;
+
+simdjson_inline int64_t number::get_int64() const noexcept {
+  return payload.signed_integer;
 }
-// Checks for ']' and ','
-simdjson_inline simdjson_result<lasx::ondemand::object_iterator> &simdjson_result<lasx::ondemand::object_iterator>::operator++() noexcept {
-  // Clear the error if there is one, so we don't yield it twice
-  if (error()) { second = SUCCESS; return *this; }
-  ++first;
-  return *this;
+
+simdjson_inline number::operator int64_t() const noexcept {
+  return get_int64();
 }
 
-} // namespace simdjson
+simdjson_inline bool number::is_double() const noexcept {
+    return get_number_type() == number_type::floating_point_number;
+}
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_OBJECT_ITERATOR_INL_H
-/* end file simdjson/generic/ondemand/object_iterator-inl.h for lasx */
-/* including simdjson/generic/ondemand/parser-inl.h for lasx: #include "simdjson/generic/ondemand/parser-inl.h" */
-/* begin file simdjson/generic/ondemand/parser-inl.h for lasx */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_PARSER_INL_H
+simdjson_inline double number::get_double() const noexcept {
+  return payload.floating_point_number;
+}
 
-/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_PARSER_INL_H */
-/* amalgamation skipped (editor-only): #include "simdjson/padded_string.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/padded_string_view.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/implementation.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/internal/dom_parser_implementation.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/dom/base.h" // for MINIMAL_DOCUMENT_CAPACITY */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/document_stream.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/parser.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/raw_json_string.h" */
-/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
+simdjson_inline number::operator double() const noexcept {
+  return get_double();
+}
 
-namespace simdjson {
-namespace lasx {
-namespace ondemand {
+simdjson_inline double number::as_double() const noexcept {
+  if(is_double()) {
+    return payload.floating_point_number;
+  }
+  if(is_int64()) {
+    return double(payload.signed_integer);
+  }
+  return double(payload.unsigned_integer);
+}
 
-simdjson_inline parser::parser(size_t max_capacity) noexcept
-  : _max_capacity{max_capacity} {
+simdjson_inline void number::append_s64(int64_t value) noexcept {
+  payload.signed_integer = value;
+  type = number_type::signed_integer;
 }
 
-simdjson_warn_unused simdjson_inline error_code parser::allocate(size_t new_capacity, size_t new_max_depth) noexcept {
-  if (new_capacity > max_capacity()) { return CAPACITY; }
-  if (string_buf && new_capacity == capacity() && new_max_depth == max_depth()) { return SUCCESS; }
+simdjson_inline void number::append_u64(uint64_t value) noexcept {
+  payload.unsigned_integer = value;
+  type = number_type::unsigned_integer;
+}
 
-  // string_capacity copied from document::allocate
-  _capacity = 0;
-  size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * new_capacity / 3 + SIMDJSON_PADDING, 64);
-  string_buf.reset(new (std::nothrow) uint8_t[string_capacity]);
-#if SIMDJSON_DEVELOPMENT_CHECKS
-  start_positions.reset(new (std::nothrow) token_position[new_max_depth]);
-#endif
-  if (implementation) {
-    SIMDJSON_TRY( implementation->set_capacity(new_capacity) );
-    SIMDJSON_TRY( implementation->set_max_depth(new_max_depth) );
-  } else {
-    SIMDJSON_TRY( simdjson::get_active_implementation()->create_dom_parser_implementation(new_capacity, new_max_depth, implementation) );
-  }
-  _capacity = new_capacity;
-  _max_depth = new_max_depth;
-  return SUCCESS;
+simdjson_inline void number::append_double(double value) noexcept {
+  payload.floating_point_number = value;
+  type = number_type::floating_point_number;
 }
-#if SIMDJSON_DEVELOPMENT_CHECKS
-simdjson_inline simdjson_warn_unused bool parser::string_buffer_overflow(const uint8_t *string_buf_loc) const noexcept {
-  return (string_buf_loc < string_buf.get()) || (size_t(string_buf_loc - string_buf.get()) >= capacity());
+
+simdjson_inline void number::skip_double() noexcept {
+  type = number_type::floating_point_number;
 }
-#endif
 
-simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(padded_string_view json) & noexcept {
-  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
+} // namespace ondemand
+} // namespace lasx
+} // namespace simdjson
 
-  json.remove_utf8_bom();
+namespace simdjson {
 
-  // Allocate if needed
-  if (capacity() < json.length() || !string_buf) {
-    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
-  }
+simdjson_inline simdjson_result<lasx::ondemand::json_type>::simdjson_result(lasx::ondemand::json_type &&value) noexcept
+    : implementation_simdjson_result_base<lasx::ondemand::json_type>(std::forward<lasx::ondemand::json_type>(value)) {}
+simdjson_inline simdjson_result<lasx::ondemand::json_type>::simdjson_result(error_code error) noexcept
+    : implementation_simdjson_result_base<lasx::ondemand::json_type>(error) {}
 
-  // Run stage 1.
-  SIMDJSON_TRY( implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular) );
-  return document::start({ reinterpret_cast<const uint8_t *>(json.data()), this });
-}
+} // namespace simdjson
+
+#endif // SIMDJSON_GENERIC_ONDEMAND_JSON_TYPE_INL_H
+/* end file simdjson/generic/ondemand/json_type-inl.h for lasx */
+/* including simdjson/generic/ondemand/logger-inl.h for lasx: #include "simdjson/generic/ondemand/logger-inl.h" */
+/* begin file simdjson/generic/ondemand/logger-inl.h for lasx */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_LOGGER_INL_H
 
-#ifdef SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON
-simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate_allow_incomplete_json(padded_string_view json) & noexcept {
-  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
+/* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_LOGGER_INL_H */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/logger.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_iterator.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value_iterator.h" */
+/* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
-  json.remove_utf8_bom();
+#include <memory>
+#include <cstring>
 
-  // Allocate if needed
-  if (capacity() < json.length() || !string_buf) {
-    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
-  }
+namespace simdjson {
+namespace lasx {
+namespace ondemand {
+namespace logger {
 
-  // Run stage 1.
-  const simdjson::error_code err = implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular);
-  if (err) {
-    if (err != UNCLOSED_STRING)
-      return err;
+static constexpr const char * DASHES = "----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------";
+static constexpr const int LOG_EVENT_LEN = 20;
+static constexpr const int LOG_BUFFER_LEN = 30;
+static constexpr const int LOG_SMALL_BUFFER_LEN = 10;
+static int log_depth = 0; // Not threadsafe. Log only.
+
+// Helper to turn unprintable or newline characters into spaces
+static inline char printable_char(char c) {
+  if (c >= 0x20) {
+    return c;
+  } else {
+    return ' ';
   }
-  return document::start({ reinterpret_cast<const uint8_t *>(json.data()), this, true });
 }
-#endif // SIMDJSON_EXPERIMENTAL_ALLOW_INCOMPLETE_JSON
 
-simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const char *json, size_t len, size_t allocated) & noexcept {
-  return iterate(padded_string_view(json, len, allocated));
+template<typename... Args>
+static inline std::string string_format(const std::string& format, const Args&... args)
+{
+  SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
+  int size_s = std::snprintf(nullptr, 0, format.c_str(), args...) + 1;
+  auto size = static_cast<size_t>(size_s);
+  if (size <= 0) return std::string();
+  std::unique_ptr<char[]> buf(new char[size]);
+  std::snprintf(buf.get(), size, format.c_str(), args...);
+  SIMDJSON_POP_DISABLE_WARNINGS
+  return std::string(buf.get(), buf.get() + size - 1);
 }
 
-simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const uint8_t *json, size_t len, size_t allocated) & noexcept {
-  return iterate(padded_string_view(json, len, allocated));
+static inline log_level get_log_level_from_env()
+{
+  SIMDJSON_PUSH_DISABLE_WARNINGS
+  SIMDJSON_DISABLE_DEPRECATED_WARNING // Disable CRT_SECURE warning on MSVC: manually verified this is safe
+      char *lvl = getenv("SIMDJSON_LOG_LEVEL");
+  SIMDJSON_POP_DISABLE_WARNINGS
+  if (lvl && simdjson_strcasecmp(lvl, "ERROR") == 0) { return log_level::error; }
+  return log_level::info;
 }
 
-simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(std::string_view json, size_t allocated) & noexcept {
-  return iterate(padded_string_view(json, allocated));
+static inline log_level log_threshold()
+{
+  static log_level threshold = get_log_level_from_env();
+  return threshold;
 }
 
-simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(std::string &json) & noexcept {
-  if(json.capacity() - json.size() < SIMDJSON_PADDING) {
-    json.reserve(json.size() + SIMDJSON_PADDING);
-  }
-  return iterate(padded_string_view(json));
+static inline bool should_log(log_level level)
+{
+  return level >= log_threshold();
 }
 
-simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const std::string &json) & noexcept {
-  return iterate(padded_string_view(json));
+inline void log_event(const json_iterator &iter, const char *type, std::string_view detail, int delta, int depth_delta) noexcept {
+  log_line(iter, "", type, detail, delta, depth_delta, log_level::info);
 }
 
-simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const simdjson_result<padded_string_view> &result) & noexcept {
-  // We don't presently have a way to temporarily get a const T& from a simdjson_result<T> without throwing an exception
-  SIMDJSON_TRY( result.error() );
-  padded_string_view json = result.value_unsafe();
-  return iterate(json);
+inline void log_value(const json_iterator &iter, token_position index, depth_t depth, const char *type, std::string_view detail) noexcept {
+  log_line(iter, index, depth, "", type, detail, log_level::info);
 }
-
-simdjson_warn_unused simdjson_inline simdjson_result<document> parser::iterate(const simdjson_result<padded_string> &result) & noexcept {
-  // We don't presently have a way to temporarily get a const T& from a simdjson_result<T> without throwing an exception
-  SIMDJSON_TRY( result.error() );
-  const padded_string &json = result.value_unsafe();
-  return iterate(json);
+inline void log_value(const json_iterator &iter, const char *type, std::string_view detail, int delta, int depth_delta) noexcept {
+  log_line(iter, "", type, detail, delta, depth_delta, log_level::info);
 }
 
-simdjson_warn_unused simdjson_inline simdjson_result<json_iterator> parser::iterate_raw(padded_string_view json) & noexcept {
-  if (json.padding() < SIMDJSON_PADDING) { return INSUFFICIENT_PADDING; }
-
-  json.remove_utf8_bom();
-
-  // Allocate if needed
-  if (capacity() < json.length()) {
-    SIMDJSON_TRY( allocate(json.length(), max_depth()) );
-  }
+inline void log_start_value(const json_iterator &iter, token_position index, depth_t depth, const char *type, std::string_view detail) noexcept {
+  log_line(iter, index, depth, "+", type, detail, log_level::info);
+  if (LOG_ENABLED) { log_depth++; }
+}
+inline void log_start_value(const json_iterator &iter, const char *type, int delta, int depth_delta) noexcept {
+  log_line(iter, "+", type, "", delta, depth_delta, log_level::info);
+  if (LOG_ENABLED) { log_depth++; }
+}
 
-  // Run stage 1.
-  SIMDJSON_TRY( implementation->stage1(reinterpret_cast<const uint8_t *>(json.data()), json.length(), stage1_mode::regular) );
-  return json_iterator(reinterpret_cast<const uint8_t *>(json.data()), this);
+inline void log_end_value(const json_iterator &iter, const char *type, int delta, int depth_delta) noexcept {
+  if (LOG_ENABLED) { log_depth--; }
+  log_line(iter, "-", type, "", delta, depth_delta, log_level::info);
 }
 
-inline simdjson_result<document_stream> parser::iterate_many(const uint8_t *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {
-  if(batch_size < MINIMAL_BATCH_SIZE) { batch_size = MINIMAL_BATCH_SIZE; }
-  if((len >= 3) && (std::memcmp(buf, "\xEF\xBB\xBF", 3) == 0)) {
-    buf += 3;
-    len -= 3;
-  }
-  if(allow_comma_separated && batch_size < len) { batch_size = len; }
-  return document_stream(*this, buf, len, batch_size, allow_comma_separated);
+inline void log_error(const json_iterator &iter, const char *error, const char *detail, int delta, int depth_delta) noexcept {
+  log_line(iter, "ERROR: ", error, detail, delta, depth_delta, log_level::error);
 }
-inline simdjson_result<document_stream> parser::iterate_many(const char *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {
-  return iterate_many(reinterpret_cast<const uint8_t *>(buf), len, batch_size, allow_comma_separated);
+inline void log_error(const json_iterator &iter, token_position index, depth_t depth, const char *error, const char *detail) noexcept {
+  log_line(iter, index, depth, "ERROR: ", error, detail, log_level::error);
 }
-inline simdjson_result<document_stream> parser::iterate_many(const std::string &s, size_t batch_size, bool allow_comma_separated) noexcept {
-  return iterate_many(s.data(), s.length(), batch_size, allow_comma_separated);
+
+inline void log_event(const value_iterator &iter, const char *type, std::string_view detail, int delta, int depth_delta) noexcept {
+  log_event(iter.json_iter(), type, detail, delta, depth_delta);
 }
-inline simdjson_result<document_stream> parser::iterate_many(const padded_string &s, size_t batch_size, bool allow_comma_separated) noexcept {
-  return iterate_many(s.data(), s.length(), batch_size, allow_comma_separated);
+
+inline void log_value(const value_iterator &iter, const char *type, std::string_view detail, int delta, int depth_delta) noexcept {
+  log_value(iter.json_iter(), type, detail, delta, depth_delta);
 }
 
-simdjson_pure simdjson_inline size_t parser::capacity() const noexcept {
-  return _capacity;
+inline void log_start_value(const value_iterator &iter, const char *type, int delta, int depth_delta) noexcept {
+  log_start_value(iter.json_iter(), type, delta, depth_delta);
 }
-simdjson_pure simdjson_inline size_t parser::max_capacity() const noexcept {
-  return _max_capacity;
+
+inline void log_end_value(const value_iterator &iter, const char *type, int delta, int depth_delta) noexcept {
+  log_end_value(iter.json_iter(), type, delta, depth_delta);
 }
-simdjson_pure simdjson_inline size_t parser::max_depth() const noexcept {
-  return _max_depth;
+
+inline void log_error(const value_iterator &iter, const char *error, const char *detail, int delta, int depth_delta) noexcept {
+  log_error(iter.json_iter(), error, detail, delta, depth_delta);
 }
 
-simdjson_inline void parser::set_max_capacity(size_t max_capacity) noexcept {
-  if(max_capacity < dom::MINIMAL_DOCUMENT_CAPACITY) {
-    _max_capacity = max_capacity;
-  } else {
-    _max_capacity = dom::MINIMAL_DOCUMENT_CAPACITY;
+inline void log_headers() noexcept {
+  if (LOG_ENABLED) {
+    if (simdjson_unlikely(should_log(log_level::info))) {
+      // Technically a static variable is not thread-safe, but if you are using threads and logging... well...
+      static bool displayed_hint{false};
+      log_depth = 0;
+      printf("\n");
+      if (!displayed_hint) {
+        // We only print this helpful header once.
+        printf("# Logging provides the depth and position of the iterator user-visible steps:\n");
+        printf("# +array says 'this is where we were when we discovered the start array'\n");
+        printf(
+            "# -array says 'this is where we were when we ended the array'\n");
+        printf("# skip says 'this is a structural or value I am skipping'\n");
+        printf("# +/-skip says 'this is a start/end array or object I am skipping'\n");
+        printf("#\n");
+        printf("# The indentation of the terms (array, string,...) indicates the depth,\n");
+        printf("# in addition to the depth being displayed.\n");
+        printf("#\n");
+        printf("# Every token in the document has a single depth determined by the tokens before it,\n");
+        printf("# and is not affected by what the token actually is.\n");
+        printf("#\n");
+        printf("# Not all structural elements are presented as tokens in the logs.\n");
+        printf("#\n");
+        printf("# We never give control to the user within an empty array or an empty object.\n");
+        printf("#\n");
+        printf("# Inside an array, having a depth greater than the array's depth means that\n");
+        printf("# we are pointing inside a value.\n");
+        printf("# Having a depth equal to the array means that we are pointing right before a value.\n");
+        printf("# Having a depth smaller than the array means that we have moved beyond the array.\n");
+        displayed_hint = true;
+      }
+      printf("\n");
+      printf("| %-*s ", LOG_EVENT_LEN, "Event");
+      printf("| %-*s ", LOG_BUFFER_LEN, "Buffer");
+      printf("| %-*s ", LOG_SMALL_BUFFER_LEN, "Next");
+      // printf("| %-*s ", 5,                    "Next#");
+      printf("| %-*s ", 5, "Depth");
+      printf("| Detail ");
+      printf("|\n");
+
+      printf("|%.*s", LOG_EVENT_LEN + 2, DASHES);
+      printf("|%.*s", LOG_BUFFER_LEN + 2, DASHES);
+      printf("|%.*s", LOG_SMALL_BUFFER_LEN + 2, DASHES);
+      // printf("|%.*s", 5+2, DASHES);
+      printf("|%.*s", 5 + 2, DASHES);
+      printf("|--------");
+      printf("|\n");
+      fflush(stdout);
+    }
   }
 }
 
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape(raw_json_string in, uint8_t *&dst, bool allow_replacement) const noexcept {
-  uint8_t *end = implementation->parse_string(in.buf, dst, allow_replacement);
-  if (!end) { return STRING_ERROR; }
-  std::string_view result(reinterpret_cast<const char *>(dst), end-dst);
-  dst = end;
-  return result;
+template <typename... Args>
+inline void log_line(const json_iterator &iter, const char *title_prefix, const char *title, std::string_view detail, int delta, int depth_delta, log_level level, Args&&... args) noexcept {
+  log_line(iter, iter.position()+delta, depth_t(iter.depth()+depth_delta), title_prefix, title, detail, level, std::forward<Args>(args)...);
 }
 
-simdjson_inline simdjson_warn_unused simdjson_result<std::string_view> parser::unescape_wobbly(raw_json_string in, uint8_t *&dst) const noexcept {
-  uint8_t *end = implementation->parse_wobbly_string(in.buf, dst);
-  if (!end) { return STRING_ERROR; }
-  std::string_view result(reinterpret_cast<const char *>(dst), end-dst);
-  dst = end;
-  return result;
+template <typename... Args>
+inline void log_line(const json_iterator &iter, token_position index, depth_t depth, const char *title_prefix, const char *title, std::string_view detail, log_level level, Args&&... args) noexcept {
+  if (LOG_ENABLED) {
+    if (simdjson_unlikely(should_log(level))) {
+      const int indent = depth * 2;
+      const auto buf = iter.token.buf;
+      auto msg = string_format(title, std::forward<Args>(args)...);
+      printf("| %*s%s%-*s ", indent, "", title_prefix,
+             LOG_EVENT_LEN - indent - int(strlen(title_prefix)), msg.c_str());
+      {
+        // Print the current structural.
+        printf("| ");
+        // Before we begin, the index might point right before the document.
+        // This could be unsafe, see https://github.com/simdjson/simdjson/discussions/1938
+        if (index < iter._root) {
+          printf("%*s", LOG_BUFFER_LEN, "");
+        } else {
+          auto current_structural = &buf[*index];
+          for (int i = 0; i < LOG_BUFFER_LEN; i++) {
+            printf("%c", printable_char(current_structural[i]));
+          }
+        }
+        printf(" ");
+      }
+      {
+        // Print the next structural.
+        printf("| ");
+        auto next_structural = &buf[*(index + 1)];
+        for (int i = 0; i < LOG_SMALL_BUFFER_LEN; i++) {
+          printf("%c", printable_char(next_structural[i]));
+        }
+        printf(" ");
+      }
+      // printf("| %5u ", *(index+1));
+      printf("| %5i ", depth);
+      printf("| %6.*s ", int(detail.size()), detail.data());
+      printf("|\n");
+      fflush(stdout);
+    }
+  }
 }
 
+} // namespace logger
 } // namespace ondemand
 } // namespace lasx
 } // namespace simdjson
 
-namespace simdjson {
-
-simdjson_inline simdjson_result<lasx::ondemand::parser>::simdjson_result(lasx::ondemand::parser &&value) noexcept
-    : implementation_simdjson_result_base<lasx::ondemand::parser>(std::forward<lasx::ondemand::parser>(value)) {}
-simdjson_inline simdjson_result<lasx::ondemand::parser>::simdjson_result(error_code error) noexcept
-    : implementation_simdjson_result_base<lasx::ondemand::parser>(error) {}
-
-} // namespace simdjson
-
-#endif // SIMDJSON_GENERIC_ONDEMAND_PARSER_INL_H
-/* end file simdjson/generic/ondemand/parser-inl.h for lasx */
-/* including simdjson/generic/ondemand/raw_json_string-inl.h for lasx: #include "simdjson/generic/ondemand/raw_json_string-inl.h" */
-/* begin file simdjson/generic/ondemand/raw_json_string-inl.h for lasx */
-#ifndef SIMDJSON_GENERIC_ONDEMAND_RAW_JSON_STRING_INL_H
+#endif // SIMDJSON_GENERIC_ONDEMAND_LOGGER_INL_H
+/* end file simdjson/generic/ondemand/logger-inl.h for lasx */
+/* including simdjson/generic/ondemand/object-inl.h for lasx: #include "simdjson/generic/ondemand/object-inl.h" */
+/* begin file simdjson/generic/ondemand/object-inl.h for lasx */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_OBJECT_INL_H
 
 /* amalgamation skipped (editor-only): #ifndef SIMDJSON_CONDITIONAL_INCLUDE */
-/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_RAW_JSON_STRING_INL_H */
+/* amalgamation skipped (editor-only): #define SIMDJSON_GENERIC_ONDEMAND_OBJECT_INL_H */
 /* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/base.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/field.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/object.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/object_iterator.h" */
 /* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/raw_json_string.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_iterator-inl.h" */
-/* amalgamation skipped (editor-only): #include "simdjson/generic/implementation_simdjson_result_base-inl.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/json_iterator.h" */
+/* amalgamation skipped (editor-only): #include "simdjson/generic/ondemand/value-inl.h" */
 /* amalgamation skipped (editor-only): #endif // SIMDJSON_CONDITIONAL_INCLUDE */
 
 namespace simdjson {
-
 namespace lasx {
 namespace ondemand {
 
@@ -121079,132 +124308,195 @@ simdjson_inline const char * raw_json_string::raw() const noexcept { return rein
 
 simdjson_inline bool raw_json_string::is_free_from_unescaped_quote(std::string_view target) noexcept {
   size_t pos{0};
-  // if the content has no escape character, just scan through it quickly!
-  for(;pos < target.size() && target[pos] != '\\';pos++) {}
-  // slow path may begin.
-  bool escaping{false};
-  for(;pos < target.size();pos++) {
-    if((target[pos] == '"') && !escaping) {
-      return false;
-    } else if(target[pos] == '\\') {
-      escaping = !escaping;
-    } else {
-      escaping = false;
+  while(pos < target.size()) {
+    pos = target.find('"', pos);
+    if(pos == std::string_view::npos) { return true; }
+    if(pos != 0 && target[pos-1] != '\\') { return false; }
+    if(pos > 1 && target[pos-2] == '\\') {
+      size_t backslash_count{2};
+      for(size_t i = 3; i <= pos; i++) {
+        if(target[pos-i] == '\\') { backslash_count++; }
+        else { break; }
+      }
+      if(backslash_count % 2 == 0) { return false; }
     }
+    pos++;
   }
-  return true;
+  return value(iter.child());
 }
 
 simdjson_inline bool raw_json_string::is_free_from_unescaped_quote(const char* target) noexcept {
   size_t pos{0};
-  // if the content has no escape character, just scan through it quickly!
-  for(;target[pos] && target[pos] != '\\';pos++) {}
-  // slow path may begin.
-  bool escaping{false};
-  for(;target[pos];pos++) {
-    if((target[pos] == '"') && !escaping) {
-      return false;
-    } else if(target[pos] == '\\') {
-      escaping = !escaping;
-    } else {
-      escaping = false;
+  while(target[pos]) {
+    const char * result = strchr(target+pos, '"');
+    if(result == nullptr) { return true; }
+    pos = result - target;
+    if(pos != 0 && target[pos-1] != '\\') { return false; }
+    if(pos > 1 && target[pos-2] == '\\') {
+      size_t backslash_count{2};
+      for(size_t i = 3; i <= pos; i++) {
+        if(target[pos-i] == '\\') { backslash_count++; }
+        else { break; }
+      }
+      if(backslash_count % 2 == 0) { return false; }
     }
+    pos++;
   }
-  return true;
+  return value(iter.child());
 }
-
-
-simdjson_inline bool raw_json_string::unsafe_is_equal(size_t length, std::string_view target) const noexcept {
-  // If we are going to call memcmp, then we must know something about the length of the raw_json_string.
-  return (length >= target.size()) && (raw()[target.size()] == '"') && !memcmp(raw(), target.data(), target.size());
+simdjson_inline simdjson_result<value> object::operator[](const std::string_view key) & noexcept {
+  return find_field_unordered(key);
 }
 
 simdjson_inline bool raw_json_string::unsafe_is_equal(std::string_view target) const noexcept {
-  // Assumptions: does not contain unescaped quote characters, and
+  // Assumptions: does not contain unescaped quote characters("), and
   // the raw content is quote terminated within a valid JSON string.
   if(target.size() <= SIMDJSON_PADDING) {
     return (raw()[target.size()] == '"') && !memcmp(raw(), target.data(), target.size());
   }
-  const char * r{raw()};
-  size_t pos{0};
-  for(;pos < target.size();pos++) {
-    if(r[pos] != target[pos]) { return false; }
+  return value(iter.child());
+}
+simdjson_inline simdjson_result<value> object::find_field(const std::string_view key) && noexcept {
+  bool has_value;
+  SIMDJSON_TRY( iter.find_field_raw(key).get(has_value) );
+  if (!has_value) {
+    logger::log_line(iter.json_iter(), "ERROR: ", "Cannot find key %.*s", "", -1, 0, logger::log_level::error, static_cast<int>(key.size()), key.data());
+    return NO_SUCH_FIELD;
   }
-  if(r[pos] != '"') { return false; }
-  return true;
+  return value(iter.child());
 }
 
-simdjson_inline bool raw_json_string::is_equal(std::string_view target) const noexcept {
-  const char * r{raw()};
-  size_t pos{0};
-  bool escaping{false};
-  for(;pos < target.size();pos++) {
-    if(r[pos] != target[pos]) { return false; }
-    // if target is a compile-time constant and it is free from
-    // quotes, then the next part could get optimized away through
-    // inlining.
-    if((target[pos] == '"') && !escaping) {
-      // We have reached the end of the raw_json_string but
-      // the target is not done.
-      return false;
-    } else if(target[pos] == '\\') {
-      escaping = !escaping;
-    } else {
-      escaping = false;
-    }
+simdjson_inline simdjson_result<object> object::start(value_iterator &iter) noexcept {
+  SIMDJSON_TRY( iter.start_object().error() );
+  return object(iter);
+}
+simdjson_inline simdjson_result<object> object::start_root(value_iterator &iter) noexcept {
+  SIMDJSON_TRY( iter.start_root_object().error() );
+  return object(iter);
+}
+simdjson_inline error_code object::consume() noexcept {
+  if(iter.is_at_key()) {
+    /**
+     * whenever you are pointing at a key, calling skip_child() is
+     * unsafe because you will hit a string and you will assume that
+     * it is string value, and this mistake will lead you to make bad
+     * depth computation.
+     */
+    /**
+     * We want to 'consume' the key. We could really
+     * just do _json_iter->return_current_and_advance(); at this
+     * point, but, for clarity, we will use the high-level API to
+     * eat the key. We assume that the compiler optimizes away
+     * most of the work.
+     */
+    simdjson_unused raw_json_string actual_key;
+    auto error = iter.field_key().get(actual_key);
+    if (error) { iter.abandon(); return error; };
+    // Let us move to the value while we are at it.
+    if ((error = iter.field_value())) { iter.abandon(); return error; }
   }
-  if(r[pos] != '"') { return false; }
-  return true;
+  auto error_skip = iter.json_iter().skip_child(iter.depth()-1);
+  if(error_skip) { iter.abandon(); }
+  return error_skip;
 }
 
+simdjson_inline simdjson_result<std::string_view> object::raw_json() noexcept {
+  const uint8_t * starting_point{iter.peek_start()};
+  auto error = consume();
+  if(error) { return error; }
+  const uint8_t * final_point{iter._json_iter->peek()};
+  return std::string_view(reinterpret_cast<const char*>(starting_point), size_t(final_point - starting_point));
+}
 
-simdjson_inline bool raw_json_string::unsafe_is_equal(const char * target) const noexcept {
-  // Assumptions: 'target' does not contain unescaped quote characters, is null terminated and
-  // the raw content is quote terminated within a valid JSON string.
-  const char * r{raw()};
-  size_t pos{0};
-  for(;target[pos];pos++) {
-    if(r[pos] != target[pos]) { return false; }
-  }
-  if(r[pos] != '"') { return false; }
-  return true;
+simdjson_inline simdjson_result<object> object::started(value_iterator &iter) noexcept {
+  SIMDJSON_TRY( iter.started_object().error() );
+  return object(iter);
 }
 
-simdjson_inline bool raw_json_string::is_equal(const char* target) const noexcept {
-  // Assumptions: does not contain unescaped quote characters, and
-  // the raw content is quote terminated within a valid JSON string.
-  const char * r{raw()};
-  size_t pos{0};
-  bool escaping{false};
-  for(;target[pos];pos++) {
-    if(r[pos] != target[pos]) { return false; }
-    // if target is a compile-time constant and it is free from
-    // quotes, then the next part could get optimized away through
-    // inlining.
-    if((target[pos] == '"') && !escaping) {
-      // We have reached the end of the raw_json_string but
-      // the target is not done.
-      return false;
-    } else if(target[pos] == '\\') {
-      escaping = !escaping;
-    } else {
-      escaping = false;
-    }
+simdjson_inline object object::resume(const value_iterator &iter) noexcept {
+  return iter;
+}
+
+simdjson_inline object::object(const value_iterator &_iter) noexcept
+  : iter{_iter}
+{
+}
+
+simdjson_inline simdjson_result<object_iterator> object::begin() noexcept {
+#if SIMDJSON_DEVELOPMENT_CHECKS
+  if (!iter.is_at_iterator_start()) { return OUT_OF_ORDER_ITERATION; }
+#endif
+  return object_iterator(iter);
+}
+simdjson_inline simdjson_result<object_iterator> object::end() noexcept {
+  return object_iterator(iter);
+}
+
+inline simdjson_result<value> object::at_pointer(std::string_view json_pointer) noexcept {
+  if (json_pointer[0] != '/') { return INVALID_JSON_POINTER; }
+  json_pointer = json_pointer.substr(1);
+  size_t slash = json_pointer.find('/');
+  std::string_view key = json_pointer.substr(0, slash);
+  // Grab the child with the given key
+  simdjson_result<value> child;
+
+  // If there is an escape character in the key, unescape it and then get the child.
+  size_t escape = key.find('~');
+  if (escape != std::string_view::npos) {
+    // Unescape the key
+    std::string unescaped(key);
+    do {
+      switch (unescaped[escape+1]) {
+        case '0':
+          unescaped.replace(escape, 2, "~");
+          break;
+        case '1':
+          unescaped.replace(escape, 2, "/");
+          break;
+        default:
+          return INVALID_JSON_POINTER; // "Unexpected ~ escape character in JSON pointer");
+      }
+      escape = unescaped.find('~', escape+1);
+    } while (escape != std::string::npos);
+    child = find_field(unescaped);  // Take note find_field does not unescape keys when matching
+  } else {
+    child = find_field(key);
   }
-  if(r[pos] != '"') { return false; }
-  return true;
+  if(child.error()) {
+    return child; // we do not continue if there was an error
+  }
+  // If there is a /, we have to recurse and look up more of the path
+  if (slash != std::string_view::npos) {
+    child = child.at_pointer(json_pointer.substr(slash));
+  }
+  return child;
 }
 
-simdjson_unused simdjson_inline bool operator==(const raw_json_string &a, std::string_view c) noexcept {
-  return a.unsafe_is_equal(c);
+inline simdjson_result<value> object::at_path(std::string_view json_path) noexcept {
+  auto json_pointer = json_path_to_pointer_conversion(json_path);
+  if (json_pointer == "-1") {
+    return INVALID_JSON_POINTER;
+  }
+  return at_pointer(json_pointer);
 }
 
-simdjson_unused simdjson_inline bool operator==(std::string_view c, const raw_json_string &a) noexcept {
-  return a == c;
+simdjson_inline simdjson_result<size_t> object::count_fields() & noexcept {
+  size_t count{0};
+  // Important: we do not consume any of the values.
+  for(simdjson_unused auto v : *this) { count++; }
+  // The above loop will always succeed, but we want to report errors.
+  if(iter.error()) { return iter.error(); }
+  // We need to move back at the start because we expect users to iterate through
+  // the object after counting the number of elements.
+  iter.reset_object();
+  return count;
 }
 
-simdjson_unused simdjson_inline bool operator!=(const raw_json_string &a, std::string_view c) noexcept {
-  return !(a == c);
+simdjson_inline simdjson_result<bool> object::is_empty() & noexcept {
+  bool is_not_empty;
+  auto error = iter.reset_object().get(is_not_empty);
+  if(error) { return error; }
+  return !is_not_empty;
 }
 
 simdjson_unused simdjson_inline bool operator!=(std::string_view c, const raw_json_string &a) noexcept {