couchbase 3.0.0 → 3.0.1

data/ext/third_party/json/include/tao/json/internal/pair.hpp

@@ -19,7 +19,7 @@ namespace tao::json::internal
       mutable basic_value< Traits > value;
 
       template< typename U >
-      pair( U&& v )
+      pair( U&& v )  // NOLINT(bugprone-forwarding-reference-overload)
          : key( Traits< std::decay_t< U > >::template default_key< Traits >::as_string() ),
            value( std::forward< U >( v ) )
       {}

data/ext/third_party/json/include/tao/json/internal/sha256.hpp

@@ -26,7 +26,7 @@ namespace tao::json::internal
 {
    // RFC 6234, 5.1
    // clang-format off
-   static std::uint32_t K[ 64 ] = {
+   static std::uint32_t K[ 64 ] = {  // NOLINT(readability-identifier-naming)
       0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
       0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
       0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
@@ -49,15 +49,15 @@ namespace tao::json::internal
    class sha256
    {
    private:
-      unsigned char M[ 64 ];
+      unsigned char M[ 64 ];  // NOLINT(readability-identifier-naming)
       std::uint64_t size;
 
-      std::uint32_t H[ 8 ];
+      std::uint32_t H[ 8 ];  // NOLINT(readability-identifier-naming)
 
       // RFC 6234, 6.2
       void process() noexcept
       {
-         std::uint32_t W[ 64 ];
+         std::uint32_t W[ 64 ];  // NOLINT(readability-identifier-naming)
 
          // step 1
          for( std::size_t t = 0, i = 0; t != 16; ++t, i += 4 ) {
@@ -68,7 +68,7 @@ namespace tao::json::internal
          }
 
          // step 2
-         std::uint32_t a, b, c, d, e, f, g, h;
+         std::uint32_t a, b, c, d, e, f, g, h;  // NOLINT(readability-isolate-declaration)
          a = H[ 0 ];
          b = H[ 1 ];
          c = H[ 2 ];
@@ -80,8 +80,8 @@ namespace tao::json::internal
 
          // step 3
          for( std::size_t t = 0; t != 64; ++t ) {
-            const std::uint32_t T1 = h + BSIG1( e ) + CH( e, f, g ) + K[ t ] + W[ t ];
-            const std::uint32_t T2 = BSIG0( a ) + MAJ( a, b, c );
+            const std::uint32_t T1 = h + BSIG1( e ) + CH( e, f, g ) + K[ t ] + W[ t ];  // NOLINT(readability-identifier-naming)
+            const std::uint32_t T2 = BSIG0( a ) + MAJ( a, b, c );                       // NOLINT(readability-identifier-naming)
             h = g;
             g = f;
             f = e;
@@ -142,7 +142,7 @@ namespace tao::json::internal
 
       void feed( const void* p, std::size_t s ) noexcept
       {
-         auto* q = static_cast< const unsigned char* >( p );
+         const auto* q = static_cast< const unsigned char* >( p );
          while( s != 0 ) {
             feed( *q++ );
             --s;

data/ext/third_party/json/include/tao/json/internal/single.hpp

@@ -18,7 +18,7 @@ namespace tao::json::internal
       mutable basic_value< Traits > value;
 
       template< typename U >
-      single( U&& v )
+      single( U&& v )  // NOLINT(bugprone-forwarding-reference-overload)
          : value( std::forward< U >( v ) )
       {}
 

data/ext/third_party/json/include/tao/json/internal/type_traits.hpp

@@ -7,32 +7,15 @@
 #include <type_traits>
 #include <typeinfo>
 
+#include "../external/pegtl/type_list.hpp"
 #include "../forward.hpp"
 
 namespace tao::json::internal
 {
-   template< typename... Ts >
-   struct type_list
-   {
-      static constexpr std::size_t size = sizeof...( Ts );
-   };
-
-   template< typename... >
-   struct merge_type_lists_t;
-
-   template< typename... Ts >
-   struct merge_type_lists_t< type_list< Ts... > >
-   {
-      using list = type_list< Ts... >;
-   };
-
-   template< typename... Vs, typename... Ws, typename... Rs >
-   struct merge_type_lists_t< type_list< Vs... >, type_list< Ws... >, Rs... >
-      : merge_type_lists_t< type_list< Vs..., Ws... >, Rs... >
-   {};
-
-   template< typename... Ts >
-   using merge_type_lists = typename merge_type_lists_t< Ts... >::list;
+   using pegtl::type_list;           // NOLINT(misc-unused-using-decls)
+   using pegtl::empty_list;          // NOLINT(misc-unused-using-decls)
+   using pegtl::type_list_concat;    // NOLINT(misc-unused-using-decls)
+   using pegtl::type_list_concat_t;  // NOLINT(misc-unused-using-decls)
 
    struct type_info_less
    {
@@ -46,7 +29,7 @@ namespace tao::json::internal
    inline constexpr bool has_as_impl = false;
 
    template< typename Trait, typename... Args >
-   inline constexpr bool has_as_impl< decltype( (void)Trait::as( std::declval< Args >()... ), void() ), Trait, Args... > = true;
+   inline constexpr bool has_as_impl< decltype( (void)Trait::as( std::declval< Args >()... ) ), Trait, Args... > = true;
 
    template< typename Trait, typename Value, typename... With >
    inline constexpr bool has_as = has_as_impl< void, Trait, const Value&, With&... >;
@@ -55,7 +38,7 @@ namespace tao::json::internal
    inline constexpr bool has_as_type_impl = false;
 
    template< template< typename... > typename Traits, typename T, typename... Args >
-   inline constexpr bool has_as_type_impl< decltype( (void)Traits< T >::template as_type< Traits, T >( std::declval< Args >()... ), void() ), Traits, T, Args... > = true;
+   inline constexpr bool has_as_type_impl< decltype( (void)Traits< T >::template as_type< Traits, T >( std::declval< Args >()... ) ), Traits, T, Args... > = true;
 
    template< template< typename... > typename Traits, typename T, typename Value, typename... With >
    inline constexpr bool has_as_type = has_as_type_impl< void, Traits, T, const Value&, With&... >;
@@ -64,7 +47,7 @@ namespace tao::json::internal
    inline constexpr bool has_to_impl = false;
 
    template< typename Trait, typename... Args >
-   inline constexpr bool has_to_impl< decltype( Trait::to( std::declval< Args >()... ), void() ), Trait, Args... > = true;
+   inline constexpr bool has_to_impl< decltype( (void)Trait::to( std::declval< Args >()... ) ), Trait, Args... > = true;
 
    template< typename Trait, typename Value, typename... With >
    inline constexpr bool has_to = has_to_impl< void, Trait, const Value&, With&... >;
@@ -73,19 +56,19 @@ namespace tao::json::internal
    inline constexpr bool has_consume_one = false;
 
    template< template< typename... > class Traits, typename P, typename U >
-   inline constexpr bool has_consume_one< Traits, P, U, decltype( (void)Traits< U >::template consume< Traits >( std::declval< P& >() ), void() ) > = true;
+   inline constexpr bool has_consume_one< Traits, P, U, decltype( (void)Traits< U >::template consume< Traits >( std::declval< P& >() ) ) > = true;
 
    template< template< typename... > class, typename, typename, typename = void >
    inline constexpr bool has_consume_two = false;
 
    template< template< typename... > class Traits, typename P, typename U >
-   inline constexpr bool has_consume_two< Traits, P, U, decltype( (void)Traits< U >::template consume< Traits >( std::declval< P& >(), std::declval< U& >() ), void() ) > = true;
+   inline constexpr bool has_consume_two< Traits, P, U, decltype( (void)Traits< U >::template consume< Traits >( std::declval< P& >(), std::declval< U& >() ) ) > = true;
 
    template< template< typename... > class Traits, typename T, typename = void >
    inline constexpr bool has_is_nothing = false;
 
    template< template< typename... > class Traits, typename T >
-   inline constexpr bool has_is_nothing< Traits, T, decltype( (void)Traits< T >::template is_nothing< Traits >( std::declval< const T& >() ), void() ) > = true;
+   inline constexpr bool has_is_nothing< Traits, T, decltype( (void)Traits< T >::template is_nothing< Traits >( std::declval< const T& >() ) ) > = true;
 
    template< template< typename... > class Traits, typename T >
    [[nodiscard]] std::enable_if_t< has_is_nothing< Traits, T >, bool > is_nothing( const T& t ) noexcept( noexcept( Traits< T >::template is_nothing< Traits >( t ) ) )
@@ -103,7 +86,7 @@ namespace tao::json::internal
    inline constexpr bool has_enable_implicit_constructor = false;
 
    template< template< typename... > class Traits, typename T >
-   inline constexpr bool has_enable_implicit_constructor< Traits, T, decltype( Traits< T >::enable_implicit_constructor, void() ) > = true;
+   inline constexpr bool has_enable_implicit_constructor< Traits, T, decltype( (void)Traits< T >::enable_implicit_constructor ) > = true;
 
    template< template< typename... > class Traits, typename T >
    inline constexpr bool enable_implicit_constructor = Traits< std::conditional_t< has_enable_implicit_constructor< Traits, T >, T, void > >::enable_implicit_constructor;

data/ext/third_party/json/include/tao/json/jaxn/consume_file.hpp

@@ -4,7 +4,7 @@
 #ifndef TAO_JSON_JAXN_CONSUME_FILE_HPP
 #define TAO_JSON_JAXN_CONSUME_FILE_HPP
 
-#include <utility>
+#include <filesystem>
 
 #include "../external/pegtl/file_input.hpp"
 
@@ -15,17 +15,17 @@
 
 namespace tao::json::jaxn
 {
-   template< typename T, template< typename... > class Traits = traits, typename F >
-   [[nodiscard]] T consume_file( F&& filename )
+   template< typename T, template< typename... > class Traits = traits >
+   [[nodiscard]] T consume_file( const std::filesystem::path& path )
    {
-      jaxn::basic_parts_parser< pegtl::file_input< pegtl::tracking_mode::lazy > > pp( std::forward< F >( filename ) );
+      jaxn::basic_parts_parser< pegtl::file_input< pegtl::tracking_mode::lazy > > pp( path );
       return json::consume< T, Traits >( pp );
    }
 
-   template< template< typename... > class Traits = traits, typename F, typename T >
-   void consume_file( F&& filename, T& t )
+   template< template< typename... > class Traits = traits, typename T >
+   void consume_file( const std::filesystem::path& path, T& t )
    {
-      jaxn::basic_parts_parser< pegtl::file_input< pegtl::tracking_mode::lazy > > pp( std::forward< F >( filename ) );
+      jaxn::basic_parts_parser< pegtl::file_input< pegtl::tracking_mode::lazy > > pp( path );
       json::consume< Traits >( pp, t );
    }
 

data/ext/third_party/json/include/tao/json/jaxn/events/from_file.hpp

@@ -4,7 +4,7 @@
 #ifndef TAO_JSON_JAXN_EVENTS_FROM_FILE_HPP
 #define TAO_JSON_JAXN_EVENTS_FROM_FILE_HPP
 
-#include <utility>
+#include <filesystem>
 
 #include "../internal/action.hpp"
 #include "../internal/errors.hpp"
@@ -16,10 +16,10 @@ namespace tao::json::jaxn::events
 {
    // Events producer to parse a file containing a JAXN string representation.
 
-   template< typename T, typename Consumer >
-   void from_file( Consumer& consumer, T&& filename )
+   template< typename Consumer >
+   void from_file( Consumer& consumer, const std::filesystem::path& path )
    {
-      pegtl::file_input< pegtl::tracking_mode::lazy > in( std::forward< T >( filename ) );
+      pegtl::file_input< pegtl::tracking_mode::lazy > in( path );
       pegtl::parse< internal::grammar, internal::action, internal::errors >( in, consumer );
    }
 

data/ext/third_party/json/include/tao/json/jaxn/events/from_string.hpp

@@ -16,14 +16,14 @@ namespace tao::json::jaxn::events
    // Events producer to parse a JAXN string representation.
 
    template< typename Consumer >
-   void from_string( Consumer& consumer, const char* data, const std::size_t size, const char* source = nullptr, const std::size_t byte = 0, const std::size_t line = 1, const std::size_t column = 0 )
+   void from_string( Consumer& consumer, const char* data, const std::size_t size, const char* source = nullptr, const std::size_t byte = 0, const std::size_t line = 1, const std::size_t column = 1 )
    {
       pegtl::memory_input< pegtl::tracking_mode::lazy, pegtl::eol::lf_crlf, const char* > in( data, data + size, source ? source : "tao::json::jaxn::events::from_string", byte, line, column );
       jaxn::events::from_input( consumer, std::move( in ) );
    }
 
    template< typename Consumer >
-   void from_string( Consumer& consumer, const char* data, const std::size_t size, const std::string& source, const std::size_t byte = 0, const std::size_t line = 1, const std::size_t column = 0 )
+   void from_string( Consumer& consumer, const char* data, const std::size_t size, const std::string& source, const std::size_t byte = 0, const std::size_t line = 1, const std::size_t column = 1 )
    {
       jaxn::events::from_string( consumer, data, size, source.c_str(), byte, line, column );
    }

data/ext/third_party/json/include/tao/json/jaxn/from_file.hpp

@@ -4,7 +4,7 @@
 #ifndef TAO_JSON_JAXN_FROM_FILE_HPP
 #define TAO_JSON_JAXN_FROM_FILE_HPP
 
-#include <string>
+#include <filesystem>
 #include <utility>
 
 #include "../events/to_value.hpp"
@@ -15,17 +15,17 @@
 namespace tao::json::jaxn
 {
    template< template< typename... > class Traits, template< typename... > class... Transformers >
-   [[nodiscard]] basic_value< Traits > basic_from_file( const std::string& filename )
+   [[nodiscard]] basic_value< Traits > basic_from_file( const std::filesystem::path& path )
    {
       json::events::transformer< json::events::to_basic_value< Traits >, Transformers... > consumer;
-      events::from_file( consumer, filename );
+      events::from_file( consumer, path );
       return std::move( consumer.value );
    }
 
    template< template< typename... > class... Transformers >
-   [[nodiscard]] value from_file( const std::string& filename )
+   [[nodiscard]] value from_file( const std::filesystem::path& path )
    {
-      return basic_from_file< traits, Transformers... >( filename );
+      return basic_from_file< traits, Transformers... >( path );
    }
 
 }  // namespace tao::json::jaxn

data/ext/third_party/json/include/tao/json/jaxn/internal/action.hpp

@@ -26,7 +26,7 @@ namespace tao::json::jaxn::internal
    {};
 
    template<>
-   struct action< rules::null >
+   struct action< rules::kw_null >
    {
       template< typename Consumer >
       static void apply0( Consumer& consumer )
@@ -36,7 +36,7 @@ namespace tao::json::jaxn::internal
    };
 
    template<>
-   struct action< rules::true_ >
+   struct action< rules::kw_true >
    {
       template< typename Consumer >
       static void apply0( Consumer& consumer )
@@ -46,7 +46,7 @@ namespace tao::json::jaxn::internal
    };
 
    template<>
-   struct action< rules::false_ >
+   struct action< rules::kw_false >
    {
       template< typename Consumer >
       static void apply0( Consumer& consumer )
@@ -177,7 +177,7 @@ namespace tao::json::jaxn::internal
    };
 
    template<>
-   struct action< rules::nan >
+   struct action< rules::kw_nan >
    {
       template< typename Consumer >
       static void apply0( Consumer& consumer )
@@ -187,7 +187,7 @@ namespace tao::json::jaxn::internal
    };
 
    template<>
-   struct action< rules::infinity< false > >
+   struct action< rules::kw_infinity< false > >
    {
       template< typename Consumer >
       static void apply0( Consumer& consumer )
@@ -197,7 +197,7 @@ namespace tao::json::jaxn::internal
    };
 
    template<>
-   struct action< rules::infinity< true > >
+   struct action< rules::kw_infinity< true > >
    {
       template< typename Consumer >
       static void apply0( Consumer& consumer )

data/ext/third_party/json/include/tao/json/jaxn/internal/bunescape_action.hpp

@@ -93,8 +93,8 @@ namespace tao::json::jaxn::internal
       template< typename Input >
       static void apply( const Input& in, std::vector< std::byte >& value )
       {
-         const auto begin = reinterpret_cast< const std::byte* >( in.begin() );
-         const auto end = begin + in.size();
+         const auto* const begin = reinterpret_cast< const std::byte* >( in.begin() );
+         const auto* const end = begin + in.size();
          value.insert( value.end(), begin, end );
       }
    };

data/ext/third_party/json/include/tao/json/jaxn/internal/errors.hpp

@@ -17,7 +17,7 @@ namespace tao::json::jaxn::internal
    struct errors
       : pegtl::normal< Rule >
    {
-      static const std::string error_message;
+      static const char* error_message;
 
       template< typename Input, typename... States >
       static void raise( const Input& in, States&&... /*unused*/ )
@@ -59,48 +59,48 @@ namespace tao::json::jaxn::internal
    };
 
    // clang-format off
-   template<> inline const std::string errors< rules::text >::error_message = "no valid JAXN";
-
-   template<> inline const std::string errors< rules::comment >::error_message = "expected '*' or '/'";
-   template<> inline const std::string errors< rules::line_comment_char >::error_message = "invalid character in line comment";
-   template<> inline const std::string errors< rules::block_comment_char >::error_message = "invalid character in block comment";
-   template<> inline const std::string errors< rules::end_block_comment >::error_message = "unterminated multi-line comment";
-
-   template<> inline const std::string errors< rules::end_array >::error_message = "incomplete array, expected value or ']'";
-   template<> inline const std::string errors< rules::end_object >::error_message = "incomplete object, expected key or '}'";
-   template<> inline const std::string errors< rules::name_separator >::error_message = "expected ':'";
-   template<> inline const std::string errors< rules::value >::error_message = "expected value";
-   template<> inline const std::string errors< rules::sor_value >::error_message = "expected value";
-
-   template<> inline const std::string errors< rules::edigits >::error_message = "expected at least one exponent digit";
-   template<> inline const std::string errors< rules::fdigits >::error_message = "expected at least one fraction digit";
-   template<> inline const std::string errors< rules::nan >::error_message = "invalid numeric literal";
-   template<> inline const std::string errors< rules::infinity< false > >::error_message = "invalid numeric literal";
-   template<> inline const std::string errors< rules::infinity< true > >::error_message = "invalid numeric literal";
-   template<> inline const std::string errors< rules::hexnum< false > >::error_message = "expected at least one hexadecimal digit";
-   template<> inline const std::string errors< rules::hexnum< true > >::error_message = "expected at least one hexadecimal digit";
-
-   template<> inline const std::string errors< rules::xdigit >::error_message = "incomplete universal character name";
-   template<> inline const std::string errors< rules::escaped >::error_message = "unknown escape sequence in string";
-   template<> inline const std::string errors< rules::chars< '"' > >::error_message = "invalid character in string";
-   template<> inline const std::string errors< rules::chars< '\'' > >::error_message = "invalid character in string";
-   template<> inline const std::string errors< rules::qstring_content< '"' > >::error_message = "unterminated string";
-   template<> inline const std::string errors< rules::qstring_content< '\'' > >::error_message = "unterminated string";
-   template<> inline const std::string errors< rules::mchars< '"' > >::error_message = "invalid character in multiline string";
-   template<> inline const std::string errors< rules::mchars< '\'' > >::error_message = "invalid character in multiline string";
-   template<> inline const std::string errors< rules::mqstring_content< '"' > >::error_message = "unterminated multiline string";
-   template<> inline const std::string errors< rules::mqstring_content< '\'' > >::error_message = "unterminated multiline string";
-   template<> inline const std::string errors< rules::string_fragment >::error_message = "expected string";
-
-   template<> inline const std::string errors< rules::bescaped >::error_message = "unknown escape sequence in binary string";
-   template<> inline const std::string errors< rules::bchars< '"' > >::error_message = "invalid character in binary string";
-   template<> inline const std::string errors< rules::bchars< '\'' > >::error_message = "invalid character in binary string";
-   template<> inline const std::string errors< rules::bqstring_content< '"' > >::error_message = "unterminated binary string";
-   template<> inline const std::string errors< rules::bqstring_content< '\'' > >::error_message = "unterminated binary string";
-   template<> inline const std::string errors< rules::bvalue >::error_message = "expected binary";
-   template<> inline const std::string errors< rules::bpart >::error_message = "expected a pair of hexadecimal digits";
-
-   template<> inline const std::string errors< pegtl::eof >::error_message = "unexpected character after JAXN value";
+   template<> inline const char* errors< rules::text >::error_message = "no valid JAXN";
+
+   template<> inline const char* errors< rules::comment >::error_message = "expected '*' or '/'";
+   template<> inline const char* errors< rules::line_comment_char >::error_message = "invalid character in line comment";
+   template<> inline const char* errors< rules::block_comment_char >::error_message = "invalid character in block comment";
+   template<> inline const char* errors< rules::end_block_comment >::error_message = "unterminated multi-line comment";
+
+   template<> inline const char* errors< rules::end_array >::error_message = "incomplete array, expected value or ']'";
+   template<> inline const char* errors< rules::end_object >::error_message = "incomplete object, expected key or '}'";
+   template<> inline const char* errors< rules::name_separator >::error_message = "expected ':'";
+   template<> inline const char* errors< rules::value >::error_message = "expected value";
+   template<> inline const char* errors< rules::sor_value >::error_message = "expected value";
+
+   template<> inline const char* errors< rules::edigits >::error_message = "expected at least one exponent digit";
+   template<> inline const char* errors< rules::fdigits >::error_message = "expected at least one fraction digit";
+   template<> inline const char* errors< rules::kw_nan >::error_message = "invalid numeric literal";
+   template<> inline const char* errors< rules::kw_infinity< false > >::error_message = "invalid numeric literal";
+   template<> inline const char* errors< rules::kw_infinity< true > >::error_message = "invalid numeric literal";
+   template<> inline const char* errors< rules::hexnum< false > >::error_message = "expected at least one hexadecimal digit";
+   template<> inline const char* errors< rules::hexnum< true > >::error_message = "expected at least one hexadecimal digit";
+
+   template<> inline const char* errors< rules::xdigit >::error_message = "incomplete universal character name";
+   template<> inline const char* errors< rules::escaped >::error_message = "unknown escape sequence in string";
+   template<> inline const char* errors< rules::chars< '"' > >::error_message = "invalid character in string";
+   template<> inline const char* errors< rules::chars< '\'' > >::error_message = "invalid character in string";
+   template<> inline const char* errors< rules::qstring_content< '"' > >::error_message = "unterminated string";
+   template<> inline const char* errors< rules::qstring_content< '\'' > >::error_message = "unterminated string";
+   template<> inline const char* errors< rules::mchars< '"' > >::error_message = "invalid character in multiline string";
+   template<> inline const char* errors< rules::mchars< '\'' > >::error_message = "invalid character in multiline string";
+   template<> inline const char* errors< rules::mqstring_content< '"' > >::error_message = "unterminated multiline string";
+   template<> inline const char* errors< rules::mqstring_content< '\'' > >::error_message = "unterminated multiline string";
+   template<> inline const char* errors< rules::string_fragment >::error_message = "expected string";
+
+   template<> inline const char* errors< rules::bescaped >::error_message = "unknown escape sequence in binary string";
+   template<> inline const char* errors< rules::bchars< '"' > >::error_message = "invalid character in binary string";
+   template<> inline const char* errors< rules::bchars< '\'' > >::error_message = "invalid character in binary string";
+   template<> inline const char* errors< rules::bqstring_content< '"' > >::error_message = "unterminated binary string";
+   template<> inline const char* errors< rules::bqstring_content< '\'' > >::error_message = "unterminated binary string";
+   template<> inline const char* errors< rules::binary_fragment >::error_message = "expected binary";
+   template<> inline const char* errors< rules::bpart >::error_message = "expected a pair of hexadecimal digits";
+
+   template<> inline const char* errors< pegtl::eof >::error_message = "unexpected character after JAXN value";
    // clang-format on
 
 }  // namespace tao::json::jaxn::internal

data/ext/third_party/json/include/tao/json/jaxn/internal/grammar.hpp

@@ -39,14 +39,14 @@ namespace tao::json::jaxn::internal
       struct element_separator : padr< one< ',' > > {};
       struct value_concat : pad< one< '+' >, ws > {};
 
-      struct false_ : pegtl::string< 'f', 'a', 'l', 's', 'e' > {};
-      struct null : pegtl::string< 'n', 'u', 'l', 'l' > {};
-      struct true_ : pegtl::string< 't', 'r', 'u', 'e' > {};
+      struct kw_false : pegtl::string< 'f', 'a', 'l', 's', 'e' > {};
+      struct kw_null : pegtl::string< 'n', 'u', 'l', 'l' > {};
+      struct kw_true : pegtl::string< 't', 'r', 'u', 'e' > {};
 
-      struct nan : pegtl::string< 'N', 'a', 'N' > {};
+      struct kw_nan : pegtl::string< 'N', 'a', 'N' > {};
 
       template< bool NEG >
-      struct infinity : pegtl::string< 'I', 'n', 'f', 'i', 'n', 'i', 't', 'y' > {};
+      struct kw_infinity : pegtl::string< 'I', 'n', 'f', 'i', 'n', 'i', 't', 'y' > {};
 
       template< bool NEG >
       struct hexnum : plus< abnf::HEXDIG > {};
@@ -77,24 +77,23 @@ namespace tao::json::jaxn::internal
       template< char D >
       struct unescaped
       {
-         using analyze_t = pegtl::analysis::generic< pegtl::analysis::rule_type::any >;
+         using rule_t = unescaped;
+         using subs_t = pegtl::empty_list;
 
          template< typename Input >
          [[nodiscard]] static bool match( Input& in )
          {
             bool result = false;
-
-            while( const std::size_t s = in.size( 4 ) ) {
-               if( const auto t = pegtl::internal::peek_utf8::peek( in, s ) ) {
-                  if( ( 0x20 <= t.data ) && ( t.data <= 0x10FFFF ) && ( t.data != '\\' ) && ( t.data != D ) && ( t.data != 0x7F ) ) {
-                     in.bump_in_this_line( t.size );
-                     result = true;
-                     continue;
-                  }
+            while( const auto t = pegtl::internal::peek_utf8::peek( in ) ) {
+               if( ( 0x20 <= t.data ) && ( t.data != '\\' ) && ( t.data != D ) && ( t.data != 0x7F ) ) {
+                  in.bump_in_this_line( t.size );
+                  result = true;
+               }
+               else {
+                  break;
                }
-               return result;
             }
-            throw pegtl::parse_error( "invalid character in string", in );
+            return result;
          }
       };
 
@@ -110,24 +109,23 @@ namespace tao::json::jaxn::internal
       template< char D >
       struct mchars_non_eol
       {
-         using analyze_t = pegtl::analysis::generic< pegtl::analysis::rule_type::any >;
+         using rule_t = mchars_non_eol;
+         using subs_t = pegtl::empty_list;
 
          template< typename Input >
          [[nodiscard]] static bool match( Input& in )
          {
             bool result = false;
-
-            while( const std::size_t s = in.size( 4 ) ) {
-               if( const auto t = pegtl::internal::peek_utf8::peek( in, s ) ) {
-                  if( ( ( 0x20 <= t.data ) && ( t.data <= 0x10FFFF ) && ( t.data != D ) && ( t.data != 0x7F ) ) || ( t.data == '\t' ) ) {
-                     in.bump_in_this_line( t.size );
-                     result = true;
-                     continue;
-                  }
+            while( const auto t = pegtl::internal::peek_utf8::peek( in ) ) {
+               if( ( ( 0x20 <= t.data ) && ( t.data != D ) && ( t.data != 0x7F ) ) || ( t.data == '\t' ) ) {
+                  in.bump_in_this_line( t.size );
+                  result = true;
+               }
+               else {
+                  break;
                }
-               return result;
             }
-            throw pegtl::parse_error( "invalid character in string", in );
+            return result;
          }
       };
 
@@ -154,7 +152,8 @@ namespace tao::json::jaxn::internal
       template< char D >
       struct bunescaped
       {
-         using analyze_t = pegtl::analysis::generic< pegtl::analysis::rule_type::any >;
+         using rule_t = bunescaped;
+         using subs_t = pegtl::empty_list;
 
          template< typename Input >
          [[nodiscard]] static bool match( Input& in )
@@ -191,9 +190,9 @@ namespace tao::json::jaxn::internal
 
       struct bdirect : list_must< bpart, one< '.' > > {};
 
-      struct bvalue : seq< binary_prefix, opt< sor< bstring, bdirect > > > {};
+      struct binary_fragment : seq< binary_prefix, opt< sor< bstring, bdirect > > > {};
 
-      struct binary : list_must< bvalue, value_concat > {};
+      struct binary : list_must< binary_fragment, value_concat > {};
 
       struct value;
 
@@ -225,7 +224,8 @@ namespace tao::json::jaxn::internal
 
       struct sor_value
       {
-         using analyze_t = pegtl::analysis::generic< pegtl::analysis::rule_type::sor, string, number< false >, object, array, false_, true_, null >;
+         using rule_t = sor_value;
+         using subs_t = pegtl::type_list< string, number< false >, object, array, kw_false, kw_true, kw_null >;
 
          template< typename Rule,
                    apply_mode A,
@@ -286,10 +286,10 @@ namespace tao::json::jaxn::internal
          {
             switch( in.peek_char() ) {
             case 'N':
-               return Control< must< nan > >::template match< A, M, Action, Control >( in, st... );
+               return Control< must< kw_nan > >::template match< A, M, Action, Control >( in, st... );
 
             case 'I':
-               return Control< must< infinity< NEG > > >::template match< A, M, Action, Control >( in, st... );
+               return Control< must< kw_infinity< NEG > > >::template match< A, M, Action, Control >( in, st... );
 
             case '0':
                if( !match_zero< NEG, A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
@@ -313,9 +313,9 @@ namespace tao::json::jaxn::internal
             switch( in.peek_char() ) {
             case '{': return Control< object >::template match< A, M, Action, Control >( in, st... );
             case '[': return Control< array >::template match< A, M, Action, Control >( in, st... );
-            case 'n': return Control< null >::template match< A, M, Action, Control >( in, st... );
-            case 't': return Control< true_ >::template match< A, M, Action, Control >( in, st... );
-            case 'f': return Control< false_ >::template match< A, M, Action, Control >( in, st... );
+            case 'n': return Control< kw_null >::template match< A, M, Action, Control >( in, st... );
+            case 't': return Control< kw_true >::template match< A, M, Action, Control >( in, st... );
+            case 'f': return Control< kw_false >::template match< A, M, Action, Control >( in, st... );
 
             case '"':
             case '\'':