couchbase 4.0.0 → 4.1.0

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/third_party/json/external/PEGTL/include/tao/pegtl/contrib/add_state.hpp

@@ -0,0 +1,69 @@
+// Copyright (c) 2021 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_CONTRIB_ADD_STATE_HPP
+#define TAO_PEGTL_CONTRIB_ADD_STATE_HPP
+
+#include <type_traits>
+
+#include "../apply_mode.hpp"
+#include "../config.hpp"
+#include "../match.hpp"
+#include "../nothing.hpp"
+#include "../rewind_mode.hpp"
+
+#include "../internal/dependent_false.hpp"
+
+namespace TAO_PEGTL_NAMESPACE
+{
+   template< typename AddState >
+   struct add_state
+      : maybe_nothing
+   {
+      template< typename Rule,
+                apply_mode A,
+                rewind_mode M,
+                template< typename... >
+                class Action,
+                template< typename... >
+                class Control,
+                typename ParseInput,
+                typename... States >
+      [[nodiscard]] static bool match( ParseInput& in, States&&... st )
+      {
+         if constexpr( std::is_constructible_v< AddState, const ParseInput&, States... > ) {
+            AddState s( static_cast< const ParseInput& >( in ), st... );
+            if( TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, s, st... ) ) {
+               if constexpr( A == apply_mode::action ) {
+                  Action< Rule >::success( static_cast< const ParseInput& >( in ), s, st... );
+               }
+               return true;
+            }
+            return false;
+         }
+         else if constexpr( std::is_default_constructible_v< AddState > ) {
+            AddState s;
+            if( TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, s, st... ) ) {
+               if constexpr( A == apply_mode::action ) {
+                  Action< Rule >::success( static_cast< const ParseInput& >( in ), s, st... );
+               }
+               return true;
+            }
+            return false;
+         }
+         else {
+            static_assert( internal::dependent_false< AddState >, "unable to instantiate new state" );
+         }
+      }
+
+      template< typename ParseInput,
+                typename... States >
+      static void success( const ParseInput& in, AddState& s, States&&... st ) noexcept( noexcept( s.success( in, st... ) ) )
+      {
+         s.success( in, st... );
+      }
+   };
+
+}  // namespace TAO_PEGTL_NAMESPACE
+
+#endif

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/third_party/json/external/PEGTL/include/tao/pegtl/contrib/http.hpp

@@ -5,7 +5,7 @@
 #define TAO_PEGTL_CONTRIB_HTTP_HPP
 
 #if !defined( __cpp_exceptions )
-#error "Exception support required tao/pegtl/contrib/http.hpp"
+#error "Exception support required for tao/pegtl/contrib/http.hpp"
 #else
 
 #include "../ascii.hpp"

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/third_party/json/external/PEGTL/include/tao/pegtl/contrib/integer.hpp

@@ -5,7 +5,7 @@
 #define TAO_PEGTL_CONTRIB_INTEGER_HPP
 
 #if !defined( __cpp_exceptions )
-#error "Exception support required tao/pegtl/contrib/integer.hpp"
+#error "Exception support required for tao/pegtl/contrib/integer.hpp"
 #else
 
 #include <cstdint>
@@ -66,7 +66,7 @@ namespace TAO_PEGTL_NAMESPACE
          return ( '0' <= c ) && ( c <= '9' );
       }
 
-      template< typename Integer, Integer Maximum = (std::numeric_limits< Integer >::max)() >
+      template< typename Integer, Integer Maximum = ( std::numeric_limits< Integer >::max )() >
       [[nodiscard]] constexpr bool accumulate_digit( Integer& result, const char digit ) noexcept
       {
          // Assumes that digit is a digit as per is_digit(); returns false on overflow.
@@ -86,7 +86,7 @@ namespace TAO_PEGTL_NAMESPACE
          return true;
       }
 
-      template< typename Integer, Integer Maximum = (std::numeric_limits< Integer >::max)() >
+      template< typename Integer, Integer Maximum = ( std::numeric_limits< Integer >::max )() >
       [[nodiscard]] constexpr bool accumulate_digits( Integer& result, const std::string_view input ) noexcept
       {
          // Assumes input is a non-empty sequence of digits; returns false on overflow.
@@ -99,7 +99,7 @@ namespace TAO_PEGTL_NAMESPACE
          return true;
       }
 
-      template< typename Integer, Integer Maximum = (std::numeric_limits< Integer >::max)() >
+      template< typename Integer, Integer Maximum = ( std::numeric_limits< Integer >::max )() >
       [[nodiscard]] constexpr bool convert_positive( Integer& result, const std::string_view input ) noexcept
       {
          // Assumes result == 0 and that input is a non-empty sequence of digits; returns false on overflow.
@@ -115,7 +115,7 @@ namespace TAO_PEGTL_NAMESPACE
 
          static_assert( std::is_signed_v< Signed > );
          using Unsigned = std::make_unsigned_t< Signed >;
-         constexpr Unsigned maximum = static_cast< Unsigned >( (std::numeric_limits< Signed >::max)() ) + 1;
+         constexpr Unsigned maximum = static_cast< Unsigned >( ( std::numeric_limits< Signed >::max )() ) + 1;
          Unsigned temporary = 0;
          if( accumulate_digits< Unsigned, maximum >( temporary, input ) ) {
             result = static_cast< Signed >( ~temporary ) + 1;
@@ -124,7 +124,7 @@ namespace TAO_PEGTL_NAMESPACE
          return false;
       }
 
-      template< typename Unsigned, Unsigned Maximum = (std::numeric_limits< Unsigned >::max)() >
+      template< typename Unsigned, Unsigned Maximum = ( std::numeric_limits< Unsigned >::max )() >
       [[nodiscard]] constexpr bool convert_unsigned( Unsigned& result, const std::string_view input ) noexcept
       {
          // Assumes result == 0 and that input is a non-empty sequence of digits; returns false on overflow.
@@ -167,8 +167,8 @@ namespace TAO_PEGTL_NAMESPACE
 
       template< typename ParseInput,
                 typename Unsigned,
-                Unsigned Maximum = (std::numeric_limits< Unsigned >::max)() >
-      [[nodiscard]] bool match_and_convert_unsigned_with_maximum( ParseInput& in, Unsigned& st )
+                Unsigned Maximum = ( std::numeric_limits< Unsigned >::max )() >
+      [[nodiscard]] bool match_and_convert_unsigned_with_maximum_throws( ParseInput& in, Unsigned& st )
       {
          // Assumes st == 0.
 
@@ -181,7 +181,7 @@ namespace TAO_PEGTL_NAMESPACE
                }
                do {
                   if( !accumulate_digit< Unsigned, Maximum >( st, c ) ) {
-                     throw TAO_PEGTL_NAMESPACE::parse_error( "integer overflow", in );  // Consistent with "as if" an action was doing the conversion.
+                     throw TAO_PEGTL_NAMESPACE::parse_error( "integer overflow", in );
                   }
                   in.bump_in_this_line();
                } while( ( !in.empty() ) && is_digit( c = in.peek_char() ) );
@@ -191,6 +191,38 @@ namespace TAO_PEGTL_NAMESPACE
          return false;
       }
 
+      template< typename ParseInput,
+                typename Unsigned,
+                Unsigned Maximum = ( std::numeric_limits< Unsigned >::max )() >
+      [[nodiscard]] bool match_and_convert_unsigned_with_maximum_nothrow( ParseInput& in, Unsigned& st )
+      {
+         // Assumes st == 0.
+
+         if( !in.empty() ) {
+            char c = in.peek_char();
+            if( c == '0' ) {
+               if( ( in.size( 2 ) < 2 ) || ( !is_digit( in.peek_char( 1 ) ) ) ) {
+                  in.bump_in_this_line();
+                  return true;
+               }
+               return false;
+            }
+            if( is_digit( c ) ) {
+               unsigned b = 0;
+
+               do {
+                  if( !accumulate_digit< Unsigned, Maximum >( st, c ) ) {
+                     return false;
+                  }
+                  ++b;
+               } while( ( !in.empty() ) && is_digit( c = in.peek_char( b ) ) );
+               in.bump_in_this_line( b );
+               return true;
+            }
+         }
+         return false;
+      }
+
    }  // namespace internal
 
    struct unsigned_action
@@ -250,7 +282,7 @@ namespace TAO_PEGTL_NAMESPACE
       {
          // This function "only" offers basic exception safety.
          st = 0;
-         return internal::match_and_convert_unsigned_with_maximum( in, st );  // Throws on overflow.
+         return internal::match_and_convert_unsigned_with_maximum_throws( in, st );  // Throws on overflow.
       }
    };
 
@@ -272,7 +304,7 @@ namespace TAO_PEGTL_NAMESPACE
       }
    };
 
-   template< typename Unsigned, Unsigned Maximum = (std::numeric_limits< Unsigned >::max)() >
+   template< typename Unsigned, Unsigned Maximum = ( std::numeric_limits< Unsigned >::max )() >
    struct maximum_rule
    {
       using rule_t = maximum_rule;
@@ -284,11 +316,11 @@ namespace TAO_PEGTL_NAMESPACE
       [[nodiscard]] static bool match( ParseInput& in )
       {
          Unsigned st = 0;
-         return internal::match_and_convert_unsigned_with_maximum< ParseInput, Unsigned, Maximum >( in, st );  // Throws on overflow.
+         return internal::match_and_convert_unsigned_with_maximum_nothrow< ParseInput, Unsigned, Maximum >( in, st );
       }
    };
 
-   template< typename Unsigned, Unsigned Maximum = (std::numeric_limits< Unsigned >::max)() >
+   template< typename Unsigned, Unsigned Maximum = ( std::numeric_limits< Unsigned >::max )() >
    struct maximum_rule_with_action
    {
       using rule_t = maximum_rule_with_action;
@@ -307,7 +339,7 @@ namespace TAO_PEGTL_NAMESPACE
       [[nodiscard]] static auto match( ParseInput& in, States&&... /*unused*/ ) -> std::enable_if_t< A == apply_mode::nothing, bool >
       {
          Unsigned st = 0;
-         return internal::match_and_convert_unsigned_with_maximum< ParseInput, Unsigned, Maximum >( in, st );  // Throws on overflow.
+         return internal::match_and_convert_unsigned_with_maximum_throws< ParseInput, Unsigned, Maximum >( in, st );
       }
 
       template< apply_mode A,
@@ -322,7 +354,7 @@ namespace TAO_PEGTL_NAMESPACE
       {
          // This function "only" offers basic exception safety.
          st = 0;
-         return internal::match_and_convert_unsigned_with_maximum< ParseInput, Unsigned, Maximum >( in, st );  // Throws on overflow.
+         return internal::match_and_convert_unsigned_with_maximum_throws< ParseInput, Unsigned, Maximum >( in, st );
       }
    };
 

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/third_party/json/external/PEGTL/include/tao/pegtl/contrib/iri.hpp

@@ -0,0 +1,106 @@
+// Copyright (c) 2021 Kelvin Hammond
+// Copyright (c) 2021 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_CONTRIB_IRI_HPP
+#define TAO_PEGTL_CONTRIB_IRI_HPP
+
+#if !defined( __cpp_exceptions )
+#error "Exception support required for tao/pegtl/contrib/iri.hpp"
+#else
+
+#include "../config.hpp"
+#include "../rules.hpp"
+#include "../utf8.hpp"
+
+#include "abnf.hpp"
+#include "uri.hpp"
+
+namespace TAO_PEGTL_NAMESPACE::iri
+{
+   // IRI grammar according to RFC 3987.
+
+   // This grammar is a direct PEG translation of the original URI grammar.
+   // It should be considered experimental -- in case of any issues, in particular
+   // missing rules for attached actions, please contact the developers.
+
+   // Note that this grammar has multiple top-level rules.
+
+   using uri::scheme;
+   using uri::port;
+   using uri::dslash;
+   using uri::IP_literal;
+   using uri::IPv4address;
+   using uri::pct_encoded;
+   using uri::sub_delims;
+   using uri::colon;
+
+   // clang-format off
+   struct ucschar : utf8::ranges<
+      0xA0, 0xD7FF,
+      0xF900, 0xFDCF,
+      0xFDF0, 0xFFEF,
+      0x10000, 0x1FFFD,
+      0x20000, 0x2FFFD,
+      0x30000, 0x3FFFD,
+      0x40000, 0x4FFFD,
+      0x50000, 0x5FFFD,
+      0x60000, 0x6FFFD,
+      0x70000, 0x7FFFD,
+      0x80000, 0x8FFFD,
+      0x90000, 0x9FFFD,
+      0xA0000, 0xAFFFD,
+      0xB0000, 0xBFFFD,
+      0xC0000, 0xCFFFD,
+      0xD0000, 0xDFFFD,
+      0xE1000, 0xEFFFD > {};
+
+   struct iprivate : utf8::ranges< 0xE000, 0xF8FF, 0xF0000, 0xFFFFD, 0x100000, 0x10FFFD > {};
+
+   struct iunreserved : sor< abnf::ALPHA, abnf::DIGIT, one< '-', '.', '_', '~' >, ucschar > {};
+
+   struct ipchar : sor< iunreserved, pct_encoded, sub_delims, one< ':', '@' > > {};
+
+   struct isegment : star< ipchar > {};
+   struct isegment_nz : plus< ipchar > {};
+   // non-zero-length segment without any colon ":"
+   struct isegment_nz_nc : plus< sor< iunreserved, pct_encoded, sub_delims, one< '@' > > > {};
+
+   struct ipath_abempty : star< one< '/' >, isegment > {};
+   struct ipath_absolute : seq< one< '/' >, opt< isegment_nz, star< one< '/' >, isegment > > > {};
+   struct ipath_noscheme : seq< isegment_nz_nc, star< one< '/' >, isegment > > {};
+   struct ipath_rootless : seq< isegment_nz, star< one< '/' >, isegment > > {};
+   struct ipath_empty : success {};
+
+   struct ipath : sor< ipath_noscheme,  // begins with a non-colon segment
+                       ipath_rootless,  // begins with a segment
+                       ipath_absolute,  // begins with "/" but not "//"
+                       ipath_abempty >  // begins with "/" or is empty
+   {};
+
+   struct ireg_name : star< sor< iunreserved, pct_encoded, sub_delims > > {};
+
+   struct ihost : sor< IP_literal, IPv4address, ireg_name > {};
+   struct iuserinfo : star< sor< iunreserved, pct_encoded, sub_delims, colon > > {};
+   struct opt_iuserinfo : opt< iuserinfo, one< '@' > > {};
+   struct iauthority : seq< opt_iuserinfo, ihost, opt< colon, port > > {};
+
+   struct iquery : star< sor< ipchar, iprivate, one< '/', '?' > > > {};
+   struct ifragment : star< sor< ipchar, one< '/', '?' > > > {};
+
+   struct opt_iquery : opt_must< one< '?' >, iquery > {};
+   struct opt_ifragment : opt_must< one< '#' >, ifragment > {};
+
+   struct ihier_part : sor< if_must< dslash, iauthority, ipath_abempty >, ipath_rootless, ipath_absolute, ipath_empty > {};
+   struct irelative_part : sor< if_must< dslash, iauthority, ipath_abempty >, ipath_noscheme, ipath_absolute, ipath_empty > {};
+   struct irelative_ref : seq< irelative_part, opt_iquery, opt_ifragment > {};
+
+   struct IRI : seq< scheme, one< ':' >, ihier_part, opt_iquery, opt_ifragment > {};
+   struct IRI_reference : sor< IRI, irelative_ref > {};
+   struct absolute_IRI : seq< scheme, one< ':' >, ihier_part, opt_iquery > {};
+   // clang-format off
+
+}  // namespace TAO_PEGTL_NAMESPACE::iri
+
+#endif
+#endif

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/third_party/json/external/PEGTL/include/tao/pegtl/contrib/proto3.hpp

@@ -0,0 +1,142 @@
+// Copyright (c) 2021 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_CONTRIB_PROTO3_HPP
+#define TAO_PEGTL_CONTRIB_PROTO3_HPP
+
+#include "../ascii.hpp"
+#include "../config.hpp"
+#include "../rules.hpp"
+
+namespace TAO_PEGTL_NAMESPACE::proto3
+{
+   // protocol buffer v3
+   // https://developers.google.com/protocol-buffers/docs/reference/proto3-spec
+
+   // clang-format off
+   struct comment_sl : seq< two< '/' >, until< eolf > > {};
+   struct comment_ml : if_must< string< '/', '*' >, until< string< '*', '/' > > > {};
+   struct sp : sor< space, comment_sl, comment_ml > {};
+   struct sps : star< sp > {};
+
+   struct comma : one< ',' > {};
+   struct dot : one< '.' > {};
+   struct equ : one< '=' > {};
+   struct semi : one< ';' > {};
+
+   struct option;
+   struct message;
+   struct extend;
+
+   struct ident_first : ranges< 'a', 'z', 'A', 'Z' > {};  // NOTE: Yes, no '_'.
+   struct ident_other : ranges< 'a', 'z', 'A', 'Z', '0', '9', '_' > {};
+   struct ident : seq< ident_first, star< ident_other > > {};
+   struct full_ident : list_must< ident, dot > {};
+
+   struct hex_lit : seq< one< '0' >, one< 'x', 'X' >, plus< xdigit > > {};
+   struct oct_lit : seq< one< '0' >, plus< odigit > > {};
+   struct dec_lit : seq< range< '1', '9' >, star< digit > >  {};
+   struct int_lit : sor< hex_lit, oct_lit, dec_lit > {};
+
+   struct sign : one< '+', '-' > {};
+   struct exp : seq< one< 'E', 'e' >, opt< sign >, plus< digit > > {};
+   struct float_lit : sor<
+      seq< plus< digit >, dot, exp >,
+      seq< plus< digit >, dot, star< digit >, opt< exp > >,
+      seq< dot, plus< digit >, opt< exp > >,
+      keyword< 'i', 'n', 'f' >,
+      keyword< 'n', 'a', 'n' > > {};
+
+   struct bool_lit : sor< keyword< 't', 'r', 'u', 'e' >,
+                          keyword< 'f', 'a', 'l', 's', 'e' > > {};
+
+   struct hex_escape : if_must< one< 'x', 'X' >, xdigit, xdigit > {};
+   struct oct_escape : if_must< odigit, odigit, odigit > {};
+   struct char_escape : one< 'a', 'b', 'f', 'n', 'r', 't', 'v', '\\', '\'', '"' > {};
+   struct escape : if_must< one< '\\' >, hex_escape, oct_escape, char_escape > {};
+   struct char_value : sor< escape, not_one< '\n', '\0' > > {};  // NOTE: No need to exclude '\' from not_one<>, see escape rule.
+   template< char Q >
+   struct str_impl : if_must< one< Q >, until< one< Q >, char_value > > {};
+   struct str_lit : sor< str_impl< '\'' >, str_impl< '"' > > {};
+
+   struct constant : sor< bool_lit, seq< opt< sign >, float_lit >, seq< opt< sign >, int_lit >, str_lit, full_ident > {};
+
+   struct option_name : seq< sor< ident, if_must< one< '(' >, full_ident, one< ')' > > >, star_must< dot, ident > > {};
+   struct option : if_must< keyword< 'o', 'p', 't', 'i', 'o', 'n' >, sps, option_name, sps, equ, sps, constant, sps, semi > {};
+
+   struct bool_type : keyword< 'b', 'o', 'o', 'l' > {};
+   struct bytes_type : keyword< 'b', 'y', 't', 'e', 's' > {};
+   struct double_type : keyword< 'd', 'o', 'u', 'b', 'l', 'e' > {};
+   struct float_type : keyword< 'f', 'l', 'o', 'a', 't' > {};
+   struct string_type : keyword< 's', 't', 'r', 'i', 'n', 'g' > {};
+
+   struct int32_type : keyword< 'i', 'n', 't', '3', '2' > {};
+   struct int64_type : keyword< 'i', 'n', 't', '6', '4' > {};
+   struct sint32_type : keyword< 's', 'i', 'n', 't', '3', '2' > {};
+   struct sint64_type : keyword< 's', 'i', 'n', 't', '6', '4' > {};
+   struct uint32_type : keyword< 'u', 'i', 'n', 't', '3', '2' > {};
+   struct uint64_type : keyword< 'u', 'i', 'n', 't', '6', '4' > {};
+   struct fixed32_type : keyword< 'f', 'i', 'x', 'e', 'd', '3', '2' > {};
+   struct fixed64_type : keyword< 'f', 'i', 'x', 'e', 'd', '6', '4' > {};
+   struct sfixed32_type : keyword< 's', 'f', 'i', 'x', 'e', 'd', '3', '2' > {};
+   struct sfixed64_type : keyword< 's', 'f', 'i', 'x', 'e', 'd', '6', '4' > {};
+
+   struct builtin_type : sor< bool_type, bytes_type, double_type, float_type, string_type, int32_type, int64_type, sint32_type, sint64_type, uint32_type, uint64_type, fixed32_type, fixed64_type, sfixed32_type, sfixed64_type > {};
+
+   struct defined_type : seq< opt< dot >, full_ident > {};  // NOTE: This replaces both message_type and enum_type -- they have the same syntax.
+
+   struct type : sor< builtin_type, defined_type > {};
+
+   struct field_option : if_must< option_name, sps, equ, sps, constant > {};
+   struct field_options : if_must< one< '[' >, sps, list< field_option, comma, sp >, sps, one< ']' > > {};
+   struct field_name : ident {};
+   struct field_number : int_lit {};
+   struct field : seq< opt< sor< keyword< 'o', 'p', 't', 'i', 'o', 'n', 'a', 'l' >, keyword< 'r', 'e', 'p', 'e', 'a', 't', 'e', 'd' > >, sps >, type, sps, field_name, sps, equ, sps, field_number, sps, opt< field_options, sps >, semi > {};
+
+   struct oneof_name : ident {};
+   struct oneof_field : if_must< type, sps, field_name, sps, equ, sps, field_number, sps, opt< field_options, sps >, semi > {};
+   struct oneof_body : sor< oneof_field, semi > {};
+   struct oneof : if_must< keyword< 'o', 'n', 'e', 'o', 'f' >, sps, oneof_name, sps, one< '{' >, sps, until< one< '}' >, oneof_body, sps >, sps > {};
+
+   struct key_type : seq< sor< bool_type, string_type, int32_type, int64_type, sint32_type, sint64_type, uint32_type, uint64_type, fixed32_type, fixed64_type, sfixed32_type, sfixed64_type >, not_at< ident_other > > {};
+   struct map_name : ident {};
+   struct map_field : if_must< keyword< 'm', 'a', 'p' >, sps, one< '<' >, sps, key_type, sps, comma, sps, type, sps, one< '>' >, sps, map_name, sps, equ, sps, field_number, sps, opt< field_options, sps >, semi > {};
+
+   struct range : if_must< int_lit, sps, keyword< 't', 'o' >, sps, sor< int_lit, keyword< 'm', 'a', 'x' > > > {};
+   struct ranges : list_must< range, comma, sp > {};
+   struct field_names : list_must< field_name, comma, sp > {};
+   struct reserved : if_must< keyword< 'r', 'e', 's', 'e', 'r', 'v', 'e', 'd' >, sps, sor< ranges, field_names >, sps, semi > {};
+
+   struct enum_name : ident {};
+   struct enum_value_option : seq< option_name, sps, equ, sps, constant > {};
+   struct enum_field : seq< ident, sps, equ, sps, int_lit, sps, opt_must< one< '[' >, sps, list_must< enum_value_option, comma, sp >, sps, one< ']' >, sps >, semi > {};
+   struct enum_body : if_must< one< '{' >, sps, star< sor< option, enum_field, semi >, sps >, one< '}' > > {};
+   struct enum_def : if_must< keyword< 'e', 'n', 'u', 'm' >, sps, enum_name, sps, enum_body > {};
+
+   struct message_thing : sor< field, enum_def, message, option, oneof, map_field, reserved, extend, semi > {};
+   struct message_body : seq< one<'{'>, sps, star< message_thing, sps >, one<'}'> > {};
+   struct message : if_must< keyword< 'm', 'e', 's', 's', 'a', 'g', 'e' >, sps, defined_type, sps, message_body > {};
+   struct extend : if_must< keyword< 'e', 'x', 't', 'e', 'n', 'd' >, sps, defined_type, sps, message_body > {};
+
+   struct package : if_must< keyword< 'p', 'a', 'c', 'k', 'a', 'g', 'e' >, sps, full_ident, sps, semi > {};
+
+   struct import_option : opt< sor< keyword< 'w', 'e', 'a', 'k' >, keyword< 'p', 'u', 'b', 'l', 'i', 'c' > > > {};
+   struct import : if_must< keyword< 'i', 'm', 'p', 'o', 'r', 't' >, sps, import_option, sps, str_lit, sps, semi > {};
+
+   struct rpc_name : ident {};
+   struct rpc_type : if_must< one< '(' >, sps, opt< keyword< 's', 't', 'r', 'e', 'a', 'm' >, sps >, defined_type, sps, one< ')' > > {};
+   struct rpc_options : if_must< one< '{' >, sps, star< sor< option, semi >, sps >, one< '}' > > {};
+   struct rpc : if_must< keyword< 'r', 'p', 'c' >, sps, rpc_name, sps, rpc_type, sps, keyword< 'r', 'e', 't', 'u', 'r', 'n', 's' >, sps, rpc_type, sps, sor< semi, rpc_options > > {};
+   struct service_name : ident {};
+   struct service : if_must< keyword< 's', 'e', 'r', 'v', 'i', 'c', 'e' >, sps, service_name, sps, one< '{' >, sps, star< sor< option, rpc, semi >, sps >, one< '}' > > {};
+
+   struct body : sor< import, package, option, message, enum_def, service, extend, semi > {};
+
+   struct quote : one< '\'', '"' > {};
+   struct head : if_must< keyword< 's', 'y', 'n', 't', 'a', 'x' >, sps, equ, sps, quote, string< 'p', 'r', 'o', 't', 'o', '3' >, quote, sps, semi > {};
+   struct proto : must< sps, head, sps, star< body, sps >, eof > {};
+   // clang-format on
+
+}  // namespace TAO_PEGTL_NAMESPACE::proto3
+
+#endif

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/third_party/json/external/PEGTL/include/tao/pegtl/contrib/separated_seq.hpp

@@ -0,0 +1,45 @@
+// Copyright (c) 2021 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_PEGTL_CONTRIB_SEPARATED_SEQ_HPP
+#define TAO_PEGTL_CONTRIB_SEPARATED_SEQ_HPP
+
+#include "../config.hpp"
+
+#include "../internal/seq.hpp"
+#include "../type_list.hpp"
+
+namespace TAO_PEGTL_NAMESPACE
+{
+   namespace internal
+   {
+      template< typename... >
+      struct sep;
+
+      template< typename... Ts, typename S, typename Rule, typename... Rules >
+      struct sep< type_list< Ts... >, S, Rule, Rules... >
+         : sep< type_list< Ts..., Rule, S >, S, Rules... >
+      {};
+
+      template< typename... Ts, typename S, typename Rule >
+      struct sep< type_list< Ts... >, S, Rule >
+      {
+         using type = seq< Ts..., Rule >;
+      };
+
+      template< typename S >
+      struct sep< type_list<>, S >
+      {
+         using type = seq<>;
+      };
+
+   }  // namespace internal
+
+   template< typename S, typename... Rules >
+   struct separated_seq
+      : internal::sep< type_list<>, S, Rules... >::type
+   {};
+
+}  // namespace TAO_PEGTL_NAMESPACE
+
+#endif

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/third_party/json/external/PEGTL/include/tao/pegtl/contrib/state_control.hpp

@@ -32,7 +32,8 @@ namespace TAO_PEGTL_NAMESPACE
                state.template start< Rule >( in, st... );
             }
 #if defined( _MSC_VER )
-            ( (void)st, ... );
+            ( (void)st,
+              ... );
 #endif
          }
 
@@ -46,7 +47,8 @@ namespace TAO_PEGTL_NAMESPACE
                Control< Rule >::success( in, st... );
             }
 #if defined( _MSC_VER )
-            ( (void)st, ... );
+            ( (void)st,
+              ... );
 #endif
          }
 
@@ -60,7 +62,8 @@ namespace TAO_PEGTL_NAMESPACE
                Control< Rule >::failure( in, st... );
             }
 #if defined( _MSC_VER )
-            ( (void)st, ... );
+            ( (void)st,
+              ... );
 #endif
          }
 
@@ -84,7 +87,8 @@ namespace TAO_PEGTL_NAMESPACE
                Control< Rule >::unwind( in, st... );
             }
 #if defined( _MSC_VER )
-            ( (void)st, ... );
+            ( (void)st,
+              ... );
 #endif
          }
 

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/third_party/json/external/PEGTL/include/tao/pegtl/contrib/uri.hpp

@@ -5,7 +5,7 @@
 #define TAO_PEGTL_CONTRIB_URI_HPP
 
 #if !defined( __cpp_exceptions )
-#error "Exception support required tao/pegtl/contrib/uri.hpp"
+#error "Exception support required for tao/pegtl/contrib/uri.hpp"
 #else
 
 #include <cstdint>
@@ -32,11 +32,7 @@ namespace TAO_PEGTL_NAMESPACE::uri
    using colon = one< ':' >;
 
    // clang-format off
-   struct dec_octet : sor<
-      rep_min_max< 1, 2, abnf::DIGIT >,
-      seq< one< '1' >, rep< 2, abnf::DIGIT > >,
-      seq< one< '2' >, range< '0', '4' >, abnf::DIGIT >,
-      seq< one< '2' >, one< '5' >, range< '0', '5' > > > {};
+   struct dec_octet : maximum_rule< std::uint8_t > {};
 
    struct IPv4address : seq< dec_octet, dot, dec_octet, dot, dec_octet, dot, dec_octet > {};