couchbase 3.0.0.alpha.3 → 3.0.1

data/ext/third_party/json/include/tao/json/external/pegtl/contrib/internal/peek_uint.hpp

@@ -0,0 +1,45 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_JSON_PEGTL_CONTRIB_INTERNAL_PEEK_UINT_HPP
+#define TAO_JSON_PEGTL_CONTRIB_INTERNAL_PEEK_UINT_HPP
+
+#include <cstddef>
+#include <cstdint>
+
+#include "../../config.hpp"
+#include "../../internal/input_pair.hpp"
+
+#include "read_uint.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE::internal
+{
+   template< typename R >
+   struct peek_uint_impl
+   {
+      using data_t = typename R::type;
+      using pair_t = input_pair< data_t >;
+
+      template< typename ParseInput >
+      [[nodiscard]] static pair_t peek( ParseInput& in ) noexcept( noexcept( in.size( sizeof( data_t ) ) ) )
+      {
+         if( in.size( sizeof( data_t ) ) < sizeof( data_t ) ) {
+            return { 0, 0 };
+         }
+         const data_t data = R::read( in.current() );
+         return { data, sizeof( data_t ) };
+      }
+   };
+
+   using peek_uint16_be = peek_uint_impl< read_uint16_be >;
+   using peek_uint16_le = peek_uint_impl< read_uint16_le >;
+
+   using peek_uint32_be = peek_uint_impl< read_uint32_be >;
+   using peek_uint32_le = peek_uint_impl< read_uint32_le >;
+
+   using peek_uint64_be = peek_uint_impl< read_uint64_be >;
+   using peek_uint64_le = peek_uint_impl< read_uint64_le >;
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
+
+#endif

data/ext/third_party/json/include/tao/json/external/pegtl/contrib/internal/peek_uint8.hpp

@@ -0,0 +1,32 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_JSON_PEGTL_CONTRIB_INTERNAL_PEEK_UINT8_HPP
+#define TAO_JSON_PEGTL_CONTRIB_INTERNAL_PEEK_UINT8_HPP
+
+#include <cstddef>
+#include <cstdint>
+
+#include "../../config.hpp"
+#include "../../internal/input_pair.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE::internal
+{
+   struct peek_uint8
+   {
+      using data_t = std::uint8_t;
+      using pair_t = input_pair< std::uint8_t >;
+
+      template< typename ParseInput >
+      [[nodiscard]] static pair_t peek( ParseInput& in ) noexcept( noexcept( in.empty() ) )
+      {
+         if( in.empty() ) {
+            return { 0, 0 };
+         }
+         return { in.peek_uint8(), 1 };
+      }
+   };
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
+
+#endif

data/ext/third_party/json/include/tao/json/external/pegtl/contrib/internal/peek_utf16.hpp

@@ -0,0 +1,54 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_JSON_PEGTL_CONTRIB_INTERNAL_PEEK_UTF16_HPP
+#define TAO_JSON_PEGTL_CONTRIB_INTERNAL_PEEK_UTF16_HPP
+
+#include <type_traits>
+
+#include "../../config.hpp"
+#include "../../internal/input_pair.hpp"
+
+#include "read_uint.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE::internal
+{
+   template< typename R >
+   struct peek_utf16_impl
+   {
+      using data_t = char32_t;
+      using pair_t = input_pair< char32_t >;
+
+      using short_t = std::make_unsigned< char16_t >::type;
+
+      static_assert( sizeof( short_t ) == 2 );
+      static_assert( sizeof( char16_t ) == 2 );
+
+      template< typename ParseInput >
+      [[nodiscard]] static pair_t peek( ParseInput& in ) noexcept( noexcept( in.size( 4 ) ) )
+      {
+         if( in.size( 2 ) < 2 ) {
+            return { 0, 0 };
+         }
+         const char32_t t = R::read( in.current() );
+         if( ( t < 0xd800 ) || ( t > 0xdfff ) ) {
+            return { t, 2 };
+         }
+         if( ( t >= 0xdc00 ) || ( in.size( 4 ) < 4 ) ) {
+            return { 0, 0 };
+         }
+         const char32_t u = R::read( in.current() + 2 );
+         if( ( u >= 0xdc00 ) && ( u <= 0xdfff ) ) {
+            const auto cp = ( ( ( t & 0x03ff ) << 10 ) | ( u & 0x03ff ) ) + 0x10000;
+            return { cp, 4 };
+         }
+         return { 0, 0 };
+      }
+   };
+
+   using peek_utf16_be = peek_utf16_impl< read_uint16_be >;
+   using peek_utf16_le = peek_utf16_impl< read_uint16_le >;
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
+
+#endif

data/ext/third_party/json/include/tao/json/external/pegtl/contrib/internal/peek_utf32.hpp

@@ -0,0 +1,43 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_JSON_PEGTL_CONTRIB_INTERNAL_PEEK_UTF32_HPP
+#define TAO_JSON_PEGTL_CONTRIB_INTERNAL_PEEK_UTF32_HPP
+
+#include <cstddef>
+
+#include "../../config.hpp"
+#include "../../internal/input_pair.hpp"
+
+#include "read_uint.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE::internal
+{
+   template< typename R >
+   struct peek_utf32_impl
+   {
+      using data_t = char32_t;
+      using pair_t = input_pair< char32_t >;
+
+      static_assert( sizeof( char32_t ) == 4 );
+
+      template< typename ParseInput >
+      [[nodiscard]] static pair_t peek( ParseInput& in ) noexcept( noexcept( in.size( 4 ) ) )
+      {
+         if( in.size( 4 ) < 4 ) {
+            return { 0, 0 };
+         }
+         const char32_t t = R::read( in.current() );
+         if( ( t <= 0x10ffff ) && !( t >= 0xd800 && t <= 0xdfff ) ) {
+            return { t, 4 };
+         }
+         return { 0, 0 };
+      }
+   };
+
+   using peek_utf32_be = peek_utf32_impl< read_uint32_be >;
+   using peek_utf32_le = peek_utf32_impl< read_uint32_le >;
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
+
+#endif

data/ext/third_party/json/include/tao/json/external/pegtl/contrib/internal/read_uint.hpp

@@ -0,0 +1,77 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_JSON_PEGTL_CONTRIB_INTERNAL_READ_UINT_HPP
+#define TAO_JSON_PEGTL_CONTRIB_INTERNAL_READ_UINT_HPP
+
+#include <cstdint>
+
+#include "../../config.hpp"
+
+#include "endian.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE::internal
+{
+   struct read_uint16_be
+   {
+      using type = std::uint16_t;
+
+      [[nodiscard]] static std::uint16_t read( const void* d ) noexcept
+      {
+         return be_to_h< std::uint16_t >( d );
+      }
+   };
+
+   struct read_uint16_le
+   {
+      using type = std::uint16_t;
+
+      [[nodiscard]] static std::uint16_t read( const void* d ) noexcept
+      {
+         return le_to_h< std::uint16_t >( d );
+      }
+   };
+
+   struct read_uint32_be
+   {
+      using type = std::uint32_t;
+
+      [[nodiscard]] static std::uint32_t read( const void* d ) noexcept
+      {
+         return be_to_h< std::uint32_t >( d );
+      }
+   };
+
+   struct read_uint32_le
+   {
+      using type = std::uint32_t;
+
+      [[nodiscard]] static std::uint32_t read( const void* d ) noexcept
+      {
+         return le_to_h< std::uint32_t >( d );
+      }
+   };
+
+   struct read_uint64_be
+   {
+      using type = std::uint64_t;
+
+      [[nodiscard]] static std::uint64_t read( const void* d ) noexcept
+      {
+         return be_to_h< std::uint64_t >( d );
+      }
+   };
+
+   struct read_uint64_le
+   {
+      using type = std::uint64_t;
+
+      [[nodiscard]] static std::uint64_t read( const void* d ) noexcept
+      {
+         return le_to_h< std::uint64_t >( d );
+      }
+   };
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
+
+#endif

data/ext/third_party/json/include/tao/json/external/pegtl/contrib/internal/set_stack_guard.hpp

@@ -0,0 +1,52 @@
+// Copyright (c) 2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_JSON_PEGTL_CONTRIB_INTERNAL_SET_STACK_GUARD_HPP
+#define TAO_JSON_PEGTL_CONTRIB_INTERNAL_SET_STACK_GUARD_HPP
+
+#include <set>
+#include <utility>
+
+#include "../../config.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE::internal
+{
+   template< typename... Cs >
+   class set_stack_guard
+   {
+   public:
+      template< typename... Ts >
+      set_stack_guard( std::set< Cs... >& set, Ts&&... ts )
+         : m_i( set.emplace( std::forward< Ts >( ts )... ) ),
+           m_s( set )
+      {}
+
+      set_stack_guard( set_stack_guard&& ) = delete;
+      set_stack_guard( const set_stack_guard& ) = delete;
+
+      void operator=( set_stack_guard&& ) = delete;
+      void operator=( const set_stack_guard& ) = delete;
+
+      ~set_stack_guard()
+      {
+         if( m_i.second ) {
+            m_s.erase( m_i.first );
+         }
+      }
+
+      explicit operator bool() const noexcept
+      {
+         return m_i.second;
+      }
+
+   private:
+      const std::pair< typename std::set< Cs... >::iterator, bool > m_i;
+      std::set< Cs... >& m_s;
+   };
+
+   template< typename... Cs >
+   set_stack_guard( std::set< Cs... >&, const typename std::set< Cs... >::value_type& ) -> set_stack_guard< Cs... >;
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
+
+#endif

data/ext/third_party/json/include/tao/json/external/pegtl/contrib/parse_tree.hpp

@@ -14,15 +14,20 @@
 #include <utility>
 #include <vector>
 
+#include "remove_first_state.hpp"
+#include "shuffle_states.hpp"
+
+#include "../apply_mode.hpp"
 #include "../config.hpp"
+#include "../demangle.hpp"
 #include "../memory_input.hpp"
 #include "../normal.hpp"
 #include "../nothing.hpp"
 #include "../parse.hpp"
+#include "../rewind_mode.hpp"
 
-#include "../analysis/counted.hpp"
-#include "../analysis/generic.hpp"
-#include "../internal/demangle.hpp"
+#include "../internal/enable_control.hpp"
+#include "../internal/has_unwind.hpp"
 #include "../internal/iterator.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE::parse_tree
@@ -62,13 +67,13 @@ namespace TAO_JSON_PEGTL_NAMESPACE::parse_tree
       template< typename U >
       [[nodiscard]] bool is_type() const noexcept
       {
-         return type == TAO_JSON_PEGTL_NAMESPACE::internal::demangle< U >();
+         return type == demangle< U >();
       }
 
       template< typename U >
       void set_type() noexcept
       {
-         type = TAO_JSON_PEGTL_NAMESPACE::internal::demangle< U >();
+         type = demangle< U >();
       }
 
       [[nodiscard]] position begin() const
@@ -102,18 +107,18 @@ namespace TAO_JSON_PEGTL_NAMESPACE::parse_tree
       [[nodiscard]] memory_input< P, Eol > as_memory_input() const
       {
          assert( has_content() );
-         return { m_begin.data, m_end.data, source, m_begin.byte, m_begin.line, m_begin.byte_in_line };
+         return { m_begin.data, m_end.data, source, m_begin.byte, m_begin.line, m_begin.column };
       }
 
       template< typename... States >
       void remove_content( States&&... /*unused*/ ) noexcept
       {
-         m_end.reset();
+         m_end = TAO_JSON_PEGTL_NAMESPACE::internal::iterator();
       }
 
       // all non-root nodes are initialized by calling this method
-      template< typename Rule, typename Input, typename... States >
-      void start( const Input& in, States&&... /*unused*/ )
+      template< typename Rule, typename ParseInput, typename... States >
+      void start( const ParseInput& in, States&&... /*unused*/ )
       {
          set_type< Rule >();
          source = in.source();
@@ -121,17 +126,21 @@ namespace TAO_JSON_PEGTL_NAMESPACE::parse_tree
       }
 
       // if parsing of the rule succeeded, this method is called
-      template< typename Rule, typename Input, typename... States >
-      void success( const Input& in, States&&... /*unused*/ ) noexcept
+      template< typename Rule, typename ParseInput, typename... States >
+      void success( const ParseInput& in, States&&... /*unused*/ ) noexcept
       {
          m_end = TAO_JSON_PEGTL_NAMESPACE::internal::iterator( in.iterator() );
       }
 
       // if parsing of the rule failed, this method is called
-      template< typename Rule, typename Input, typename... States >
-      void failure( const Input& /*unused*/, States&&... /*unused*/ ) noexcept
-      {
-      }
+      template< typename Rule, typename ParseInput, typename... States >
+      void failure( const ParseInput& /*unused*/, States&&... /*unused*/ ) noexcept
+      {}
+
+      // if parsing of the rule failed with an exception, this method is called
+      template< typename Rule, typename ParseInput, typename... States >
+      void unwind( const ParseInput& /*unused*/, States&&... /*unused*/ ) noexcept
+      {}
 
       // if parsing succeeded and the (optional) transform call
       // did not discard the node, it is appended to its parent.
@@ -147,8 +156,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE::parse_tree
 
    struct node
       : basic_node< node >
-   {
-   };
+   {};
 
    namespace internal
    {
@@ -182,160 +190,36 @@ namespace TAO_JSON_PEGTL_NAMESPACE::parse_tree
 
       template< typename Selector, typename... Parameters >
       void transform( Parameters&&... /*unused*/ ) noexcept
-      {
-      }
+      {}
 
-      template< typename Selector, typename Input, typename Node, typename... States >
-      auto transform( const Input& in, std::unique_ptr< Node >& n, States&&... st ) noexcept( noexcept( Selector::transform( in, n, st... ) ) )
-         -> decltype( Selector::transform( in, n, st... ), void() )
+      template< typename Selector, typename ParseInput, typename Node, typename... States >
+      auto transform( const ParseInput& in, std::unique_ptr< Node >& n, States&&... st ) noexcept( noexcept( Selector::transform( in, n, st... ) ) )
+         -> decltype( (void)Selector::transform( in, n, st... ) )
       {
          Selector::transform( in, n, st... );
       }
 
-      template< typename Selector, typename Input, typename Node, typename... States >
-      auto transform( const Input& /*unused*/, std::unique_ptr< Node >& n, States&&... st ) noexcept( noexcept( Selector::transform( n, st... ) ) )
-         -> decltype( Selector::transform( n, st... ), void() )
+      template< typename Selector, typename ParseInput, typename Node, typename... States >
+      auto transform( const ParseInput& /*unused*/, std::unique_ptr< Node >& n, States&&... st ) noexcept( noexcept( Selector::transform( n, st... ) ) )
+         -> decltype( (void)Selector::transform( n, st... ) )
       {
          Selector::transform( n, st... );
       }
 
-      template< unsigned Level, typename Analyse, template< typename... > class Selector >
-      struct is_leaf
-         : std::false_type
-      {
-      };
+      template< typename Rule, template< typename... > class Selector >
+      inline constexpr bool is_selected_node = ( TAO_JSON_PEGTL_NAMESPACE::internal::enable_control< Rule > && Selector< Rule >::value );
 
-      template< analysis::rule_type Type, template< typename... > class Selector >
-      struct is_leaf< 0, analysis::generic< Type >, Selector >
-         : std::true_type
-      {
-      };
+      template< unsigned Level, typename Subs, template< typename... > class Selector >
+      inline constexpr bool is_leaf{};
 
-      template< analysis::rule_type Type, std::size_t Count, template< typename... > class Selector >
-      struct is_leaf< 0, analysis::counted< Type, Count >, Selector >
-         : std::true_type
-      {
-      };
-
-      template< analysis::rule_type Type, typename... Rules, template< typename... > class Selector >
-      struct is_leaf< 0, analysis::generic< Type, Rules... >, Selector >
-         : std::false_type
-      {
-      };
-
-      template< analysis::rule_type Type, std::size_t Count, typename... Rules, template< typename... > class Selector >
-      struct is_leaf< 0, analysis::counted< Type, Count, Rules... >, Selector >
-         : std::false_type
-      {
-      };
+      template< typename... Rules, template< typename... > class Selector >
+      inline constexpr bool is_leaf< 0, type_list< Rules... >, Selector > = ( sizeof...( Rules ) == 0 );
 
       template< unsigned Level, typename Rule, template< typename... > class Selector >
-      inline constexpr bool is_unselected_leaf = !Selector< Rule >::value && is_leaf< Level, typename Rule::analyze_t, Selector >::value;
-
-      template< unsigned Level, analysis::rule_type Type, typename... Rules, template< typename... > class Selector >
-      struct is_leaf< Level, analysis::generic< Type, Rules... >, Selector >
-         : std::bool_constant< ( is_unselected_leaf< Level - 1, Rules, Selector > && ... ) >
-      {
-      };
+      inline constexpr bool is_unselected_branch = ( !is_selected_node< Rule, Selector > && is_leaf< Level, typename Rule::subs_t, Selector > );
 
-      template< unsigned Level, analysis::rule_type Type, std::size_t Count, typename... Rules, template< typename... > class Selector >
-      struct is_leaf< Level, analysis::counted< Type, Count, Rules... >, Selector >
-         : std::bool_constant< ( is_unselected_leaf< Level - 1, Rules, Selector > && ... ) >
-      {
-      };
-
-      template< typename T >
-      struct control
-      {
-         template< typename Input, typename Tuple, std::size_t... Is >
-         static void start_impl( const Input& in, const Tuple& t, std::index_sequence< Is... > /*unused*/ ) noexcept( noexcept( T::start( in, std::get< sizeof...( Is ) >( t ), std::get< Is >( t )... ) ) )
-         {
-            T::start( in, std::get< sizeof...( Is ) >( t ), std::get< Is >( t )... );
-         }
-
-         template< typename Input, typename... States >
-         static void start( const Input& in, States&&... st ) noexcept( noexcept( start_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - 1 >() ) ) )
-         {
-            start_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - 1 >() );
-         }
-
-         template< typename Input, typename Tuple, std::size_t... Is >
-         static void success_impl( const Input& in, const Tuple& t, std::index_sequence< Is... > /*unused*/ ) noexcept( noexcept( T::success( in, std::get< sizeof...( Is ) >( t ), std::get< Is >( t )... ) ) )
-         {
-            T::success( in, std::get< sizeof...( Is ) >( t ), std::get< Is >( t )... );
-         }
-
-         template< typename Input, typename... States >
-         static void success( const Input& in, States&&... st ) noexcept( noexcept( success_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - 1 >() ) ) )
-         {
-            success_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - 1 >() );
-         }
-
-         template< typename Input, typename Tuple, std::size_t... Is >
-         static void failure_impl( const Input& in, const Tuple& t, std::index_sequence< Is... > /*unused*/ ) noexcept( noexcept( T::failure( in, std::get< sizeof...( Is ) >( t ), std::get< Is >( t )... ) ) )
-         {
-            T::failure( in, std::get< sizeof...( Is ) >( t ), std::get< Is >( t )... );
-         }
-
-         template< typename Input, typename... States >
-         static void failure( const Input& in, States&&... st ) noexcept( noexcept( failure_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - 1 >() ) ) )
-         {
-            failure_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - 1 >() );
-         }
-
-         template< typename Input, typename Tuple, std::size_t... Is >
-         static void raise_impl( const Input& in, const Tuple& t, std::index_sequence< Is... > /*unused*/ ) noexcept( noexcept( T::raise( in, std::get< Is >( t )... ) ) )
-         {
-            T::raise( in, std::get< Is >( t )... );
-         }
-
-         template< typename Input, typename... States >
-         static void raise( const Input& in, States&&... st ) noexcept( noexcept( raise_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - 1 >() ) ) )
-         {
-            raise_impl( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - 1 >() );
-         }
-
-         template< template< typename... > class Action, typename Iterator, typename Input, typename Tuple, std::size_t... Is >
-         static auto apply_impl( const Iterator& begin, const Input& in, const Tuple& t, std::index_sequence< Is... > /*unused*/ ) noexcept( noexcept( T::template apply< Action >( begin, in, std::get< Is >( t )... ) ) )
-            -> decltype( T::template apply< Action >( begin, in, std::get< Is >( t )... ) )
-         {
-            return T::template apply< Action >( begin, in, std::get< Is >( t )... );
-         }
-
-         template< template< typename... > class Action, typename Iterator, typename Input, typename... States >
-         static auto apply( const Iterator& begin, const Input& in, States&&... st ) noexcept( noexcept( apply_impl< Action >( begin, in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - 1 >() ) ) )
-            -> decltype( apply_impl< Action >( begin, in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - 1 >() ) )
-         {
-            return apply_impl< Action >( begin, in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - 1 >() );
-         }
-
-         template< template< typename... > class Action, typename Input, typename Tuple, std::size_t... Is >
-         static auto apply0_impl( const Input& in, const Tuple& t, std::index_sequence< Is... > /*unused*/ ) noexcept( noexcept( T::template apply0< Action >( in, std::get< Is >( t )... ) ) )
-            -> decltype( T::template apply0< Action >( in, std::get< Is >( t )... ) )
-         {
-            return T::template apply0< Action >( in, std::get< Is >( t )... );
-         }
-
-         template< template< typename... > class Action, typename Input, typename... States >
-         static auto apply0( const Input& in, States&&... st ) noexcept( noexcept( apply0_impl< Action >( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - 1 >() ) ) )
-            -> decltype( apply0_impl< Action >( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - 1 >() ) )
-         {
-            return apply0_impl< Action >( in, std::tie( st... ), std::make_index_sequence< sizeof...( st ) - 1 >() );
-         }
-
-         template< apply_mode A,
-                   rewind_mode M,
-                   template< typename... >
-                   class Action,
-                   template< typename... >
-                   class Control,
-                   typename Input,
-                   typename... States >
-         [[nodiscard]] static bool match( Input& in, States&&... st )
-         {
-            return T::template match< A, M, Action, Control >( in, st... );
-         }
-      };
+      template< unsigned Level, typename... Rules, template< typename... > class Selector >
+      inline constexpr bool is_leaf< Level, type_list< Rules... >, Selector > = ( is_unselected_branch< Level - 1, Rules, Selector > && ... );
 
       template< typename Node, template< typename... > class Selector, template< typename... > class Control >
       struct make_control
@@ -344,49 +228,29 @@ namespace TAO_JSON_PEGTL_NAMESPACE::parse_tree
          struct state_handler;
 
          template< typename Rule >
-         using type = control< state_handler< Rule, Selector< Rule >::value, is_leaf< 8, typename Rule::analyze_t, Selector >::value > >;
+         using type = rotate_states_right< state_handler< Rule, is_selected_node< Rule, Selector >, is_leaf< 8, typename Rule::subs_t, Selector > > >;
       };
 
       template< typename Node, template< typename... > class Selector, template< typename... > class Control >
       template< typename Rule >
       struct make_control< Node, Selector, Control >::state_handler< Rule, false, true >
-         : Control< Rule >
-      {
-         template< typename Input, typename... States >
-         static void start( const Input& in, state< Node >& /*unused*/, States&&... st ) noexcept( noexcept( Control< Rule >::start( in, st... ) ) )
-         {
-            Control< Rule >::start( in, st... );
-         }
-
-         template< typename Input, typename... States >
-         static void success( const Input& in, state< Node >& /*unused*/, States&&... st ) noexcept( noexcept( Control< Rule >::success( in, st... ) ) )
-         {
-            Control< Rule >::success( in, st... );
-         }
-
-         template< typename Input, typename... States >
-         static void failure( const Input& in, state< Node >& /*unused*/, States&&... st ) noexcept( noexcept( Control< Rule >::failure( in, st... ) ) )
-         {
-            Control< Rule >::failure( in, st... );
-         }
-      };
+         : remove_first_state< Control< Rule > >
+      {};
 
       template< typename Node, template< typename... > class Selector, template< typename... > class Control >
       template< typename Rule >
       struct make_control< Node, Selector, Control >::state_handler< Rule, false, false >
-         : Control< Rule >
+         : remove_first_state< Control< Rule > >
       {
-         template< typename Input, typename... States >
-         static void start( const Input& in, state< Node >& state, States&&... st )
+         template< typename ParseInput, typename... States >
+         static void start( const ParseInput& /*unused*/, state< Node >& state, States&&... /*unused*/ )
          {
-            Control< Rule >::start( in, st... );
             state.emplace_back();
          }
 
-         template< typename Input, typename... States >
-         static void success( const Input& in, state< Node >& state, States&&... st )
+         template< typename ParseInput, typename... States >
+         static void success( const ParseInput& /*unused*/, state< Node >& state, States&&... /*unused*/ )
          {
-            Control< Rule >::success( in, st... );
             auto n = std::move( state.back() );
             state.pop_back();
             for( auto& c : n->children ) {
@@ -394,10 +258,15 @@ namespace TAO_JSON_PEGTL_NAMESPACE::parse_tree
             }
          }
 
-         template< typename Input, typename... States >
-         static void failure( const Input& in, state< Node >& state, States&&... st ) noexcept( noexcept( Control< Rule >::failure( in, st... ) ) )
+         template< typename ParseInput, typename... States >
+         static void failure( const ParseInput& /*unused*/, state< Node >& state, States&&... /*unused*/ )
+         {
+            state.pop_back();
+         }
+
+         template< typename ParseInput, typename... States >
+         static void unwind( const ParseInput& /*unused*/, state< Node >& state, States&&... /*unused*/ )
          {
-            Control< Rule >::failure( in, st... );
             state.pop_back();
          }
       };
@@ -405,20 +274,19 @@ namespace TAO_JSON_PEGTL_NAMESPACE::parse_tree
       template< typename Node, template< typename... > class Selector, template< typename... > class Control >
       template< typename Rule, bool B >
       struct make_control< Node, Selector, Control >::state_handler< Rule, true, B >
-         : Control< Rule >
+         : remove_first_state< Control< Rule > >
       {
-         template< typename Input, typename... States >
-         static void start( const Input& in, state< Node >& state, States&&... st )
+         template< typename ParseInput, typename... States >
+         static void start( const ParseInput& in, state< Node >& state, States&&... st )
          {
             Control< Rule >::start( in, st... );
             state.emplace_back();
             state.back()->template start< Rule >( in, st... );
          }
 
-         template< typename Input, typename... States >
-         static void success( const Input& in, state< Node >& state, States&&... st )
+         template< typename ParseInput, typename... States >
+         static void success( const ParseInput& in, state< Node >& state, States&&... st )
          {
-            Control< Rule >::success( in, st... );
             auto n = std::move( state.back() );
             state.pop_back();
             n->template success< Rule >( in, st... );
@@ -426,14 +294,25 @@ namespace TAO_JSON_PEGTL_NAMESPACE::parse_tree
             if( n ) {
                state.back()->emplace_back( std::move( n ), st... );
             }
+            Control< Rule >::success( in, st... );
          }
 
-         template< typename Input, typename... States >
-         static void failure( const Input& in, state< Node >& state, States&&... st ) noexcept( noexcept( Control< Rule >::failure( in, st... ) ) && noexcept( std::declval< Node& >().template failure< Rule >( in, st... ) ) )
+         template< typename ParseInput, typename... States >
+         static void failure( const ParseInput& in, state< Node >& state, States&&... st )
          {
-            Control< Rule >::failure( in, st... );
             state.back()->template failure< Rule >( in, st... );
             state.pop_back();
+            Control< Rule >::failure( in, st... );
+         }
+
+         template< typename ParseInput, typename... States >
+         static void unwind( const ParseInput& in, state< Node >& state, States&&... st )
+         {
+            state.back()->template unwind< Rule >( in, st... );
+            state.pop_back();
+            if constexpr( TAO_JSON_PEGTL_NAMESPACE::internal::has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
+               Control< Rule >::unwind( in, st... );
+            }
          }
       };
 
@@ -533,9 +412,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE::parse_tree
              template< typename... > class Selector = internal::store_all,
              template< typename... > class Action = nothing,
              template< typename... > class Control = normal,
-             typename Input,
+             typename ParseInput,
              typename... States >
-   [[nodiscard]] std::unique_ptr< Node > parse( Input&& in, States&&... st )
+   [[nodiscard]] std::unique_ptr< Node > parse( ParseInput&& in, States&&... st )
    {
       internal::state< Node > state;
       if( !TAO_JSON_PEGTL_NAMESPACE::parse< Rule, Action, internal::make_control< Node, Selector, Control >::template type >( in, st..., state ) ) {
@@ -549,9 +428,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE::parse_tree
              template< typename... > class Selector = internal::store_all,
              template< typename... > class Action = nothing,
              template< typename... > class Control = normal,
-             typename Input,
+             typename ParseInput,
              typename... States >
-   [[nodiscard]] std::unique_ptr< node > parse( Input&& in, States&&... st )
+   [[nodiscard]] std::unique_ptr< node > parse( ParseInput&& in, States&&... st )
    {
       return parse< Rule, node, Selector, Action, Control >( in, st... );
    }