updating single

fixing incorrect max/min usage
minor tweaks to style
2026-06-08 17:27:07 +00:00 · 2024-09-27 09:26:51 -04:00 · 2024-09-27 09:24:23 -04:00 · 2024-09-26 21:03:50 -04:00 · 2024-09-26 20:49:28 -04:00 · 2024-09-26 20:38:31 -04:00
153 changed files with 2520 additions and 20415 deletions
@@ -25,7 +25,6 @@ CompileFlags:
 Diagnostics:
    Suppress:
        - pp_including_mainfile_in_preamble
        - unused-includes
 ---
 # Amalgamated files that require or partly define an implementation
 If:
@@ -13,7 +13,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
-      - uses: uraimo/run-on-arch-action@v3
+      - uses: uraimo/run-on-arch-action@v2
        name: Test
        id: runcmd
        with:
@@ -1,8 +1,9 @@
 name: Doxygen GitHub Pages
 on:
-  release:
+  push:
-    types: [created]
+    branches:
      - master
  # Allows you to run this workflow manually from the Actions tab
  workflow_dispatch:
@@ -24,7 +24,7 @@ jobs:
      implementations: haswell westmere fallback
      UBSAN_OPTIONS: halt_on_error=1
      MAXLEN: -max_len=4000
-      CLANGVERSION: 19
+      CLANGVERSION: 15
      # which optimization level to use for the sanitizer build (see build_fuzzer.variants.sh)
      OPTLEVEL: -O3
@@ -125,7 +125,7 @@ jobs:
        done
    - name: Save the corpus as a github artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v3
      with:
        name: corpus
        path: corpus.tar
@@ -148,7 +148,7 @@ jobs:
      run: tar cf valgrind.tar valgrind-*.txt
    - name: Save valgrind output as a github artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v3
      if: always()
      with:
        name: valgrindresults
@@ -156,7 +156,7 @@ jobs:
        if-no-files-found: ignore
    - name: Archive any crashes as an artifact
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v3
      if: always()
      with:
        name: crashes
@@ -20,7 +20,7 @@ jobs:
          - msystem: "MINGW64"
            install: mingw-w64-x86_64-libxml2 mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-clang
            type: Debug
-          - msystem: "MINGW64"
+            - msystem: "MINGW64"
            install: mingw-w64-x86_64-libxml2 mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-clang
            type: RelWithDebInfo
    env:
@@ -13,7 +13,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
-      - uses: uraimo/run-on-arch-action@v3
+      - uses: uraimo/run-on-arch-action@v2
        name: Test
        id: runcmd
        with:
@@ -13,7 +13,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
-      - uses: uraimo/run-on-arch-action@v3
+      - uses: uraimo/run-on-arch-action@v2
        name: Test
        id: runcmd
        with:
@@ -13,7 +13,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
-      - uses: uraimo/run-on-arch-action@v3
+      - uses: uraimo/run-on-arch-action@v2
        name: Test
        id: runcmd
        with:
@@ -10,6 +10,7 @@ jobs:
       fail-fast: false
       matrix:
         include:
           - {arch: ARM}
           - {arch: ARM64}
           - {arch: ARM64EC}
     steps:
@@ -18,4 +19,4 @@ jobs:
       - name: Use cmake
         run: |
           cmake -A ${{ matrix.arch }} -DCMAKE_SYSTEM_VERSION="10.0.22621.0" -DCMAKE_CROSSCOMPILING=1 -DSIMDJSON_DEVELOPER_MODE=ON -D SIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_EXCEPTIONS=OFF -B build  &&
-           cmake --build build --verbose
+           cmake --build build --verbose
@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.14)
 project(
    simdjson
    # The version number is modified by tools/release.py
-    VERSION 3.12.2
+    VERSION 3.10.0
    DESCRIPTION "Parsing gigabytes of JSON per second"
    HOMEPAGE_URL "https://simdjson.org/"
    LANGUAGES CXX C
@@ -20,14 +20,10 @@ string(
 # ---- Options, variables ----
 # These version numbers are modified by tools/release.py
-set(SIMDJSON_LIB_VERSION "25.0.0" CACHE STRING "simdjson library version")
+set(SIMDJSON_LIB_VERSION "23.0.0" CACHE STRING "simdjson library version")
-set(SIMDJSON_LIB_SOVERSION "25" CACHE STRING "simdjson library soversion")
+set(SIMDJSON_LIB_SOVERSION "23" CACHE STRING "simdjson library soversion")
-option(SIMDJSON_BUILD_STATIC_LIB "Build simdjson_static library along with simdjson (only makes sense if BUILD_SHARED_LIBS=ON)" OFF)
+option(SIMDJSON_BUILD_STATIC_LIB "Build simdjson_static library along with simdjson" OFF)
 if(SIMDJSON_BUILD_STATIC_LIB AND NOT BUILD_SHARED_LIBS)
  message(WARNING "SIMDJSON_BUILD_STATIC_LIB only makes sense if BUILD_SHARED_LIBS is set to ON")
  message(WARNING "You might be building and installing a two identical static libraries.")
 endif()
 option(SIMDJSON_ENABLE_THREADS "Link with thread support" ON)
@@ -43,20 +39,6 @@ if(SIMDJSON_DISABLE_DEPRECATED_API)
  )
 endif()
 if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.25.0")
    option(SIMDJSON_STATIC_REFLECTION "Enables static reflection (experimental), requires C++26" OFF)
 else()
    set(SIMDJSON_STATIC_REFLECTION OFF CACHE BOOL "Enables static reflection (experimental)" FORCE)
    message(WARNING "SIMDJSON_STATIC_REFLECTION is disabled because your CMake version is below 3.25")
 endif()
 if(SIMDJSON_STATIC_REFLECTION)
  simdjson_add_props(
      target_compile_definitions PUBLIC
      SIMDJSON_STATIC_REFLECTION=1
  )
 endif()
 option(SIMDJSON_DEVELOPMENT_CHECKS "Enable development-time aids, such as \
 checks for incorrect API usage. Enabled by default in DEBUG." OFF)
 if(SIMDJSON_DEVELOPMENT_CHECKS)
@@ -69,7 +51,6 @@ endif()
 if(is_top_project)
  option(SIMDJSON_DEVELOPER_MODE "Enable targets for developing simdjson" OFF)
  option(BUILD_SHARED_LIBS "Build simdjson as a shared library" OFF)
  option(SIMDJSON_SINGLEHEADER "Disable singleheader generation" ON)
 endif()
 include(cmake/handle-deprecations.cmake)
@@ -112,16 +93,7 @@ simdjson_add_props(
    PRIVATE "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>"
 )
-if(SIMDJSON_STATIC_REFLECTION)
+simdjson_add_props(target_compile_features PUBLIC cxx_std_11)
  # We would like to require C++26, but no compiler supports that!
  # This is a hack:
  simdjson_add_props(
      target_compile_options PUBLIC
      -freflection -fexpansion-statements -stdlib=libc++ -std=c++26
  )
 else()
  simdjson_add_props(target_compile_features PUBLIC cxx_std_11)
 endif()
 # workaround for GNU GCC poor AVX load/store code generation
 if(
@@ -183,13 +155,11 @@ endif()
 include(CMakePackageConfigHelpers)
 include(GNUInstallDirs)
-if(SIMDJSON_SINGLEHEADER)
+install(
-  install(
+    FILES singleheader/simdjson.h
-      FILES singleheader/simdjson.h
+    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
-      DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+    COMPONENT simdjson_Development
-      COMPONENT simdjson_Development
+)
  )
 endif()
 install(
    TARGETS simdjson
@@ -233,7 +203,6 @@ if(SIMDJSON_BUILD_STATIC_LIB)
      TARGETS simdjson_static
      EXPORT simdjson_staticTargets
      ARCHIVE COMPONENT simdjson_Development
      INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
  )
  install(
      EXPORT simdjson_staticTargets
@@ -310,7 +279,6 @@ enable_testing()
 add_custom_target(all_tests)
 add_subdirectory(windows)
 include(cmake/CPM.cmake)
 add_subdirectory(dependencies) ## This needs to be before tools because of cxxopts
 add_subdirectory(tools)  ## This needs to be before tests because of cxxopts
@@ -318,9 +286,8 @@ add_subdirectory(tools)  ## This needs to be before tests because of cxxopts
 # most of the data has been moved to https://github.com/simdjson/simdjson-data
 add_subdirectory(jsonexamples)
-if(SIMDJSON_SINGLEHEADER)
+
 add_subdirectory(singleheader)
 endif()
@@ -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         = "3.12.2"
+PROJECT_NUMBER         = "3.10.0"
 # 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
@@ -186,7 +186,7 @@
      same "printed page" as the copyright notice for easier
      identification within third-party archives.
-   Copyright 2018-2025 The simdjson authors
+   Copyright 2018-2023 The simdjson authors
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
@@ -1,18 +0,0 @@
 Copyright 2018-2025 The simdjson authors
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
 the Software without restriction, including without limitation the rights to
 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 the Software, and to permit persons to whom the Software is furnished to do so,
 subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@@ -1,7 +1,7 @@
 [![Ubuntu 20.04 CI](https://github.com/simdjson/simdjson/workflows/Ubuntu%2020.04%20CI%20(GCC%209)/badge.svg)](https://simdjson.org/plots.html)
 [![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/simdjson.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:simdjson)
-[![][license img]][license] [![][licensemit img]][licensemit]
+[![][license img]][license]
 [![Doxygen Documentation](https://img.shields.io/badge/docs-doxygen-green.svg)](https://simdjson.github.io/simdjson/)
@@ -31,7 +31,6 @@ Table of Contents
 * [Documentation](#documentation)
 * [Godbolt](#godbolt)
 * [Performance results](#performance-results)
 * [Packages](#packages)
 * [Bindings and Ports of simdjson](#bindings-and-ports-of-simdjson)
 * [About simdjson](#about-simdjson)
 * [Funding](#funding)
@@ -62,8 +61,6 @@ Real-world usage
 - [ada-url](https://github.com/ada-url/ada)
 - [fastgron](https://github.com/adamritter/fastgron)
 - [WasmEdge](https://wasmedge.org)
 - [RonDB](https://github.com/logicalclocks/rondb)
 If you are planning to use simdjson in a product, please work from one of our releases.
@@ -108,7 +105,6 @@ Documentation
 Usage documentation is available:
 * [Basics](doc/basics.md) is an overview of how to use simdjson and its APIs.
 * [Builder](doc/builder.md) is an overview of how to efficiently write JSON strings using simdjson.
 * [Performance](doc/performance.md) shows some more advanced scenarios and how to tune for them.
 * [Implementation Selection](doc/implementation-selection.md) describes runtime CPU detection and
  how you can work with it.
@@ -147,9 +143,6 @@ speed for [synthetic files over various sizes generated with a script](https://g
 For NDJSON files, we can exceed 3 GB/s with [our  multithreaded parsing functions](https://github.com/simdjson/simdjson/blob/master/doc/parse_many.md).
 Packages
 ------------------------------
 [![Packaging status](https://repology.org/badge/vertical-allrepos/simdjson.svg)](https://repology.org/project/simdjson/versions)
 Bindings and Ports of simdjson
@@ -208,17 +201,12 @@ For the video inclined, <br />
 Funding
 -------
-The work is supported by the Natural Sciences and Engineering Research Council of Canada under grants
+The work is supported by the Natural Sciences and Engineering Research Council of Canada under grant
-RGPIN-2017-03910 and RGPIN-2024-03787.
+number RGPIN-2017-03910.
 [license]: LICENSE
 [license img]: https://img.shields.io/badge/License-Apache%202-blue.svg
 [licensemit]: LICENSE-MIT
 [licensemit img]: https://img.shields.io/badge/License-MIT-blue.svg
 Contributing to simdjson
 ------------------------
@@ -228,7 +216,7 @@ Head over to [CONTRIBUTING.md](CONTRIBUTING.md) for information on contributing
 License
 -------
-This code is made available under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0.html) as well as under the MIT License. As a user, you can pick the license you prefer.
+This code is made available under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0.html).
 Under Windows, we build some tools using the windows/dirent_portable.h file (which is outside our library code): it is under the liberal (business-friendly) MIT license.
@@ -4,9 +4,6 @@ add_subdirectory(dom)
 include_directories( . linux )
 link_libraries(simdjson-windows-headers test-data)
 link_libraries(simdjson)
 if(SIMDJSON_STATIC_REFLECTION)
  add_compile_definitions(SIMDJSON_STATIC_REFLECTION=1)
 endif(SIMDJSON_STATIC_REFLECTION)
 add_executable(benchfeatures benchfeatures.cpp)
 add_executable(get_corpus_benchmark get_corpus_benchmark.cpp)
@@ -35,6 +32,3 @@ if (TARGET benchmark::benchmark)
  endif()
 endif()
 if(SIMDJSON_STATIC_REFLECTION)
  add_subdirectory(static_reflect)
 endif(SIMDJSON_STATIC_REFLECTION)
@@ -122,7 +122,6 @@ struct event_aggregate {
  }
  double elapsed_sec() const { return total.elapsed_sec() / iterations; }
  double total_elapsed_ns() const { return total.elapsed_ns(); }
  double elapsed_ns() const { return total.elapsed_ns() / iterations; }
  double cycles() const { return total.cycles() / iterations; }
  double instructions() const { return total.instructions() / iterations; }
@@ -23,30 +23,7 @@ struct simdjson_ondemand {
 };
 BENCHMARK_TEMPLATE(large_random, simdjson_ondemand)->UseManualTime();
 #if SIMDJSON_STATIC_REFLECTION
 struct simdjson_ondemand_static_reflect {
  static constexpr diff_flags DiffFlags = diff_flags::NONE;
  ondemand::parser parser{};
  bool run(simdjson::padded_string &json, std::vector<point> &result) {
    auto doc = parser.iterate(json);
    //ondemand::array arr = doc.get_array();
    //arr.get<std::vector<point>>(result);
    // We can also do it like so:
    for (ondemand::object coord : doc) {
      result.emplace_back(coord.get<point>());
    }
    // It seems that doing the reflection is slower than doing the manual lookup.
    // E.g., it is faster if we do result.emplace_back(coord["x"], coord["y"], coord["z"]);
    return true;
  }
 };
 BENCHMARK_TEMPLATE(large_random, simdjson_ondemand_static_reflect)->UseManualTime();
 #endif
 } // namespace large_random
 #endif // SIMDJSON_EXCEPTIONS
@@ -1,44 +0,0 @@
 # Include reflect-cpp
 CPMAddPackage(
  NAME reflect-cpp
  GITHUB_REPOSITORY getml/reflect-cpp
  GIT_TAG v0.17.0
  EXCLUDE_FROM_ALL YES
 )
 if(NOT WIN32)
 # We want the check whether Rust is available before trying to build a crate.
 CPMAddPackage(
  NAME corrosion
  GITHUB_REPOSITORY corrosion-rs/corrosion
  VERSION 0.4.4
  DOWNLOAD_ONLY ON
  OPTIONS "Rust_FIND_QUIETLY OFF"
 )
 include("${corrosion_SOURCE_DIR}/cmake/FindRust.cmake")
 endif()
 if(RUST_FOUND)
  message(STATUS "Rust found: " ${Rust_VERSION} )
  add_subdirectory("${corrosion_SOURCE_DIR}" "${PROJECT_BINARY_DIR}/_deps/corrosion" EXCLUDE_FROM_ALL)
  # Important: we want to build in release mode!
  corrosion_import_crate(MANIFEST_PATH "serde-benchmark/Cargo.toml" NO_LINKER_OVERRIDE PROFILE release)
 else()
  message(STATUS "Rust/Cargo is unavailable." )
  message(STATUS "We will not benchmark serde-benchmark." )
  if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
    message(STATUS "Under macOS, you may be able to install rust with")
    message(STATUS "curl https://sh.rustup.rs -sSf | sh")
  elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
    message(STATUS "Under Linux, you may be able to install rust with a command such as")
    message(STATUS "apt-get install cargo" )
    message(STATUS "or" )
    message(STATUS "curl https://sh.rustup.rs -sSf | sh")
  endif()
 endif()
 add_subdirectory(twitter_data)
@@ -1,103 +0,0 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
 version = 3
 [[package]]
 name = "itoa"
 version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 [[package]]
 name = "libc"
 version = "0.2.158"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
 [[package]]
 name = "memchr"
 version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 [[package]]
 name = "proc-macro2"
 version = "1.0.86"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
 dependencies = [
 "unicode-ident",
 ]
 [[package]]
 name = "quote"
 version = "1.0.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
 dependencies = [
 "proc-macro2",
 ]
 [[package]]
 name = "ryu"
 version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 [[package]]
 name = "serde"
 version = "1.0.209"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "99fce0ffe7310761ca6bf9faf5115afbc19688edd00171d81b1bb1b116c63e09"
 dependencies = [
 "serde_derive",
 ]
 [[package]]
 name = "serde-benchmark"
 version = "0.1.0"
 dependencies = [
 "libc",
 "serde",
 "serde_json",
 ]
 [[package]]
 name = "serde_derive"
 version = "1.0.209"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a5831b979fd7b5439637af1752d535ff49f4860c0f341d1baeb6faf0f4242170"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn",
 ]
 [[package]]
 name = "serde_json"
 version = "1.0.127"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8043c06d9f82bd7271361ed64f415fe5e12a77fdb52e573e7f06a516dea329ad"
 dependencies = [
 "itoa",
 "memchr",
 "ryu",
 "serde",
 ]
 [[package]]
 name = "syn"
 version = "2.0.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
 dependencies = [
 "proc-macro2",
 "quote",
 "unicode-ident",
 ]
 [[package]]
 name = "unicode-ident"
 version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
@@ -1,17 +0,0 @@
 [package]
 name = "serde-benchmark"
 version = "0.1.0"
 [lib]
 path = "lib.rs"
 crate-type = ["cdylib"]
 [dependencies]
 serde = { version = "1.0", features = ["derive"] }
 libc = "0.2"
 serde_json = "1.0"
 [profile.release]
 opt-level = 3
 debug = false
 lto = true
@@ -1,18 +0,0 @@
 ## Rust Serde FFI
 This folder includes FFI bindings for rust/serde.
 ### Links
 - https://github.com/eqrion/cbindgen/blob/master/docs.md
 - https://gist.github.com/zbraniecki/b251714d77ffebbc73c03447f2b2c69f
 - https://michael-f-bryan.github.io/rust-ffi-guide/setting_up.html
 ### Building
 - Generating cbindgen output
  - Install dependencies with `brew install cbindgen` or `apt-get install cbindgen` or `cargo install cbindgen` or the equivalent: we used `cargo install --version 0.23.0 cbindgen`.
  - Go to the directory where this README.md file is located
  - Generate with `cbindgen --config cbindgen.toml --crate serde-benchmark --output serde_benchmark.h`
 - Building
  - Run with `cargo build --release`
@@ -1,12 +0,0 @@
 autogen_warning = "/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */"
 include_version = true
 braces = "SameLine"
 line_length = 100
 tab_width = 2
 language = "C++"
 namespaces = ["serde_benchmark"]
 include_guard = "serde_benchmark_ffi_h"
 [parse]
 parse_deps = true
 include = ["serde_json", "serde"]
@@ -1,170 +0,0 @@
 extern crate serde;
 extern crate serde_json;
 extern crate libc;
 use std::slice;
 use libc::{c_char, size_t};
 use serde::{Serialize, Deserialize};
 /******************************************************/
 /******************************************************/
 /**
 * Warning: the C++ code may not generate the same JSON.
 */
 /******************************************************/
 /******************************************************/
 // This has no equivalent in C++:
 #[derive(Serialize, Deserialize)]
 pub struct Metadata {
    result_type: String,
    iso_language_code: String,
 }
 #[derive(Serialize, Deserialize)]
 pub struct User {
    id: i64,
    id_str: String,
    name: String,
    screen_name: String,
    location: String,
    description: String,
    // C++ does not have those:
    // url: Option<String>,
    //protected: bool,
    //listed_count: i64,
    //created_at: String,
    //favourites_count: i64,
    //utc_offset: Option<i64>,
    //time_zone: Option<String>,
    //geo_enabled: bool,
    verified: bool,
    followers_count: i64,
    friends_count: i64,
    statuses_count: i64,
    // C++ does not have those:
    //lang: String,
    //profile_background_color: String,
    //profile_background_image_url: String,
    //profile_background_image_url_https: String,
    //profile_background_tile: bool,
    //profile_image_url: String,
    //profile_image_url_https: String,
    //profile_banner_url: Option<String>,
    //profile_link_color: String,
    //profile_sidebar_border_color: String,
    //profile_sidebar_fill_color: String,
    //profile_text_color: String,
    //profile_use_background_image: bool,
    //default_profile: bool,
    //default_profile_image: bool,
    //following: bool,
    //follow_request_sent: bool,
    //notifications: bool,
 }
 #[derive(Serialize, Deserialize)]
 pub struct Hashtag {
    text: String,
    // C++ has those but D. Lemire does not know what they are, they don't appear in the JSON:
    // int64_t indices_start;
    // int64_t indices_end;
 }
 #[derive(Serialize, Deserialize)]
 pub struct Url {
    url: String,
    expanded_url: String,
    display_url: String,
    // C++ has those but D. Lemire does not know what they are, they don't appear in the JSON:
    // int64_t indices_start;
    // int64_t indices_end;
 }
 #[derive(Serialize, Deserialize)]
 pub struct UserMention {
    id: i64,
    name: String,
    screen_name: String,
    // Not in the C++ equivalent:
    //id_str: String,
    //indices: Vec<i64>,
    // C++ has those but D. Lemire does not know what they are, they don't appear in the JSON:
    // int64_t indices_start;
    // int64_t indices_end;
 }
 #[derive(Serialize, Deserialize)]
 pub struct Entities {
    hashtags: Vec<Hashtag>,
    urls: Vec<Url>,
    user_mentions: Vec<UserMention>,
 }
 #[derive(Serialize, Deserialize)]
 pub struct Status {
    created_at: String,
    id: i64,
    text: String,
    user: User,
    entities: Entities,
    retweet_count: i64,
    favorite_count: i64,
    favorited: bool,
    retweeted: bool,
    // None of these are in the C++ equivalent:
    /*
    metadata: Metadata,
    id_str: String,
    source: String,
    truncated: bool,
    in_reply_to_status_id: Option<i64>,
    in_reply_to_status_id_str: Option<String>,
    in_reply_to_user_id: Option<i64>,
    in_reply_to_user_id_str: Option<String>,
    in_reply_to_screen_name: Option<String>,
    geo: Option<String>,
    coordinates: Option<String>,
    place: Option<String>,
    contributors: Option<String>,
    lang: String,
    */
 }
 #[derive(Serialize, Deserialize)]
 pub struct TwitterData {
    statuses: Vec<Status>,
 }
 #[no_mangle]
 pub unsafe extern "C" fn  twitter_from_str(raw_input: *const c_char, raw_input_length: size_t) -> *mut TwitterData {
  let input = std::str::from_utf8_unchecked(slice::from_raw_parts(raw_input as *const u8, raw_input_length));
  match serde_json::from_str(&input) {
    Ok(result) => Box::into_raw(Box::new(result)),
    Err(_) => std::ptr::null_mut(),
  }
 }
 #[no_mangle]
 pub unsafe extern "C" fn str_from_twitter(raw: *mut TwitterData) -> *const c_char {
  let twitter_thing = { &*raw };
  let serialized = serde_json::to_string(&twitter_thing).unwrap();
  return std::ffi::CString::new(serialized.as_str()).unwrap().into_raw()
 }
 #[no_mangle]
 pub unsafe extern "C" fn free_twitter(raw: *mut TwitterData) {
  if raw.is_null() {
    return;
  }
  drop(Box::from_raw(raw))
 }
 #[no_mangle]
 pub unsafe extern fn free_string(ptr: *const c_char) {
    let _ = std::ffi::CString::from_raw(ptr as *mut _);
 }
@@ -1,32 +0,0 @@
 #ifndef serde_benchmark_ffi_h
 #define serde_benchmark_ffi_h
 /* Generated with cbindgen:0.24.3 */
 /* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */
 #include <cstdarg>
 #include <cstdint>
 #include <cstdlib>
 #include <ostream>
 #include <new>
 namespace serde_benchmark {
 struct TwitterData;
 extern "C" {
 TwitterData *twitter_from_str(const char *raw_input, size_t raw_input_length);
 const char *str_from_twitter(TwitterData *raw);
 void free_twitter(TwitterData *raw);
 void free_string(const char *ptr);
 } // extern "C"
 } // namespace serde_benchmark
 #endif // serde_benchmark_ffi_h
@@ -1,15 +0,0 @@
 # Add executable targets
 add_executable(benchmark_serialization_twitter benchmark_serialization_twitter.cpp)
 if(TARGET serde-benchmark)
    message(STATUS "serde-benchmark target was created. Linking benchmarks and serde-benchmark.")
    target_link_libraries(benchmark_serialization_twitter PRIVATE serde-benchmark)
    target_compile_definitions(benchmark_serialization_twitter PRIVATE SIMDJSON_RUST_VERSION="${Rust_VERSION}")
 endif()
 target_link_libraries(benchmark_serialization_twitter PRIVATE simdjson::simdjson nlohmann_json)
 target_link_libraries(benchmark_serialization_twitter PRIVATE reflectcpp)
 target_compile_definitions(benchmark_serialization_twitter PRIVATE SIMDJSON_BENCH_CPP_REFLECT=1)
 target_compile_definitions(benchmark_serialization_twitter PRIVATE JSON_FILE="${EXAMPLE_JSON}")
@@ -1,52 +0,0 @@
 #ifndef BENCHMARK_HELPER_HPP
 #define BENCHMARK_HELPER_HPP
 #include "event_counter.h"
 #include <atomic>
 inline event_collector &get_collector() {
  static event_collector collector;
  return collector;
 }
 template <class function_type>
 event_aggregate bench(const function_type &function, size_t min_repeat = 10,
                      size_t min_time_ns = 1000000000,
                      size_t max_repeat = 100000) {
  event_collector &collector = get_collector();
  event_aggregate aggregate{};
  size_t N = min_repeat;
  if (N == 0) {
    N = 1;
  }
  for (size_t i = 0; i < N; i++) {
    std::atomic_thread_fence(std::memory_order_acquire);
    collector.start();
    function();
    std::atomic_thread_fence(std::memory_order_release);
    event_count allocate_count = collector.end();
    aggregate << allocate_count;
    if ((i + 1 == N) && (aggregate.total_elapsed_ns() < min_time_ns) &&
        (N < max_repeat)) {
      N *= 10;
    }
  }
  return aggregate;
 }
 // Source of the 2 functions below:
 // https://github.com/simdutf/simdutf/blob/master/benchmarks/base64/benchmark_base64.cpp
 inline void pretty_print(size_t strings, size_t bytes, std::string name,
                         event_aggregate agg) {
  event_collector &collector = get_collector();
  printf("%-60s : ", name.c_str());
  printf(" %5.2f MB/s ", bytes * 1000 / agg.elapsed_ns());
  printf(" %5.2f Ms/s ", strings * 1000 / agg.elapsed_ns());
  if (collector.has_events()) {
    printf(" %5.2f GHz ", agg.cycles() / agg.elapsed_ns());
    printf(" %5.2f c/b ", agg.cycles() / bytes);
    printf(" %5.2f i/b ", agg.instructions() / bytes);
    printf(" %5.2f i/c ", agg.instructions() / agg.cycles());
  }
  printf("\n");
 }
 #endif
@@ -1,142 +0,0 @@
 #include <cassert>
 #include <cstdlib>
 #include <ctime>
 #include <format>
 #include <fstream>
 #include <iostream>
 #include <nlohmann/json.hpp>
 #include <simdjson.h>
 #include <string>
 #include "twitter_data.h"
 #include "nlohmann_twitter_data.h"
 #include "benchmark_helper.h"
 #if SIMDJSON_BENCH_CPP_REFLECT
 #include <rfl.hpp>
 #include <rfl/json.hpp>
 void bench_reflect_cpp(TwitterData &data) {
  std::string output = rfl::json::write(data);
  size_t output_volume = output.size();
  printf("# output volume: %zu bytes\n", output_volume);
  volatile size_t measured_volume = 0;
  pretty_print(1, output_volume, "bench_reflect_cpp",
               bench([&data, &measured_volume, &output_volume]() {
                 std::string output = rfl::json::write(data);
                 measured_volume = output.size();
                 if (measured_volume != output_volume) {
                   printf("mismatch\n");
                 }
               }));
 }
 #endif // SIMDJSON_BENCH_CPP_REFLECT
 #ifdef SIMDJSON_RUST_VERSION
 #include "../serde-benchmark/serde_benchmark.h"
 void bench_rust(serde_benchmark::TwitterData *data) {
  const char * output = serde_benchmark::str_from_twitter(data);
  size_t output_volume = strlen(output);
  printf("# output volume: %zu bytes\n", output_volume);
  volatile size_t measured_volume = 0;
  pretty_print(1, output_volume, "bench_rust",
               bench([&data, &measured_volume, &output_volume]() {
                 const char * output = serde_benchmark::str_from_twitter(data);
                 serde_benchmark::free_string(output);
               }));
 }
 #endif
 template <class T> void bench_simdjson_static_reflection(T &data) {
  simdjson::builder::string_builder sb;
  simdjson::builder::append(sb, data);
  std::string_view p;
  if(sb.view().get(p)) {
    std::cerr << "Error!" << std::endl;
  }
  size_t output_volume = p.size();
  sb.clear();
  printf("# output volume: %zu bytes\n", output_volume);
  volatile size_t measured_volume = 0;
  pretty_print(sizeof(data), output_volume, "bench_simdjson_static_reflection",
               bench([&data, &measured_volume, &output_volume, &sb]() {
                 sb.clear();
                 simdjson::builder::append(sb, data);
                 std::string_view p;
                 if(sb.view().get(p)) {
                   std::cerr << "Error!" << std::endl;
                 }
                 measured_volume = sb.size();
                 if (measured_volume != output_volume) {
                   printf("mismatch\n");
                 }
               }));
 }
 void bench_nlohmann(TwitterData &data) {
  std::string output = nlohmann_serialize(data);
  size_t output_volume = output.size();
  printf("# output volume: %zu bytes\n", output_volume);
  volatile size_t measured_volume = 0;
  pretty_print(1, output_volume, "bench_nlohmann",
               bench([&data, &measured_volume, &output_volume]() {
                 std::string output = nlohmann_serialize(data);
                 measured_volume = output.size();
                 if (measured_volume != output_volume) {
                   printf("mismatch\n");
                 }
               }));
 }
 size_t WriteCallback(void *contents, size_t size, size_t nmemb, void *userp) {
  ((std::string *)userp)->append((char *)contents, size * nmemb);
  return size * nmemb;
 }
 std::string read_file(std::string filename) {
  printf("# Reading file %s\n", filename.c_str());
  constexpr size_t read_size = 4096;
  auto stream = std::ifstream(filename.c_str());
  stream.exceptions(std::ios_base::badbit);
  std::string out;
  std::string buf(read_size, '\0');
  while (stream.read(&buf[0], read_size)) {
    out.append(buf, 0, size_t(stream.gcount()));
  }
  out.append(buf, 0, size_t(stream.gcount()));
  return out;
 }
 int main() {
  // Testing correctness of round-trip (serialization + deserialization)
  std::string json_str = read_file(JSON_FILE);
  // Loading up the data into a structure.
  simdjson::ondemand::parser parser;
  simdjson::ondemand::document doc;
  if(parser.iterate(simdjson::pad(json_str)).get(doc)) {
    std::cerr << "Error loading the document!" << std::endl;
    return EXIT_FAILURE;
  }
  TwitterData my_struct;
  if(doc.get<TwitterData>().get(my_struct)) {
    std::cerr << "Error loading TwitterData!" << std::endl;
    return EXIT_FAILURE;
  }
  // Benchmarking the serialization
  bench_nlohmann(my_struct);
  bench_simdjson_static_reflection(my_struct);
 #ifdef SIMDJSON_RUST_VERSION
  printf("# WARNING: The Rust benchmark may not be directly comparable since it does not use an equivalent data structure.\n");
  serde_benchmark::TwitterData * td = serde_benchmark::twitter_from_str(json_str.c_str(), json_str.size());
  bench_rust(td);
  serde_benchmark::free_twitter(td);
 #endif
 #if SIMDJSON_BENCH_CPP_REFLECT
  bench_reflect_cpp(my_struct);
 #endif
  return EXIT_SUCCESS;
 }
@@ -1,117 +0,0 @@
 #ifndef NLOHMANN_TWITTER_DATA_H
 #define NLOHMANN_TWITTER_DATA_H
 #include "twitter_data.h"
 #include <nlohmann/json.hpp>
 void to_json(nlohmann::json &j, const User &u) {
  j = nlohmann::json{{"id", u.id},
                     {"name", u.name},
                     {"screen_name", u.screen_name},
                     {"location", u.location},
                     {"description", u.description},
                     {"verified", u.verified},
                     {"followers_count", u.followers_count},
                     {"friends_count", u.friends_count},
                     {"statuses_count", u.statuses_count}};
 }
 void to_json(nlohmann::json &j, const Hashtag &h) {
  j = nlohmann::json{{"text", h.text},
                     {"indices_start", h.indices_start},
                     {"indices_end", h.indices_end}};
 }
 void to_json(nlohmann::json &j, const Url &u) {
  j = nlohmann::json{{"url", u.url},
                     {"expanded_url", u.expanded_url},
                     {"display_url", u.display_url},
                     {"indices_start", u.indices_start},
                     {"indices_end", u.indices_end}};
 }
 void to_json(nlohmann::json &j, const UserMention &um) {
  j = nlohmann::json{{"id", um.id},
                     {"name", um.name},
                     {"screen_name", um.screen_name},
                     {"indices_start", um.indices_start},
                     {"indices_end", um.indices_end}};
 }
 void to_json(nlohmann::json &j, const Entities &e) {
  j = nlohmann::json{{"hashtags", e.hashtags},
                     {"urls", e.urls},
                     {"user_mentions", e.user_mentions}};
 }
 void to_json(nlohmann::json &j, const Status &s) {
  j = nlohmann::json{{"created_at", s.created_at},
                     {"id", s.id},
                     {"text", s.text},
                     {"user", s.user},
                     {"entities", s.entities},
                     {"retweet_count", s.retweet_count},
                     {"favorite_count", s.favorite_count},
                     {"favorited", s.favorited},
                     {"retweeted", s.retweeted}};
 }
 std::string nlohmann_serialize(const std::vector<Hashtag>& v) {
  nlohmann::json a = nlohmann::json::array();
  for(const Hashtag & h : v) {
    a.push_back(nlohmann::json{{"text", h.text},
                     {"indices_start", h.indices_start},
                     {"indices_end", h.indices_end}});
  }
  return a.dump();
 }
 std::string nlohmann_serialize(const std::vector<Url>& v) {
  nlohmann::json a = nlohmann::json::array();
  for(const Url & u : v) {
    a.push_back(nlohmann::json{{"url", u.url},
                     {"expanded_url", u.expanded_url},
                     {"display_url", u.display_url},
                     {"indices_start", u.indices_start},
                     {"indices_end", u.indices_end}});
  }
  return a.dump();
 }
 std::string nlohmann_serialize(const std::vector<UserMention>& v) {
  nlohmann::json a = nlohmann::json::array();
  for(const UserMention & um : v) {
    a.push_back(nlohmann::json{{"id", um.id},
                     {"name", um.name},
                     {"screen_name", um.screen_name},
                     {"indices_start", um.indices_start},
                     {"indices_end", um.indices_end}});
  }
  return a.dump();
 }
 std::string nlohmann_serialize(const std::vector<Status>& v) {
  nlohmann::json a = nlohmann::json::array();
  for(const Status & s : v) {
    a.push_back(nlohmann::json{{"created_at", s.created_at},
                     {"id", s.id},
                     {"text", s.text},
                     {"user", s.user},
                     {"entities", s.entities},
                     {"retweet_count", s.retweet_count},
                     {"favorite_count", s.favorite_count},
                     {"favorited", s.favorited},
                     {"retweeted", s.retweeted}});
  }
  return a.dump();
 }
 void to_json(nlohmann::json &j, const TwitterData &t) {
  j = nlohmann::json{{"statuses", t.statuses}};
 }
 std::string nlohmann_serialize(const TwitterData &data) {
  return nlohmann_serialize(data.statuses);
 }
 #endif // NLOHMANN_TWITTER_DATA_H
@@ -1,71 +0,0 @@
 #ifndef TWITTER_DATA_H
 #define TWITTER_DATA_H
 #include <string>
 #include <vector>
 struct User {
  int64_t id;
  std::string id_str;
  std::string name;
  std::string screen_name;
  std::string location;
  std::string description;
  bool verified;
  int64_t followers_count;
  int64_t friends_count;
  int64_t statuses_count;
  bool operator<=>(const User &other) const = default;
 };
 struct Hashtag {
  std::string text;
  int64_t indices_start;
  int64_t indices_end;
  bool operator<=>(const Hashtag &other) const = default;
 };
 struct Url {
  std::string url;
  std::string expanded_url;
  std::string display_url;
  int64_t indices_start;
  int64_t indices_end;
  bool operator<=>(const Url &other) const = default;
 };
 struct UserMention {
  int64_t id;
  std::string name;
  std::string screen_name;
  int64_t indices_start;
  int64_t indices_end;
  bool operator<=>(const UserMention &other) const = default;
 };
 struct Entities {
  std::vector<Hashtag> hashtags;
  std::vector<Url> urls;
  std::vector<UserMention> user_mentions;
  bool operator==(const Entities &other) const = default;
 };
 struct Status {
  std::string created_at;
  int64_t id;
  std::string text;
  User user;
  Entities entities;
  int64_t retweet_count;
  int64_t favorite_count;
  bool favorited;
  bool retweeted;
  bool operator==(const Status &other) const = default;
 };
 struct TwitterData {
  std::vector<Status> statuses;
  bool operator==(const TwitterData &other) const = default;
 };
 #endif
@@ -1,24 +0,0 @@
 # SPDX-License-Identifier: MIT
 #
 # SPDX-FileCopyrightText: Copyright (c) 2019-2023 Lars Melchior and contributors
 set(CPM_DOWNLOAD_VERSION 0.40.2)
 set(CPM_HASH_SUM "c8cdc32c03816538ce22781ed72964dc864b2a34a310d3b7104812a5ca2d835d")
 if(CPM_SOURCE_CACHE)
  set(CPM_DOWNLOAD_LOCATION "${CPM_SOURCE_CACHE}/cpm/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
 elseif(DEFINED ENV{CPM_SOURCE_CACHE})
  set(CPM_DOWNLOAD_LOCATION "$ENV{CPM_SOURCE_CACHE}/cpm/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
 else()
  set(CPM_DOWNLOAD_LOCATION "${CMAKE_BINARY_DIR}/cmake/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
 endif()
 # Expand relative path. This is important if the provided path contains a tilde (~)
 get_filename_component(CPM_DOWNLOAD_LOCATION ${CPM_DOWNLOAD_LOCATION} ABSOLUTE)
 file(DOWNLOAD
     https://github.com/cpm-cmake/CPM.cmake/releases/download/v${CPM_DOWNLOAD_VERSION}/CPM.cmake
     ${CPM_DOWNLOAD_LOCATION} EXPECTED_HASH SHA256=${CPM_HASH_SUM}
 )
 include(${CPM_DOWNLOAD_LOCATION})
@@ -110,14 +110,8 @@ endif()
 # We compile tools, tests, etc. with C++ 17. Override yourself if you need on a
 # target.
-if(SIMDJSON_STATIC_REFLECTION)
+set(SIMDJSON_CXX_STANDARD 17 CACHE STRING "the C++ standard to use for simdjson")
-  # This is temporary.
+set(CMAKE_CXX_STANDARD ${SIMDJSON_CXX_STANDARD})
  set(SIMDJSON_CXX_STANDARD 26 CACHE STRING "the C++ standard to use for simdjson")
  #set(CMAKE_CXX_STANDARD ${SIMDJSON_CXX_STANDARD})
 else()
  set(SIMDJSON_CXX_STANDARD 17 CACHE STRING "the C++ standard to use for simdjson")
  set(CMAKE_CXX_STANDARD ${SIMDJSON_CXX_STANDARD})
 endif()
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_THREAD_PREFER_PTHREAD ON)
@@ -1,4 +1,5 @@
 include(CMakeDependentOption)
 include(import.cmake)
 option(SIMDJSON_ALLOW_DOWNLOADS
        "Allow dependencies to be downloaded during configure time"
@@ -10,21 +11,17 @@ cmake_dependent_option(SIMDJSON_GOOGLE_BENCHMARKS "compile the Google Benchmark
        SIMDJSON_ALLOW_DOWNLOADS OFF)
 if(SIMDJSON_GOOGLE_BENCHMARKS)
-  CPMAddPackage(
+  set_off(BENCHMARK_ENABLE_TESTING)
-        NAME google_benchmarks
+  set_off(BENCHMARK_ENABLE_INSTALL)
-        URL https://github.com/google/benchmark/archive/refs/tags/v1.7.1.zip
+  set_off(BENCHMARK_ENABLE_WERROR)
-        OPTIONS
+
-        "BENCHMARK_ENABLE_TESTING OFF"
+  import_dependency(google_benchmarks google/benchmark v1.7.1)
-        "BENCHMARK_ENABLE_INSTALL OFF"
+  add_dependency(google_benchmarks)
        "BENCHMARK_ENABLE_WERROR OFF"
  )
 endif()
-CPMAddPackage(
+# The bulk of our benchmarking and testing data has been moved simdjson/simdjson-data
-        NAME simdjson-data
+import_dependency(simdjson-data simdjson/simdjson-data a5b13babe65c1bba7186b41b43d4cbdc20a5c470)
-        URL https://github.com/simdjson/simdjson-data/archive/a5b13babe65c1bba7186b41b43d4cbdc20a5c470.zip
+add_dependency(simdjson-data)
 )
 option(SIMDJSON_USE_BOOST_JSON "Try to include BOOST_JSON, this may break your binaries under some systems." OFF)
 # This prevents variables declared with set() from unnecessarily escaping and
 # should not be called more than once
@@ -41,30 +38,20 @@ function(competition_scope_)
 int main() {}
 ]] SIMDJSON_FOUND_STRING_VIEW)
  if(SIMDJSON_FOUND_STRING_VIEW AND SIMDJSON_USE_BOOST_JSON)
-    CPMAddPackage(
+    import_dependency(boostjson boostorg/json ee8d72d)
        NAME boostjson
        URL https://github.com/boostorg/json/archive/ee8d72d8502b409b5561200299cad30ccdb91415.zip
    )
    add_library(boostjson STATIC "${boostjson_SOURCE_DIR}/src/src.cpp")
    target_compile_definitions(boostjson PUBLIC BOOST_JSON_STANDALONE)
    target_include_directories(boostjson SYSTEM PUBLIC
            "${boostjson_SOURCE_DIR}/include")
    target_compile_definitions(boostjson INTERFACE SIMDJSON_COMPETITION_BOOSTJSON)
  endif()
-  CPMAddPackage(
+
-      NAME cjson
+  import_dependency(cjson DaveGamble/cJSON c69134d)
      URL https://github.com/DaveGamble/cJSON/archive/c69134d01746dcf551dd7724b4edb12f922eb0d1.zip
      DOWNLOAD_ONLY YES
  )
  add_library(cjson STATIC "${cjson_SOURCE_DIR}/cJSON.c")
  target_include_directories(cjson SYSTEM PUBLIC "${cjson_SOURCE_DIR}")
  target_compile_definitions(cjson INTERFACE SIMDJSON_COMPETITION_CJSON)
-  CPMAddPackage(
+  import_dependency(fastjson mikeando/fastjson 485f994)
      NAME fastjson
      URL https://github.com/mikeando/fastjson/archive/485f994a61a64ac73fa6a40d4d639b99b463563b.zip
      DOWNLOAD_ONLY YES
  )
  add_library(fastjson STATIC
          "${fastjson_SOURCE_DIR}/src/fastjson.cpp"
          "${fastjson_SOURCE_DIR}/src/fastjson2.cpp"
@@ -73,36 +60,28 @@ int main() {}
          "${fastjson_SOURCE_DIR}/include")
  target_compile_definitions(fastjson INTERFACE SIMDJSON_COMPETITION_FASTJSON)
-  CPMAddPackage(
+  import_dependency(gason vivkin/gason 7aee524)
      NAME gason
      URL https://github.com/vivkin/gason/archive/7aee524189da1c1ecd19f67981e3d903dae25470.zip
      DOWNLOAD_ONLY YES
  )
  add_library(gason STATIC "${gason_SOURCE_DIR}/src/gason.cpp")
  target_include_directories(gason SYSTEM PUBLIC "${gason_SOURCE_DIR}/src")
  target_compile_definitions(gason INTERFACE SIMDJSON_COMPETITION_GASON)
-  CPMAddPackage(
+  import_dependency(jsmn zserge/jsmn 18e9fe4)
      NAME jsmn
      URL https://github.com/zserge/jsmn/archive/18e9fe42cbfe21d65076f5c77ae2be379ad1270f.zip
      DOWNLOAD_ONLY YES
  )
  add_library(jsmn STATIC "${jsmn_SOURCE_DIR}/jsmn.c")
  target_include_directories(jsmn SYSTEM PUBLIC "${jsmn_SOURCE_DIR}")
  target_compile_definitions(jsmn INTERFACE SIMDJSON_COMPETITION_JSMN)
-  CPMAddPackage(
+  message(STATUS "Importing json (nlohmann/json@v3.10.5)")
-      NAME nlohmann_json
+  set(nlohmann_json_SOURCE_DIR "${dep_root}/json")
-      URL https://github.com/nlohmann/json/archive/refs/tags/v3.10.5.zip
+  if(NOT EXISTS "${nlohmann_json_SOURCE_DIR}")
-  )
+    file(DOWNLOAD
            "https://github.com/nlohmann/json/releases/download/v3.10.5/json.hpp"
            "${nlohmann_json_SOURCE_DIR}/nlohmann/json.hpp")
  endif()
  add_library(nlohmann_json INTERFACE)
  target_include_directories(nlohmann_json SYSTEM INTERFACE "${nlohmann_json_SOURCE_DIR}")
  target_compile_definitions(nlohmann_json INTERFACE SIMDJSON_COMPETITION_NLOHMANN_JSON)
-  set_property(TARGET nlohmann_json APPEND PROPERTY INTERFACE_COMPILE_DEFINITIONS SIMDJSON_COMPETITION_NLOHMANN_JSON)
+  import_dependency(json11 dropbox/json11 ec4e452)
  CPMAddPackage(
      NAME json11
      URL https://github.com/dropbox/json11/archive/ec4e45219af1d7cde3d58b49ed762376fccf1ace.zip
      DOWNLOAD_ONLY YES
  )
  add_library(json11 STATIC "${json11_SOURCE_DIR}/json11.cpp")
  target_include_directories(json11 SYSTEM PUBLIC "${json11_SOURCE_DIR}")
  target_compile_definitions(json11 INTERFACE SIMDJSON_COMPETITION_JSON11)
@@ -112,11 +91,7 @@ int main() {}
  target_include_directories(jsoncpp SYSTEM PUBLIC "${jsoncpp_SOURCE_DIR}")
  target_compile_definitions(jsoncpp INTERFACE SIMDJSON_COMPETITION_JSONCPP)
-  CPMAddPackage(
+  import_dependency(rapidjson Tencent/rapidjson f54b0e4)
      NAME rapidjson
      URL https://github.com/Tencent/rapidjson/archive/805d7ed5dfe97a39b8b0816fd5eeed8731dc4936.zip
      DOWNLOAD_ONLY YES
  )
  add_library(rapidjson INTERFACE)
  target_compile_definitions(rapidjson INTERFACE RAPIDJSON_HAS_STDSTRING)
  include (TestBigEndian)
@@ -135,22 +110,14 @@ int main() {}
    target_compile_definitions(rapidjson INTERFACE SIMDJSON_COMPETITION_RAPIDJSON)
  endif()
-  CPMAddPackage(
+  import_dependency(sajson chadaustin/sajson 2dcfd35)
      NAME sajson
      URL https://github.com/chadaustin/sajson/archive/2dcfd350586375f9910f74821d4f07d67ae455ba.zip
      DOWNLOAD_ONLY YES
  )
  add_library(sajson INTERFACE)
  target_compile_definitions(sajson INTERFACE SAJSON_UNSORTED_OBJECT_KEYS)
  target_include_directories(sajson SYSTEM INTERFACE
          "${sajson_SOURCE_DIR}/include")
  target_compile_definitions(sajson INTERFACE SIMDJSON_COMPETITION_SAJSON)
-  CPMAddPackage(
+  import_dependency(ujson4c esnme/ujson4c e14f3fd)
      NAME ujson4c
      URL https://github.com/esnme/ujson4c/archive/e14f3fd5207fe30d1bdea723f260609e69d1abfa.zip
      DOWNLOAD_ONLY YES
  )
  add_library(ujson4c STATIC
          "${ujson4c_SOURCE_DIR}/src/ujdecode.c"
          "${ujson4c_SOURCE_DIR}/3rdparty/ultrajsondec.c")
@@ -159,11 +126,7 @@ int main() {}
          "${ujson4c_SOURCE_DIR}/3rdparty")
  target_compile_definitions(ujson4c INTERFACE SIMDJSON_COMPETITION_UJSON4C)
-  CPMAddPackage(
+  import_dependency(yyjson ibireme/yyjson c385651)
      NAME yyjson
      URL https://github.com/ibireme/yyjson/archive/c3856514de0a67d7b66939bf3ed491a2d6e61277.zip
      DOWNLOAD_ONLY YES
  )
  add_library(yyjson STATIC "${yyjson_SOURCE_DIR}/src/yyjson.c")
  target_include_directories(yyjson SYSTEM PUBLIC "${yyjson_SOURCE_DIR}/src")
  target_compile_definitions(yyjson INTERFACE SIMDJSON_COMPETITION_YYJSON)
@@ -188,12 +151,10 @@ cmake_dependent_option(SIMDJSON_CXXOPTS "Download cxxopts (necessary for tools)"
        SIMDJSON_ALLOW_DOWNLOADS OFF)
 if(SIMDJSON_CXXOPTS)
-  CPMAddPackage(
+  set_off(CXXOPTS_BUILD_EXAMPLES)
-        NAME cxxopts
+  set_off(CXXOPTS_BUILD_TESTS)
-        URL https://github.com/jarro2783/cxxopts/archive/59656709c0c58fcd0ed18b38e02938dbe05284c5.zip
+  set_off(CXXOPTS_ENABLE_INSTALL)
-        OPTIONS
+
-        "CXXOPTS_BUILD_EXAMPLES OFF"
+  import_dependency(cxxopts jarro2783/cxxopts 5965670)
-        "CXXOPTS_BUILD_TESTS OFF"
+  add_dependency(cxxopts)
        "CXXOPTS_ENABLE_INSTALL OFF"
  )
 endif()
@@ -0,0 +1,48 @@
 set(dep_root "${simdjson_SOURCE_DIR}/dependencies/.cache")
 if(DEFINED ENV{simdjson_DEPENDENCY_CACHE_DIR})
  set(dep_root "$ENV{simdjson_DEPENDENCY_CACHE_DIR}")
 endif()
 function(import_dependency NAME GITHUB_REPO COMMIT)
  message(STATUS "Importing ${NAME} (${GITHUB_REPO}@${COMMIT})")
  set(target "${dep_root}/${NAME}")
  # If the folder exists in the cache, then we assume that everything is as
  # should be and do nothing
  if(EXISTS "${target}")
    set("${NAME}_SOURCE_DIR" "${target}" PARENT_SCOPE)
    return()
  endif()
  set(zip_url "https://github.com/${GITHUB_REPO}/archive/${COMMIT}.zip")
  set(archive "${dep_root}/archive.zip")
  set(dest "${dep_root}/_extract")
  file(DOWNLOAD "${zip_url}" "${archive}")
  file(MAKE_DIRECTORY "${dest}")
  execute_process(
          WORKING_DIRECTORY "${dest}"
          COMMAND "${CMAKE_COMMAND}" -E tar xf "${archive}")
  file(REMOVE "${archive}")
  # GitHub archives only ever have one folder component at the root, so this
  # will always match that single folder
  file(GLOB dir LIST_DIRECTORIES YES "${dest}/*")
  file(RENAME "${dir}" "${target}")
  set("${NAME}_SOURCE_DIR" "${target}" PARENT_SCOPE)
 endfunction()
 # Delegates to the dependency
 macro(add_dependency NAME)
  if(NOT DEFINED "${NAME}_SOURCE_DIR")
    message(FATAL_ERROR "Missing ${NAME}_SOURCE_DIR variable")
  endif()
  add_subdirectory("${${NAME}_SOURCE_DIR}" "${PROJECT_BINARY_DIR}/_deps/${NAME}" EXCLUDE_FROM_ALL)
 endmacro()
 function(set_off NAME)
  set("${NAME}" OFF CACHE INTERNAL "")
 endfunction()
@@ -17,7 +17,7 @@ An overview of what you need to know to use simdjson, with examples.
  - [Using the parsed JSON](#using-the-parsed-json)
    - [Using the parsed JSON: additional examples](#using-the-parsed-json-additional-examples)
  - [Adding support for custom types](#adding-support-for-custom-types)
-    - [1. Specialize `simdjson::ondemand::value::get` to get custom types (pre-C++20)](#1-specialize-simdjsonondemandvalueget-to-get-custom-types-pre-c20)
+    - [1. Specialize `simdjson::ondemand::value::get` to get custom types](#1-specialize-simdjsonondemandvalueget-to-get-custom-types)
    - [2. Use `tag_invoke` for custom types (C++20)](#2-use-tag_invoke-for-custom-types-c20)
  - [Minifying JSON strings without parsing](#minifying-json-strings-without-parsing)
  - [UTF-8 validation (alone)](#utf-8-validation-alone)
@@ -48,7 +48,7 @@ Requirements
 ------------------
 - A recent compiler (LLVM clang 6 or better, GNU GCC 7.4 or better, Xcode 11 or better) on a 64-bit (PPC, ARM or x64 Intel/AMD) POSIX systems such as macOS, freeBSD or Linux. We require that the compiler supports the C++11 standard or better.
- Visual Studio 2017 or better under 64-bit Windows. Users should target a 64-bit build (x64 or ARM64) instead of a 32-bit build (x86). We support the LLVM clang compiler under Visual Studio (clang-cl) as well as as the regular Visual Studio compiler. For better release performance (both compile time and execution time), we recommend Visual Studio users adopt LLVM (clang-cl). We also support MinGW 64-bit under Windows.
+- Visual Studio 2017 or better under 64-bit Windows. Users should target a 64-bit build (x64 or ARM64) instead of a 32-bit build (x86). We support the LLVM clang compiler under Visual Studio (clangcl) as well as as the regular Visual Studio compiler. We also support MinGW 64-bit under Windows.
 Support for AVX-512 require a processor with AVX512-VBMI2 support (Ice Lake or better, AMD Zen 4 or better) under a 64-bit system and a recent compiler (LLVM clang 6 or better, GCC 8 or better, Visual Studio 2019 or better). You need a correspondingly recent assembler such as gas (2.30+) or nasm (2.14+): recent compilers usually come with recent assemblers. If you mix a recent compiler with an incompatible/old assembler (e.g., when using a recent compiler with an old Linux distribution), you may get errors at build time because the compiler produces instructions that the assembler does not recognize: you should update your assembler to match your compiler (e.g., upgrade binutils to version 2.30 or better under Linux) or use an older compiler matching the capabilities of your assembler.
@@ -209,25 +209,6 @@ std::string data = "my data";
 simdjson::padded_string my_padded_data(data); // copies to a padded buffer
 ```
 You can then parse the JSON data from the `simdjson::padded_string` instance:
 ```c++
 ondemand::document doc = parser.iterate(my_padded_data);
 ```
 Whenever you pass an `std::string` reference to `parser::iterate`,
 the parser will access the bytes beyond the end of
 the string but before the end of the allocated memory (`std::string::capacity()`).
 If you are using a sanitizer that checks for reading uninitialized bytes or `std::string`'s
 container-overflow checks, you may encounter sanitizer warnings.
 You can safely ignore these warnings. Or you can call `simdjson::pad(std::string&)` to pad the
 string with `SIMDJSON_PADDING` spaces: this function returns a `simdjson::padding_string_view` which can be be passed to the parser's iterator function:
 ```c++
 std::string json = "[1]";
 ondemand::document doc = parser.iterate(simdjson::pad(json));
 ```
 We recommend against creating many `std::string` or many `std::padding_string` instances in your application to store your JSON data.
 Consider reusing the same buffers and limiting memory allocations.
@@ -268,7 +249,7 @@ documents.
 For code safety, you should keep (1) the `parser` instance, (2) the input string and (3) the document instance alive throughout your parsing. Additionally, you should follow the following rules:
 - A `parser` may have at most one document open at a time, since it holds allocated memory used for the parsing.
- By design, you should only have one `document` instance per JSON document. Thus, if you must pass a document instance to a function, you should avoid passing it by value: choose to pass it by reference instance to avoid the copy. In any case, the `document` class does not have a copy constructor.
+- By design, you should only have one `document` instance per JSON document. Thus, if you must pass a document instance to a function, you should avoid passing it by value: choose to pass it by reference instance to avoid the copy. (We also provide a `document_reference` class if you need to pass by value.)
 During the `iterate` call, the original JSON text is never modified--only read. After you are done
 with the document, the source (whether file or string) can be safely discarded.
@@ -422,13 +403,9 @@ support for users who avoid exceptions. See [the simdjson error handling documen
  of the object: to warn you, an OUT_OF_ORDER_ITERATION error is generated [when development checks](#avoiding-pitfalls-enable-development-checks) are active. If you need to access an object more
  than once, you may call `reset()` on it although we discourage this practice. Keep in mind that
  you should consume each value at most once.
  When you are iterating through an object, you are advancing through its keys and values. You should not also access the object or other objects. E.g. within a loop over `myobject`, you should not be accessing `myobject`. The following is an anti-pattern: `for(auto value: myobject) {myobject["mykey"]}`.
  You should never reset an object as you are iterating through it. The following is an anti-pattern: `for(auto value: myobject) {myobject.reset()}`.
 * **Array Index:** Because it is forward-only, you cannot look up an array element by index by index. Instead,
  you should iterate through the array and keep an index yourself. Exceptionally, if need a single value
-  out of the array, you may use an array access (e.g., `array[1]`). You should never reset an array as you are iterating through it. The following is an anti-pattern: `for(auto value: myarray) {myarray.reset()}`.
+  out of the array, you may use an array access (e.g., `array[1]`).
 * **Field Access:** To get the value of the "foo" field in an object, use `object["foo"]`. This will
  scan through the object looking for the field with the matching string, doing a character-by-character
  comparison. It may generate the error `simdjson::NO_SUCH_FIELD` if there is no such key in the object, it may throw an exception (see [Error handling](#error-handling)). For efficiency reason, you should avoid looking up the same field repeatedly: e.g., do
@@ -551,7 +528,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
  double value;
  auto doc = parser.iterate(abstract_json);
  auto error = doc["str"]["123"]["abc"].get(value);
-  if (error) { std::cerr << simdjson::error_message(error) << std::endl; return EXIT_FAILURE; }
+  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
  cout << value << endl; // Prints 3.14
  ```
  This examples also show how we can string several operations and only check for the error once, a strategy we call  *error chaining*.
@@ -561,7 +538,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
  For this purpose, `array` instances have a `count_elements` method. Users should be
  aware that the `count_elements` method can be costly since it requires scanning the
  whole array. You should only call `count_elements` as a last resort as it may
-  require scanning the document twice or more. You should never use the `count_elements` as part of an attempt to iterate through the array: use a `for` loop to iterate through arrays. In the spirit of On-Demand, the `count_elements` function does not validate the values in the array: they are validated when they are consumed. You may use it as follows if your document is itself an array:
+  require scanning the document twice or more. You may use it as follows if your document is itself an array:
  ```C++
  auto cars_json = R"( [ 40.1, 39.9, 37.7, 40.4 ] )"_padded;
@@ -813,19 +790,24 @@ for (ondemand::object points : parser.iterate(points_json)) {
 Adding support for custom types
 ----------------------
-There are 3 main ways provided by simdjson to deserialize a value into a custom type:
+There are 2 main ways provided by simdjson to deserialize a value into a custom type:
 1. Provide a [**template specialization** for member functions](https://en.cppreference.com/w/cpp/language/template_specialization#Members_of_specializations)
   1. Specialize `simdjson::ondemand::document::get` for the whole document
   2. Specialize `simdjson::ondemand::value::get` for each value
 2. Using `tag_invoke` *(the recommended way if your system supports C++20 or better)*
 3. Using static reflectioin (requires C++26 or better)
-We describe all of them in the following sections. Most users who have systems compatible with
+The differences between the two approaches are as follows:
 C++20 or better should skip ahead to [using `tag_invoke` for custom types (C++20)](#2-use-tag_invoke-for-custom-types-c20) as it is more powerful and simpler.
 The C++26 approach is even simpler.
-### 1. Specialize `simdjson::ondemand::value::get` to get custom types (pre-C++20)
+1. Your compiler needs to support C++20 for `tag_invoke`.
 2. The first way limits you to know your type fully, but in the `tag_invoke` way, you can use C++20 concepts and template meta programming as well.
 3. Another difference between the two ways is that in `tag_invoke` way you may or may not mark your deserialization function (`tag_invoke` itself) as `noexcept`, but in the
   *template specialization* way (the first way) you HAVE TO mark your specialization as `noexcept` which means that you may need to catch exceptions so
   that your function does not throw any exception all the while it potentially can (for example any type like `std::string`, `std::vector`, etc. that has an allocator can potentially throw exceptions).
 4. Another difference is that the `tag_invoke` way can work on both `document` and `value` but in the first way you have to provide 2 distinct specializations.
 5. If you by mistake use both way with each other, the *specialization way* will be used silently due to backward-compatibility.
 ### 1. Specialize `simdjson::ondemand::value::get` to get custom types
 Suppose you have your own types, such as a `Car` struct:
@@ -861,14 +843,13 @@ type:
 We may do so by providing additional template definitions to the `ondemand::value` type.
 We may start by providing a definition for `std::vector<double>` as follows. Observe
-how we guard the code with `#if !SIMDJSON_SUPPORTS_DESERIALIZATION`: that is because the necessary code
+how we guard the code with `#ifndef __cpp_concepts`: that is because the necessary code
 is automatically provided by simdjson if C++20 (and concepts) are available.
 See [Use `tag_invoke` for custom types](#2-use-tag_invoke-for-custom-types-c20) if you have
 C++20 support.
 ```c++
-#if !SIMDJSON_SUPPORTS_DESERIALIZATION
+#ifndef __cpp_concepts // because the code is unnecessary with C++20
 // The code is unnecessary with C++20:
 template <>
 simdjson_inline simdjson_result<std::vector<double>>
 simdjson::ondemand::value::get() noexcept {
@@ -880,7 +861,7 @@ simdjson::ondemand::value::get() noexcept {
    double val;
    error = v.get_double().get(val);
    if (error) { return error; }
-    vec.push_back(val);
+    try { vec.push_back(val); } catch (...) { return simdjson::UNEXPECTED_ERROR; }
  }
  return vec;
 }
@@ -896,10 +877,27 @@ simdjson_inline simdjson_result<Car> simdjson::ondemand::value::get() noexcept {
  auto error = get_object().get(obj);
  if (error) { return error; }
  Car car;
-  if((error = obj["make"].get_string(car.make))) { return error; }
+  // Instead of repeatedly obj["something"], we iterate through the object which
-  if((error = obj["model"].get_string(car.model))) { return error; }
+  // we expect to be faster.
-  if((error = obj["year"].get_int64().get(car.year))) { return error; }
+  for (auto field : obj) {
-  if((error = obj["tire_pressure"].get<std::vector<double>>().get(car.tire_pressure))) { return error; }
+    raw_json_string key;
    error = field.key().get(key);
    if (error) { return error; }
    if (key == "make") {
      error = field.value().get_string(car.make);
      if (error) { return error; }
    } else if (key == "model") {
      error = field.value().get_string(car.model);
      if (error) { return error; }
    } else if (key == "year") {
      error = field.value().get_int64().get(car.year);
      if (error) { return error; }
    } else if (key == "tire_pressure") {
      error = field.value().get<std::vector<double>>().get(car.tire_pressure);
      if (error) { return error; }
    }
  }
  return car;
 }
 ```
@@ -923,8 +921,7 @@ struct Car {
  std::vector<double> tire_pressure;
 };
-#if !SIMDJSON_SUPPORTS_DESERIALIZATION
+#ifndef __cpp_concepts // because the code is unnecessary with C++20
 // This code is not necessary if you have a C++20 compliant system:
 template <>
 simdjson_inline simdjson_result<std::vector<double>>
 simdjson::ondemand::value::get() noexcept {
@@ -942,16 +939,33 @@ simdjson::ondemand::value::get() noexcept {
 }
 #endif
 template <>
 simdjson_inline simdjson_result<Car> simdjson::ondemand::value::get() noexcept {
  ondemand::object obj;
  auto error = get_object().get(obj);
  if (error) { return error; }
  Car car;
-  if((error = obj["make"].get_string(car.make))) { return error; }
+  // Instead of repeatedly obj["something"], we iterate through the object which
-  if((error = obj["model"].get_string(car.model))) { return error; }
+  // we expect to be faster.
-  if((error = obj["year"].get_int64().get(car.year))) { return error; }
+  for (auto field : obj) {
-  if((error = obj["tire_pressure"].get<std::vector<double>>().get(car.tire_pressure))) { return error; }
+    raw_json_string key;
    error = field.key().get(key);
    if (error) { return error; }
    if (key == "make") {
      error = field.value().get_string(car.make);
      if (error) { return error; }
    } else if (key == "model") {
      error = field.value().get_string(car.model);
      if (error) { return error; }
    } else if (key == "year") {
      error = field.value().get_int64().get(car.year);
      if (error) { return error; }
    } else if (key == "tire_pressure") {
      error = field.value().get<std::vector<double>>().get(car.tire_pressure);
      if (error) { return error; }
    }
  }
  return car;
 }
@@ -969,6 +983,7 @@ int main(void) {
    Car c(val); // an exception may be thrown
    std::cout << c.make << std::endl;
  }
  direct();
  return EXIT_SUCCESS;
 }
 ```
@@ -989,11 +1004,11 @@ int main(void) {
  ondemand::parser parser;
  ondemand::document doc;
  auto error = parser.iterate(json).get(doc);
-  if (error) { std::cerr << simdjson::error_message(error) << std::endl; return EXIT_FAILURE; }
+  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
  for (auto val : doc) {
    Car c;
    error = val.get<Car>().get(c);
-    if (error) { std::cerr << simdjson::error_message(error) << std::endl; return EXIT_FAILURE; }
+    if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
    std::cout << c.make << std::endl;
  }
  return EXIT_SUCCESS;
@@ -1024,19 +1039,16 @@ struct Car {
  std::vector<double> tire_pressure;
 };
-#if !SIMDJSON_SUPPORTS_DESERIALIZATION
+#ifndef __cpp_concepts // because the code is unnecessary with C++20
 // This code is not necessary if you have a C++20 compliant system:
 template <>
 simdjson_inline simdjson_result<std::vector<double>>
 simdjson::ondemand::value::get() noexcept {
  ondemand::array array;
-  auto error = get_array().get(array);
+  if (auto error = get_array().get(array); error) { return error; }
  if (error) { return error; }
  std::vector<double> vec;
  for (auto v : array) {
    double val;
-    error = v.get_double().get(val);
+    if (auto error = v.get_double().get(val); error) { return error; }
    if (error) { return error; }
    vec.push_back(val);
  }
  return vec;
@@ -1047,26 +1059,30 @@ template <>
 simdjson_inline simdjson_result<Car> simdjson::ondemand::document::get() & noexcept {
  ondemand::object obj;
  auto error = get_object().get(obj);
-  if (error) { return error; }
+  if (error) {
    return error;
  }
  Car car;
-  if((error = obj["make"].get_string(car.make))) { return error; }
+  // Instead of repeatedly obj["something"], we iterate through the object which
-  if((error = obj["model"].get_string(car.model))) { return error; }
+  // we expect to be faster.
-  if((error = obj["year"].get_int64().get(car.year))) { return error; }
+  for (auto field : obj) {
-  if((error = obj["tire_pressure"].get<std::vector<double>>().get(car.tire_pressure))) { return error; }
+    raw_json_string key;
-  return car;
+    error = field.key().get(key);
-}
+    if (error) { return error; }
-
+    if (key == "make") {
-
+      error = field.value().get_string(car.make);
-template <>
+      if (error) { return error; }
-simdjson_inline simdjson_result<Car> simdjson::ondemand::document::get() noexcept {
+    } else if (key == "model") {
-  ondemand::object obj;
+      error = field.value().get_string(car.model);
-  auto error = get_object().get(obj);
+      if (error) { return error; }
-  if (error) { return error; }
+    } else if (key == "year") {
-  Car car;
+      error = field.value().get_int64().get(car.year);
-  if((error = obj["make"].get_string(car.make))) { return error; }
+      if (error) { return error; }
-  if((error = obj["model"].get_string(car.model))) { return error; }
+    } else if (key == "tire_pressure") {
-  if((error = obj["year"].get_int64().get(car.year))) { return error; }
+      error = field.value().get<std::vector<double>>().get(car.tire_pressure);
-  if((error = obj["tire_pressure"].get<std::vector<double>>().get(car.tire_pressure))) { return error; }
+      if (error) { return error; }
    }
  }
  return car;
 }
@@ -1083,75 +1099,68 @@ int main(void) {
 ### 2. Use `tag_invoke` for custom types (C++20)
-In C++20, the standard introduced the notion of *customization point*.
+A standard approach to provide support for deserialization is to add a `tag_invoke` function
-A customization point is a function or function object that can be customized for different types. It allows library authors to provide default behavior while giving users the ability to override this behavior for specific types.
+in your own class:
 A tag_invoke function serves as a mechanism for customization points. It is not directly part of the C++ standard library but is often used in libraries that implement customization points.
 The tag_invoke function is typically a generic function that takes a tag type and additional arguments.
 The first argument is usually a tag type (often an empty struct) that uniquely identifies the customization point (e.g., deserialization of custom types in simdjson). Users or library providers can specialize tag_invoke for their types by defining it in the appropriate namespace, often inline namespace.
 If your system supports C++20, we recommend that you adopt the `tag_invoke` approach
 instead to deserialize custom types. It may prove to be considerably simpler. When
 simdjson detects the necessary support, it sets the `SIMDJSON_SUPPORTS_DESERIALIZATION` macro
 to 1, otherwise it is set to 0.
 Consider a custom class `Car`:
 ```C++
 /**
 * A custom type that we want to parse.
 */
 struct Car {
  std::string make;
  std::string model;
-  int year;
+  int year = 0;
-  std::vector<float> tire_pressure;
+  std::vector<double> tire_pressure;
  friend simdjson_result<Car>
  tag_invoke(simdjson::deserialize_tag, std::type_identity<Car>, auto &val) {
    simdjson::ondemand::object obj;
    auto error = val.get_object().get(obj);
    if (error) {
      return error;
    }
    Car car{};
    // Instead of repeatedly obj["something"], we iterate through the object
    // which we expect to be faster.
    for (auto field : obj) {
      simdjson::ondemand::raw_json_string key;
      error = field.key().get(key);
      if (error) {
        return error;
      }
      if (key == "make") {
        error = field.value().get_string(car.make);
        if (error) {
          return error;
        }
      } else if (key == "model") {
        error = field.value().get_string(car.model);
        if (error) {
          return error;
        }
      } else if (key == "year") {
        error = field.value().get(car.year);
        if (error) {
          return error;
        }
      } else if (key == "tire_pressure") {
        error = field.value().get(car.tire_pressure);
        if (error) {
          return error;
        }
      }
    }
    return car;
  }
 };
 ```
-Observe how we defined the class to use types that simdjson does not directly support (`float`, `int`).
+Let us explain each argument of `tag_invoke`:
 With C++20 support, the library grabs from the JSON the generic type (`double`, `int`) and then it
 casts it automatically.
-You may support deserializing directly from a JSON value or document to your own `Car` instance
+- `simdjson::deserialize_tag`: it is the tag for Customization Point Object (CPO)
-by defining a single `tag_invoke` function:
+- `std::type_identity<T>`: We specify the custom type we want here
-
+- `simdjson::ondemand::value&` or `simdjson::ondemand::document&`: the value or document that we want to deserialize from; you may want to just specify `auto&` to capture both of them.
 ```C++
 namespace simdjson {
 // This tag_invoke MUST be inside simdjson namespace
 template <typename simdjson_value>
 auto tag_invoke(deserialize_tag, simdjson_value &val, Car& car) {
  ondemand::object obj;
  auto error = val.get_object().get(obj);
  if (error) {
    return error;
  }
  if ((error = obj["make"].get_string(car.make))) {
    return error;
  }
  if ((error = obj["model"].get_string(car.model))) {
    return error;
  }
  if ((error = obj["year"].get(car.year))) {
    return error;
  }
  if ((error = obj["tire_pressure"].get<std::vector<float>>().get(
           car.tire_pressure))) {
    return error;
  }
  return simdjson::SUCCESS;
 }
 } // namespace simdjson
 ```
 Observe how we call `get<std::vector<float>>()` even though we never defined support
 for `std::vector<float>` in the simdjson library: it is all automated thanks to C++20 concepts.
 Importantly, the `tag_invoke` function must be inside the `simdjson` namespace.
 Let us explain each argument of `tag_invoke` function.
 - `simdjson::deserialize_tag`: it is the tag for Customization Point Object (CPO). You may often ignore this parameter. It is used to indicate that you mean to provide a deserialization function for simdjson.
 - `var`: It receives automatically a `simdjson` value type (document, value, document_reference).
 - The third parameter is an instance of the type that you want to support.
 You can use it like so:
@@ -1170,6 +1179,11 @@ Observe how we first get an instance of `document` and then we cast.
 You can also handle errors explicitly:
 ```cpp
  simdjson::padded_string json =
      R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
       "tire_pressure": [ 40.1, 39.9 ] })"_padded;
  simdjson::ondemand::parser parser;
  simdjson::ondemand::document doc = parser.iterate(json);
  Car c;
  auto error = doc.get(c);
  if(error) { std::cerr << simdjson::error_message(error); return false; }
@@ -1201,6 +1215,8 @@ explicit casting. The cast may throw an exception.
 Once more, you can handle errors explicitly:
 ```cpp
  simdjson::ondemand::parser parser;
  simdjson::ondemand::document doc = parser.iterate(json);
  for (auto val : doc) {
    Car c;
    auto error = val.get(c);
@@ -1223,13 +1239,25 @@ You can also use the custom `Car` type as part of a template such as `std::vecto
  }
 ```
-By default, we support a wide range of standard templates such as
+You can also extend support to arbitrary templates.
-`std::vector`,  `std::list`, `std::set`, `std::stack`, `std:queue`,
+Suppose your custom types are `std::unique_ptr<any type>`,
-`std:deque`, `std::priority_queue`, `std::unordered_set`, `std::multiset`,
+you could add the following `tag_invoke`:
 `std::unordered_multiset`, `std::unique_ptr`, `std::shared_ptr`, `std::optional`,
 etc. They are handled automatically.
-E.g., you can recover an `std::unique_ptr<Car>` like so:
+```C++
 namespace simdjson {
  // This tag_invoke MUST be inside simdjson namespace since we can't make it a friend of unique_ptr
  template <typename T>
  auto tag_invoke(deserialize_tag, std::type_identity<std::unique_ptr<T>>, auto &val) {
    return simdjson_result{std::make_unique<T>(val.template get<T>())};
  }
 } // namespace simdjson
 ```
 You can also mark your `tag_invoke` function as `noexcept` and we will obey that, unlike the *template specialization* way.
 You would use it like this:
 ```C++
 int main() {
  auto const json = R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
@@ -1242,82 +1270,6 @@ int main() {
 }
 ```
 You may also conditionally fill in `std::optional` values.
 ```C++
  padded_string json =
      R"( { "car1": { "make": "Toyota", "model": "Camry",  "year": 2018,
       "tire_pressure": [ 40.1, 39.9 ] }
 })"_padded;
  ondemand::parser parser;
  ondemand::document doc = parser.iterate(json);
  std::optional<Car> car;
  error = doc["key not found"].get<std::optional<Car>>().get(car);
  // car has no value, error != simdjson::SUCCESS
  error = doc["car1"].get<std::optional<Car>>().get(car);
  // car has value Car{"Toyota", "Camry", 2018, {40.1f, 39.9f}}
  // error is simdjson::SUCCESS
 ```
 And so forth.
 Advanced users may want to overwrite the defaults provided by the simdjson library.
 Suppose for example that you want to construct an instance of `std::list<Car>`, but
 you also want to filter out any car made by Toyota. You may provide your own
 `tag_invoke` function:
 ```c++
 namespace simdjson {
 // suppose we want to filter out all Toyotas
 template <typename simdjson_value>
 auto tag_invoke(deserialize_tag, simdjson_value &val, std::list<Car>& car) {
  ondemand::array arr;
  auto error = val.get_array().get(arr);
  if (error) {
    return error;
  }
  for (auto v : arr) {
    Car c;
    if ((error = v.get<Car>().get(c))) {
      return error;
    }
    if(c.make != "Toyota") {
      car.push_back(c);
    }
  }
  return simdjson::SUCCESS;
 }
 }
 ```
 With this code, deserializing an `std::list<Car>` instance would capture only the cars
 that are not made by Toyota.
 ### 3. Using static reflection (C++26)
 If you have a C++26 compatible compiler, you can compile
 your code with the `SIMDJSON_STATIC_REFLECTION` macro set:
 ```cpp
 #define SIMDJSON_STATIC_REFLECTION 1
 //...
 #include "simdjson.h"
 ```
 Then you can deserialize a type such as `Car` automatically:
 ```cpp
 std::string json =  R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
       "tire_pressure": [ 40.1, 39.9 ] } )";
 simdjson::ondemand::parser parser;
 simdjson::ondemand::document doc = parser.iterate(simdjson::pad(json)).get(doc);
 Car c = doc.get<Car>();
 ```
 You can also automatically serialize the `Car` instance to a JSON string, see
 our [Builder documentation](builder.md).
 Minifying JSON strings without parsing
 ----------------------
@@ -1332,7 +1284,6 @@ In some cases, you may have valid JSON strings that you do not wish to parse but
  std::unique_ptr<char[]> buffer{new char[length]};
  size_t new_length{}; // It will receive the minified length.
  auto error = simdjson::minify(some_string, length, buffer.get(), new_length);
  if(error) { std::cerr << simdjson::error_message(error); }
  // The buffer variable now has "[1,2,3,4]" and new_length has value 9.
 ```
@@ -1476,11 +1427,9 @@ be represented as `value` instances. You can check that a document is a scalar w
 JSONPath
 ------------
-The simdjson library supports a subset of [JSONPath](https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00) through the `at_path()` method, allowing you to reach further into the document in a single call. The subset of JSONPath that is implemented is the subset that is trivially convertible into the JSON Pointer format, using `.` to access a field and `[]` to access a specific index.
+The simdjson library now supports a subset of [JSONPath](https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00) through the `at_path()` method, allowing you to reach further into the document in a single call. The subset of JSONPath that is implemented is the subset that is trivially convertible into the JSON Pointer format, using `.` to access a field and `[]` to access a specific index.
-This implementation relies on `at_path()` converting its argument to JSON Pointer and then calling `at_pointer`, which makes use of
+This implementation relies on `at_path()` converting its argument to JSON Pointer and then calling `at_pointer`, which makes use of [`rewind`](#rewind) to reset the parser at the beginning of the document. Hence, it invalidates all previously parsed values, objects and arrays: make sure to consume the values between each call to `at_path`.
 [`rewind`](#rewind) to reset the parser at the beginning of the document. Hence, it invalidates all previously parsed values, objects
 and arrays: make sure to consume the values between each call to `at_path`.
 Consider the following example:
@@ -1521,18 +1470,6 @@ doc.at_path(".\\u00E9") == 123; // true
 doc.at_path((const char*)u8".\u00E9") // returns an error (NO_SUCH_FIELD)
 ```
 We also support the `$` prefix. When you start a JSONPath expression with $, you are indicating that the path starts from the root of the JSON document. E.g.,
 ```c++
 auto json = R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;
 ondemand::parser parser;
 ondemand::document doc = parser.iterate(json);
 ondemand::object obj = doc.get_object();
 int64_t x = obj.at_path("$.c.foo.a[1]"); // 20
 x = obj.at_path("$.d.foo2.a.2"); // 30
 ```
 Error handling
 --------------
@@ -1544,7 +1481,7 @@ pair. You can retrieve the value with .get() without generating an exception, li
 ```c++
 ondemand::document doc;
 auto error = parser.iterate(json).get(doc);
-if(error) { std::cerr << simdjson::error_message(error); exit(1); }
+if (error) { cerr << error << endl; exit(1); }
 ```
 When there is no error, the error code `simdjson::SUCCESS`is returned: it evaluates as false as a Boolean.
@@ -1575,7 +1512,7 @@ bool simple_error_example() {
    auto error = doc["bad number"].get_double().get(x);
    // returns "simdjson::NUMBER_ERROR"
    if (error != SUCCESS) {
-      std::cerr << simdjson::error_message(error) << std::endl;
+      std::cout << error << std::endl;
      return false;
    }
    std::cout << "Got " << x << std::endl;
@@ -1628,6 +1565,7 @@ We can write a "quick start" example where we attempt to parse the following JSO
 Our program loads the file, selects value corresponding to key `"search_metadata"` which expected to be an object, and then
 it selects the key `"count"` within that object.
 ```C++
 #include <iostream>
 #include "simdjson.h"
@@ -1635,10 +1573,10 @@ it selects the key `"count"` within that object.
 int main(void) {
  simdjson::ondemand::parser parser;
  auto error = padded_string::load("twitter.json").get(json);
-  if (error) { std::cerr << simdjson::error_message(error) << std::endl; return EXIT_FAILURE; }
+  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
  simdjson::ondemand::document tweets;
  error = parser.iterate(json).get(tweets);
-  if (error) { std::cerr << simdjson::error_message(error) << std::endl; return EXIT_FAILURE; }
+  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
  simdjson::ondemand::value res;
  error = tweets["search_metadata"]["count"].get(res);
  if (error != SUCCESS) {
@@ -1654,7 +1592,7 @@ The following is a similar example where one wants to get the id of the first tw
 triggering exceptions. To do this, we use `["statuses"].at(0)["id"]`. We break that expression down:
 - Get the list of tweets (the `"statuses"` key of the document) using `["statuses"]`). The result is expected to be an array.
- Get the first tweet using `.at(0)`. The result is expected to be an object. Observe that the `at` method can only be called once on an array (it cannot be used for iteration).
+- Get the first tweet using `.at(0)`. The result is expected to be an object.
 - Get the id of the tweet using ["id"]. We expect the value to be a non-negative integer.
 Observe how we use the `at` method when querying an index into an array, and not the bracket operator.
@@ -1669,18 +1607,18 @@ int main(void) {
  simdjson::ondemand::document tweets;
  padded_string json;
  auto error = padded_string::load("twitter.json").get(json);
-  if (error) { std::cerr << simdjson::error_message(error) << std::endl; return EXIT_FAILURE; }
+  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
  error = parser.iterate(json).get(tweets);
-  if (error) { std::cerr << simdjson::error_message(error) << std::endl; return EXIT_FAILURE; }
+  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
  uint64_t identifier;
  error = tweets["statuses"].at(0)["id"].get(identifier);
-  if (error) { std::cerr << simdjson::error_message(error) << std::endl; return EXIT_FAILURE; }
+  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
  std::cout << identifier << std::endl;
 }
 ```
-*Important remark*: The `at` method can only be called once on an array. It cannot be used
+The `at` method can only be called once on an array. It cannot be used
-to iterate through the values of an array. We deliberately forbid this usage to avoid performance antipatterns. If you need to iterate through the values of an array, you should use a `for` loop.
+to iterate through the values of an array.
 ### Error handling examples without exceptions
@@ -1698,40 +1636,40 @@ bool parse() {
  // Iterating through an array of objects
  auto error = parser.iterate(cars_json).get(doc);
-  if (error) { std::cerr << simdjson::error_message(error) << std::endl; return false; }
+  if (error) { std::cerr << error << std::endl; return false; }
  ondemand::array cars; // invalid until the get() succeeds
  error = doc.get_array().get(cars);
  for (auto car_value : cars) {
    ondemand::object car; // invalid until the get() succeeds
    error = car_value.get_object().get(car);
-    if (error) { std::cerr << simdjson::error_message(error) << std::endl; return false; }
+    if (error) { std::cerr << error << std::endl; return false; }
    // Accessing a field by name
    std::string_view make;
    std::string_view model;
    error = car["make"].get(make);
-    if (error) { std::cerr << simdjson::error_message(error) << std::endl; return false; }
+    if (error) { std::cerr << error << std::endl; return false; }
    error = car["model"].get(model);
-    if (error) { std::cerr << simdjson::error_message(error) << std::endl; return false; }
+    if (error) { std::cerr << error << std::endl; return false; }
    cout << "Make/Model: " << make << "/" << model << endl;
    // Casting a JSON element to an integer
    uint64_t year{};
    error = car["year"].get(year);
-    if (error) { std::cerr << simdjson::error_message(error) << std::endl; return false; }
+    if (error) { std::cerr << error << std::endl; return false; }
    cout << "- This car is " << 2020 - year << " years old." << endl;
    // Iterating through an array of floats
    double total_tire_pressure = 0;
    ondemand::array pressures;
    error = car["tire_pressure"].get_array().get(pressures);
-    if (error) { std::cerr << simdjson::error_message(error) << std::endl; return false; }
+    if (error) { std::cerr << error << std::endl; return false; }
    for (auto tire_pressure_value : pressures) {
      double tire_pressure;
      error = tire_pressure_value.get_double().get(tire_pressure);
-      if (error) { std::cerr << simdjson::error_message(error) << std::endl; return false; }
+      if (error) { std::cerr << error << std::endl; return false; }
      total_tire_pressure += tire_pressure;
    }
    cout << "- Average tire pressure: " << (total_tire_pressure / 4) << endl;
@@ -1853,7 +1791,7 @@ auto doc = parser.iterate(broken_json);
 int64_t i;
 auto error = doc["integer"].get_int64().get(i);    // Expect to get integer from "integer" key, but get TAPE_ERROR
 if (error) {
-  std::cerr << simdjson::error_message(error) << std::endl;    // Prints TAPE_ERROR error message
+  std::cout << error << std::endl;    // Prints TAPE_ERROR error message
  // Recover a pointer to the location of the first error:
  const char * ptr;
  doc.current_location().get(ptr);
@@ -1890,7 +1828,7 @@ auto doc = parser.iterate(json);
 int64_t i;
 auto error = doc["integer"].get_int64().get(i);    // Incorrect call on array, INCORRECT_TYPE error
 if (error) {
-  std::cerr << simdjson::error_message(error) << std::endl;     // Prints INCORRECT_TYPE error message
+  std::cout << error << std::endl;     // Prints INCORRECT_TYPE error message
  std::cout<< doc.current_location() << std::endl;  // Prints "[1,2,3] " (location of INCORRECT_TYPE error)
 }
 ```
@@ -1999,7 +1937,6 @@ to the document `rewind()` method, except that it does not rewind the
 internal string buffer. Thus you should consume values only once
 even if you can iterate through the array or object more than once.
 If you unescape a string within an array more than once, you have unsafe code.
 You must not call `reset()` on an object or an array as you are iterating through it.
 Newline-Delimited JSON (ndjson) and JSON lines
@@ -2011,7 +1948,7 @@ serialize data into streams of multiple JSON documents. That is, instead of one
 write out multiple records as independent JSON documents, to be read one-by-one.
 The simdjson library also supports multithreaded JSON streaming through a large file
-containing many smaller JSON documents in either [ndjson](https://github.com/ndjson/ndjson-spec)
+containing many smaller JSON documents in either [ndjson](http://ndjson.org)
 or [JSON lines](http://jsonlines.org) format. If your JSON documents all contain arrays
 or objects, we even support direct file concatenation without whitespace. However, if there
 is content between your JSON documents, it should be exclusively ASCII white-space characters.
@@ -2064,7 +2001,7 @@ for (auto doc: stream) {
    error = doc.at_pointer("/4").get(val);
    // error == simdjson::CAPACITY
    if (error) {
-      std::cerr << simdjson::error_message(error) << std::endl;
+      std::cerr << error << std::endl;
      // We left 293 bytes unprocessed at the tail end of the input.
      std::cout << " unprocessed bytes at the end: " << stream.truncated_bytes() << std::endl;
      break;
@@ -2939,7 +2876,6 @@ Performance tips
 	std::string_view year = data["year"];
 	std::string_view rating = data["rating"];
  ```
 - You will get better performance if you seek the keys in the order in which they appear in the document. So if processing `{"a":1, "b":2, "c":3}`, do `value1 = data["a"]; value2 = data["b"]; value3 data["c"];` and not `value2 = data["b"]; value1 = data["a"]; value3 data["c"];`. Of course, it is not always possible to know for sure in which order the keys appear.
@@ -1,141 +0,0 @@
 Builder
 ==========
 Sometimes you want to generate JSON string outputs efficiently.
 The simdjson library provides high-performance low-level facilities.
 When using these low-level functionalities, you are responsible to
 define the structure of your JSON document. However, string escaping
 and UTF-8 validation is automated.
 Overview: string_builder
 ---------------------------
 The string_builder class is a low-level utility for constructing JSON strings representing documents. It is optimized for performance, potentially leveraging kernel-specific features like SIMD instructions for tasks such as string escaping. This class supports atomic types (e.g., booleans, numbers, strings) but does not handle composed types directly (like arrays or objects).
 An `string_builder` is created with an initial buffer capacity (e.g., 1kB). The memory
 is reallocated when needed. It has the following methods to add content to the string:
 - `append(number_type v)`: Appends a number (including booleans) to the JSON buffer. Booleans are converted to the strings "false" or "true". Numbers are formatted according to the JSON standard, with floating-point numbers using the shortest representation that accurately reflects the value.
 - `append(char c)`: Appends a single character to the JSON buffer.
 - `append_null()`: Appends the string "null" to the JSON buffer.
 - `clear()`: Clears the contents of the JSON buffer, resetting the position to 0 while retaining the allocated capacity.
 - `escape_and_append(std::string_view input)`: Appends a string view to the JSON buffer after escaping special characters (e.g., quotes, backslashes) as required by JSON.
 - `escape_and_append_with_quotes(std::string_view input)` Appends a string view surrounded by double quotes (e.g., "input") to the JSON buffer after escaping special characters.
 Parameters:
 - `escape_and_append_with_quotes(char input)`: Appends a single character surrounded by double quotes (e.g., "c") to the JSON buffer after escaping it if necessary.
 - `append_raw(const char *c)`: Appends a null-terminated C string directly to the JSON buffer without escaping.
 - `append_raw(std::string_view input)`: Appends a string view directly to the JSON buffer without escaping.
 - `append_raw(const char *str, size_t len)`: Appends a specified number of characters from a C string directly to the JSON
 After writting the content, if you have reasons to believe that the content might violate UTF-8 conventions, you can check it as follows:
 - `validate_unicode()`: Checks if the content in the JSON buffer is valid UTF-8. Returns: true if the content is valid UTF-8, false otherwise.
 Once you are satisfied, you can recover the string as follows:
 - `operator std::string()`: Converts the JSON buffer to an std::string. (Might throw if an error occurred.)
 - `operator std::string_view()`: Converts the JSON buffer to an std::string_view.  (Might throw if an error occurred.)
 - `view()`: Returns a view of the written JSON buffer as a `simdjson_result<std::string_view>`.
 The later method (`view()`) is recommended.
 Example: string_builder
 ---------------------------
 ```C++
    void serialize_car(const Car& car, simdjson::builder::string_builder& builder) {
        // start of JSON
        builder.append_raw("{");
        // "make"
        builder.escape_and_append_with_quotes("make");
        builder.append_raw(":");
        builder.escape_and_append_with_quotes(car.make);
        // "model"
        builder.append_raw(",");
        builder.escape_and_append_with_quotes("model");
        builder.append_raw(":");
        builder.escape_and_append_with_quotes(car.model);
        // "year"
        builder.append_raw(",");
        builder.escape_and_append_with_quotes("year");
        builder.append_raw(":");
        builder.append(car.year);
        // "tire_pressure"
        builder.append_raw(",");
        builder.escape_and_append_with_quotes("tire_pressure");
        builder.append_raw(":[");
        // vector tire_pressure
        for (size_t i = 0; i < car.tire_pressure.size(); ++i) {
            builder.append(car.tire_pressure[i]);
            if (i < car.tire_pressure.size() - 1) {
                builder.append_raw(",");
            }
        }
        // end of array
        builder.append_raw("]");
        // end of object
        builder.append_raw("}");
    }
    bool car_test() {
        simdjson::builder::string_builder sb;
        Car c = {"Toyota", "Corolla", 2017, {30.0,30.2,30.513,30.79}};
        serialize_car(c, sb);
        std::string_view p;
        if(sb.view().get(p)) {
            return false; // there was an error
        }
        // p holds the JSON:
        // "{\"make\":\"Toyota\",\"model\":\"Corolla\",\"year\":2017,\"tire_pressure\":[30.0,30.2,30.513,30.79]}"
        return true;
    }
 ```
 C++26 static reflection
 ------------------------
 If you have a compiler with support C++26 static reflection, you can compile
 your code with the `SIMDJSON_STATIC_REFLECTION` macro set:
 ```cpp
 #define SIMDJSON_STATIC_REFLECTION 1
 //...
 #include "simdjson.h"
 ```
 And then you can append your data structures to a `string_builder` instance
 automatically. In most cases, it should work automatically:
 ```cpp
    bool car_test() {
        simdjson::builder::string_builder sb;
        Car c = {"Toyota", "Corolla", 2017, {30.0,30.2,30.513,30.79}};
        append(sb, c);
        std::string_view p;
        if(sb.view().get(p)) {
            return false; // there was an error
        }
        // p holds the JSON:
        // "{\"make\":\"Toyota\",\"model\":\"Corolla\",\"year\":2017,\"tire_pressure\":[30.0,30.2,30.513,30.79]}"
        return true;
    }
 ```
 If you prefer, you can also create a string directly:
 ```cpp
  std::string json;
  if(simdjson::builder::to_json_string(c).get(json)) {
    // there was an error
  } else {
    // json contain the serialized JSON
  }
 ```
@@ -8,7 +8,6 @@ An overview of what you need to know to use simdjson, with examples.
 * [Using the Parsed JSON](#using-the-parsed-json)
 * [C++17 Support](#c17-support)
 * [JSON Pointer](#json-pointer)
 * [JSONPath](#jsonpath)
 * [Error Handling](#error-handling)
  * [Error Handling Example](#error-handling-example)
  * [Exceptions](#exceptions)
@@ -60,26 +59,6 @@ std::string data = "my data";
 simdjson::padded_string my_padded_data(data); // copies to a padded buffer
 ```
 You can then parse the JSON document from the `simdjson::padded_string` instance:
 ```cpp
 simdjson::dom::parser parser;
 simdjson::dom::element doc = parser.parse(my_padded_data);
 ```
 Whenever you pass an `std::string` reference to `parser::parse`,
 the parser will access the bytes beyond the end of
 the string but before the end of the allocated memory (`std::string::capacity()`).
 If you are using a sanitizer that checks for reading uninitialized bytes or `std::string`'s
 container-overflow checks, you may encounter sanitizer warnings.
 You can safely ignore these warnings. Or you can call `simdjson::pad(std::string&)` to pad the
 string with `SIMDJSON_PADDING` spaces: this function returns a `simdjson::padding_string_view` which can be be passed to the parser's iterator function:
 ```c++
 std::string json = "[1]";
 dom::element doc = parser.parse(simdjson::pad(json));
 ```
 The parsed document resulting from the `parser.load` and `parser.parse` calls depends on the `parser` instance. Thus the `parser` instance must remain in scope. Furthermore, you must have at most one parsed document in play per `parser` instance.
 You cannot copy a `parser` instance, you may only move it.
@@ -278,49 +257,6 @@ for (dom::element car_element : cars) {
 }
 ```
 JSONPath
 ------------
 The simdjson library supports a subset of [JSONPath](https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00) through the `at_path()` method, allowing you to reach further into the document in a single call. The subset of JSONPath that is implemented is the subset that is trivially convertible into the JSON Pointer format, using `.` to access a field and `[]` to access a specific index.
 Consider the following example:
 ```c++
 auto cars_json = R"( [
  { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
  { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
  { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
 ] )"_padded;
 dom::parser parser;
 dom::element doc;
 auto error = parser.parse(cars_json).get(doc);
 if(error) { /*won't happen*/ }
 double p;
 error = doc.at_path("[0].tire_pressure[1]").get(p);
 if(error) { /*won't happen*/ }
 cout << p << endl; // Prints 39.9
 ```
 We also support the `$` prefix. When you start a JSONPath expression with $, you are indicating that the path starts from the root of the JSON document. E.g.,
 ```c++
 auto json = R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;
 dom::parser parser;
 dom::element doc;
 auto error = parser.parse(json).get(doc);
 if(error) { /*won't happen*/ }
 dom::object obj;
 error = doc.get_object().get(obj);
 if(error) { /*won't happen*/ }
 int64_t x;
 error = obj.at_path("$[3].foo.a[1]").get(x);
 if(error) { /*won't happen*/ }
 if(x != 20) { /*won't happen*/ }
 x = obj.at_path("$.d.foo2.a.2");
 if(error) { /*won't happen*/ }
 ```
 Error Handling
@@ -25,7 +25,6 @@ Contents
 - [Use cases](#use-cases)
 - [Tracking your position](#tracking-your-position)
 - [Incomplete streams](#incomplete-streams)
 - [C++20 features](#c20-features)
 Motivation
 -----------
@@ -103,12 +102,7 @@ remove almost entirely its cost and replaces it by the overhead of a thread, whi
 cheaper. Ain't that awesome!
 Thread support is only active if thread supported is detected in which case the macro
-SIMDJSON_THREADS_ENABLED is set.  You can also manually pass `SIMDJSON_THREADS_ENABLED=1` flag
+SIMDJSON_THREADS_ENABLED is set. Otherwise the library runs in  single-thread mode.
 to the library. Otherwise the library runs in single-thread mode.
 You should be consistent. If you link against the simdjson library built for multithreading
 (i.e., with `SIMDJSON_THREADS_ENABLED`), then you should build your application with multithreading
 system (setting `SIMDJSON_THREADS_ENABLED=1` and linking against a thread library).
 A `document_stream` instance uses at most two threads: there is a main thread and a worker thread.
@@ -130,7 +124,7 @@ If your documents are all objects or arrays, then you may even have nothing betw
 E.g., `[1,2]{"32":1}` is recognized as two documents.
 Some official formats **(non-exhaustive list)**:
- [Newline-Delimited JSON (NDJSON)](https://github.com/ndjson/ndjson-spec/)
+- [Newline-Delimited JSON (NDJSON)](http://ndjson.org/)
 - [JSON lines (JSONL)](http://jsonlines.org/)
 - [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464) <- Not supported by JsonStream!
 - [More on Wikipedia...](https://en.wikipedia.org/wiki/JSON_streaming)
@@ -294,111 +288,3 @@ string
 object
 array
 ```
 C++20 features
 --------------------
 In C++20, the standard introduced the notion of *customization point*.
 A customization point is a function or function object that can be customized for different types. It allows library authors to provide default behavior while giving users the ability to override this behavior for specific types.
 A tag_invoke function serves as a mechanism for customization points. It is not directly part of the C++ standard library but is often used in libraries that implement customization points.
 The tag_invoke function is typically a generic function that takes a tag type and additional arguments.
 The first argument is usually a tag type (often an empty struct) that uniquely identifies the customization point (e.g., deserialization of custom types in simdjson). Users or library providers can specialize tag_invoke for their types by defining it in the appropriate namespace, often inline namespace.
 You can deserialize you own data structures conveniently if your system supports C++20.
 When it is the case, the macro `SIMDJSON_SUPPORTS_DESERIALIZATION` will be set to 1 by
 the simdjson library.
 Consider a custom class `Car`:
 ```C++
 struct Car {
  std::string make;
  std::string model;
  int year;
  std::vector<float> tire_pressure;
 };
 ```
 You may support deserializing directly from a JSON value or document to your own `Car` instance
 by defining a single `tag_invoke` function:
 ```C++
 namespace simdjson {
 // This tag_invoke MUST be inside simdjson namespace
 template <typename simdjson_value>
 auto tag_invoke(deserialize_tag, simdjson_value &val, Car& car) {
  ondemand::object obj;
  auto error = val.get_object().get(obj);
  if (error) {
    return error;
  }
  if ((error = obj["make"].get_string(car.make))) {
    return error;
  }
  if ((error = obj["model"].get_string(car.model))) {
    return error;
  }
  if ((error = obj["year"].get(car.year))) {
    return error;
  }
  if ((error = obj["tire_pressure"].get<std::vector<float>>().get(
           car.tire_pressure))) {
    return error;
  }
  return simdjson::SUCCESS;
 }
 } // namespace simdjson
 ```
 Importantly, the `tag_invoke` function must be inside the `simdjson` namespace.
 Let us explain each argument of `tag_invoke` function.
 - `simdjson::deserialize_tag`: it is the tag for Customization Point Object (CPO). You may often ignore this parameter. It is used to indicate that you mean to provide a deserialization function for simdjson.
 - `var`: It receives automatically a `simdjson` value type (document, value, document_reference).
 - The third parameter is an instance of the type that you want to support.
 Please see our main documentation (`basics.md`) under
 "Use `tag_invoke` for custom types (C++20)" for details about
 tag_invoke functions.
 Given a stream of JSON documents, you can add them to a data struture
 such as a `std::vector<Car>` like so if you support exceptions:
 ```C++
  padded_string json =
      R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
       "tire_pressure": [ 40.1, 39.9 ] }
  { "make": "Kia",    "model": "Soul",   "year": 2012,
       "tire_pressure": [ 30.1, 31.0 ] }
  { "make": "Toyota", "model": "Tercel", "year": 1999,
       "tire_pressure": [ 29.8, 30.0 ] }
 )"_padded;
  ondemand::parser parser;
  ondemand::document_stream stream;
  [[maybe_unused]] auto error = parser.iterate_many(json).get(stream);
  std::vector<Car> cars;
  for(auto doc : stream) {
    cars.push_back((Car)doc); // an exception may be thrown
  }
 ```
 Otherwise you may use this longer version for explicit handling of errors:
 ```C++
  std::vector<Car> cars;
  for(auto doc : stream) {
    Car c;
    if ((error = doc.get<Car>().get(c))) {
      std::cerr << simdjson::error_message(error); << std::endl;
      return EXIT_FAILURE;
    }
    cars.push_back(c);
  }
 ```
@@ -102,7 +102,7 @@ or indexing (`object["key"]`). In some cases, the values are even deserialized d
 maps.
 The DOM approach is conceptually simple and "programmer friendly". Using the
-DOM tree is often easy enough that many users process the DOM as-is instead of creating
+DOM tree is often easy enough that many users use the DOM as-is instead of creating
 their own custom data structures.
 The DOM approach was the only way to parse JSON documents up to version 0.6 of the simdjson library.
@@ -103,12 +103,7 @@ cases, remove almost entirely its cost and replaces it by the overhead of a thre
 of magnitude cheaper. Ain't that awesome!
 Thread support is only active if thread supported is detected in which case the macro
-SIMDJSON_THREADS_ENABLED is set.  You can also manually pass `SIMDJSON_THREADS_ENABLED=1` flag
+SIMDJSON_THREADS_ENABLED is set. Otherwise the library runs in  single-thread mode.
 to the library. Otherwise the library runs in single-thread mode.
 You should be consistent. If you link against the simdjson library built for multithreading
 (i.e., with `SIMDJSON_THREADS_ENABLED`), then you should build your application with multithreading
 system (setting `SIMDJSON_THREADS_ENABLED=1` and linking against a thread library).
 A `document_stream` instance uses at most two threads: there is a main thread and a worker thread.
 You should expect the main thread to be fully occupied while the worker thread is partially busy
@@ -130,7 +125,7 @@ Whitespace Characters:
 - **Nothing**
 Some official formats **(non-exhaustive list)**:
- [Newline-Delimited JSON (NDJSON)](https://github.com/ndjson/ndjson-spec)
+- [Newline-Delimited JSON (NDJSON)](http://ndjson.org/)
 - [JSON lines (JSONL)](http://jsonlines.org/)
 - [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464) <- Not supported by JsonStream!
 - [More on Wikipedia...](https://en.wikipedia.org/wiki/JSON_streaming)
@@ -158,9 +158,7 @@ On Intel and AMD Windows platforms, Microsoft Visual Studio enables programmers
 When compiling with Visual Studio, we recommend the flags `/Ob2 /O2` or better. We do not recommend that you compile simdjson with architecture-specific flags such as  `arch:AVX2`. The simdjson library automatically selects the best execution kernel at runtime.
-Recent versions of Microsoft Visual Studio on Windows provides support for the LLVM Clang compiler. You  only need to install the "Clang compiler" optional component (clang-cl). You may also get a copy of the 64-bit LLVM CLang compiler for [Windows directly from LLVM](https://releases.llvm.org/download.html). The simdjson library fully supports the LLVM Clang compiler under Windows. In fact, you may get better performance out of simdjson with the LLVM Clang compiler than with the regular Visual Studio compiler. Meanwhile the [LLVM CLang compiler is binary compatible with Visual Studio](https://clang.llvm.org/docs/MSVCCompatibility.html) which means that you can combine their binaries (executables and libraries).
+Recent versions of Microsoft Visual Studio on Windows provides support for the LLVM Clang compiler. You  only need to install the "Clang compiler" optional component (ClangCL). You may also get a copy of the 64-bit LLVM CLang compiler for [Windows directly from LLVM](https://releases.llvm.org/download.html). The simdjson library fully supports the LLVM Clang compiler under Windows. In fact, you may get better performance out of simdjson with the LLVM Clang compiler than with the regular Visual Studio compiler. Meanwhile the [LLVM CLang compiler is binary compatible with Visual Studio](https://clang.llvm.org/docs/MSVCCompatibility.html) which means that you can combine their binaries (executables and libraries).
 We recommend Visual Studio users prefer LLVM (clang-cl). It compiles to faster release binaries. Furthermore, it compilers faster in release mode.
 Under Windows, we also support the GNU GCC compiler via MSYS2. The performance of 64-bit MSYS2 under Windows is excellent (on par with Linux).
@@ -243,8 +241,8 @@ long page_size() {
 // Returns true if the buffer + len + simdjson::SIMDJSON_PADDING crosses the
 // page boundary.
 bool need_allocation(const char *buf, size_t len) {
-  return ((reinterpret_cast<uintptr_t>(buf + len - 1) % page_size())
+  return ((reinterpret_cast<uintptr_t>(buf + len - 1) % page_size()) <
-    + simdjson::SIMDJSON_PADDING > static_cast<uintptr_t>(page_size()));
+          simdjson::SIMDJSON_PADDING);
 }
 simdjson::padded_string_view
@@ -20,14 +20,10 @@ IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
  endif()
  add_quickstart_test(quickstart_noexceptions   quickstart_noexceptions.cpp NO_EXCEPTIONS LABELS acceptance)
-  if(NOT SIMDJSON_STATIC_REFLECTION)
+  add_quickstart_test(quickstart_noexceptions11 quickstart_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11)
    add_quickstart_test(quickstart_noexceptions11 quickstart_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11)
  endif(NOT SIMDJSON_STATIC_REFLECTION)
  add_quickstart_test(quickstart2_noexceptions   quickstart2_noexceptions.cpp NO_EXCEPTIONS LABELS acceptance)
-  if(NOT SIMDJSON_STATIC_REFLECTION)
+  add_quickstart_test(quickstart2_noexceptions11 quickstart2_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11)
    add_quickstart_test(quickstart2_noexceptions11 quickstart2_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11)
  endif(NOT SIMDJSON_STATIC_REFLECTION)
  # On-Demand Quick Start
  if (SIMDJSON_EXCEPTIONS)
@@ -37,8 +33,6 @@ IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
  endif()
  add_quickstart_test(quickstart_ondemand_noexceptions   quickstart_ondemand_noexceptions.cpp NO_EXCEPTIONS LABELS quickstart_ondemand acceptance)
-  if(NOT SIMDJSON_STATIC_REFLECTION)
+  add_quickstart_test(quickstart_ondemand_noexceptions11 quickstart_ondemand_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11 LABELS quickstart_ondemand)
    add_quickstart_test(quickstart_ondemand_noexceptions11 quickstart_ondemand_noexceptions.cpp NO_EXCEPTIONS CXX_STANDARD c++11 LABELS quickstart_ondemand)
  endif(NOT SIMDJSON_STATIC_REFLECTION)
 endif()
@@ -72,7 +72,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
    // make this dynamic, so it works regardless of how it was compiled
    // or what hardware it runs on
-    constexpr std::size_t Nimplementations_max=4;
+    constexpr std::size_t Nimplementations_max=3;
    const std::size_t Nimplementations = supported_implementations.size();
    if(Nimplementations>Nimplementations_max) {
@@ -53,4 +53,5 @@
 #include "simdjson/dom.h"
 #include "simdjson/ondemand.h"
 #endif // SIMDJSON_H
@@ -19,7 +19,7 @@ SIMDJSON_NO_SANITIZE_UNDEFINED
 // See issue https://github.com/simdjson/simdjson/issues/1965
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_inline int trailing_zeroes(uint64_t input_num) {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
  unsigned long ret;
  // Search the mask data from least significant bit (LSB)
  // to the most significant bit (MSB) for a set bit (1).
@@ -35,15 +35,9 @@ simdjson_inline uint64_t clear_lowest_bit(uint64_t input_num) {
  return input_num & (input_num-1);
 }
 // We sometimes call leading_zeroes on inputs that are zero,
 // but the algorithms do not end up using the returned value.
 // Sadly, sanitizers are not smart enough to figure it out.
 // Applies only when SIMDJSON_PREFER_REVERSE_BITS is defined and true.
 // (See below.)
 SIMDJSON_NO_SANITIZE_UNDEFINED
 /* result might be undefined when input_num is zero */
 simdjson_inline int leading_zeroes(uint64_t input_num) {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
  unsigned long leading_zero = 0;
  // Search the mask data from most significant bit (MSB)
  // to least significant bit (LSB) for a set bit (1).
@@ -96,7 +90,7 @@ simdjson_inline uint64_t zero_leading_bit(uint64_t rev_bits, int leading_zeroes)
 #endif
 simdjson_inline bool add_overflow(uint64_t value1, uint64_t value2, uint64_t *result) {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
  *result = value1 + value2;
  return *result < value1;
 #else
@@ -23,7 +23,6 @@ public:
  ) const noexcept final;
  simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
  simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 } // namespace arm64
@@ -51,12 +51,6 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace arm64
 } // namespace simdjson
 #ifndef SIMDJSON_SWAR_NUMBER_PARSING
 #if SIMDJSON_IS_BIG_ENDIAN
 #define SIMDJSON_SWAR_NUMBER_PARSING 0
 #else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
 #endif
 #endif
 #endif // SIMDJSON_ARM64_NUMBERPARSING_DEFS_H
@@ -12,7 +12,7 @@ namespace arm64 {
 namespace {
 namespace simd {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
 namespace {
 // Start of private section with Visual Studio workaround
@@ -121,7 +121,7 @@ namespace {
    // We return uint32_t instead of uint16_t because that seems to be more efficient for most
    // purposes (cutting it down to uint16_t costs performance in some compilers).
    simdjson_inline uint32_t to_bitmask() const {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
      const uint8x16_t bit_mask =  simdjson_make_uint8x16_t(0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,
                                                   0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80);
 #else
@@ -134,12 +134,6 @@ namespace {
      tmp = vpaddq_u8(tmp, tmp);
      return vgetq_lane_u16(vreinterpretq_u16_u8(tmp), 0);
    }
    // Returns 4-bit out of each byte, alternating between the high 4 bits and low
    // bits result it is 64 bit.
    simdjson_inline uint64_t to_bitmask64() const {
      return vget_lane_u64(
          vreinterpret_u64_u8(vshrn_n_u16(vreinterpretq_u16_u8(*this), 4)), 0);
    }
    simdjson_inline bool any() const { return vmaxvq_u32(vreinterpretq_u32_u8(*this)) != 0; }
  };
@@ -158,7 +152,7 @@ namespace {
    // Splat constructor
    simdjson_inline simd8(uint8_t _value) : simd8(splat(_value)) {}
    // Member-by-member initialization
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
    simdjson_inline simd8(
      uint8_t v0,  uint8_t v1,  uint8_t v2,  uint8_t v3,  uint8_t v4,  uint8_t v5,  uint8_t v6,  uint8_t v7,
      uint8_t v8,  uint8_t v9,  uint8_t v10, uint8_t v11, uint8_t v12, uint8_t v13, uint8_t v14, uint8_t v15
@@ -216,7 +210,7 @@ namespace {
    // Bit-specific operations
    simdjson_inline simd8<bool> any_bits_set(simd8<uint8_t> bits) const { return vtstq_u8(*this, bits); }
-    simdjson_inline bool any_bits_set_anywhere() const { return vmaxvq_u32(vreinterpretq_u32_u8(*this)) != 0; }
+    simdjson_inline bool any_bits_set_anywhere() const { return this->max_val() != 0; }
    simdjson_inline bool any_bits_set_anywhere(simd8<uint8_t> bits) const { return (*this & bits).any_bits_set_anywhere(); }
    template<int N>
    simdjson_inline simd8<uint8_t> shr() const { return vshrq_n_u8(*this, N); }
@@ -229,12 +223,7 @@ namespace {
      return lookup_table.apply_lookup_16_to(*this);
    }
-    // Returns 4-bit out of each byte, alternating between the high 4 bits and low
+
    // bits result it is 64 bit.
    simdjson_inline uint64_t to_bitmask64() const {
      return vget_lane_u64(
          vreinterpret_u64_u8(vshrn_n_u16(vreinterpretq_u16_u8(*this), 4)), 0);
    }
    // Copies to 'output" all bytes corresponding to a 0 in the mask (interpreted as a bitset).
    // Passing a 0 value for mask would be equivalent to writing out every byte to output.
    // Only the first 16 - count_ones(mask) bytes of the result are significant but 16 bytes
@@ -257,7 +246,7 @@ namespace {
      uint64x2_t shufmask64 = {thintable_epi8[mask1], thintable_epi8[mask2]};
      uint8x16_t shufmask = vreinterpretq_u8_u64(shufmask64);
      // we increment by 0x08 the second half of the mask
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
      uint8x16_t inc = simdjson_make_uint8x16_t(0, 0, 0, 0, 0, 0, 0, 0, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08);
 #else
      uint8x16_t inc = {0, 0, 0, 0, 0, 0, 0, 0, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08};
@@ -287,7 +276,7 @@ namespace {
      uint8x8_t compactmask1 = vcreate_u8(thintable_epi8[mask1]);
      uint8x8_t compactmask2 = vcreate_u8(thintable_epi8[mask2]);
      // we increment by 0x08 the second half of the mask
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
      uint8x8_t inc = simdjson_make_uint8x8_t(0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08);
 #else
      uint8x8_t inc = {0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08};
@@ -339,7 +328,7 @@ namespace {
    // Array constructor
    simdjson_inline simd8(const int8_t* values) : simd8(load(values)) {}
    // Member-by-member initialization
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
    simdjson_inline simd8(
      int8_t v0,  int8_t v1,  int8_t v2,  int8_t v3, int8_t v4,  int8_t v5,  int8_t v6,  int8_t v7,
      int8_t v8,  int8_t v9,  int8_t v10, int8_t v11, int8_t v12, int8_t v13, int8_t v14, int8_t v15
@@ -460,7 +449,7 @@ namespace {
    }
    simdjson_inline uint64_t to_bitmask() const {
-#if SIMDJSON_REGULAR_VISUAL_STUDIO
+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
      const uint8x16_t bit_mask = simdjson_make_uint8x16_t(
        0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,
        0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80
@@ -46,32 +46,6 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
  };
 }
 struct escaping {
  static constexpr uint32_t BYTES_PROCESSED = 16;
  simdjson_inline static escaping copy_and_find(const uint8_t *src, uint8_t *dst);
  simdjson_inline bool has_escape() { return escape_bits != 0; }
  simdjson_inline int escape_index() { return trailing_zeroes(escape_bits) / 4; }
  uint64_t escape_bits;
 }; // struct escaping
 simdjson_inline escaping escaping::copy_and_find(const uint8_t *src, uint8_t *dst) {
  static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "escaping finder must process fewer than SIMDJSON_PADDING bytes");
  simd8<uint8_t> v(src);
  v.store(dst);
  simd8<bool> is_quote = (v == '"');
  simd8<bool> is_backslash = (v == '\\');
  simd8<bool> is_control = (v < 32);
  return {
    (is_backslash | is_quote | is_control).to_bitmask64()
  };
 }
 } // unnamed namespace
 } // namespace arm64
 } // namespace simdjson
@@ -9,7 +9,6 @@
 #include "simdjson/compiler_check.h"
 #include "simdjson/error.h"
 #include "simdjson/portability.h"
 #include "simdjson/concepts.h"
 /**
 * @brief The top level simdjson namespace, containing everything the library provides.
@@ -50,8 +50,6 @@ double from_chars(const char *first, const char* end) noexcept;
 #define SIMDJSON_ISALIGNED_N(ptr, n) (((uintptr_t)(ptr) & ((n)-1)) == 0)
 #if SIMDJSON_REGULAR_VISUAL_STUDIO
  // We could use [[deprecated]] but it requires C++14
  #define simdjson_deprecated __declspec(deprecated)
  #define simdjson_really_inline __forceinline
  #define simdjson_never_inline __declspec(noinline)
@@ -90,8 +88,6 @@ double from_chars(const char *first, const char* end) noexcept;
  #define SIMDJSON_POP_DISABLE_UNUSED_WARNINGS
 #else // SIMDJSON_REGULAR_VISUAL_STUDIO
  // We could use [[deprecated]] but it requires C++14
  #define simdjson_deprecated __attribute__((deprecated))
  #define simdjson_really_inline inline __attribute__((always_inline))
  #define simdjson_never_inline inline __attribute__((noinline))
@@ -50,55 +50,16 @@
 #endif
 #endif
 #ifndef SIMDJSON_CONSTEXPR_LAMBDA
 #if SIMDJSON_CPLUSPLUS17
 #define SIMDJSON_CONSTEXPR_LAMBDA constexpr
 #else
 #define SIMDJSON_CONSTEXPR_LAMBDA
 #endif
 #endif
 #ifdef __has_include
 #if __has_include(<version>)
 #include <version>
 #endif
 #endif
-// The current specification is unclear on how we detect
+#ifdef __cpp_concepts
 // static reflection, both __cpp_lib_reflection and
 // __cpp_impl_reflection are proposed in the draft specification.
 // For now, we disable static reflect by default. It must be
 // specified at compiler time.
 #ifndef SIMDJSON_STATIC_REFLECTION
 #define SIMDJSON_STATIC_REFLECTION 0 // disabled by default.
 #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
+#else // __cpp_concepts
 #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)
 #if !defined(SIMDJSON_CONSTEVAL)
 #if defined(__cpp_consteval) && __cpp_consteval >= 201811L
 #define SIMDJSON_CONSTEVAL 1
 #else
 #define SIMDJSON_CONSTEVAL 0
 #endif // defined(__cpp_consteval) && __cpp_consteval >= 201811L
 #endif // !defined(SIMDJSON_CONSTEVAL)
 #endif // SIMDJSON_COMPILER_CHECK_H
@@ -1,114 +0,0 @@
 #ifndef SIMDJSON_CONCEPTS_H
 #define SIMDJSON_CONCEPTS_H
 #if SIMDJSON_SUPPORTS_DESERIALIZATION
 #include <concepts>
 #include <type_traits>
 namespace simdjson {
 namespace concepts {
 namespace details {
 #define SIMDJSON_IMPL_CONCEPT(name, method)                                    \
  template <typename T>                                                        \
  concept supports_##name = !std::is_const_v<T> && requires {                  \
    typename std::remove_cvref_t<T>::value_type;                               \
    requires requires(typename std::remove_cvref_t<T>::value_type &&val,       \
                      T obj) {                                                 \
      obj.method(std::move(val));                                              \
      requires !requires { obj = std::move(val); };                            \
    };                                                                         \
  };
 SIMDJSON_IMPL_CONCEPT(emplace_back, emplace_back)
 SIMDJSON_IMPL_CONCEPT(emplace, emplace)
 SIMDJSON_IMPL_CONCEPT(push_back, push_back)
 SIMDJSON_IMPL_CONCEPT(add, add)
 SIMDJSON_IMPL_CONCEPT(push, push)
 SIMDJSON_IMPL_CONCEPT(append, append)
 SIMDJSON_IMPL_CONCEPT(insert, insert)
 SIMDJSON_IMPL_CONCEPT(op_append, operator+=)
 #undef SIMDJSON_IMPL_CONCEPT
 } // namespace details
 /// Check if T is a container that we can append to, including:
 ///   std::vector, std::deque, std::list, std::string, ...
 template <typename T>
 concept appendable_containers =
    details::supports_emplace_back<T> || details::supports_emplace<T> ||
    details::supports_push_back<T> || details::supports_push<T> ||
    details::supports_add<T> || details::supports_append<T> ||
    details::supports_insert<T>;
 /// Insert into the container however possible
 template <appendable_containers T, typename... Args>
 constexpr decltype(auto) emplace_one(T &vec, Args &&...args) {
  if constexpr (details::supports_emplace_back<T>) {
    return vec.emplace_back(std::forward<Args>(args)...);
  } else if constexpr (details::supports_emplace<T>) {
    return vec.emplace(std::forward<Args>(args)...);
  } else if constexpr (details::supports_push_back<T>) {
    return vec.push_back(std::forward<Args>(args)...);
  } else if constexpr (details::supports_push<T>) {
    return vec.push(std::forward<Args>(args)...);
  } else if constexpr (details::supports_add<T>) {
    return vec.add(std::forward<Args>(args)...);
  } else if constexpr (details::supports_append<T>) {
    return vec.append(std::forward<Args>(args)...);
  } else if constexpr (details::supports_insert<T>) {
    return vec.insert(std::forward<Args>(args)...);
  } else if constexpr (details::supports_op_append<T> && sizeof...(Args) == 1) {
    return vec.operator+=(std::forward<Args>(args)...);
  } else {
    static_assert(!sizeof(T *),
                  "We don't know how to add things to this container");
  }
 }
 /// This checks if the container will return a reference to the newly added
 /// element after an insert which for example `std::vector::emplace_back` does
 /// since C++17; this will allow some optimizations.
 template <typename T>
 concept returns_reference = appendable_containers<T> && requires {
  typename std::remove_cvref_t<T>::reference;
  requires requires(typename std::remove_cvref_t<T>::value_type &&val, T obj) {
    {
      emplace_one(obj, std::move(val))
    } -> std::same_as<typename std::remove_cvref_t<T>::reference>;
  };
 };
 template <typename T>
 concept smart_pointer = requires(std::remove_cvref_t<T> ptr) {
  // Check if T has a member type named element_type
  typename std::remove_cvref_t<T>::element_type;
  // Check if T has a get() member function
  {
    ptr.get()
  } -> std::same_as<typename std::remove_cvref_t<T>::element_type *>;
  // Check if T can be dereferenced
  { *ptr } -> std::same_as<typename std::remove_cvref_t<T>::element_type &>;
 };
 template <typename T>
 concept optional_type = requires(std::remove_cvref_t<T> obj) {
  typename std::remove_cvref_t<T>::value_type;
  { obj.value() } -> std::same_as<typename std::remove_cvref_t<T>::value_type&>;
  requires requires(typename std::remove_cvref_t<T>::value_type &&val) {
    obj.emplace(std::move(val));
    obj = std::move(val);
    {
      obj.value_or(val)
    } -> std::convertible_to<typename std::remove_cvref_t<T>::value_type>;
  };
  { static_cast<bool>(obj) } -> std::same_as<bool>; // convertible to bool
 };
 } // namespace concepts
 } // namespace simdjson
 #endif // SIMDJSON_SUPPORTS_DESERIALIZATION
 #endif // SIMDJSON_CONCEPTS_H
@@ -7,7 +7,6 @@
 #include "simdjson/dom/array.h"
 #include "simdjson/dom/element.h"
 #include "simdjson/error-inl.h"
 #include "simdjson/jsonpathutil.h"
 #include "simdjson/internal/tape_ref-inl.h"
 #include <limits>
@@ -45,13 +44,6 @@ inline simdjson_result<dom::element> simdjson_result<dom::array>::at_pointer(std
  if (error()) { return error(); }
  return first.at_pointer(json_pointer);
 }
 inline simdjson_result<dom::element> simdjson_result<dom::array>::at_path(std::string_view json_path) const noexcept {
  auto json_pointer = json_path_to_pointer_conversion(json_path);
  if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
  return at_pointer(json_pointer);
 }
 inline simdjson_result<dom::element> simdjson_result<dom::array>::at(size_t index) const noexcept {
  if (error()) { return error(); }
  return first.at(index);
@@ -121,12 +113,6 @@ inline simdjson_result<element> array::at_pointer(std::string_view json_pointer)
  return child;
 }
 inline simdjson_result<element> array::at_path(std::string_view json_path) const noexcept {
  auto json_pointer = json_path_to_pointer_conversion(json_path);
  if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
  return at_pointer(json_pointer);
 }
 inline simdjson_result<element> array::at(size_t index) const noexcept {
  SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914
  size_t i=0;
@@ -108,21 +108,6 @@ public:
   */
  inline simdjson_result<element> at_pointer(std::string_view json_pointer) const noexcept;
  /**
   * Get the value associated with the given JSONPath expression. We only support
   * JSONPath queries that trivially convertible to JSON Pointer queries: key
   * names and array indices.
   *
   * https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00
   *
   * @return The value associated with the given JSONPath expression, or:
   *         - INVALID_JSON_POINTER if the JSONPath to JSON Pointer conversion fails
   *         - NO_SUCH_FIELD if a field does not exist in an object
   *         - INDEX_OUT_OF_BOUNDS if an array index is larger than an array length
   *         - INCORRECT_TYPE if a non-integer is used to access an array
  */
  inline simdjson_result<element> at_path(std::string_view json_path) const noexcept;
  /**
   * Get the value at the given index. This function has linear-time complexity and
   * is equivalent to the following:
@@ -167,7 +152,6 @@ public:
  simdjson_inline simdjson_result(error_code error) noexcept; ///< @private
  inline simdjson_result<dom::element> at_pointer(std::string_view json_pointer) const noexcept;
  inline simdjson_result<dom::element> at_path(std::string_view json_path) const noexcept;
  inline simdjson_result<dom::element> at(size_t index) const noexcept;
 #if SIMDJSON_EXCEPTIONS
@@ -9,7 +9,6 @@
 #include "simdjson/dom/object-inl.h"
 #include "simdjson/error-inl.h"
 #include "simdjson/jsonpathutil.h"
 #include <ostream>
 #include <limits>
@@ -123,11 +122,6 @@ simdjson_inline simdjson_result<dom::element> simdjson_result<dom::element>::at_
  if (error()) { return error(); }
  return first.at_pointer(json_pointer);
 }
 simdjson_inline simdjson_result<dom::element> simdjson_result<dom::element>::at_path(const std::string_view json_path) const noexcept {
  auto json_pointer = json_path_to_pointer_conversion(json_path);
  if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
  return at_pointer(json_pointer);
 }
 #ifndef SIMDJSON_DISABLE_DEPRECATED_API
 [[deprecated("For standard compliance, use at_pointer instead, and prefix your pointers with a slash '/', see RFC6901 ")]]
 simdjson_inline simdjson_result<dom::element> simdjson_result<dom::element>::at(const std::string_view json_pointer) const noexcept {
@@ -418,11 +412,6 @@ inline simdjson_result<element> element::at_pointer(std::string_view json_pointe
    }
  }
 }
 inline simdjson_result<element> element::at_path(std::string_view json_path) const noexcept {
  auto json_pointer = json_path_to_pointer_conversion(json_path);
  if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
  return at_pointer(json_pointer);
 }
 #ifndef SIMDJSON_DISABLE_DEPRECATED_API
 [[deprecated("For standard compliance, use at_pointer instead, and prefix your pointers with a slash '/', see RFC6901 ")]]
 inline simdjson_result<element> element::at(std::string_view json_pointer) const noexcept {
@@ -372,8 +372,6 @@ public:
   *         - INCORRECT_TYPE if this is not an object
   */
  inline simdjson_result<element> operator[](const char *key) const noexcept;
  simdjson_result<element> operator[](int) const noexcept = delete;
  /**
   * Get the value associated with the given JSON pointer.  We use the RFC 6901
@@ -399,21 +397,6 @@ public:
   */
  inline simdjson_result<element> at_pointer(const std::string_view json_pointer) const noexcept;
  /**
   * Get the value associated with the given JSONPath expression. We only support
   * JSONPath queries that trivially convertible to JSON Pointer queries: key
   * names and array indices.
   *
   * https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00
   *
   * @return The value associated with the given JSONPath expression, or:
   *         - INVALID_JSON_POINTER if the JSONPath to JSON Pointer conversion fails
   *         - NO_SUCH_FIELD if a field does not exist in an object
   *         - INDEX_OUT_OF_BOUNDS if an array index is larger than an array length
   *         - INCORRECT_TYPE if a non-integer is used to access an array
  */
  inline simdjson_result<element> at_path(std::string_view json_path) const noexcept;
 #ifndef SIMDJSON_DISABLE_DEPRECATED_API
  /**
   *
@@ -542,9 +525,7 @@ public:
  simdjson_inline simdjson_result<dom::element> operator[](std::string_view key) const noexcept;
  simdjson_inline simdjson_result<dom::element> operator[](const char *key) const noexcept;
  simdjson_result<dom::element> operator[](int) const noexcept = delete;
  simdjson_inline simdjson_result<dom::element> at_pointer(const std::string_view json_pointer) const noexcept;
  simdjson_inline simdjson_result<dom::element> at_path(const std::string_view json_path) const noexcept;
  [[deprecated("For standard compliance, use at_pointer instead, and prefix your pointers with a slash '/', see RFC6901 ")]]
  simdjson_inline simdjson_result<dom::element> at(const std::string_view json_pointer) const noexcept;
  simdjson_inline simdjson_result<dom::element> at(size_t index) const noexcept;
@@ -7,7 +7,6 @@
 #include "simdjson/dom/element-inl.h"
 #include "simdjson/error-inl.h"
 #include "simdjson/jsonpathutil.h"
 #include <cstring>
@@ -35,11 +34,6 @@ inline simdjson_result<dom::element> simdjson_result<dom::object>::at_pointer(st
  if (error()) { return error(); }
  return first.at_pointer(json_pointer);
 }
 inline simdjson_result<dom::element> simdjson_result<dom::object>::at_path(std::string_view json_path) const noexcept {
  auto json_pointer = json_path_to_pointer_conversion(json_path);
  if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
  return at_pointer(json_pointer);
 }
 inline simdjson_result<dom::element> simdjson_result<dom::object>::at_key(std::string_view key) const noexcept {
  if (error()) { return error(); }
  return first.at_key(key);
@@ -137,12 +131,6 @@ inline simdjson_result<element> object::at_pointer(std::string_view json_pointer
  return child;
 }
 inline simdjson_result<element> object::at_path(std::string_view json_path) const noexcept {
  auto json_pointer = json_path_to_pointer_conversion(json_path);
  if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
  return at_pointer(json_pointer);
 }
 inline simdjson_result<element> object::at_key(std::string_view key) const noexcept {
  iterator end_field = end();
  for (iterator field = begin(); field != end_field; ++field) {
@@ -145,7 +145,6 @@ public:
   *         - INCORRECT_TYPE if this is not an object
   */
  inline simdjson_result<element> operator[](const char *key) const noexcept;
  simdjson_result<element> operator[](int) const noexcept = delete;
  /**
   * Get the value associated with the given JSON pointer. We use the RFC 6901
@@ -172,21 +171,6 @@ public:
   */
  inline simdjson_result<element> at_pointer(std::string_view json_pointer) const noexcept;
  /**
   * Get the value associated with the given JSONPath expression. We only support
   * JSONPath queries that trivially convertible to JSON Pointer queries: key
   * names and array indices.
   *
   * https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00
   *
   * @return The value associated with the given JSONPath expression, or:
   *         - INVALID_JSON_POINTER if the JSONPath to JSON Pointer conversion fails
   *         - NO_SUCH_FIELD if a field does not exist in an object
   *         - INDEX_OUT_OF_BOUNDS if an array index is larger than an array length
   *         - INCORRECT_TYPE if a non-integer is used to access an array
  */
  inline simdjson_result<element> at_path(std::string_view json_path) const noexcept;
  /**
   * Get the value associated with the given key.
   *
@@ -259,9 +243,7 @@ public:
  inline simdjson_result<dom::element> operator[](std::string_view key) const noexcept;
  inline simdjson_result<dom::element> operator[](const char *key) const noexcept;
  simdjson_result<dom::element> operator[](int) const noexcept = delete;
  inline simdjson_result<dom::element> at_pointer(std::string_view json_pointer) const noexcept;
  inline simdjson_result<dom::element> at_path(std::string_view json_path) const noexcept;
  inline simdjson_result<dom::element> at_key(std::string_view key) const noexcept;
  inline simdjson_result<dom::element> at_key_case_insensitive(std::string_view key) const noexcept;
@@ -202,22 +202,6 @@ public:
   *   simdjson::dom::parser parser;
   *   simdjson::dom::element element = parser.parse(padded_json_copy.get(), json_len, false);
   *
   * ### std::string references
   *
   * If you pass a mutable std::string reference (std::string&), the parser will seek to extend
   * its capacity to SIMDJSON_PADDING bytes beyond the end of the string.
   *
   * Whenever you pass an std::string reference, the parser will access the bytes beyond the end of
   * the string but before the end of the allocated memory (std::string::capacity()).
   * If you are using a sanitizer that checks for reading uninitialized bytes or std::string's
   * container-overflow checks, you may encounter sanitizer warnings.
   * You can safely ignore these warnings. Or you can call simdjson::pad(std::string&) to pad the
   * string with SIMDJSON_PADDING spaces: this function returns a simdjson::padding_string_view
   * which can be be passed to the parser's parse function:
   *
   *    std::string json = R"({ "foo": 1 } { "foo": 2 } { "foo": 3 } )";
   *    element doc = parser.parse(simdjson::pad(json));
   *
   * ### Parser Capacity
   *
   * If the parser's current capacity is less than len, it will allocate enough capacity
@@ -565,14 +549,9 @@ public:
  /**
   * The parser instance can use threads when they are available to speed up some
   * operations. It is enabled by default. Changing this attribute will change the
-   * behavior of the parser for future operations. Set to true by default.
+   * behavior of the parser for future operations.
   */
  bool threaded{true};
 #else
  /**
   * When SIMDJSON_THREADS_ENABLED is not defined, the parser instance cannot use threads.
   */
  bool threaded{false};
 #endif
  /** @private Use the new DOM API instead */
  class Iterator;
@@ -49,8 +49,7 @@ enum error_code {
  SCALAR_DOCUMENT_AS_VALUE,   ///< A scalar document is treated as a value.
  OUT_OF_BOUNDS,              ///< Attempted to access location outside of document.
  TRAILING_CONTENT,           ///< Unexpected trailing content in the JSON input
-  OUT_OF_CAPACITY,            ///< The capacity was exceeded, we cannot allocate enough memory.
+  NUM_ERROR_CODES
  NUM_ERROR_CODES             ///< Placeholder for end of error code list.
 };
 /**
@@ -87,7 +86,7 @@ struct simdjson_error : public std::exception {
   */
  simdjson_error(error_code error) noexcept : _error{error} { }
  /** The error message */
-  const char *what() const noexcept override { return error_message(error()); }
+  const char *what() const noexcept { return error_message(error()); }
  /** The error code */
  error_code error() const noexcept { return _error; }
 private:
@@ -26,7 +26,6 @@ public:
  ) const noexcept final;
  simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
  simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 } // namespace fallback
@@ -75,12 +75,6 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace fallback
 } // namespace simdjson
 #ifndef SIMDJSON_SWAR_NUMBER_PARSING
 #if SIMDJSON_IS_BIG_ENDIAN
 #define SIMDJSON_SWAR_NUMBER_PARSING 0
 #else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
 #endif
 #endif
 #endif // SIMDJSON_FALLBACK_NUMBERPARSING_DEFS_H
@@ -29,24 +29,6 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
  return { src[0] };
 }
 struct escaping {
  static constexpr uint32_t BYTES_PROCESSED = 1;
  simdjson_inline static escaping copy_and_find(const uint8_t *src, uint8_t *dst);
  simdjson_inline bool has_escape() { return escape_bits; }
  simdjson_inline int escape_index() { return 0; }
  bool escape_bits;
 }; // struct escaping
 simdjson_inline escaping escaping::copy_and_find(const uint8_t *src, uint8_t *dst) {
  dst[0] = src[0];
  return { (src[0] == '\\') || (src[0] == '"') || (src[0] < 32) };
 }
 } // unnamed namespace
 } // namespace fallback
 } // namespace simdjson
@@ -16,4 +16,5 @@
 #include "simdjson/internal/jsoncharutils_tables.h"
 #include "simdjson/internal/numberparsing_tables.h"
 #include "simdjson/internal/simdprune_tables.h"
 #endif // SIMDJSON_GENERIC_DEPENDENCIES_H
@@ -574,6 +574,7 @@ simdjson_unused simdjson_inline simdjson_result<number_type> get_number_type(con
 // Our objective is accurate parsing (ULP of 0) at high speed.
 template<typename W>
 simdjson_inline error_code parse_number(const uint8_t *const src, W &writer) {
  //
  // Check for minus sign
  //
@@ -45,9 +45,4 @@
 #include "simdjson/generic/ondemand/token_iterator-inl.h"
 #include "simdjson/generic/ondemand/value_iterator-inl.h"
 // JSON builder, ideally they should not be part of the ondemand directory
 // but it is convenient for now to have them here.
 #include "simdjson/generic/ondemand/json_string_builder.h"
 #include "simdjson/generic/ondemand/json_string_builder-inl.h"
 #include "simdjson/generic/ondemand/json_builder.h"
@@ -2,7 +2,6 @@
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
 #define SIMDJSON_GENERIC_ONDEMAND_ARRAY_INL_H
 #include "simdjson/jsonpathutil.h"
 #include "simdjson/generic/ondemand/base.h"
 #include "simdjson/generic/ondemand/array.h"
 #include "simdjson/generic/ondemand/array_iterator-inl.h"
@@ -164,6 +163,53 @@ inline simdjson_result<value> array::at_pointer(std::string_view json_pointer) n
  return child;
 }
 inline std::string json_path_to_pointer_conversion(std::string_view json_path) {
  if (json_path.empty() || (json_path.front() != '.' &&
      json_path.front() != '[')) {
    return "-1"; // This is just a sentinel value, the caller should check for this and return an error.
  }
  std::string result;
  // Reserve space to reduce allocations, adjusting for potential increases due
  // to escaping.
  result.reserve(json_path.size() * 2);
  size_t i = 0;
  while (i < json_path.length()) {
    if (json_path[i] == '.') {
      result += '/';
    } else if (json_path[i] == '[') {
      result += '/';
      ++i; // Move past the '['
      while (i < json_path.length() && json_path[i] != ']') {
          if (json_path[i] == '~') {
            result += "~0";
          } else if (json_path[i] == '/') {
            result += "~1";
          } else {
            result += json_path[i];
          }
          ++i;
      }
      if (i == json_path.length() || json_path[i] != ']') {
          return "-1"; // Using sentinel value that will be handled as an error by the caller.
      }
    } else {
      if (json_path[i] == '~') {
          result += "~0";
      } else if (json_path[i] == '/') {
          result += "~1";
      } else {
          result += json_path[i];
      }
    }
    ++i;
  }
  return result;
 }
 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; }
@@ -44,8 +44,7 @@ public:
   * calling this function, if successful, the array is 'rewinded' at its
   * beginning as if it had never been accessed. If the JSON is malformed (e.g.,
   * there is a missing comma), then an error is returned and it is no longer
-   * safe to continue. Note that count_elements() does not validate the JSON values,
+   * safe to continue.
   * only the structure of the array.
   *
   * To check that an array is empty, it is more performant to use
   * the is_empty() method.
@@ -131,37 +130,6 @@ public:
   *         - INDEX_OUT_OF_BOUNDS if the array index is larger than an array length
   */
  simdjson_inline simdjson_result<value> at(size_t index) noexcept;
 #if SIMDJSON_SUPPORTS_DESERIALIZATION
  /**
   * Get this array as the given type.
   *
   * @param out This is set to a value of the given type, parsed from the JSON. If there is an error, this may not be initialized.
   * @returns INCORRECT_TYPE If the JSON array is not of the given type.
   * @returns SUCCESS If the parse succeeded and the out parameter was set to the value.
   */
  template <typename T>
  simdjson_inline error_code get(T &out)
     noexcept(custom_deserializable<T, array> ? nothrow_custom_deserializable<T, array> : true) {
    static_assert(custom_deserializable<T, array>);
    return deserialize(*this, out);
  }
  /**
   * Get this array as the given type.
   *
   * @returns A value of the given type, parsed from the JSON.
   * @returns INCORRECT_TYPE If the JSON value is not the given type.
   */
  template <typename T>
  simdjson_inline simdjson_result<T> get()
    noexcept(custom_deserializable<T, value> ? nothrow_custom_deserializable<T, value> : true)
  {
    static_assert(std::is_default_constructible<T>::value, "The specified type is not default constructible.");
    T out{};
    SIMDJSON_TRY(get<T>(out));
    return out;
  }
 #endif // SIMDJSON_SUPPORTS_DESERIALIZATION
 protected:
  /**
   * Go to the end of the array, no matter where you are right now.
@@ -240,28 +208,7 @@ public:
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_path(std::string_view json_path) noexcept;
  simdjson_inline simdjson_result<std::string_view> raw_json() noexcept;
 #if SIMDJSON_SUPPORTS_DESERIALIZATION
  // TODO: move this code into object-inl.h
  template<typename T>
  simdjson_inline simdjson_result<T> get() noexcept {
    if (error()) { return error(); }
    if constexpr (std::is_same_v<T, SIMDJSON_IMPLEMENTATION::ondemand::array>) {
      return first;
    }
    return first.get<T>();
  }
  template<typename T>
  simdjson_inline error_code get(T& out) noexcept {
    if (error()) { return error(); }
    if constexpr (std::is_same_v<T, SIMDJSON_IMPLEMENTATION::ondemand::array>) {
      out = first;
    } else {
      SIMDJSON_TRY( first.get<T>(out) );
    }
    return SUCCESS;
  }
 #endif // SIMDJSON_SUPPORTS_DESERIALIZATION
 };
 } // namespace simdjson
@@ -13,6 +13,5 @@
 #include "simdjson/padded_string.h"
 #include "simdjson/padded_string_view.h"
 #include "simdjson/internal/dom_parser_implementation.h"
 #include "simdjson/jsonpathutil.h"
 #endif // SIMDJSON_GENERIC_ONDEMAND_DEPENDENCIES_H
@@ -88,25 +88,8 @@ concept nothrow_deserializable = nothrow_custom_deserializable<T, ValT> || is_bu
 /// Deserialize Tag
 inline constexpr struct deserialize_tag {
  using array_type = SIMDJSON_IMPLEMENTATION::ondemand::array;
  using object_type = SIMDJSON_IMPLEMENTATION::ondemand::object;
  using value_type = SIMDJSON_IMPLEMENTATION::ondemand::value;
  using document_type = SIMDJSON_IMPLEMENTATION::ondemand::document;
  using document_reference_type = SIMDJSON_IMPLEMENTATION::ondemand::document_reference;
  // Customization Point for array
  template <typename T>
    requires custom_deserializable<T, value_type>
  [[nodiscard]] constexpr /* error_code */ auto operator()(array_type &object, T& output) const noexcept(nothrow_custom_deserializable<T, value_type>) {
    return tag_invoke(*this, object, output);
  }
  // Customization Point for object
  template <typename T>
    requires custom_deserializable<T, value_type>
  [[nodiscard]] constexpr /* error_code */ auto operator()(object_type &object, T& output) const noexcept(nothrow_custom_deserializable<T, value_type>) {
    return tag_invoke(*this, object, output);
  }
  // Customization Point for value
  template <typename T>
@@ -122,14 +105,6 @@ inline constexpr struct deserialize_tag {
    return tag_invoke(*this, object, output);
  }
  // Customization Point for document reference
  template <typename T>
    requires custom_deserializable<T, document_reference_type>
  [[nodiscard]] constexpr /* error_code */ auto operator()(document_reference_type &object, T& output) const noexcept(nothrow_custom_deserializable<T, document_reference_type>) {
    return tag_invoke(*this, object, output);
  }
 } deserialize{};
 } // namespace simdjson
@@ -3,15 +3,17 @@
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
 #define SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_INL_H
 #include "simdjson/generic/ondemand/base.h"
 #include "simdjson/generic/ondemand/array-inl.h"
 #include "simdjson/generic/ondemand/array_iterator.h"
 #include "simdjson/generic/ondemand/document.h"
 #include "simdjson/generic/ondemand/json_iterator-inl.h"
 #include "simdjson/generic/ondemand/json_path_to_pointer_conversion.h"
 #include "simdjson/generic/ondemand/json_path_to_pointer_conversion-inl.h"
 #include "simdjson/generic/ondemand/json_type.h"
 #include "simdjson/generic/ondemand/object-inl.h"
 #include "simdjson/generic/ondemand/raw_json_string.h"
 #include "simdjson/generic/ondemand/value.h"
 #include "simdjson/generic/ondemand/value-inl.h"
 #include "simdjson/generic/ondemand/array-inl.h"
 #include "simdjson/generic/ondemand/json_iterator-inl.h"
 #include "simdjson/generic/ondemand/object-inl.h"
 #include "simdjson/generic/ondemand/value_iterator-inl.h"
 #include "simdjson/generic/ondemand/deserialize.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
@@ -177,19 +179,10 @@ template<> simdjson_inline error_code document::get(int64_t& out) & noexcept { r
 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>(); }
+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(); }
@@ -246,14 +239,7 @@ simdjson_inline simdjson_result<value> document::operator[](const char *key) & n
 }
 simdjson_inline error_code document::consume() noexcept {
-  bool scalar = false;
+  auto error = iter.skip_child(0);
  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;
 }
@@ -275,8 +261,6 @@ simdjson_inline simdjson_result<json_type> document::type() noexcept {
 }
 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; }
@@ -485,7 +469,7 @@ simdjson_inline simdjson_result<T> simdjson_result<SIMDJSON_IMPLEMENTATION::onde
  return first.get<T>();
 }
 template<typename T>
-simdjson_deprecated simdjson_inline simdjson_result<T> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::get() && noexcept {
+simdjson_inline simdjson_result<T> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::get() && noexcept {
  if (error()) { return error(); }
  return std::forward<SIMDJSON_IMPLEMENTATION::ondemand::document>(first).get<T>();
 }
@@ -501,7 +485,7 @@ simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::do
 }
 template<> simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::get<SIMDJSON_IMPLEMENTATION::ondemand::document>() & noexcept = delete;
-template<> simdjson_deprecated simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::get<SIMDJSON_IMPLEMENTATION::ondemand::document>() && noexcept {
+template<> simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::get<SIMDJSON_IMPLEMENTATION::ondemand::document>() && noexcept {
  if (error()) { return error(); }
  return std::forward<SIMDJSON_IMPLEMENTATION::ondemand::document>(first);
 }
@@ -832,26 +816,6 @@ simdjson_inline simdjson_result<bool> simdjson_result<SIMDJSON_IMPLEMENTATION::o
  if (error()) { return error(); }
  return first.is_null();
 }
 template<typename T>
 simdjson_inline simdjson_result<T> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::get() & noexcept {
  if (error()) { return error(); }
  return first.get<T>();
 }
 template<typename T>
 simdjson_inline simdjson_result<T> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::get() && noexcept {
  if (error()) { return error(); }
  return std::forward<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>(first).get<T>();
 }
 template <class T>
 simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::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<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::get(T &out) && noexcept {
  if (error()) { return error(); }
  return std::forward<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>(first).get<T>(out);
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::json_type> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::type() noexcept {
  if (error()) { return error(); }
  return first.type();
@@ -864,18 +828,6 @@ simdjson_inline simdjson_result<bool> simdjson_result<SIMDJSON_IMPLEMENTATION::o
  if (error()) { return error(); }
  return first.is_string();
 }
 template <>
 simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::get(SIMDJSON_IMPLEMENTATION::ondemand::document_reference &out) & noexcept {
  if (error()) { return error(); }
  out = first;
  return SUCCESS;
 }
 template <>
 simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::get(SIMDJSON_IMPLEMENTATION::ondemand::document_reference &out) && noexcept {
  if (error()) { return error(); }
  out = first;
  return SUCCESS;
 }
 simdjson_inline simdjson_result<bool> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::is_negative() noexcept {
  if (error()) { return error(); }
  return first.is_negative();
@@ -893,12 +845,10 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::number> simdj
  return first.get_number();
 }
 #if SIMDJSON_EXCEPTIONS
-template <class T>
+template <class T, typename std::enable_if<std::is_same<T, SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::value == false>::type>
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator T() noexcept(false) {
  static_assert(std::is_same<T, SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::value == false, "You should not call get<T> when T is a document");
  static_assert(std::is_same<T, SIMDJSON_IMPLEMENTATION::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>();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator SIMDJSON_IMPLEMENTATION::ondemand::array() & noexcept(false) {
  if (error()) { throw simdjson_error(error()); }
@@ -224,7 +224,7 @@ public:
   * Be mindful that the document instance must remain in scope while you are accessing object, array and value instances.
   *
   * @param out This is set to a value of the given type, parsed from the JSON. If there is an error, this may not be initialized.
-   * @returns INCORRECT_TYPE If the JSON value is of the given type.
+   * @returns INCORRECT_TYPE If the JSON value is not an object.
   * @returns SUCCESS If the parse succeeded and the out parameter was set to the value.
   */
  template<typename T>
@@ -254,7 +254,7 @@ public:
 #endif
  }
  /** @overload template<typename T> error_code get(T &out) & noexcept */
-  template<typename T> simdjson_deprecated simdjson_inline error_code get(T &out) && noexcept;
+  template<typename T> simdjson_inline error_code get(T &out) && noexcept;
 #if SIMDJSON_EXCEPTIONS
  /**
@@ -267,10 +267,7 @@ public:
   * @returns An instance of type T
   */
  template <class T>
-  explicit simdjson_inline operator T() & noexcept(false);
+  explicit simdjson_inline operator T() noexcept(false);
  template <class T>
  explicit simdjson_deprecated simdjson_inline operator T() && noexcept(false);
  /**
   * Cast this JSON value to an array.
   *
@@ -354,8 +351,7 @@ public:
   * calling this function, if successful, the array is 'rewinded' at its
   * beginning as if it had never been accessed. If the JSON is malformed (e.g.,
   * there is a missing comma), then an error is returned and it is no longer
-   * safe to continue. Note that count_elements() does not validate the JSON values,
+   * safe to continue.
   * only the structure of the array.
   */
  simdjson_inline simdjson_result<size_t> count_elements() & noexcept;
   /**
@@ -467,7 +463,6 @@ public:
  simdjson_inline simdjson_result<value> operator[](std::string_view key) & noexcept;
  /** @overload simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) & noexcept; */
  simdjson_inline simdjson_result<value> operator[](const char *key) & noexcept;
 simdjson_result<value> operator[](int) & noexcept = delete;
  /**
   * Get the type of this JSON value. It does not validate or consume the value.
@@ -736,11 +731,6 @@ protected:
 /**
 * A document_reference is a thin wrapper around a document reference instance.
 * The document_reference instances are used primarily/solely for streams of JSON
 * documents. They differ from document instances when parsing a scalar value
 * (a document that is not an array or an object). In the case of a document,
 * we expect the document to be fully consumed. In the case of a document_reference,
 * we allow trailing content.
 */
 class document_reference {
 public:
@@ -766,70 +756,7 @@ public:
  simdjson_inline simdjson_result<value> get_value() noexcept;
  simdjson_inline simdjson_result<bool> is_null() noexcept;
-  template <typename T>
+  template<typename T> simdjson_inline simdjson_result<T> get() & noexcept;
  simdjson_inline simdjson_result<T> get() &
 #if SIMDJSON_SUPPORTS_DESERIALIZATION
    noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document> : true)
 #else
    noexcept
 #endif
  {
    static_assert(std::is_default_constructible<T>::value, "Cannot initialize the specified type.");
    T out{};
    SIMDJSON_TRY(get<T>(out));
    return out;
  }
  template<typename T>
  simdjson_inline simdjson_result<T> get() &&
 #if SIMDJSON_SUPPORTS_DESERIALIZATION
    noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document> : true)
 #else
    noexcept
 #endif
  {
      static_assert(!std::is_same<T, array>::value && !std::is_same<T, object>::value, "You should never hold either an ondemand::array or ondemand::object without a corresponding ondemand::document_reference being alive; that would be Undefined Behaviour.");
      return static_cast<document&>(*this).get<T>();
  }
  /**
   * Get this value as the given type.
   *
   * Supported types: object, array, raw_json_string, string_view, uint64_t, int64_t, double, bool, value
   *
   * Be mindful that the document instance must remain in scope while you are accessing object, array and value instances.
   *
   * @param out This is set to a value of the given type, parsed from the JSON. If there is an error, this may not be initialized.
   * @returns INCORRECT_TYPE If the JSON value is not an object.
   * @returns SUCCESS If the parse succeeded and the out parameter was set to the value.
   */
  template<typename T>
  simdjson_inline error_code get(T &out) &
 #if SIMDJSON_SUPPORTS_DESERIALIZATION
    noexcept(custom_deserializable<T, document> ? nothrow_custom_deserializable<T, document_reference> : true)
 #else
    noexcept
 #endif
  {
 #if SIMDJSON_SUPPORTS_DESERIALIZATION
    if constexpr (custom_deserializable<T, document_reference>) {
        return deserialize(*this, out);
    } else {
 #endif // SIMDJSON_SUPPORTS_DESERIALIZATION
      // Unless the simdjson library or the user provides an inline implementation, calling this method should
      // immediately fail.
      static_assert(!sizeof(T), "The get method with given type is not implemented by the simdjson library. "
        "The supported types are ondemand::object, ondemand::array, raw_json_string, std::string_view, uint64_t, "
        "int64_t, double, and bool. We recommend you use get_double(), get_bool(), get_uint64(), get_int64(), "
        " get_object(), get_array(), get_raw_json_string(), or get_string() instead of the get template."
        " You may also add support for custom types, see our documentation.");
      static_cast<void>(out); // to get rid of unused errors
      return UNINITIALIZED;
 #if SIMDJSON_SUPPORTS_DESERIALIZATION
    }
 #endif
  }
  /** @overload template<typename T> error_code get(T &out) & noexcept */
  template<typename T> simdjson_inline error_code get(T &out) && noexcept;
  simdjson_inline simdjson_result<std::string_view> raw_json() noexcept;
  simdjson_inline operator document&() const noexcept;
 #if SIMDJSON_EXCEPTIONS
@@ -854,7 +781,6 @@ public:
  simdjson_inline simdjson_result<value> find_field(const char *key) & noexcept;
  simdjson_inline simdjson_result<value> operator[](std::string_view key) & noexcept;
  simdjson_inline simdjson_result<value> operator[](const char *key) & noexcept;
  simdjson_result<value> operator[](int) & noexcept = delete;
  simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) & noexcept;
  simdjson_inline simdjson_result<value> find_field_unordered(const char *key) & noexcept;
@@ -907,7 +833,7 @@ public:
  simdjson_inline simdjson_result<bool> is_null() noexcept;
  template<typename T> simdjson_inline simdjson_result<T> get() & noexcept;
-  template<typename T> simdjson_deprecated simdjson_inline simdjson_result<T> get() && noexcept;
+  template<typename T> simdjson_inline simdjson_result<T> get() && noexcept;
  template<typename T> simdjson_inline error_code get(T &out) & noexcept;
  template<typename T> simdjson_inline error_code get(T &out) && noexcept;
@@ -933,7 +859,6 @@ public:
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field(const char *key) & noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](std::string_view key) & noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](const char *key) & noexcept;
  simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](int) & noexcept = delete;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field_unordered(std::string_view key) & noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field_unordered(const char *key) & noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::json_type> type() noexcept;
@@ -983,14 +908,8 @@ public:
  simdjson_inline simdjson_result<bool> get_bool() noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> get_value() noexcept;
  simdjson_inline simdjson_result<bool> is_null() noexcept;
  template<typename T> simdjson_inline simdjson_result<T> get() & noexcept;
  template<typename T> simdjson_inline simdjson_result<T> get() && noexcept;
  template<typename T> simdjson_inline error_code get(T &out) & noexcept;
  template<typename T> simdjson_inline error_code get(T &out) && noexcept;
 #if SIMDJSON_EXCEPTIONS
-  template <class T>
+  template <class T, typename std::enable_if<std::is_same<T, SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::value == false>::type>
  explicit simdjson_inline operator T() noexcept(false);
  simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::array() & noexcept(false);
  simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::object() & noexcept(false);
@@ -1011,7 +930,6 @@ public:
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field(const char *key) & noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](std::string_view key) & noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](const char *key) & noexcept;
  simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](int) & noexcept = delete;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field_unordered(std::string_view key) & noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field_unordered(const char *key) & noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::json_type> type() noexcept;
@@ -152,6 +152,7 @@ simdjson_inline document_stream::iterator::iterator(document_stream* _stream, bo
 }
 simdjson_inline simdjson_result<ondemand::document_reference> document_stream::iterator::operator*() noexcept {
  //if(stream->error) { return stream->error; }
  return simdjson_result<ondemand::document_reference>(stream->doc, stream->error);
 }
@@ -316,7 +316,7 @@ private:
  friend class document;
  friend class json_iterator;
  friend struct simdjson_result<ondemand::document_stream>;
-  friend struct simdjson::internal::simdjson_result_base<ondemand::document_stream>;
+  friend struct internal::simdjson_result_base<ondemand::document_stream>;
 };  // document_stream
 } // namespace ondemand
@@ -1,156 +0,0 @@
 /**
 * This file is part of the builder API. It is temporarily in the ondemand directory
 * but we will move it to a builder directory later.
 */
 #ifndef SIMDJSON_GENERIC_BUILDER_H
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
 #define SIMDJSON_GENERIC_STRING_BUILDER_H
 #include "simdjson/generic/builder/json_string_builder.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 #if SIMDJSON_STATIC_REFLECTION
 #include <charconv>
 #include <cstring>
 #include <experimental/meta>
 #include <string_view>
 #include <type_traits>
 #include <utility>
 namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
 namespace builder {
 // Concept that checks if a type is a container but not a string (because
 // strings handling must be handled differently)
 template <typename T>
 concept container_but_not_string =
    requires(T a) {
      { a.size() } -> std::convertible_to<std::size_t>;
      {
        a[std::declval<std::size_t>()]
      }; // check if elements are accessible for the subscript operator
    } && !std::is_same_v<T, std::string> &&
    !std::is_same_v<T, std::string_view> && !std::is_same_v<T, const char *>;
 template <class T>
  requires(container_but_not_string<T>)
 constexpr void atom(string_builder &b, const T &t) {
  if (t.size() == 0) {
    b.append_raw("[]");
    return;
  }
  b.append('[');
  atom(b, t[0]);
  for (size_t i = 1; i < t.size(); ++i) {
    b.append(',');
    atom(b, t[i]);
  }
  b.append(']');
 }
 template <class T>
  requires(std::is_same_v<T, std::string> ||
           std::is_same_v<T, std::string_view> ||
           std::is_same_v<T, const char *> ||
           std::is_same_v<T, char>)
 constexpr void atom(string_builder &b, const T &t) {
  b.escape_and_append_with_quotes(t);
 }
 template<typename number_type,
         typename = typename std::enable_if<std::is_arithmetic<number_type>::value && !std::is_same_v<number_type, char>>::type>
 constexpr void atom(string_builder &b, const number_type t) {
  b.append(t);
 }
 #if SIMDJSON_CONSTEVAL
 consteval std::string consteval_to_quoted_escaped(std::string_view input);
 #endif
 template <class T>
  requires(std::is_class_v<T> && !container_but_not_string<T> &&
           !std::is_same_v<T, std::string> &&
           !std::is_same_v<T, std::string_view>)
 constexpr void atom(string_builder &b, const T &t) {
  int i = 0;
  b.append('{');
  template for (constexpr auto mem : std::meta::nonstatic_data_members_of(^^T)) {
    constexpr std::string_view key = std::string_view(std::meta::identifier_of(mem));
    if (i != 0)
      b.append(',');
    b.append_raw(consteval_to_quoted_escaped(key));
    b.append(':');
    atom(b, t.*mem);
    i++;
  }
  b.append('}');
  /*[:expand(std::meta::nonstatic_data_members_of(^T)):] >> [&]<auto dm> {
    if (i != 0)
      b.append(',');
    constexpr auto key = consteval_to_quoted_escaped(std::meta::identifier_of(dm));
    b.append_raw(key);
    b.append(':');
    atom(b, t.[:dm:]);
    i++;
  };
  b.append('}');*/
 }
 // works for struct
 template <class Z> void append(string_builder &b, const Z &z) {
  int i = 0;
  b.append('{');
  template for (constexpr auto dm : std::meta::nonstatic_data_members_of(^^Z)) {
    if (i != 0)
      b.append(',');
    constexpr auto key = consteval_to_quoted_escaped(std::meta::identifier_of(dm));
    b.append_raw(key);
    b.append(':');
    atom(b, z.[:dm:]);
    i++;
  }
  b.append('}');
 }
 // works for container
 template <class Z>
  requires(container_but_not_string<Z>)
 void append(string_builder &b, const Z &z) {
  if (z.size() == 0) {
    b.append_raw("[]");
    return;
  }
  b.append('[');
  atom(b, z[0]);
  for (size_t i = 1; i < z.size(); ++i) {
    b.append(',');
    atom(b, z[i]);
  }
  b.append(']');
 }
 template <class Z>
 simdjson_result<std::string> to_json_string(const Z &z) {
  string_builder b;
  append(b, z);
  std::string_view s;
  if(auto e = b.view().get(s); e) { return e; }
  return std::string(s);
 }
 template <class Z>
 simdjson_error to_json(const Z &z, std::string &s) {
  string_builder b;
  append(b, z);
  std::string_view view;
  if(auto e = b.view().get(view); e) { return e; }
  s.assign(view);
  return SUCCESS;
 }
 } // namespace json_builder
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson
 #endif // SIMDJSON_STATIC_REFLECTION
 #endif
@@ -0,0 +1,67 @@
 #pragma once
 #ifndef SIMDJSON_ONDEMAND_GENERIC_JSON_PATH_TO_POINTER_CONVERSION_INL_H
 #define SIMDJSON_ONDEMAND_GENERIC_JSON_PATH_TO_POINTER_CONVERSION_INL_H
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
 #define SIMDJSON_GENERIC_ONDEMAND_JSON_PATH_TO_POINTER_CONVERSION_INL_H
 #include "simdjson/generic/ondemand/json_path_to_pointer_conversion.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {}
 namespace ondemand {
 simdjson_inline std::string json_path_to_pointer_conversion(std::string_view json_path) {
  if (json_path.empty() || (json_path.front() != '.' && json_path.front() != '[') {
    return "-1"; // Sentinel value to be handled as an error by the caller.
  }
  std::string result;
  // Reserve space to reduce allocations, adjusting for potential increases due
  // to escaping.
  result.reserve(json_path.size() * 2);
  // Skip the initial '.' as it's assumed every path starts with it.
  size_t i = 0;
  while (i < json_path.length()) {
    if (json_path[i] == '.') {
      result += '/';
    } else if (json_path[i] == '[') {
      result += '/';
      ++i; // Move past the '['
      while (i < json_path.length() && json_path[i] != ']') {
        if (json_path[i] == '~') {
          result += "~0";
        } else if (json_path[i] == '/') {
          result += "~1";
        } else {
          result += json_path[i];
        }
        ++i;
      }
      if (i == json_path.length() || json_path[i] != ']') {
        return "-1"; // Returning sentinel value that will be handled as an error by the caller
      }
    } else {
      if (json_path[i] == '~') {
        result += "~0";
      } else if (json_path[i] == '/') {
        result += "~1";
      } else {
        result += json_path[i];
      }
    }
    ++i;
  }
  return simdjson_result<std::string>(result);
 }
 } // namespace ondemand
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson
 #endif // SIMDJSON_ONDEMAND_GENERIC_JSON_PATH_TO_POINTER_CONVERSION_INL_H
@@ -0,0 +1,22 @@
 #pragma once
 #ifndef SIMDJSON_ONDEMAND_GENERIC_JSON_PATH_TO_POINTER_CONVERSION_H
 #define SIMDJSON_ONDEMAND_GENERIC_JSON_PATH_TO_POINTER_CONVERSION_H
 namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
 namespace internal {
 /**
 * Converts JSONPath to JSON Pointer.
 * @param json_path The JSONPath string to be converted.
 * @return A string containing the equivalent JSON Pointer.
 * @throws simdjson_error If the conversion fails.
 */
 simdjson_inline std::string json_path_to_pointer_conversion(std::string_view json_path);
 } // namespace internal
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson
 #endif // SIMDJSON_JSON_PATH_TO_POINTER_CONVERSION_H
@@ -1,495 +0,0 @@
 /**
 * This file is part of the builder API. It is temporarily in the ondemand
 * directory but we will move it to a builder directory later.
 */
 #include <array>
 #include <cstring>
 #include <type_traits>
 #ifndef SIMDJSON_GENERIC_STRING_BUILDER_INL_H
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
 #define SIMDJSON_GENERIC_STRING_BUILDER_INL_H
 #include "simdjson/generic/builder/json_string_builder.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 /*
 * Empirically, we have found that an inlined optimization is important for
 * performance. The following macros are not ideal. We should find a better
 * way to inline the code.
 */
 #if defined(__SSE2__) || defined(__x86_64__) || defined(__x86_64) ||           \
    (defined(_M_AMD64) || defined(_M_X64) ||                                   \
     (defined(_M_IX86_FP) && _M_IX86_FP == 2))
 #ifndef SIMDJSON_EXPERIMENTAL_HAS_SSE2
 #define SIMDJSON_EXPERIMENTAL_HAS_SSE2 1
 #endif
 #endif
 #if defined(__aarch64__) || defined(_M_ARM64)
 #ifndef SIMDJSON_EXPERIMENTAL_HAS_NEON
 #define SIMDJSON_EXPERIMENTAL_HAS_NEON 1
 #endif
 #endif
 #if SIMDJSON_EXPERIMENTAL_HAS_NEON
 #include <arm_neon.h>
 #endif
 #if SIMDJSON_EXPERIMENTAL_HAS_SSE2
 #include <emmintrin.h>
 #endif
 namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
 namespace builder {
 SIMDJSON_CONSTEXPR_LAMBDA simdjson_inline bool
 simple_needs_escaping(std::string_view v) {
  for (char c : v) {
    if ((uint8_t(c) < 32) | (c == '"') | (c == '\\')) {
      return true;
    }
  }
  return false;
 }
 #if SIMDJSON_EXPERIMENTAL_HAS_NEON
 simdjson_inline bool fast_needs_escaping(std::string_view view) {
  if (view.size() < 16) {
    return simple_needs_escaping(view);
  }
  size_t i = 0;
  uint8x16_t running = vdupq_n_u8(0);
  uint8x16_t v34 = vdupq_n_u8(34);
  uint8x16_t v92 = vdupq_n_u8(92);
  for (; i + 15 < view.size(); i += 16) {
    uint8x16_t word = vld1q_u8((const uint8_t *)view.data() + i);
    running = vorrq_u8(running, vceqq_u8(word, v34));
    running = vorrq_u8(running, vceqq_u8(word, v92));
    running = vorrq_u8(running, vcltq_u8(word, vdupq_n_u8(32)));
  }
  if (i < view.size()) {
    uint8x16_t word =
        vld1q_u8((const uint8_t *)view.data() + view.length() - 16);
    running = vorrq_u8(running, vceqq_u8(word, v34));
    running = vorrq_u8(running, vceqq_u8(word, v92));
    running = vorrq_u8(running, vcltq_u8(word, vdupq_n_u8(32)));
  }
  return vmaxvq_u32(vreinterpretq_u32_u8(running)) != 0;
 }
 #elif SIMDJSON_EXPERIMENTAL_HAS_SSE2
 simdjson_inline bool fast_needs_escaping(std::string_view view) {
  if (view.size() < 16) {
    return simple_needs_escaping(view);
  }
  size_t i = 0;
  __m128i running = _mm_setzero_si128();
  for (; i + 15 < view.size(); i += 16) {
    __m128i word = _mm_loadu_si128(reinterpret_cast<const __m128i *>(view.data() + i));
    running = _mm_or_si128(running, _mm_cmpeq_epi8(word, _mm_set1_epi8(34)));
    running = _mm_or_si128(running, _mm_cmpeq_epi8(word, _mm_set1_epi8(92)));
    running = _mm_or_si128(
        running, _mm_cmpeq_epi8(_mm_subs_epu8(word, _mm_set1_epi8(31)),
                                _mm_setzero_si128()));
  }
  if (i < view.size()) {
    __m128i word =
        _mm_loadu_si128(reinterpret_cast<const __m128i *>(view.data() + view.length() - 16));
    running = _mm_or_si128(running, _mm_cmpeq_epi8(word, _mm_set1_epi8(34)));
    running = _mm_or_si128(running, _mm_cmpeq_epi8(word, _mm_set1_epi8(92)));
    running = _mm_or_si128(
        running, _mm_cmpeq_epi8(_mm_subs_epu8(word, _mm_set1_epi8(31)),
                                _mm_setzero_si128()));
  }
  return _mm_movemask_epi8(running) != 0;
 }
 #else
 simdjson_inline bool fast_needs_escaping(std::string_view view) {
  return simple_needs_escaping(view);
 }
 #endif
 static SIMDJSON_CONSTEXPR_LAMBDA std::array<uint8_t, 256> json_quotable_character = {
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 SIMDJSON_CONSTEXPR_LAMBDA inline size_t
 find_next_json_quotable_character(const std::string_view view,
                                  size_t location) noexcept {
  for (auto pos = view.begin() + location; pos != view.end(); ++pos) {
    if (json_quotable_character[static_cast<uint8_t>(*pos)]) {
      return pos - view.begin();
    }
  }
  return size_t(view.size());
 }
 SIMDJSON_CONSTEXPR_LAMBDA static std::string_view control_chars[] = {
    "\\x0000", "\\x0001", "\\x0002", "\\x0003", "\\x0004", "\\x0005", "\\x0006",
    "\\x0007", "\\x0008", "\\t",     "\\n",     "\\x000b", "\\f",     "\\r",
    "\\x000e", "\\x000f", "\\x0010", "\\x0011", "\\x0012", "\\x0013", "\\x0014",
    "\\x0015", "\\x0016", "\\x0017", "\\x0018", "\\x0019", "\\x001a", "\\x001b",
    "\\x001c", "\\x001d", "\\x001e", "\\x001f"};
 SIMDJSON_CONSTEXPR_LAMBDA void escape_json_char(char c, char *&out) {
  if (c == '"') {
    memcpy(out, "\\\"", 2);
    out += 2;
  } else if (c == '\\') {
    memcpy(out, "\\\\", 2);
    out += 2;
  } else {
    std::string_view v = control_chars[uint8_t(c)];
    memcpy(out, v.data(), v.size());
    out += v.size();
  }
 }
 inline size_t write_string_escaped(const std::string_view input, char *out) {
  size_t mysize = input.size();
  if (!fast_needs_escaping(input)) { // fast path!
    memcpy(out, input.data(), input.size());
    return input.size();
  }
  const char *const initout = out;
  size_t location = find_next_json_quotable_character(input, 0);
  memcpy(out, input.data(), location);
  out += location;
  escape_json_char(input[location], out);
  location += 1;
  while (location < mysize) {
    size_t newlocation = find_next_json_quotable_character(input, location);
    memcpy(out, input.data() + location, newlocation - location);
    out += newlocation - location;
    location = newlocation;
    if (location == mysize) {
      break;
    }
    escape_json_char(input[location], out);
    location += 1;
  }
  return out - initout;
 }
 #if SIMDJSON_CONSTEVAL
 // unoptimized, meant for compile-time execution
 consteval std::string consteval_to_quoted_escaped(std::string_view input) {
  std::string out = "\"";
  for (char c : input) {
    if (json_quotable_character[uint8_t(c)]) {
      if (c == '"') {
        out.append("\\\"");
      } else if (c == '\\') {
        out.append("\\\\");
      } else {
        std::string_view v = control_chars[uint8_t(c)];
        out.append(v);
      }
    } else {
      out.push_back(c);
    }
  }
  out.push_back('"');
  return out;
 }
 #endif // SIMDJSON_CONSTEVAL
 simdjson_inline string_builder::string_builder(size_t initial_capacity)
    : buffer(new(std::nothrow) char[initial_capacity]), position(0),
      capacity(buffer.get() != nullptr ? initial_capacity : 0),
      is_valid(buffer.get() != nullptr) {}
 simdjson_inline bool string_builder::capacity_check(size_t upcoming_bytes) {
  // We use the convention that when is_valid is false, then the capacity and
  // the position are 0.
  // Most of the time, this function will return true.
  if (simdjson_likely(upcoming_bytes <= capacity - position)) {
    return true;
  }
  // check for overflow, most of the time there is no overflow
  if (simdjson_likely(position + upcoming_bytes < position)) {
    return false;
  }
  // We will rarely get here.
  grow_buffer((std::max)(capacity * 2, position + upcoming_bytes));
  // If the buffer allocation failed, we set is_valid to false.
  return is_valid;
 }
 simdjson_inline void string_builder::grow_buffer(size_t desired_capacity) {
  if (!is_valid) {
    return;
  }
  std::unique_ptr<char[]> new_buffer(new (std::nothrow) char[desired_capacity]);
  if (new_buffer.get() == nullptr) {
    set_valid(false);
    return;
  }
  std::memcpy(new_buffer.get(), buffer.get(), position);
  buffer.swap(new_buffer);
  capacity = desired_capacity;
 }
 simdjson_inline void string_builder::set_valid(bool valid) noexcept {
  if (!valid) {
    is_valid = false;
    capacity = 0;
    position = 0;
    buffer.reset();
  } else {
    is_valid = true;
  }
 }
 simdjson_inline size_t string_builder::size() const noexcept {
  return position;
 }
 simdjson_inline void string_builder::append(char c) noexcept {
  if (capacity_check(1)) {
    buffer.get()[position++] = c;
  }
 }
 simdjson_inline void string_builder::append_null() noexcept {
  constexpr char null_literal[] = "null";
  constexpr size_t null_len = sizeof(null_literal) - 1;
  if (capacity_check(null_len)) {
    std::memcpy(buffer.get() + position, null_literal, null_len);
    position += null_len;
  }
 }
 simdjson_inline void string_builder::clear() noexcept {
  position = 0;
  // if it was invalid, we should try to repair it
  if (!is_valid) {
    capacity = 0;
    buffer.reset();
    is_valid = true;
  }
 }
 namespace internal {
 // We could specialize further for 32-bit integers.
 int int_log2(uint32_t x) { return (63 - leading_zeroes(x | 1)); }
 int fast_digit_count(uint32_t x) {
  static uint64_t table[] = {
      4294967296,  8589934582,  8589934582,  8589934582,  12884901788,
      12884901788, 12884901788, 17179868184, 17179868184, 17179868184,
      21474826480, 21474826480, 21474826480, 21474826480, 25769703776,
      25769703776, 25769703776, 30063771072, 30063771072, 30063771072,
      34349738368, 34349738368, 34349738368, 34349738368, 38554705664,
      38554705664, 38554705664, 41949672960, 41949672960, 41949672960,
      42949672960, 42949672960};
  return uint32_t((x + table[int_log2(x)]) >> 32);
 }
 int int_log2(uint64_t x) { return 63 - leading_zeroes(x | 1); }
 int fast_digit_count(uint64_t x) {
  static uint64_t table[] = {9,
                             99,
                             999,
                             9999,
                             99999,
                             999999,
                             9999999,
                             99999999,
                             999999999,
                             9999999999,
                             99999999999,
                             999999999999,
                             9999999999999,
                             99999999999999,
                             999999999999999ULL,
                             9999999999999999ULL,
                             99999999999999999ULL,
                             999999999999999999ULL,
                             9999999999999999999ULL};
  int y = (19 * int_log2(x) >> 6);
  y += x > table[y];
  return y + 1;
 }
 template <typename number_type, typename = typename std::enable_if<
                                    std::is_unsigned<number_type>::value>::type>
 simdjson_inline size_t digit_count(number_type v) noexcept {
  static_assert(sizeof(number_type) == 8 || sizeof(number_type) == 4 ||
                    sizeof(number_type) == 2 || sizeof(number_type) == 1,
                "We only support 8-bit, 16-bit, 32-bit and 64-bit numbers");
  return fast_digit_count(v);
 }
 } // namespace internal
 template <typename number_type, typename>
 simdjson_inline void string_builder::append(number_type v) noexcept {
  static_assert(std::is_same<number_type, bool>::value ||
                    std::is_integral<number_type>::value ||
                    std::is_floating_point<number_type>::value,
                "Unsupported number type");
  // If C++17 is available, we can 'if constexpr' here.
  SIMDJSON_IF_CONSTEXPR(std::is_same<number_type, bool>::value) {
    if (v) {
      constexpr char true_literal[] = "true";
      constexpr size_t true_len = sizeof(true_literal) - 1;
      if (capacity_check(true_len)) {
        std::memcpy(buffer.get() + position, true_literal, true_len);
        position += true_len;
      }
    } else {
      constexpr char false_literal[] = "false";
      constexpr size_t false_len = sizeof(false_literal) - 1;
      if (capacity_check(false_len)) {
        std::memcpy(buffer.get() + position, false_literal, false_len);
        position += false_len;
      }
    }
  }
  else SIMDJSON_IF_CONSTEXPR(std::is_unsigned<number_type>::value) {
    constexpr size_t max_number_size = 20;
    if (capacity_check(max_number_size)) {
      using unsigned_type = typename std::make_unsigned<number_type>::type;
      unsigned_type pv = static_cast<unsigned_type>(v);
      size_t dc = internal::digit_count(pv);
      char *write_pointer = buffer.get() + position + dc - 1;
      // optimization opportunity: if v is large, we can do better.
      while (pv >= 10) {
        *write_pointer-- = char('0' + (pv % 10));
        pv /= 10;
      }
      *write_pointer = char('0' + pv);
      position += dc;
    }
  }
  else SIMDJSON_IF_CONSTEXPR(std::is_integral<number_type>::value) {
    constexpr size_t max_number_size = 20;
    if (capacity_check(max_number_size)) {
      using unsigned_type = typename std::make_unsigned<number_type>::type;
      bool negative = v < 0;
      unsigned_type pv = static_cast<unsigned_type>(negative ? -v : v);
      size_t dc = internal::digit_count(pv);
      if (negative) {
        buffer.get()[position++] = '-';
      }
      char *write_pointer = buffer.get() + position + dc - 1;
      // optimization opportunity: if v is large, we can do better.
      while (pv >= 10) {
        *write_pointer-- = char('0' + (pv % 10));
        pv /= 10;
      }
      *write_pointer = char('0' + pv);
      position += dc;
    }
  }
  else SIMDJSON_IF_CONSTEXPR(std::is_floating_point<number_type>::value) {
    constexpr size_t max_number_size = 24;
    if (capacity_check(max_number_size)) {
      // We could specialize for float.
      char *end = simdjson::internal::to_chars(buffer.get() + position, nullptr,
                                               double(v));
      position = end - buffer.get();
    }
  }
 }
 simdjson_inline void
 string_builder::escape_and_append(std::string_view input) noexcept {
  // escaping might turn a control character into \x00xx so 6 characters.
  if (capacity_check(6 * input.size())) {
    position += write_string_escaped(input, buffer.get() + position);
  }
 }
 simdjson_inline void
 string_builder::escape_and_append_with_quotes(std::string_view input) noexcept {
  // escaping might turn a control character into \x00xx so 6 characters.
  if (capacity_check(2 + 6 * input.size())) {
    buffer.get()[position++] = '"';
    position += write_string_escaped(input, buffer.get() + position);
    buffer.get()[position++] = '"';
  }
 }
 simdjson_inline void
 string_builder::escape_and_append_with_quotes(char input) noexcept {
  // escaping might turn a control character into \x00xx so 6 characters.
  if (capacity_check(2 + 6 * 1)) {
    buffer.get()[position++] = '"';
    std::string_view cinput(&input, 1);
    position += write_string_escaped(cinput, buffer.get() + position);
    buffer.get()[position++] = '"';
  }
 }
 simdjson_inline void string_builder::append_raw(const char *c) noexcept {
  size_t len = std::strlen(c);
  append_raw(c, len);
 }
 simdjson_inline void
 string_builder::append_raw(std::string_view input) noexcept {
  if (capacity_check(input.size())) {
    std::memcpy(buffer.get() + position, input.data(), input.size());
    position += input.size();
  }
 }
 simdjson_inline void string_builder::append_raw(const char *str,
                                                size_t len) noexcept {
  if (capacity_check(len)) {
    std::memcpy(buffer.get() + position, str, len);
    position += len;
  }
 }
 #if SIMDJSON_EXCEPTIONS
 simdjson_inline string_builder::operator std::string() const noexcept(false) {
  return std::string(std::string_view());
 }
 simdjson_inline string_builder::operator std::string_view() const
    noexcept(false) {
  return view();
 }
 #endif
 simdjson_inline simdjson_result<std::string_view>
 string_builder::view() const noexcept {
  if (!is_valid) {
    return simdjson::OUT_OF_CAPACITY;
  }
  return std::string_view(buffer.get(), position);
 }
 simdjson_inline simdjson_result<const char *> string_builder::c_str() noexcept {
  if (capacity_check(1)) {
    buffer.get()[position] = '\0';
    return buffer.get();
  }
  return simdjson::OUT_OF_CAPACITY;
 }
 simdjson_inline bool string_builder::validate_unicode() const noexcept {
  return simdjson::validate_utf8(buffer.get(), position);
 }
 } // namespace builder
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson
 #endif // SIMDJSON_GENERIC_STRING_BUILDER_INL_H
@@ -1,172 +0,0 @@
 /**
 * This file is part of the builder API. It is temporarily in the ondemand directory
 * but we will move it to a builder directory later.
 */
 #ifndef SIMDJSON_GENERIC_STRING_BUILDER_H
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
 #define SIMDJSON_GENERIC_STRING_BUILDER_H
 #include "simdjson/generic/implementation_simdjson_result_base.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
 namespace builder {
 /**
 * A builder for JSON strings representing documents. This is a low-level
 * builder that is not meant to be used directly by end-users. Though it
 * supports atomic types (Booleans, strings), it does not support composed
 * types (arrays and objects).
 *
 * Ultimately, this class should support kernel-specific optimizations. E.g.,
 * it may make use of SIMD instructions to escape strings faster.
 */
 class string_builder {
 public:
  simdjson_inline string_builder(size_t initial_capacity = 1024);
  /**
   * Append number (includes Booleans). Booleans are mapped to the strings
   * false and true. Numbers are converted to strings abiding by the JSON standard.
   * Floating-point numbers are converted to the shortest string that 'correctly'
   * represents the number.
   */
  template<typename number_type,
         typename = typename std::enable_if<std::is_arithmetic<number_type>::value>::type>
  simdjson_inline void append(number_type v) noexcept;
  /**
   * Append character c.
   */
  simdjson_inline void append(char c)  noexcept;
  /**
   * Append the string 'null'.
   */
  simdjson_inline void append_null()  noexcept;
  /**
   * Clear the content.
   */
  simdjson_inline void clear()  noexcept;
  /**
   * Append the std::string_view, after escaping it.
   * There is no UTF-8 validation.
   */
  simdjson_inline void escape_and_append(std::string_view input)  noexcept;
  /**
   * Append the std::string_view surrounded by double quotes, after escaping it.
   * There is no UTF-8 validation.
   */
  simdjson_inline void escape_and_append_with_quotes(std::string_view input)  noexcept;
  /**
   * Append the character surrounded by double quotes, after escaping it.
   * There is no UTF-8 validation.
   */
  simdjson_inline void escape_and_append_with_quotes(char input)  noexcept;
  /**
   * Append the C string directly, without escaping.
   * There is no UTF-8 validation.
   */
  simdjson_inline void append_raw(const char *c)  noexcept;
  /**
   * Append the std::string_view directly, without escaping.
   * There is no UTF-8 validation.
   */
  simdjson_inline void append_raw(std::string_view input)  noexcept;
  /**
   * Append len characters from str.
   * There is no UTF-8 validation.
   */
  simdjson_inline void append_raw(const char *str, size_t len) noexcept;
 #if SIMDJSON_EXCEPTIONS
  /**
   * Creates an std::string from the written JSON buffer.
   * Throws if memory allocation failed
   *
   * The result may not be valid UTF-8 if some of your content was not valid UTF-8.
   * Use validate_unicode() to check the content if needed.
   */
  simdjson_inline operator std::string() const noexcept(false);
  /**
   * Creates an std::string_view from the written JSON buffer.
   * Throws if memory allocation failed.
   *
   * The result may not be valid UTF-8 if some of your content was not valid UTF-8.
   * Use validate_unicode() to check the content if needed.
   */
  simdjson_inline operator std::string_view() const noexcept(false);
 #endif
  /**
   * Returns a view on the written JSON buffer. Returns an error
   * if memory allocation failed.
   *
   * The result may not be valid UTF-8 if some of your content was not valid UTF-8.
   * Use validate_unicode() to check the content.
   */
  simdjson_inline simdjson_result<std::string_view> view() const noexcept;
  /**
   * Appends the null character to the buffer and returns
   * a pointer to the beginning of the written JSON buffer.
   * Returns an error if memory allocation failed.
   * The result is null-terminated.
   *
   * The result may not be valid UTF-8 if some of your content was not valid UTF-8.
   * Use validate_unicode() to check the content.
   */
  simdjson_inline simdjson_result<const char *> c_str() noexcept;
  /**
   * Return true if the content is valid UTF-8.
   */
  simdjson_inline bool validate_unicode() const noexcept;
  /**
   * Returns the current size of the written JSON buffer.
   * If an error occurred, returns 0.
   */
  simdjson_inline size_t size() const noexcept;
 private:
  /**
   * Returns true if we can write at least upcoming_bytes bytes.
   * The underlying buffer is reallocated if needed. It is designed
   * to be called before writing to the buffer. It should be fast.
   */
  simdjson_inline bool capacity_check(size_t upcoming_bytes);
  /**
   * Grow the buffer to at least desired_capacity bytes.
   * If the allocation fails, is_valid is set to false. We expect
   * that this function would not be repeatedly called.
   */
  simdjson_inline void grow_buffer(size_t desired_capacity);
  /**
   * We use this helper function to make sure that is_valid is kept consistent.
   */
  simdjson_inline void set_valid(bool valid) noexcept;
  std::unique_ptr<char[]> buffer{};
  size_t position{0};
  size_t capacity{0};
  bool is_valid{true};
 };
 }
 }
 } // namespace simdjson
 #endif // SIMDJSON_GENERIC_STRING_BUILDER_H
@@ -271,7 +271,6 @@ simdjson_inline  simdjson_result<std::string_view> simdjson_result<SIMDJSON_IMPL
  if (error()) { return error(); }
  return first.raw_json();
 }
 } // namespace simdjson
 #endif // SIMDJSON_GENERIC_ONDEMAND_OBJECT_INL_H
@@ -202,36 +202,6 @@ public:
   */
  simdjson_inline simdjson_result<std::string_view> raw_json() noexcept;
 #if SIMDJSON_SUPPORTS_DESERIALIZATION
  /**
   * Get this object as the given type.
   *
   * @param out This is set to a value of the given type, parsed from the JSON. If there is an error, this may not be initialized.
   * @returns INCORRECT_TYPE If the JSON object is not of the given type.
   * @returns SUCCESS If the parse succeeded and the out parameter was set to the value.
   */
  template <typename T>
  simdjson_inline error_code get(T &out)
     noexcept(custom_deserializable<T, object> ? nothrow_custom_deserializable<T, object> : true) {
    static_assert(custom_deserializable<T, object>);
    return deserialize(*this, out);
  }
  /**
   * Get this array as the given type.
   *
   * @returns A value of the given type, parsed from the JSON.
   * @returns INCORRECT_TYPE If the JSON value is not the given type.
   */
  template <typename T>
  simdjson_inline simdjson_result<T> get()
    noexcept(custom_deserializable<T, value> ? nothrow_custom_deserializable<T, value> : true)
  {
    static_assert(std::is_default_constructible<T>::value, "The specified type is not default constructible.");
    T out{};
    SIMDJSON_TRY(get<T>(out));
    return out;
  }
 #endif // SIMDJSON_SUPPORTS_DESERIALIZATION
 protected:
  /**
   * Go to the end of the object, no matter where you are right now.
@@ -275,32 +245,12 @@ public:
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](std::string_view key) && noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_path(std::string_view json_path) noexcept;
  inline simdjson_result<bool> reset() noexcept;
  inline simdjson_result<bool> is_empty() noexcept;
  inline simdjson_result<size_t> count_fields() & noexcept;
  inline simdjson_result<std::string_view> raw_json() noexcept;
  #if SIMDJSON_SUPPORTS_DESERIALIZATION
  // TODO: move this code into object-inl.h
  template<typename T>
  simdjson_inline simdjson_result<T> get() noexcept {
    if (error()) { return error(); }
    if constexpr (std::is_same_v<T, SIMDJSON_IMPLEMENTATION::ondemand::object>) {
      return first;
    }
    return first.get<T>();
  }
  template<typename T>
  simdjson_inline error_code get(T& out) noexcept {
    if (error()) { return error(); }
    if constexpr (std::is_same_v<T, SIMDJSON_IMPLEMENTATION::ondemand::object>) {
      out = first;
    } else {
      SIMDJSON_TRY( first.get<T>(out) );
    }
    return SUCCESS;
  }
 #endif // SIMDJSON_SUPPORTS_DESERIALIZATION
 };
 } // namespace simdjson
@@ -84,22 +84,6 @@ public:
   * using a sanitizer that verifies that no uninitialized byte is read, then you should initialize the
   * SIMDJSON_PADDING bytes to avoid runtime warnings.
   *
   * ### std::string references
   *
   * If you pass a mutable std::string reference (std::string&), the parser will seek to extend
   * its capacity to SIMDJSON_PADDING bytes beyond the end of the string.
   *
   * Whenever you pass an std::string reference, the parser will access the bytes beyond the end of
   * the string but before the end of the allocated memory (std::string::capacity()).
   * If you are using a sanitizer that checks for reading uninitialized bytes or std::string's
   * container-overflow checks, you may encounter sanitizer warnings.
   * You can safely ignore these warnings. Or you can call simdjson::pad(std::string&) to pad the
   * string with SIMDJSON_PADDING spaces: this function returns a simdjson::padding_string_view
   * which can be be passed to the parser's iterate function:
   *
   *    std::string json = R"({ "foo": 1 } { "foo": 2 } { "foo": 3 } )";
   *    document doc = parser.iterate(simdjson::pad(json));
   *
   * @param json The JSON to parse.
   * @param len The length of the JSON.
   * @param capacity The number of bytes allocated in the JSON (must be at least len+SIMDJSON_PADDING).
@@ -294,12 +278,8 @@ public:
   * behavior of the parser for future operations.
   */
  bool threaded{true};
  #else
  /**
   * When SIMDJSON_THREADS_ENABLED is not defined, the parser instance cannot use threads.
   */
  bool threaded{false};
  #endif
  /**
   * Unescape this JSON string, replacing \\ with \, \n with newline, etc. to a user-provided buffer.
   * The result must be valid UTF-8.
@@ -360,7 +340,7 @@ public:
 private:
  /** @private [for benchmarking access] The implementation to use */
-  std::unique_ptr<simdjson::internal::dom_parser_implementation> implementation{};
+  std::unique_ptr<internal::dom_parser_implementation> implementation{};
  size_t _capacity{0};
  size_t _max_capacity;
  size_t _max_depth{DEFAULT_MAX_DEPTH};
@@ -20,39 +20,36 @@ 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};
-  while(pos < target.size()) {
+  // if the content has no escape character, just scan through it quickly!
-    pos = target.find('"', pos);
+  for(;pos < target.size() && target[pos] != '\\';pos++) {}
-    if(pos == std::string_view::npos) { return true; }
+  // slow path may begin.
-    if(pos != 0 && target[pos-1] != '\\') { return false; }
+  bool escaping{false};
-    if(pos > 1 && target[pos-2] == '\\') {
+  for(;pos < target.size();pos++) {
-      size_t backslash_count{2};
+    if((target[pos] == '"') && !escaping) {
-      for(size_t i = 3; i <= pos; i++) {
+      return false;
-        if(target[pos-i] == '\\') { backslash_count++; }
+    } else if(target[pos] == '\\') {
-        else { break; }
+      escaping = !escaping;
-      }
+    } else {
-      if(backslash_count % 2 == 0) { return false; }
+      escaping = false;
    }
    pos++;
  }
  return true;
 }
 simdjson_inline bool raw_json_string::is_free_from_unescaped_quote(const char* target) noexcept {
  size_t pos{0};
-  while(target[pos]) {
+  // if the content has no escape character, just scan through it quickly!
-    const char * result = strchr(target+pos, '"');
+  for(;target[pos] && target[pos] != '\\';pos++) {}
-    if(result == nullptr) { return true; }
+  // slow path may begin.
-    pos = result - target;
+  bool escaping{false};
-    if(pos != 0 && target[pos-1] != '\\') { return false; }
+  for(;target[pos];pos++) {
-    if(pos > 1 && target[pos-2] == '\\') {
+    if((target[pos] == '"') && !escaping) {
-      size_t backslash_count{2};
+      return false;
-      for(size_t i = 3; i <= pos; i++) {
+    } else if(target[pos] == '\\') {
-        if(target[pos-i] == '\\') { backslash_count++; }
+      escaping = !escaping;
-        else { break; }
+    } else {
-      }
+      escaping = false;
      if(backslash_count % 2 == 0) { return false; }
    }
    pos++;
  }
  return true;
 }
@@ -64,7 +61,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());
@@ -3,27 +3,24 @@
 #ifndef SIMDJSON_ONDEMAND_DESERIALIZE_H
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
 #define SIMDJSON_ONDEMAND_DESERIALIZE_H
 #include "simdjson/generic/ondemand/object.h"
 #include "simdjson/generic/ondemand/array.h"
 #include "simdjson/generic/ondemand/base.h"
 #include "simdjson/generic/ondemand/array.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 #include <concepts>
 #include <limits>
-#if SIMDJSON_STATIC_REFLECTION
+#include <list>
-#include <experimental/meta>
+#include <memory>
-#endif
+#include <string>
 #include <vector>
 namespace simdjson {
 template <typename T>
 constexpr bool require_custom_serialization = false;
 //////////////////////////////
 // Number deserialization
 //////////////////////////////
 template <std::unsigned_integral T>
  requires(!require_custom_serialization<T>)
 error_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept {
  using limits = std::numeric_limits<T>;
@@ -37,7 +34,6 @@ error_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept {
 }
 template <std::floating_point T>
  requires(!require_custom_serialization<T>)
 error_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept {
  double x;
  SIMDJSON_TRY(val.get_double().get(x));
@@ -46,7 +42,6 @@ error_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept {
 }
 template <std::signed_integral T>
  requires(!require_custom_serialization<T>)
 error_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept {
  using limits = std::numeric_limits<T>;
@@ -60,27 +55,65 @@ error_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept {
 }
 //////////////////////////////
-// String deserialization
+// STL list deserialization
 //////////////////////////////
-error_code tag_invoke(deserialize_tag, auto &val, char &out) noexcept {
+template <typename T, typename AllocT, typename ValT>
-  std::string_view x;
+error_code tag_invoke(deserialize_tag, ValT &val,
-  SIMDJSON_TRY(val.get_string().get(x));
+                      std::list<T, AllocT> &out) noexcept(false) {
-  if(x.size() != 1) {
+
-    return INCORRECT_TYPE;
+  // For better error messages, don't use these as constraints on
  // the tag_invoke CPO.
  static_assert(
      deserializable<T, ValT>,
      "The specified type inside the list must itself be deserializable");
  static_assert(
      std::is_default_constructible_v<T>,
      "The specified type inside the list must default constructible.");
  SIMDJSON_IMPLEMENTATION::ondemand::array arr;
  SIMDJSON_TRY(val.get_array().get(arr));
  for (auto v : arr) {
    if (auto const err = v.get<T>().get(out.emplace_back()); err) {
      // If an error occurs, the empty element that we just inserted gets
      // removed. We're not using a temp variable because if T is a heavy type,
      // we want the valid path to be the fast path and the slow path be the
      // path that has errors in it.
      static_cast<void>(out.pop_back());
      return err;
    }
  }
  out = x[0];
  return SUCCESS;
 }
 //////////////////////////////
 // std::string deserialization
 //////////////////////////////
-error_code tag_invoke(deserialize_tag, auto &val, std::string &out) noexcept {
+template <typename CharT,
-  std::string_view x;
+          typename TraitsT,
-  SIMDJSON_TRY(val.get_string().get(x));
+          typename AllocT,
-  out.assign(x.data(), x.size());
+          typename ValT>
 error_code tag_invoke(deserialize_tag, ValT &val, std::basic_string<CharT, TraitsT, AllocT> &out) noexcept(false) {
  using string_type = std::basic_string<CharT, TraitsT, AllocT>;
  if constexpr (std::same_as<string_type, string_type>) {
    SIMDJSON_TRY(val.get_string(out));
  } else {
    // todo: optimize performance
    std::string tmp;
    SIMDJSON_TRY(val.get_string(tmp));
    for (auto const ch : tmp) {
      out.push_back(ch);
    }
  }
  return SUCCESS;
 }
 //////////////////////////////
 // STL Vector deserialization
 //////////////////////////////
 /**
 * STL containers have several constructors including one that takes a single
 * size argument. Thus, some compilers (Visual Studio) will not be able to
@@ -88,293 +121,75 @@ error_code tag_invoke(deserialize_tag, auto &val, std::string &out) noexcept {
 * explicitly specify the type of the container as needed: e.g.,
 * doc.get<std::vector<int>>().
 */
-template <concepts::appendable_containers T, typename ValT>
+template <typename T, typename AllocT, typename ValT>
-  requires(!require_custom_serialization<T>)
+error_code tag_invoke(deserialize_tag, ValT &val,
-error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(false) {
+                      std::vector<T, AllocT> &out) noexcept(false) {
  using value_type = typename std::remove_cvref_t<T>::value_type;
  /*static_assert(
      deserializable<value_type, ValT>,
      "The specified type inside the container must itself be deserializable");*/
  static_assert(
      std::is_default_constructible_v<value_type>,
      "The specified type inside the container must default constructible.");
  SIMDJSON_IMPLEMENTATION::ondemand::array arr;
  if constexpr (std::is_same_v<std::remove_cvref_t<ValT>, SIMDJSON_IMPLEMENTATION::ondemand::array>) {
    arr = val;
  } else {
    SIMDJSON_TRY(val.get_array().get(arr));
  }
  for (auto v : arr) {
    if constexpr (concepts::returns_reference<T>) {
      if (auto const err = v.get<value_type>().get(concepts::emplace_one(out));
          err) {
        // If an error occurs, the empty element that we just inserted gets
        // removed. We're not using a temp variable because if T is a heavy
        // type, we want the valid path to be the fast path and the slow path be
        // the path that has errors in it.
        if constexpr (requires { out.pop_back(); }) {
          static_cast<void>(out.pop_back());
        }
        return err;
      }
    } else {
      value_type temp;
      if (auto const err = v.get<value_type>().get(temp); err) {
        return err;
      }
      concepts::emplace_one(out, std::move(temp));
    }
  }
  return SUCCESS;
 }
 /**
 * This CPO (Customization Point Object) will help deserialize into
 * smart pointers.
 *
 * If constructing T is nothrow, this conversion should be nothrow as well since
 * we return MEMALLOC if we're not able to allocate memory instead of throwing
 * the error message.
 *
 * @tparam T The type inside the smart pointer
 * @tparam ValT document/value type
 * @param val document/value
 * @param out a reference to the smart pointer
 * @return status of the conversion
 */
 template <concepts::smart_pointer T, typename ValT>
  requires(!require_custom_serialization<T>)
 error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(nothrow_deserializable<typename std::remove_cvref_t<T>::element_type, ValT>) {
  using element_type = typename std::remove_cvref_t<T>::element_type;
  // For better error messages, don't use these as constraints on
  // the tag_invoke CPO.
  static_assert(
-      deserializable<element_type, ValT>,
+      deserializable<T, ValT>,
      "The specified type inside the vector must itself be deserializable");
  static_assert(
      std::is_default_constructible_v<T>,
      "The specified type inside the vector must default constructible.");
  SIMDJSON_IMPLEMENTATION::ondemand::array arr;
  SIMDJSON_TRY(val.get_array().get(arr));
  for (auto v : arr) {
    if (auto const err = v.get<T>().get(out.emplace_back()); err) {
      // If an error occurs, the empty element that we just inserted gets
      // removed. We're not using a temp variable because if T is a heavy type,
      // we want the valid path to be the fast path and the slow path be the
      // path that has errors in it.
      static_cast<void>(out.pop_back());
      return err;
    }
  }
  return SUCCESS;
 }
 //////////////////////////////
 // std::unique_ptr deserialization
 //////////////////////////////
 /**
 * This CPO (Customization Point Object) will help deserialize into
 * `unique_ptr`s.
 *
 * If constructing T is nothrow, this conversion should be nothrow as well since
 * we return MEMALLOC if we're not able to allocate memory instead of throwing
 * the the error message.
 *
 * @tparam T The type inside the unique_ptr
 * @tparam Deleter The Deleter of the unique_ptr
 * @tparam ValT document/value type
 * @param val document/value
 * @param out output unique_ptr
 * @return status of the conversion
 */
 template <typename T, typename Deleter, typename ValT>
 error_code tag_invoke(deserialize_tag, ValT &val,
                      std::unique_ptr<T, Deleter>
                          &out) noexcept(nothrow_deserializable<T, ValT>) {
  // For better error messages, don't use these as constraints on
  // the tag_invoke CPO.
  static_assert(
      deserializable<T, ValT>,
      "The specified type inside the unique_ptr must itself be deserializable");
  static_assert(
-      std::is_default_constructible_v<element_type>,
+      std::is_default_constructible_v<T>,
      "The specified type inside the unique_ptr must default constructible.");
-  auto ptr = new (std::nothrow) element_type();
+  auto ptr = new (std::nothrow) T();
  if (ptr == nullptr) {
    return MEMALLOC;
  }
-  SIMDJSON_TRY(val.template get<element_type>(*ptr));
+  SIMDJSON_TRY(val.template get<T>(*ptr));
  out.reset(ptr);
  return SUCCESS;
 }
 /**
 * This CPO (Customization Point Object) will help deserialize into optional types.
 */
 template <concepts::optional_type T, typename ValT>
  requires(!require_custom_serialization<T>)
 error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(nothrow_deserializable<typename std::remove_cvref_t<T>::value_type, ValT>) {
  using value_type = typename std::remove_cvref_t<T>::value_type;
  static_assert(
      deserializable<value_type, ValT>,
      "The specified type inside the unique_ptr must itself be deserializable");
  static_assert(
      std::is_default_constructible_v<value_type>,
      "The specified type inside the unique_ptr must default constructible.");
  if (!out) {
    out.emplace();
  }
  SIMDJSON_TRY(val.template get<value_type>(out.value()));
  return SUCCESS;
 }
 #if SIMDJSON_STATIC_REFLECTION
 template <typename T>
 constexpr bool user_defined_type = (std::is_class_v<T>
 && !std::is_same_v<T, std::string> && !std::is_same_v<T, std::string_view> && !concepts::optional_type<T> &&
 !concepts::appendable_containers<T> && !require_custom_serialization<T>);
 // workaround from
 // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2996r3.html#back-and-forth
 // for missing expansion statements
 /*namespace __impl {
 template <auto... vals> struct replicator_type {
  template <typename F> constexpr void operator>>(F body) const {
    (body.template operator()<vals>(), ...);
  }
 };
 template <auto... vals> replicator_type<vals...> replicator = {};
 } // namespace __impl
 template <typename R> consteval auto expand(R range) {
  std::vector<std::meta::info> args;
  for (auto r : range) {
    args.push_back(std::meta::reflect_value(r));
  }
  return substitute(^__impl::replicator, args);
 }*/
 // end of workaround
 template <typename T, typename ValT>
  requires(user_defined_type<T> && std::is_class_v<T>)
  constexpr error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept {
  SIMDJSON_IMPLEMENTATION::ondemand::object obj;
  if constexpr (std::is_same_v<std::remove_cvref_t<ValT>, SIMDJSON_IMPLEMENTATION::ondemand::object>) {
    obj = val;
  } else {
    SIMDJSON_TRY(val.get_object().get(obj));
  }
  template for (constexpr auto mem : std::meta::nonstatic_data_members_of(^^T)) {
    if(std::meta::is_const(mem)) {
      continue;
    }
    std::string_view key = std::string_view(std::meta::identifier_of(mem));
    if(error_code e = obj[key].get(out.[:mem:]); e != simdjson::SUCCESS && e != simdjson::NO_SUCH_FIELD) {
      return e;
    }
  }
  return simdjson::SUCCESS;
 }
 template <typename simdjson_value, typename T>
  requires(user_defined_type<std::remove_cvref_t<T>>)
 error_code tag_invoke(deserialize_tag, simdjson_value &val, std::unique_ptr<T> &out) noexcept {
  if (!out) {
    out = std::make_unique<T>();
    if (!out) {
      return MEMALLOC;
    }
  }
  if (auto err = val.get(*out)) {
    out.reset();
    return err;
  }
  return SUCCESS;
 }
 template <typename simdjson_value, typename T>
  requires(user_defined_type<std::remove_cvref_t<T>>)
 error_code tag_invoke(deserialize_tag, simdjson_value &val, std::shared_ptr<T> &out) noexcept {
  if (!out) {
    out = std::make_shared<T>();
    if (!out) {
      return MEMALLOC;
    }
  }
  if (auto err = val.get(*out)) {
    out.reset();
    return err;
  }
  return SUCCESS;
 }
 #endif // SIMDJSON_STATIC_REFLECTION
 ////////////////////////////////////////
 // Unique pointers
 ////////////////////////////////////////
 error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<bool> &out) noexcept {
  if (!out) {
    out = std::make_unique<bool>();
    if (!out) { return MEMALLOC; }
  }
  SIMDJSON_TRY(val.get_bool().get(*out));
  return SUCCESS;
 }
 error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<int64_t> &out) noexcept {
  if (!out) {
    out = std::make_unique<int64_t>();
    if (!out) { return MEMALLOC; }
  }
  SIMDJSON_TRY(val.get_int64().get(*out));
  return SUCCESS;
 }
 error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<uint64_t> &out) noexcept {
  if (!out) {
    out = std::make_unique<uint64_t>();
    if (!out) { return MEMALLOC; }
  }
  SIMDJSON_TRY(val.get_uint64().get(*out));
  return SUCCESS;
 }
 error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<double> &out) noexcept {
  if (!out) {
    out = std::make_unique<double>();
    if (!out) { return MEMALLOC; }
  }
  SIMDJSON_TRY(val.get_double().get(*out));
  return SUCCESS;
 }
 error_code tag_invoke(deserialize_tag, auto &val, std::unique_ptr<std::string_view> &out) noexcept {
  if (!out) {
    out = std::make_unique<std::string_view>();
    if (!out) { return MEMALLOC; }
  }
  SIMDJSON_TRY(val.get_string().get(*out));
  return SUCCESS;
 }
 ////////////////////////////////////////
 // Shared pointers
 ////////////////////////////////////////
 error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<bool> &out) noexcept {
  if (!out) {
    out = std::make_shared<bool>();
    if (!out) { return MEMALLOC; }
  }
  SIMDJSON_TRY(val.get_bool().get(*out));
  return SUCCESS;
 }
 error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<int64_t> &out) noexcept {
  if (!out) {
    out = std::make_shared<int64_t>();
    if (!out) { return MEMALLOC; }
  }
  SIMDJSON_TRY(val.get_int64().get(*out));
  return SUCCESS;
 }
 error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<uint64_t> &out) noexcept {
  if (!out) {
    out = std::make_shared<uint64_t>();
    if (!out) { return MEMALLOC; }
  }
  SIMDJSON_TRY(val.get_uint64().get(*out));
  return SUCCESS;
 }
 error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<double> &out) noexcept {
  if (!out) {
    out = std::make_shared<double>();
    if (!out) { return MEMALLOC; }
  }
  SIMDJSON_TRY(val.get_double().get(*out));
  return SUCCESS;
 }
 error_code tag_invoke(deserialize_tag, auto &val, std::shared_ptr<std::string_view> &out) noexcept {
  if (!out) {
    out = std::make_shared<std::string_view>();
    if (!out) { return MEMALLOC; }
  }
  SIMDJSON_TRY(val.get_string().get(*out));
  return SUCCESS;
 }
 } // namespace simdjson
 #endif // SIMDJSON_ONDEMAND_DESERIALIZE_H
@@ -6,6 +6,8 @@
 #include "simdjson/generic/ondemand/array.h"
 #include "simdjson/generic/ondemand/array_iterator.h"
 #include "simdjson/generic/ondemand/json_iterator.h"
 #include "simdjson/generic/ondemand/json_path_to_pointer_conversion.h"
 #include "simdjson/generic/ondemand/json_path_to_pointer_conversion-inl.h"
 #include "simdjson/generic/ondemand/json_type.h"
 #include "simdjson/generic/ondemand/object.h"
 #include "simdjson/generic/ondemand/raw_json_string.h"
@@ -34,7 +34,6 @@ public:
   *
   * You may use get_double(), get_bool(), get_uint64(), get_int64(),
   * get_object(), get_array(), get_raw_json_string(), or get_string() instead.
   * When SIMDJSON_SUPPORTS_DESERIALIZATION is set, custom types are also supported.
   *
   * @returns A value of the given type, parsed from the JSON.
   * @returns INCORRECT_TYPE If the JSON value is not the given type.
@@ -58,7 +57,6 @@ public:
   * Get this value as the given type.
   *
   * Supported types: object, array, raw_json_string, string_view, uint64_t, int64_t, double, bool
   * If the macro SIMDJSON_SUPPORTS_DESERIALIZATION is set, then custom types are also supported.
   *
   * @param out This is set to a value of the given type, parsed from the JSON. If there is an error, this may not be initialized.
   * @returns INCORRECT_TYPE If the JSON value is not an object.
@@ -165,17 +163,6 @@ public:
   * Important: a value should be consumed once. Calling get_string() twice on the same value
   * is an error.
   *
   * In some instances, you may want to allow replacement of invalid Unicode sequences.
   * You may do so by passing the allow_replacement parameter as true. In the following
   * example, the string "431924697b\udff0L\u0001Y" is not valid Unicode. By passing true
   * to get_string, we allow the replacement of the invalid Unicode sequences with the Unicode
   * replacement character (U+FFFD).
   *
   *   simdjson::ondemand::parser parser;
   *   auto json = R"({"deviceId":"431924697b\udff0L\u0001Y"})"_padded;
   *   simdjson::ondemand::document doc = parser.iterate(json);
   *   auto view = doc["deviceId"].get_string(true);
   *
   * @returns An UTF-8 string. The string is stored in the parser and will be invalidated the next
   *          time it parses a document or when it is destroyed.
   * @returns INCORRECT_TYPE if the JSON value is not a string.
@@ -427,7 +414,6 @@ public:
  simdjson_inline simdjson_result<value> operator[](std::string_view key) noexcept;
  /** @overload simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) noexcept; */
  simdjson_inline simdjson_result<value> operator[](const char *key) noexcept;
  simdjson_result<value> operator[](int) noexcept = delete;
  /**
   * Get the type of this JSON value. It does not validate or consume the value.
@@ -795,7 +781,6 @@ public:
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](std::string_view key) noexcept;
  /** @overload simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field_unordered(std::string_view key) noexcept; */
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](const char *key) noexcept;
  simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](int) noexcept = delete;
  /**
   * Get the type of this JSON value.
@@ -6,9 +6,9 @@
 #include "simdjson/generic/atomparsing.h"
 #include "simdjson/generic/numberparsing.h"
 #include "simdjson/generic/ondemand/json_iterator.h"
 #include "simdjson/generic/ondemand/value_iterator.h"
 #include "simdjson/generic/ondemand/json_type-inl.h"
 #include "simdjson/generic/ondemand/raw_json_string-inl.h"
 #include "simdjson/generic/ondemand/value_iterator.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 namespace simdjson {
@@ -799,8 +799,6 @@ simdjson_inline simdjson_result<bool> value_iterator::is_root_null(bool check_tr
  if(result) { // we have something that looks like a null.
    if (check_trailing && !_json_iter->is_single_token()) { return TRAILING_CONTENT; }
    advance_root_scalar("null");
  } else if (json[0] == 'n') {
    return incorrect_type_error("Not a null but starts with n");
  }
  return result;
 }
@@ -4,14 +4,8 @@
 #include "simdjson/haswell/intrinsics.h"
 #if !SIMDJSON_CAN_ALWAYS_RUN_HASWELL
 // We enable bmi2 only if LLVM/clang is used, because GCC may not
 // make good use of it. See https://github.com/simdjson/simdjson/pull/2243
 #if defined(__clang__)
 SIMDJSON_TARGET_REGION("avx2,bmi,bmi2,pclmul,lzcnt,popcnt")
 #else
 SIMDJSON_TARGET_REGION("avx2,bmi,pclmul,lzcnt,popcnt")
 #endif
 #endif
 #include "simdjson/haswell/bitmanipulation.h"
 #include "simdjson/haswell/bitmask.h"
@@ -28,7 +28,6 @@ public:
  ) const noexcept final;
  simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
  simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 } // namespace haswell
@@ -41,31 +41,6 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
  };
 }
 struct escaping {
  static constexpr uint32_t BYTES_PROCESSED = 32;
  simdjson_inline static escaping copy_and_find(const uint8_t *src, uint8_t *dst);
  simdjson_inline bool has_escape() { return escape_bits != 0; }
  simdjson_inline int escape_index() { return trailing_zeroes(escape_bits); }
  uint64_t escape_bits;
 }; // struct escaping
 simdjson_inline escaping escaping::copy_and_find(const uint8_t *src, uint8_t *dst) {
  static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "escaping finder must process fewer than SIMDJSON_PADDING bytes");
  simd8<uint8_t> v(src);
  v.store(dst);
  simd8<bool> is_quote = (v == '"');
  simd8<bool> is_backslash = (v == '\\');
  simd8<bool> is_control = (v < 32);
  return {
    uint64_t((is_backslash | is_quote | is_control).to_bitmask())
  };
 }
 } // unnamed namespace
 } // namespace haswell
 } // namespace simdjson
@@ -28,7 +28,6 @@ public:
  ) const noexcept final;
  simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
  simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 } // namespace icelake
@@ -77,6 +77,7 @@ namespace simd {
    friend simdjson_really_inline uint64_t operator==(const simd8<T> lhs, const simd8<T> rhs) {
      return _mm512_cmpeq_epi8_mask(lhs, rhs);
    }
    static const int SIZE = sizeof(base<T>::value);
    template<int N=1>
@@ -147,18 +148,14 @@ namespace simd {
    // Copies to 'output" all bytes corresponding to a 0 in the mask (interpreted as a bitset).
    // Passing a 0 value for mask would be equivalent to writing out every byte to output.
-    // Only the first 64 - count_ones(mask) bytes of the result are significant but 64 bytes
+    // Only the first 32 - count_ones(mask) bytes of the result are significant but 32 bytes
    // get written.
    // Design consideration: it seems like a function with the
    // signature simd8<L> compress(uint32_t mask) would be
    // sensible, but the AVX ISA makes this kind of approach difficult.
    template<typename L>
    simdjson_inline void compress(uint64_t mask, L * output) const {
-      // we deliberately avoid _mm512_mask_compressstoreu_epi8 for portability
+      _mm512_mask_compressstoreu_epi8 (output,~mask,*this);
      // (AMD Zen4 has terrible performance with it, it is effectively broken)
      // _mm512_mask_compressstoreu_epi8 (output,~mask,*this);
      __m512i compressed = _mm512_maskz_compress_epi8(~mask, *this);
      _mm512_storeu_si512(output, compressed); // could use a mask
    }
    template<typename L>
@@ -41,35 +41,6 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
  };
 }
 struct escaping {
  static constexpr uint32_t BYTES_PROCESSED = 64;
  simdjson_inline static escaping copy_and_find(const uint8_t *src, uint8_t *dst);
  simdjson_inline bool has_escape() { return escape_bits != 0; }
  simdjson_inline int escape_index() { return trailing_zeroes(uint64_t(escape_bits)); }
  __mmask64 escape_bits;
 }; // struct escaping
 simdjson_inline escaping escaping::copy_and_find(const uint8_t *src, uint8_t *dst) {
  static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "escaping finder must process fewer than SIMDJSON_PADDING bytes");
  simd8<uint8_t> v(src);
  v.store(dst);
  __mmask64 is_quote = _mm512_cmpeq_epi8_mask(v, _mm512_set1_epi8('"'));
  __mmask64 is_backslash = _mm512_cmpeq_epi8_mask(v, _mm512_set1_epi8('\\'));
  __mmask64 is_control = _mm512_cmplt_epi8_mask(v, _mm512_set1_epi8(32));
  return {
    (is_backslash | is_quote | is_control)
  };
 }
 } // unnamed namespace
 } // namespace icelake
 } // namespace simdjson
@@ -26,15 +26,6 @@ simdjson_inline simdjson_warn_unused bool validate_utf8(const std::string_view s
  return validate_utf8(sv.data(), sv.size());
 }
 /**
 * Write the string to the output buffer while escaping double-quote, backlash and ascii control characters.
 *
 * @param input the string_view to escape
 * @param out output buffer (for escaped string): to be safe, it should have 6 * input.size() allocated bytes.
 * @return number of bytes written
 */
 simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) noexcept;
 /**
 * Validate the UTF-8 string.
 *
@@ -136,14 +127,6 @@ public:
   */
  simdjson_warn_unused virtual bool validate_utf8(const char *buf, size_t len) const noexcept = 0;
  /**
   * Write the string to the output buffer while escaping double-quote, backlash and ascii control characters.
   *
   * @param input the string_view to escape
   * @param out output buffer (for escaped string): to be safe, it should have 6 * input.size() allocated bytes.
   * @return number of bytes written
   */
  simdjson_warn_unused virtual size_t write_string_escaped(const std::string_view input, char *out) const noexcept = 0;
 protected:
  /** @private Construct an implementation with the given name and description. For subclasses. */
  simdjson_inline implementation(
@@ -1,64 +0,0 @@
 #ifndef SIMDJSON_JSONPATHUTIL_H
 #define SIMDJSON_JSONPATHUTIL_H
 #include <string>
 #include <string_view>
 namespace simdjson {
 /**
 * Converts JSONPath to JSON Pointer.
 * @param json_path The JSONPath string to be converted.
 * @return A string containing the equivalent JSON Pointer.
 */
 inline std::string json_path_to_pointer_conversion(std::string_view json_path) {
  size_t i = 0;
  // if JSONPath starts with $, skip it
  if (!json_path.empty() && json_path.front() == '$') {
    i = 1;
  }
  if (json_path.empty() || (json_path[i] != '.' &&
      json_path[i] != '[')) {
    return "-1"; // This is just a sentinel value, the caller should check for this and return an error.
  }
  std::string result;
  // Reserve space to reduce allocations, adjusting for potential increases due
  // to escaping.
  result.reserve(json_path.size() * 2);
  while (i < json_path.length()) {
    if (json_path[i] == '.') {
      result += '/';
    } else if (json_path[i] == '[') {
      result += '/';
      ++i; // Move past the '['
      while (i < json_path.length() && json_path[i] != ']') {
          if (json_path[i] == '~') {
            result += "~0";
          } else if (json_path[i] == '/') {
            result += "~1";
          } else {
            result += json_path[i];
          }
          ++i;
      }
      if (i == json_path.length() || json_path[i] != ']') {
          return "-1"; // Using sentinel value that will be handled as an error by the caller.
      }
    } else {
      if (json_path[i] == '~') {
          result += "~0";
      } else if (json_path[i] == '/') {
          result += "~1";
      } else {
          result += json_path[i];
      }
    }
    ++i;
  }
  return result;
 }
 } // namespace simdjson
 #endif // SIMDJSON_JSONPATHUTIL_H
@@ -23,7 +23,6 @@ public:
  ) const noexcept final;
  simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
  simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 } // namespace lasx
@@ -36,12 +36,6 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace lasx
 } // namespace simdjson
 #ifndef SIMDJSON_SWAR_NUMBER_PARSING
 #if SIMDJSON_IS_BIG_ENDIAN
 #define SIMDJSON_SWAR_NUMBER_PARSING 0
 #else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
 #endif
 #endif
 #endif // SIMDJSON_LASX_NUMBERPARSING_DEFS_H
@@ -40,31 +40,6 @@ simdjson_inline backslash_and_quote backslash_and_quote::copy_and_find(const uin
  };
 }
 struct escaping {
  static constexpr uint32_t BYTES_PROCESSED = 16;
  simdjson_inline static escaping copy_and_find(const uint8_t *src, uint8_t *dst);
  simdjson_inline bool has_escape() { return escape_bits != 0; }
  simdjson_inline int escape_index() { return trailing_zeroes(escape_bits); }
  uint64_t escape_bits;
 }; // struct escaping
 simdjson_inline escaping escaping::copy_and_find(const uint8_t *src, uint8_t *dst) {
  static_assert(SIMDJSON_PADDING >= (BYTES_PROCESSED - 1), "escaping finder must process fewer than SIMDJSON_PADDING bytes");
  simd8<uint8_t> v(src);
  v.store(dst);
  simd8<bool> is_quote = (v == '"');
  simd8<bool> is_backslash = (v == '\\');
  simd8<bool> is_control = (v < 32);
  return {
    (is_backslash | is_quote | is_control).to_bitmask()
  };
 }
 } // unnamed namespace
 } // namespace lasx
 } // namespace simdjson
@@ -23,7 +23,6 @@ public:
  ) const noexcept final;
  simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
  simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
  simdjson_warn_unused size_t write_string_escaped(const std::string_view input, char *out) const noexcept final;
 };
 } // namespace lsx
@@ -36,12 +36,6 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace lsx
 } // namespace simdjson
 #ifndef SIMDJSON_SWAR_NUMBER_PARSING
 #if SIMDJSON_IS_BIG_ENDIAN
 #define SIMDJSON_SWAR_NUMBER_PARSING 0
 #else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
 #endif
 #endif
 #endif // SIMDJSON_LSX_NUMBERPARSING_DEFS_H
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Daniel Lemire	db91f62bd7	updating single	2024-09-27 09:26:51 -04:00
Daniel Lemire	20cd6e30ee	fixing incorrect max/min usage	2024-09-27 09:24:23 -04:00
Daniel Lemire	e45d8edbd6	minor tweaks to style	2024-09-26 21:03:50 -04:00
Daniel Lemire	6efb8d81bd	Merge branch 'builder_development_branch' into general-madness-simpler	2024-09-26 20:49:28 -04:00
Daniel Lemire	f562878afc	missing file	2024-09-26 20:38:31 -04:00
Daniel Lemire	60aa25a0c2	adding a comment	2024-09-26 20:35:49 -04:00
Daniel Lemire	d01662560d	simpler madness	2024-09-26 20:35:01 -04:00
Daniel Lemire	a63c77a977	typo	2024-09-26 17:20:44 -04:00
M. Bahoosh	bbb3cb80a6	Minimal tag_invokes for STL types	2024-09-26 09:27:38 -10:00
Daniel Lemire	43219e50e0	update CI on the builder_development_branch (no code change) (#2262 )	2024-09-25 12:33:04 -04:00
M. Bahoosh	49b9860899	Making `tag_invoke` a "put" as opposed to a "get" (#2256 ) * fix: add tests related to issue 2227 (#2229) * fix: add tests related to issue 2227 * avoiding name clash * pedantic fix * deprecate rvalue get on document * selectively deprecating * Fix ndjson spec link (#2234) * fix ndjson spec link The link in the readme of parse_many links to a casino spam site * fix link * [no-ci] Update README.md * Make simdjson compile again * Enable SIMDJSON_SINGLEHEADER=OFF in VS Code With singleheader on, clangd can't find the right include files. * Add missing include directives to static build targets of simdjson. (#2240) * adding a warning * adding warning regarding SIMDJSON_BUILD_STATIC_LIB * release candidate * pedantic viable size * Making tag_invoke a feeder instead of a producer * adding missing undef silencer (#2253) * Ignore pragma once when amalgamating source files (#2248) With gcc it causes an error in `simdjson.cpp`: ``` simdjson.cpp:548:9: warning: #pragma once in main file 548 \| #pragma once \| ^~~~ ``` It had previously been commented out in: https://github.com/simdjson/simdjson/commit/6ef555e6fb79363fae057a9a46b52cd208d9e305 However, this was lost in an upgrade: https://github.com/simdjson/simdjson/commit/2a4ff7346813b120f2b5b40e95d69352b593cc9c * Update CI (#2254) * adding missing undef silencer * Updating CI * more fixes * fix * big endian fix * Moving to the new tag_invoke signature * Fix nlohmann ambiguity on C++23-enabled clang * Revert "Merge branch 'master' of https://github.com/simdjson/simdjson into builder_development_branch_extra" This reverts commit `3eeecbab34`, reversing changes made to `6858b208b4`. --------- Co-authored-by: Daniel Lemire <daniel@lemire.me> Co-authored-by: Sasha Lopoukhine <superlopuh@gmail.com> Co-authored-by: John Keiser <john@johnkeiser.com> Co-authored-by: Tan Li Boon <undisputed-seraphim@users.noreply.github.com> Co-authored-by: tobil4sk <tobil4sk@outlook.com>	2024-09-24 14:47:58 -04:00
Daniel Lemire	0388d79770	Extending the deserialization code with more defaults + docs (#2233 ) * Make custom types easier with some predefined cases + docs * missing include * adding Ubuntu 24 CXX 20 * using concepts all the way * minor tweak * tiny tweak * tweaks * more tweaking * saving --------- Co-authored-by: Daniel Lemire <dlemire@lemire.me>	2024-08-11 14:14:35 -04:00
Daniel Lemire	c0fa1aec66	fix: correct small issues with deserialize (#2232 )	2024-08-09 16:07:08 -04:00
M. Bahoosh	6e61b7f6ef	Making `tag_invoke` to support `ondemand::document` as well + docs (#2228 ) * Making `tag_invoke` to support `ondemand::document` as well + docs * Fix typos and doc update by @lemire Co-authored-by: Daniel Lemire <daniel@lemire.me> * Better docs by @lemire Co-authored-by: Daniel Lemire <daniel@lemire.me> * Preserving the old, disallowing in the new I'm disabling `document::get() &&` if the user has provided a `tag_invoke`d version; otherwise, we retain the compatibility. --------- Co-authored-by: Daniel Lemire <daniel@lemire.me>	2024-08-09 15:25:52 -04:00
M. Bahoosh	a76e778804	tag_invoke based custom types (#2219 ) * tag_invoke based custom types Now you can use tag_invoke to add a custom type or a group of custom types. * Fixing macro usage + Fixing noexcept * Fixing the usage of #include We don't need <concepts> at all seems like it * Fixing tag_invoke impl for MSVC	2024-08-07 09:16:31 -04:00