From 786c68b1586b5fd004d205f28d0031a68292dcea Mon Sep 17 00:00:00 2001
From: Daniel Lemire <daniel@lemire.me>
Date: Thu, 18 Sep 2025 15:17:32 -0600
Subject: [PATCH] release 4.0.5

---
 CMakeLists.txt                      |   2 +-
 Doxyfile                            |   2 +-
 include/simdjson/simdjson_version.h |   4 +-
 singleheader/simdjson.cpp           |   2 +-
 singleheader/simdjson.h             | 230 ++++++++++++++++++++++------
 singleheader/singleheader.zip       | Bin 8255469 -> 8263839 bytes
 6 files changed, 184 insertions(+), 56 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index cdf0398e4..6ca301252 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.14)
 project(
     simdjson
     # The version number is modified by tools/release.py
-    VERSION 4.0.4
+    VERSION 4.0.5
     DESCRIPTION "Parsing gigabytes of JSON per second"
     HOMEPAGE_URL "https://simdjson.org/"
     LANGUAGES CXX C
diff --git a/Doxyfile b/Doxyfile
index 8a6613150..a5e26a063 100644
--- a/Doxyfile
+++ b/Doxyfile
@@ -38,7 +38,7 @@ PROJECT_NAME           = simdjson
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = "4.0.4"
+PROJECT_NUMBER         = "4.0.5"
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
diff --git a/include/simdjson/simdjson_version.h b/include/simdjson/simdjson_version.h
index 35baebf9f..c76eac1fd 100644
--- a/include/simdjson/simdjson_version.h
+++ b/include/simdjson/simdjson_version.h
@@ -4,7 +4,7 @@
 #define SIMDJSON_SIMDJSON_VERSION_H
 
 /** The version of simdjson being used (major.minor.revision) */
-#define SIMDJSON_VERSION "4.0.4"
+#define SIMDJSON_VERSION "4.0.5"
 
 namespace simdjson {
 enum {
@@ -19,7 +19,7 @@ enum {
   /**
    * The revision (major.minor.REVISION) of simdjson being used.
    */
-  SIMDJSON_VERSION_REVISION = 4
+  SIMDJSON_VERSION_REVISION = 5
 };
 } // namespace simdjson
 
diff --git a/singleheader/simdjson.cpp b/singleheader/simdjson.cpp
index 09a1ed591..444793391 100644
--- a/singleheader/simdjson.cpp
+++ b/singleheader/simdjson.cpp
@@ -1,4 +1,4 @@
-/* auto-generated on 2025-09-17 18:58:25 -0600. version 4.0.4 Do not edit! */
+/* auto-generated on 2025-09-18 15:16:38 -0600. version 4.0.5 Do not edit! */
 /* including simdjson.cpp:  */
 /* begin file simdjson.cpp */
 #define SIMDJSON_SRC_SIMDJSON_CPP
diff --git a/singleheader/simdjson.h b/singleheader/simdjson.h
index 6060be00f..d43cba637 100644
--- a/singleheader/simdjson.h
+++ b/singleheader/simdjson.h
@@ -1,4 +1,4 @@
-/* auto-generated on 2025-09-17 18:58:25 -0600. version 4.0.4 Do not edit! */
+/* auto-generated on 2025-09-18 15:16:38 -0600. version 4.0.5 Do not edit! */
 /* including simdjson.h:  */
 /* begin file simdjson.h */
 #ifndef SIMDJSON_H
@@ -2508,7 +2508,7 @@ namespace std {
 #define SIMDJSON_SIMDJSON_VERSION_H
 
 /** The version of simdjson being used (major.minor.revision) */
-#define SIMDJSON_VERSION "4.0.4"
+#define SIMDJSON_VERSION "4.0.5"
 
 namespace simdjson {
 enum {
@@ -2523,7 +2523,7 @@ enum {
   /**
    * The revision (major.minor.REVISION) of simdjson being used.
    */
-  SIMDJSON_VERSION_REVISION = 4
+  SIMDJSON_VERSION_REVISION = 5
 };
 } // namespace simdjson
 
@@ -44853,7 +44853,9 @@ struct string_constant {
  */
 class string_builder {
 public:
-  simdjson_inline string_builder(size_t initial_capacity = 1024);
+  simdjson_inline string_builder(size_t initial_capacity = DEFAULT_INITIAL_CAPACITY);
+
+  static constexpr size_t DEFAULT_INITIAL_CAPACITY = 1024;
 
   /**
    * Append number (includes Booleans). Booleans are mapped to the strings
@@ -45067,7 +45069,7 @@ private:
 #if !SIMDJSON_STATIC_REFLECTION
 // fallback implementation until we have static reflection
 template <class Z>
-simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = simdjson::arm64::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
   simdjson::arm64::builder::string_builder b(initial_capacity);
   b.append(z);
   std::string_view s;
@@ -45075,6 +45077,16 @@ simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024)
   if(e) { return e; }
   return std::string(s);
 }
+template <class Z>
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = simdjson::arm64::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+  simdjson::arm64::builder::string_builder b(initial_capacity);
+  b.append(z);
+  std::string_view sv;
+  auto e = b.view().get(sv);
+  if(e) { return e; }
+  s.assign(sv.data(), sv.size());
+  return simdjson::SUCCESS;
+}
 #endif
 
 
@@ -46038,7 +46050,7 @@ void append(string_builder &b, const Z &z) {
 }
 
 template <class Z>
-simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
   string_builder b(initial_capacity);
   append(b, z);
   std::string_view s;
@@ -46047,8 +46059,8 @@ simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity
 }
 
 template <class Z>
-simdjson_error to_json(const Z &z, std::string &s) {
-  string_builder b;
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
+  string_builder b(initial_capacity);
   append(b, z);
   std::string_view view;
   if(auto e = b.view().get(view); e) { return e; }
@@ -46065,9 +46077,13 @@ string_builder& operator<<(string_builder& b, const Z& z) {
 } // namespace arm64
 // Alias the function template to 'to' in the global namespace
 template <class Z>
-simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = arm64::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
   return arm64::builder::to_json_string(z, initial_capacity);
 }
+template <class Z>
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = arm64::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+  return arm64::builder::to_json(z, s, initial_capacity);
+}
 } // namespace simdjson
 
 #endif // SIMDJSON_STATIC_REFLECTION
@@ -57867,7 +57883,9 @@ struct string_constant {
  */
 class string_builder {
 public:
-  simdjson_inline string_builder(size_t initial_capacity = 1024);
+  simdjson_inline string_builder(size_t initial_capacity = DEFAULT_INITIAL_CAPACITY);
+
+  static constexpr size_t DEFAULT_INITIAL_CAPACITY = 1024;
 
   /**
    * Append number (includes Booleans). Booleans are mapped to the strings
@@ -58081,7 +58099,7 @@ private:
 #if !SIMDJSON_STATIC_REFLECTION
 // fallback implementation until we have static reflection
 template <class Z>
-simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = simdjson::fallback::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
   simdjson::fallback::builder::string_builder b(initial_capacity);
   b.append(z);
   std::string_view s;
@@ -58089,6 +58107,16 @@ simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024)
   if(e) { return e; }
   return std::string(s);
 }
+template <class Z>
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = simdjson::fallback::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+  simdjson::fallback::builder::string_builder b(initial_capacity);
+  b.append(z);
+  std::string_view sv;
+  auto e = b.view().get(sv);
+  if(e) { return e; }
+  s.assign(sv.data(), sv.size());
+  return simdjson::SUCCESS;
+}
 #endif
 
 
@@ -59052,7 +59080,7 @@ void append(string_builder &b, const Z &z) {
 }
 
 template <class Z>
-simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
   string_builder b(initial_capacity);
   append(b, z);
   std::string_view s;
@@ -59061,8 +59089,8 @@ simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity
 }
 
 template <class Z>
-simdjson_error to_json(const Z &z, std::string &s) {
-  string_builder b;
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
+  string_builder b(initial_capacity);
   append(b, z);
   std::string_view view;
   if(auto e = b.view().get(view); e) { return e; }
@@ -59079,9 +59107,13 @@ string_builder& operator<<(string_builder& b, const Z& z) {
 } // namespace fallback
 // Alias the function template to 'to' in the global namespace
 template <class Z>
-simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = fallback::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
   return fallback::builder::to_json_string(z, initial_capacity);
 }
+template <class Z>
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = fallback::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+  return fallback::builder::to_json(z, s, initial_capacity);
+}
 } // namespace simdjson
 
 #endif // SIMDJSON_STATIC_REFLECTION
@@ -71380,7 +71412,9 @@ struct string_constant {
  */
 class string_builder {
 public:
-  simdjson_inline string_builder(size_t initial_capacity = 1024);
+  simdjson_inline string_builder(size_t initial_capacity = DEFAULT_INITIAL_CAPACITY);
+
+  static constexpr size_t DEFAULT_INITIAL_CAPACITY = 1024;
 
   /**
    * Append number (includes Booleans). Booleans are mapped to the strings
@@ -71594,7 +71628,7 @@ private:
 #if !SIMDJSON_STATIC_REFLECTION
 // fallback implementation until we have static reflection
 template <class Z>
-simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = simdjson::haswell::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
   simdjson::haswell::builder::string_builder b(initial_capacity);
   b.append(z);
   std::string_view s;
@@ -71602,6 +71636,16 @@ simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024)
   if(e) { return e; }
   return std::string(s);
 }
+template <class Z>
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = simdjson::haswell::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+  simdjson::haswell::builder::string_builder b(initial_capacity);
+  b.append(z);
+  std::string_view sv;
+  auto e = b.view().get(sv);
+  if(e) { return e; }
+  s.assign(sv.data(), sv.size());
+  return simdjson::SUCCESS;
+}
 #endif
 
 
@@ -72565,7 +72609,7 @@ void append(string_builder &b, const Z &z) {
 }
 
 template <class Z>
-simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
   string_builder b(initial_capacity);
   append(b, z);
   std::string_view s;
@@ -72574,8 +72618,8 @@ simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity
 }
 
 template <class Z>
-simdjson_error to_json(const Z &z, std::string &s) {
-  string_builder b;
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
+  string_builder b(initial_capacity);
   append(b, z);
   std::string_view view;
   if(auto e = b.view().get(view); e) { return e; }
@@ -72592,9 +72636,13 @@ string_builder& operator<<(string_builder& b, const Z& z) {
 } // namespace haswell
 // Alias the function template to 'to' in the global namespace
 template <class Z>
-simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = haswell::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
   return haswell::builder::to_json_string(z, initial_capacity);
 }
+template <class Z>
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = haswell::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+  return haswell::builder::to_json(z, s, initial_capacity);
+}
 } // namespace simdjson
 
 #endif // SIMDJSON_STATIC_REFLECTION
@@ -84893,7 +84941,9 @@ struct string_constant {
  */
 class string_builder {
 public:
-  simdjson_inline string_builder(size_t initial_capacity = 1024);
+  simdjson_inline string_builder(size_t initial_capacity = DEFAULT_INITIAL_CAPACITY);
+
+  static constexpr size_t DEFAULT_INITIAL_CAPACITY = 1024;
 
   /**
    * Append number (includes Booleans). Booleans are mapped to the strings
@@ -85107,7 +85157,7 @@ private:
 #if !SIMDJSON_STATIC_REFLECTION
 // fallback implementation until we have static reflection
 template <class Z>
-simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = simdjson::icelake::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
   simdjson::icelake::builder::string_builder b(initial_capacity);
   b.append(z);
   std::string_view s;
@@ -85115,6 +85165,16 @@ simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024)
   if(e) { return e; }
   return std::string(s);
 }
+template <class Z>
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = simdjson::icelake::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+  simdjson::icelake::builder::string_builder b(initial_capacity);
+  b.append(z);
+  std::string_view sv;
+  auto e = b.view().get(sv);
+  if(e) { return e; }
+  s.assign(sv.data(), sv.size());
+  return simdjson::SUCCESS;
+}
 #endif
 
 
@@ -86078,7 +86138,7 @@ void append(string_builder &b, const Z &z) {
 }
 
 template <class Z>
-simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
   string_builder b(initial_capacity);
   append(b, z);
   std::string_view s;
@@ -86087,8 +86147,8 @@ simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity
 }
 
 template <class Z>
-simdjson_error to_json(const Z &z, std::string &s) {
-  string_builder b;
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
+  string_builder b(initial_capacity);
   append(b, z);
   std::string_view view;
   if(auto e = b.view().get(view); e) { return e; }
@@ -86105,9 +86165,13 @@ string_builder& operator<<(string_builder& b, const Z& z) {
 } // namespace icelake
 // Alias the function template to 'to' in the global namespace
 template <class Z>
-simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = icelake::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
   return icelake::builder::to_json_string(z, initial_capacity);
 }
+template <class Z>
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = icelake::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+  return icelake::builder::to_json(z, s, initial_capacity);
+}
 } // namespace simdjson
 
 #endif // SIMDJSON_STATIC_REFLECTION
@@ -98521,7 +98585,9 @@ struct string_constant {
  */
 class string_builder {
 public:
-  simdjson_inline string_builder(size_t initial_capacity = 1024);
+  simdjson_inline string_builder(size_t initial_capacity = DEFAULT_INITIAL_CAPACITY);
+
+  static constexpr size_t DEFAULT_INITIAL_CAPACITY = 1024;
 
   /**
    * Append number (includes Booleans). Booleans are mapped to the strings
@@ -98735,7 +98801,7 @@ private:
 #if !SIMDJSON_STATIC_REFLECTION
 // fallback implementation until we have static reflection
 template <class Z>
-simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = simdjson::ppc64::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
   simdjson::ppc64::builder::string_builder b(initial_capacity);
   b.append(z);
   std::string_view s;
@@ -98743,6 +98809,16 @@ simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024)
   if(e) { return e; }
   return std::string(s);
 }
+template <class Z>
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = simdjson::ppc64::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+  simdjson::ppc64::builder::string_builder b(initial_capacity);
+  b.append(z);
+  std::string_view sv;
+  auto e = b.view().get(sv);
+  if(e) { return e; }
+  s.assign(sv.data(), sv.size());
+  return simdjson::SUCCESS;
+}
 #endif
 
 
@@ -99706,7 +99782,7 @@ void append(string_builder &b, const Z &z) {
 }
 
 template <class Z>
-simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
   string_builder b(initial_capacity);
   append(b, z);
   std::string_view s;
@@ -99715,8 +99791,8 @@ simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity
 }
 
 template <class Z>
-simdjson_error to_json(const Z &z, std::string &s) {
-  string_builder b;
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
+  string_builder b(initial_capacity);
   append(b, z);
   std::string_view view;
   if(auto e = b.view().get(view); e) { return e; }
@@ -99733,9 +99809,13 @@ string_builder& operator<<(string_builder& b, const Z& z) {
 } // namespace ppc64
 // Alias the function template to 'to' in the global namespace
 template <class Z>
-simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = ppc64::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
   return ppc64::builder::to_json_string(z, initial_capacity);
 }
+template <class Z>
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = ppc64::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+  return ppc64::builder::to_json(z, s, initial_capacity);
+}
 } // namespace simdjson
 
 #endif // SIMDJSON_STATIC_REFLECTION
@@ -112465,7 +112545,9 @@ struct string_constant {
  */
 class string_builder {
 public:
-  simdjson_inline string_builder(size_t initial_capacity = 1024);
+  simdjson_inline string_builder(size_t initial_capacity = DEFAULT_INITIAL_CAPACITY);
+
+  static constexpr size_t DEFAULT_INITIAL_CAPACITY = 1024;
 
   /**
    * Append number (includes Booleans). Booleans are mapped to the strings
@@ -112679,7 +112761,7 @@ private:
 #if !SIMDJSON_STATIC_REFLECTION
 // fallback implementation until we have static reflection
 template <class Z>
-simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = simdjson::westmere::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
   simdjson::westmere::builder::string_builder b(initial_capacity);
   b.append(z);
   std::string_view s;
@@ -112687,6 +112769,16 @@ simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024)
   if(e) { return e; }
   return std::string(s);
 }
+template <class Z>
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = simdjson::westmere::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+  simdjson::westmere::builder::string_builder b(initial_capacity);
+  b.append(z);
+  std::string_view sv;
+  auto e = b.view().get(sv);
+  if(e) { return e; }
+  s.assign(sv.data(), sv.size());
+  return simdjson::SUCCESS;
+}
 #endif
 
 
@@ -113650,7 +113742,7 @@ void append(string_builder &b, const Z &z) {
 }
 
 template <class Z>
-simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
   string_builder b(initial_capacity);
   append(b, z);
   std::string_view s;
@@ -113659,8 +113751,8 @@ simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity
 }
 
 template <class Z>
-simdjson_error to_json(const Z &z, std::string &s) {
-  string_builder b;
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
+  string_builder b(initial_capacity);
   append(b, z);
   std::string_view view;
   if(auto e = b.view().get(view); e) { return e; }
@@ -113677,9 +113769,13 @@ string_builder& operator<<(string_builder& b, const Z& z) {
 } // namespace westmere
 // Alias the function template to 'to' in the global namespace
 template <class Z>
-simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = westmere::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
   return westmere::builder::to_json_string(z, initial_capacity);
 }
+template <class Z>
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = westmere::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+  return westmere::builder::to_json(z, s, initial_capacity);
+}
 } // namespace simdjson
 
 #endif // SIMDJSON_STATIC_REFLECTION
@@ -125886,7 +125982,9 @@ struct string_constant {
  */
 class string_builder {
 public:
-  simdjson_inline string_builder(size_t initial_capacity = 1024);
+  simdjson_inline string_builder(size_t initial_capacity = DEFAULT_INITIAL_CAPACITY);
+
+  static constexpr size_t DEFAULT_INITIAL_CAPACITY = 1024;
 
   /**
    * Append number (includes Booleans). Booleans are mapped to the strings
@@ -126100,7 +126198,7 @@ private:
 #if !SIMDJSON_STATIC_REFLECTION
 // fallback implementation until we have static reflection
 template <class Z>
-simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = simdjson::lsx::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
   simdjson::lsx::builder::string_builder b(initial_capacity);
   b.append(z);
   std::string_view s;
@@ -126108,6 +126206,16 @@ simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024)
   if(e) { return e; }
   return std::string(s);
 }
+template <class Z>
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = simdjson::lsx::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+  simdjson::lsx::builder::string_builder b(initial_capacity);
+  b.append(z);
+  std::string_view sv;
+  auto e = b.view().get(sv);
+  if(e) { return e; }
+  s.assign(sv.data(), sv.size());
+  return simdjson::SUCCESS;
+}
 #endif
 
 
@@ -127071,7 +127179,7 @@ void append(string_builder &b, const Z &z) {
 }
 
 template <class Z>
-simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
   string_builder b(initial_capacity);
   append(b, z);
   std::string_view s;
@@ -127080,8 +127188,8 @@ simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity
 }
 
 template <class Z>
-simdjson_error to_json(const Z &z, std::string &s) {
-  string_builder b;
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
+  string_builder b(initial_capacity);
   append(b, z);
   std::string_view view;
   if(auto e = b.view().get(view); e) { return e; }
@@ -127098,9 +127206,13 @@ string_builder& operator<<(string_builder& b, const Z& z) {
 } // namespace lsx
 // Alias the function template to 'to' in the global namespace
 template <class Z>
-simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = lsx::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
   return lsx::builder::to_json_string(z, initial_capacity);
 }
+template <class Z>
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = lsx::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+  return lsx::builder::to_json(z, s, initial_capacity);
+}
 } // namespace simdjson
 
 #endif // SIMDJSON_STATIC_REFLECTION
@@ -139320,7 +139432,9 @@ struct string_constant {
  */
 class string_builder {
 public:
-  simdjson_inline string_builder(size_t initial_capacity = 1024);
+  simdjson_inline string_builder(size_t initial_capacity = DEFAULT_INITIAL_CAPACITY);
+
+  static constexpr size_t DEFAULT_INITIAL_CAPACITY = 1024;
 
   /**
    * Append number (includes Booleans). Booleans are mapped to the strings
@@ -139534,7 +139648,7 @@ private:
 #if !SIMDJSON_STATIC_REFLECTION
 // fallback implementation until we have static reflection
 template <class Z>
-simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = simdjson::lasx::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
   simdjson::lasx::builder::string_builder b(initial_capacity);
   b.append(z);
   std::string_view s;
@@ -139542,6 +139656,16 @@ simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024)
   if(e) { return e; }
   return std::string(s);
 }
+template <class Z>
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = simdjson::lasx::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+  simdjson::lasx::builder::string_builder b(initial_capacity);
+  b.append(z);
+  std::string_view sv;
+  auto e = b.view().get(sv);
+  if(e) { return e; }
+  s.assign(sv.data(), sv.size());
+  return simdjson::SUCCESS;
+}
 #endif
 
 
@@ -140505,7 +140629,7 @@ void append(string_builder &b, const Z &z) {
 }
 
 template <class Z>
-simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
   string_builder b(initial_capacity);
   append(b, z);
   std::string_view s;
@@ -140514,8 +140638,8 @@ simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity
 }
 
 template <class Z>
-simdjson_error to_json(const Z &z, std::string &s) {
-  string_builder b;
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
+  string_builder b(initial_capacity);
   append(b, z);
   std::string_view view;
   if(auto e = b.view().get(view); e) { return e; }
@@ -140532,9 +140656,13 @@ string_builder& operator<<(string_builder& b, const Z& z) {
 } // namespace lasx
 // Alias the function template to 'to' in the global namespace
 template <class Z>
-simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = lasx::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
   return lasx::builder::to_json_string(z, initial_capacity);
 }
+template <class Z>
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = lasx::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+  return lasx::builder::to_json(z, s, initial_capacity);
+}
 } // namespace simdjson
 
 #endif // SIMDJSON_STATIC_REFLECTION
diff --git a/singleheader/singleheader.zip b/singleheader/singleheader.zip
index b88c12d2f290e8cdb74cb5ce5f6bfe053f3ff98b..9c3e6c26c4d1b1f53b853e746d618a4e92a35467 100644
GIT binary patch
delta 5439
zcmd6rYfMvT7{}#OXepFR3$-9p?i8`KNC9z3E4Lj5Rsm645wReG<svPpXpLgtH5=@m
z(~T!F6O)a^7@b^VJ(^|1?c3aRe$vUZjb$J9VO~hw#y+^q19$<4rv*c#$uDhB&-v$l
zpZDMA{hxF1!I;<Sfxo<h4C}qTrHjU2N$n{np5~$By`Z#+424FUsY%ORnW0#rPE)H@
zinf{-Yh6>LB2}eUY2jRNO#Bf_s0X2*gnAL`O(>60A3}Wz<r69()Q?ahq5gyh5Go=x
zkWew9iwO-PR6?kf&|pGC2$d1Kgitx5p@fDJx|GmxLYEO5L8yYzNJ66sjds$QFFzKI
z4{-OJ=ifhT-LmMc6}I)ps9X)yfdggF^~TCqdTOIiXf!hRhug6w9v)iw;&Yt@M!%LU
zgOb~^K>$m<gQ4eEY>1=hPAn3K#3Koa5=lgsBT2{#M1>?HYD9yiAS;nnM2n;$=|~2$
z3duxPBd;M@$QriiPIl?9^4z?9{l>zwN~V}8WAufUIeLRWhbh~l1U>5^gZ|>ZBH8o5
zDY6tAbxJDh@u4kE4qdzC!C<(P83aQ@lc3vF5)b=^bqS%FnJ?0YmSNo`=uU1CgJM|c
zKdHbo=@Z~;&}spk6qzLMNYr|?!OzL&FnoKr%NPcR0FyvsZBtcO*{TwhNecXEt!uAI
z0NuSJnQ!UFoSeMUQW)wo9)}wPe1A|^u8x7`-9`zBhc^fz{IfM`(5V<H7&PYfa7vpk
zguqOFA$yOtMe{z;@q(Z~OD|-vpD=co!`00`DIl&B@L@C=FA-96-uNYII84nFwsV!f
zRWZFX=?PX_OI>4a<&M@mOLa{PM|p~j`pYvFWmXDB(A;l+I6h7vsM@MGO&`s~I`OJn
z8q!kXnA0ZbS}o5CeJ=NExi1vMOK8WH0dXJG4Lvr#z;UBOkE}&<kX$4W$wvy<8x^mQ
zT$~?^9wB-uFiDJzYv##G%oXmLgS$HQb2n>6C&LHDK<@G>X1zO>uX_5`XVS6X?1>h!
zwJOGDpT5?w$a#j~C;?<&U}kb2WG69^T$LZWz!bQsyc-hnlWudM+mLn0dZZ93LW+?$
z5Cbdj+wgnf{P;|&T_=H_?>5LHUi^nwDh~K5Ao3T3bo|WIF6KRZMZ?^^H)<*og06R6
z{Dj$9Y?QJ?3&UMHY`t$AOJ;JH@2)EA-WrQ#qO*l@)E$~1_y>dDRHEjt`RoLPpLTd#
zQ)RuisqtCMb6`D@Qlt#oh?FCnkj=;zcGP4%88SakjOr+tKunj>4JUS#OUKW2<;2-5
z&dG@^ZrS%2hU>&{1@J*EGR@>V2<tK`xO&=v$du3RGj}B79{02nk;yS4+KN;l+mK3R
zJ5q)0U`Iq|x$pcq>F9COVmR)!aqgY%$!1p>&t09D2zvjD%sfz>mMjK!ClfIq@8n>h
zcx<G2N8Gawl*Pz*`BiV5EC#kRkLlfYGN&~+o88E1euHLLIn8aMX*uml5xpI^2F*w{
zQiJS7YLQ(?9a7KU8r<z$F+Zm3@2Hl-KBa}zbla2`SAor4otFq~{-4VE(0r<TYG9+L
z`u_zsJjQ2_Ew{A4YUfSfDyTQr3ZU_vWya>#sI+hfw!rfiSAoq9iN}F$^7de&jQ!yu
z-Z0q5tO8wl$V62`;pR=Vpj)lw!S%pUA&5W9@Por00fI|-$P<2A<DCpYI?aBNILNGk
z-x?AlAiLk<=Xlg-K^l-oqzP$8_8={19`#x8&W~-6I&E=Wn}XeGyXaz5a6_VI?g?-E
zShyb;;`U753SVMvV++HLqp_jhP@dj8qZ{9G+Lm%vbu7Jgt&6I<ArUq8W)<t?>ln&t
zMcR<P$UbC0(vBQphcXV<{xLr$`lP@f&o$jM1$L*4>AE4YbM7Yk=g&wX7`|^)PVTUO
zCmu+i@+c)M_@E#AEo0xhFr2l$VHpoPzp~HdEKf@nP^T@7tJ+D|>^a=kc2gyKioe+V
f*X&1=_)ngJ!u~OP%JUB#uZ-DMKC&f;@LB19bYp<-

delta 2081
zcma*peN0<b6aerQN@>gYM+=1kg_SYJD6g!1qkD92tOK`4fjOvrtz(oA2X1AEScWDy
z4O_gEm~di(P!$v7f`J5hBxc$fl_e^|jBZQjMl``poRSzt{YOvxoHmTGHu)ueugyK@
z+;i`JZ*1xh|NFnJ`$uwR{^ICu?oS=)%p((TkfF%jq&&4Qzc44iFgr(`$>cJOR(-Dd
z%-Pn?(`vnz(dyyyxF+pIN~nlXKSKQp6%!gjsD#i!LZyVt2$d5WL})OfA%un!8b)Y1
zp%H{e5*kHlG@%MYm4wC+8cV2(&^SWl3EfU;0-=e7CK0M8G?~y8LU+ti%|~yAx)Xdi
z;-+EURI_c}1oh(@?V}QPV50ox@l@4bKYhxpI$aF^?Tu8ENTi3WAFxrd_E}USm~Ny-
z0>p|HF#1iZ(lL4~741Z6XctOHyHN((gEEm8Wg!OXP&V3&^e6}AqCAw33Q!>`LdEDY
z^f*6yYhUFL0XimIpUzKdI&xLe)_X7#xCI*{^W0VU$<?s$Hk%HUx7h;VbjG9bwZTGR
zVM-bdOhb_dTuZh@IA2r}z_WMQb-OUa+J_x^V)qDeHO@Q-7wSrOxxXp-sfzAc5x9;^
zBv9N?V*Wp#@b8$W5*+apiyD@zy3fO?O)7KTZ7M+qv>!cz4xodml)u|_XnFdP1q=<A
zD28>$F(LK$hKy3^8Zt64*<ud`<_;SK6HBF9cO@!NU$>RHFQwobES2zcdZW#^nm9#@
z4D>U`hiXcmHI@qHcp^JfG-AgJZ$yVt87fClq9f=i;`kN5!W6c7UBX0t`CUb;S39)M
z;2?O#YEll5)Mi0{6qo5$4PFKUTXRGL3$BWC-gVu!BLEf?gQNM0A1hXSeCim-%A_#X
zY<j4=ffmzFua0>VVS2N~4$f*qm8c3;qhshPbR5<2oVE6%a;p+Wuhq^89drFz8wgoy
zbKLAmZBf5Z`GyaMNWqX`_R3d?1xwlp1r#Ki!@aWh1fZolDb&nca-g3Jk9DwWGkO};
zp?cJS8c`EE!Lw>hnq;f|FS3?d9yiNP-!fj7pO9?GSZMXjpIW^4#1)Z3=BS>xpp&Q>
zokA_hids<{Up?O*Shsm{UK_jVK)V9M*$&QYB?Z5)lEU)1HAC3gAzf|W8^b<r4TVF0
z)jn87&SIs)y^4m9fivEk0*l{Q?1n{c_hCqAY|97dkTDc+#3*22Z;l6MrZB*LPX<>m
z)JUPxV9Iy@>WL@eao9`#;2E**Z40;Er#@p;*@jvBx6e#aoDx3&xWl{8o?w#+N-^LB
z766-|^u&$>Zp9)SW^w}Hi?FyL2!AtQ4g)WR$Y$}DpCjyA2YLpbMxCe&J&VrpVb{)H
z`f2lt7P{wJuuTiAxN$u}4(zE;4UY$n+=oTcBieX8&Qx|A9C$LKbEpSBhkDWTsE=Q+
zdg1<WTcxvh(mo@k<6N~%Va?E+=5BNnl)3uS|2s3v;peY<1NnEX_Ie)<Ka~g;!xF_H
zzi0Q_ZbJFL-m~v_AASSy_wUI#;;OxGkMzM)9x`J4vo}6c+hhB+lIC?gz76~XCDcyM