couchbase 3.0.1-universal-darwin-19 → 3.0.2-universal-darwin-19

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

@@ -1,45 +0,0 @@
-// 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

@@ -1,32 +0,0 @@
-// 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

@@ -1,54 +0,0 @@
-// 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

@@ -1,43 +0,0 @@
-// 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

@@ -1,77 +0,0 @@
-// 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

@@ -1,52 +0,0 @@
-// 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

@@ -1,88 +0,0 @@
-// 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

@@ -1,33 +0,0 @@
-// 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

@@ -1,440 +0,0 @@
-// 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