couchbase 3.0.3-universal-darwin-20

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/json.hpp

@@ -0,0 +1,88 @@
+// 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_JSON_HPP
+#define TAO_JSON_PEGTL_CONTRIB_JSON_HPP
+
+#include "../ascii.hpp"
+#include "../config.hpp"
+#include "../rules.hpp"
+#include "../utf8.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE::json
+{
+   // JSON grammar according to RFC 8259
+
+   // clang-format off
+   struct ws : one< ' ', '\t', '\n', '\r' > {};
+
+   template< typename R, typename P = ws >
+   struct padr : internal::seq< R, internal::star< P > > {};
+
+   struct begin_array : padr< one< '[' > > {};
+   struct begin_object : padr< one< '{' > > {};
+   struct end_array : one< ']' > {};
+   struct end_object : one< '}' > {};
+   struct name_separator : pad< one< ':' >, ws > {};
+   struct value_separator : padr< one< ',' > > {};
+
+   struct false_ : string< 'f', 'a', 'l', 's', 'e' > {};  // NOLINT(readability-identifier-naming)
+   struct null : string< 'n', 'u', 'l', 'l' > {};
+   struct true_ : string< 't', 'r', 'u', 'e' > {};  // NOLINT(readability-identifier-naming)
+
+   struct digits : plus< digit > {};
+   struct exp : seq< one< 'e', 'E' >, opt< one< '-', '+'> >, must< digits > > {};
+   struct frac : if_must< one< '.' >, digits > {};
+   struct int_ : sor< one< '0' >, digits > {};  // NOLINT(readability-identifier-naming)
+   struct number : seq< opt< one< '-' > >, int_, opt< frac >, opt< exp > > {};
+
+   struct xdigit : pegtl::xdigit {};
+   struct unicode : list< seq< one< 'u' >, rep< 4, must< xdigit > > >, one< '\\' > > {};
+   struct escaped_char : one< '"', '\\', '/', 'b', 'f', 'n', 'r', 't' > {};
+   struct escaped : sor< escaped_char, unicode > {};
+   struct unescaped : utf8::range< 0x20, 0x10FFFF > {};
+   struct char_ : if_then_else< one< '\\' >, must< escaped >, unescaped > {};  // NOLINT(readability-identifier-naming)
+
+   struct string_content : until< at< one< '"' > >, must< char_ > > {};
+   struct string : seq< one< '"' >, must< string_content >, any >
+   {
+      using content = string_content;
+   };
+
+   struct key_content : until< at< one< '"' > >, must< char_ > > {};
+   struct key : seq< one< '"' >, must< key_content >, any >
+   {
+      using content = key_content;
+   };
+
+   struct value;
+
+   struct array_element;
+   struct array_content : opt< list_must< array_element, value_separator > > {};
+   struct array : seq< begin_array, array_content, must< end_array > >
+   {
+      using begin = begin_array;
+      using end = end_array;
+      using element = array_element;
+      using content = array_content;
+   };
+
+   struct member : if_must< key, name_separator, value > {};
+   struct object_content : opt< list_must< member, value_separator > > {};
+   struct object : seq< begin_object, object_content, must< end_object > >
+   {
+      using begin = begin_object;
+      using end = end_object;
+      using element = member;
+      using content = object_content;
+   };
+
+   struct value : padr< sor< string, number, object, array, false_, true_, null > > {};
+   struct array_element : seq< value > {};
+
+   struct text : seq< star< ws >, value > {};
+   // clang-format on
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE::json
+
+#endif

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

@@ -0,0 +1,33 @@
+// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_JSON_PEGTL_CONTRIB_JSON_POINTER_HPP
+#define TAO_JSON_PEGTL_CONTRIB_JSON_POINTER_HPP
+
+#include "../ascii.hpp"
+#include "../config.hpp"
+#include "../rules.hpp"
+#include "../utf8.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE::json_pointer
+{
+   // JSON pointer grammar according to RFC 6901
+
+   // clang-format off
+   struct unescaped : utf8::ranges< 0x0, 0x2E, 0x30, 0x7D, 0x7F, 0x10FFFF > {};
+   struct escaped : seq< one< '~' >, one< '0', '1' > > {};
+
+   struct reference_token : star< sor< unescaped, escaped > > {};
+   struct json_pointer : star< one< '/' >, reference_token > {};
+   // clang-format on
+
+   // relative JSON pointer, see ...
+
+   // clang-format off
+   struct non_negative_integer : sor< one< '0' >, plus< digit > > {};
+   struct relative_json_pointer : seq< non_negative_integer, sor< one< '#' >, json_pointer > > {};
+   // clang-format on
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE::json_pointer
+
+#endif

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

@@ -0,0 +1,440 @@
+// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_JSON_PEGTL_CONTRIB_PARSE_TREE_HPP
+#define TAO_JSON_PEGTL_CONTRIB_PARSE_TREE_HPP
+
+#include <cassert>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <tuple>
+#include <type_traits>
+#include <typeindex>
+#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 "../internal/enable_control.hpp"
+#include "../internal/has_unwind.hpp"
+#include "../internal/iterator.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE::parse_tree
+{
+   template< typename T >
+   struct basic_node
+   {
+      using node_t = T;
+      using children_t = std::vector< std::unique_ptr< node_t > >;
+      children_t children;
+
+      std::string_view type;
+      std::string source;
+
+      TAO_JSON_PEGTL_NAMESPACE::internal::iterator m_begin;
+      TAO_JSON_PEGTL_NAMESPACE::internal::iterator m_end;
+
+      // each node will be default constructed
+      basic_node() = default;
+
+      // no copy/move is necessary
+      // (nodes are always owned/handled by a std::unique_ptr)
+      basic_node( const basic_node& ) = delete;
+      basic_node( basic_node&& ) = delete;
+
+      ~basic_node() = default;
+
+      // no assignment either
+      basic_node& operator=( const basic_node& ) = delete;
+      basic_node& operator=( basic_node&& ) = delete;
+
+      [[nodiscard]] bool is_root() const noexcept
+      {
+         return type.empty();
+      }
+
+      template< typename U >
+      [[nodiscard]] bool is_type() const noexcept
+      {
+         return type == demangle< U >();
+      }
+
+      template< typename U >
+      void set_type() noexcept
+      {
+         type = demangle< U >();
+      }
+
+      [[nodiscard]] position begin() const
+      {
+         return position( m_begin, source );
+      }
+
+      [[nodiscard]] position end() const
+      {
+         return position( m_end, source );
+      }
+
+      [[nodiscard]] bool has_content() const noexcept
+      {
+         return m_end.data != nullptr;
+      }
+
+      [[nodiscard]] std::string_view string_view() const noexcept
+      {
+         assert( has_content() );
+         return std::string_view( m_begin.data, m_end.data - m_begin.data );
+      }
+
+      [[nodiscard]] std::string string() const
+      {
+         assert( has_content() );
+         return std::string( m_begin.data, m_end.data );
+      }
+
+      template< tracking_mode P = tracking_mode::eager, typename Eol = eol::lf_crlf >
+      [[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.column };
+      }
+
+      template< typename... States >
+      void remove_content( States&&... /*unused*/ ) noexcept
+      {
+         m_end = TAO_JSON_PEGTL_NAMESPACE::internal::iterator();
+      }
+
+      // all non-root nodes are initialized by calling this method
+      template< typename Rule, typename ParseInput, typename... States >
+      void start( const ParseInput& in, States&&... /*unused*/ )
+      {
+         set_type< Rule >();
+         source = in.source();
+         m_begin = TAO_JSON_PEGTL_NAMESPACE::internal::iterator( in.iterator() );
+      }
+
+      // if parsing of the rule succeeded, this method is called
+      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 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.
+      // note that "child" is the node whose Rule just succeeded
+      // and "*this" is the parent where the node should be appended.
+      template< typename... States >
+      void emplace_back( std::unique_ptr< node_t >&& child, States&&... /*unused*/ )
+      {
+         assert( child );
+         children.emplace_back( std::move( child ) );
+      }
+   };
+
+   struct node
+      : basic_node< node >
+   {};
+
+   namespace internal
+   {
+      template< typename Node >
+      struct state
+      {
+         std::vector< std::unique_ptr< Node > > stack;
+
+         state()
+         {
+            emplace_back();
+         }
+
+         void emplace_back()
+         {
+            stack.emplace_back( std::make_unique< Node >() );
+         }
+
+         [[nodiscard]] std::unique_ptr< Node >& back() noexcept
+         {
+            assert( !stack.empty() );
+            return stack.back();
+         }
+
+         void pop_back() noexcept
+         {
+            assert( !stack.empty() );
+            return stack.pop_back();
+         }
+      };
+
+      template< typename Selector, typename... Parameters >
+      void transform( Parameters&&... /*unused*/ ) noexcept
+      {}
+
+      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 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< typename Rule, template< typename... > class Selector >
+      inline constexpr bool is_selected_node = ( TAO_JSON_PEGTL_NAMESPACE::internal::enable_control< Rule > && Selector< Rule >::value );
+
+      template< unsigned Level, typename Subs, template< typename... > class Selector >
+      inline constexpr bool is_leaf{};
+
+      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_branch = ( !is_selected_node< Rule, Selector > && is_leaf< Level, typename Rule::subs_t, Selector > );
+
+      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
+      {
+         template< typename Rule, bool, bool >
+         struct state_handler;
+
+         template< typename Rule >
+         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 >
+         : 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 >
+         : remove_first_state< Control< Rule > >
+      {
+         template< typename ParseInput, typename... States >
+         static void start( const ParseInput& /*unused*/, state< Node >& state, States&&... /*unused*/ )
+         {
+            state.emplace_back();
+         }
+
+         template< typename ParseInput, typename... States >
+         static void success( const ParseInput& /*unused*/, state< Node >& state, States&&... /*unused*/ )
+         {
+            auto n = std::move( state.back() );
+            state.pop_back();
+            for( auto& c : n->children ) {
+               state.back()->children.emplace_back( std::move( c ) );
+            }
+         }
+
+         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*/ )
+         {
+            state.pop_back();
+         }
+      };
+
+      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 >
+         : remove_first_state< Control< Rule > >
+      {
+         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 ParseInput, typename... States >
+         static void success( const ParseInput& in, state< Node >& state, States&&... st )
+         {
+            auto n = std::move( state.back() );
+            state.pop_back();
+            n->template success< Rule >( in, st... );
+            transform< Selector< Rule > >( in, n, st... );
+            if( n ) {
+               state.back()->emplace_back( std::move( n ), st... );
+            }
+            Control< Rule >::success( in, st... );
+         }
+
+         template< typename ParseInput, typename... States >
+         static void failure( const ParseInput& in, state< Node >& state, States&&... 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... );
+            }
+         }
+      };
+
+      template< typename >
+      using store_all = std::true_type;
+
+      template< typename >
+      struct selector;
+
+      template< typename T >
+      struct selector< std::tuple< T > >
+      {
+         using type = typename T::type;
+      };
+
+      template< typename... Ts >
+      struct selector< std::tuple< Ts... > >
+      {
+         static_assert( sizeof...( Ts ) == 0, "multiple matches found" );
+         using type = std::false_type;
+      };
+
+      template< typename T >
+      using selector_t = typename selector< T >::type;
+
+      template< typename Rule, typename Collection >
+      using select_tuple = std::conditional_t< Collection::template contains< Rule >, std::tuple< Collection >, std::tuple<> >;
+
+   }  // namespace internal
+
+   template< typename Rule, typename... Collections >
+   using selector = internal::selector_t< decltype( std::tuple_cat( std::declval< internal::select_tuple< Rule, Collections > >()... ) ) >;
+
+   template< typename Base >
+   struct apply
+      : std::true_type
+   {
+      template< typename... Rules >
+      struct on
+      {
+         using type = Base;
+
+         template< typename Rule >
+         static constexpr bool contains = ( std::is_same_v< Rule, Rules > || ... );
+      };
+   };
+
+   struct store_content
+      : apply< store_content >
+   {};
+
+   // some nodes don't need to store their content
+   struct remove_content
+      : apply< remove_content >
+   {
+      template< typename Node, typename... States >
+      static void transform( std::unique_ptr< Node >& n, States&&... st ) noexcept( noexcept( n->Node::remove_content( st... ) ) )
+      {
+         n->remove_content( st... );
+      }
+   };
+
+   // if a node has only one child, replace the node with its child, otherwise remove content
+   struct fold_one
+      : apply< fold_one >
+   {
+      template< typename Node, typename... States >
+      static void transform( std::unique_ptr< Node >& n, States&&... st ) noexcept( noexcept( n->children.size(), n->Node::remove_content( st... ) ) )
+      {
+         if( n->children.size() == 1 ) {
+            n = std::move( n->children.front() );
+         }
+         else {
+            n->remove_content( st... );
+         }
+      }
+   };
+
+   // if a node has no children, discard the node, otherwise remove content
+   struct discard_empty
+      : apply< discard_empty >
+   {
+      template< typename Node, typename... States >
+      static void transform( std::unique_ptr< Node >& n, States&&... st ) noexcept( noexcept( n->children.empty(), n->Node::remove_content( st... ) ) )
+      {
+         if( n->children.empty() ) {
+            n.reset();
+         }
+         else {
+            n->remove_content( st... );
+         }
+      }
+   };
+
+   template< typename Rule,
+             typename Node,
+             template< typename... > class Selector = internal::store_all,
+             template< typename... > class Action = nothing,
+             template< typename... > class Control = normal,
+             typename ParseInput,
+             typename... States >
+   [[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 ) ) {
+         return nullptr;
+      }
+      assert( state.stack.size() == 1 );
+      return std::move( state.back() );
+   }
+
+   template< typename Rule,
+             template< typename... > class Selector = internal::store_all,
+             template< typename... > class Action = nothing,
+             template< typename... > class Control = normal,
+             typename ParseInput,
+             typename... States >
+   [[nodiscard]] std::unique_ptr< node > parse( ParseInput&& in, States&&... st )
+   {
+      return parse< Rule, node, Selector, Action, Control >( in, st... );
+   }
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE::parse_tree
+
+#endif