couchbase 1.3.15 → 3.0.0.alpha.5

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

@@ -0,0 +1,218 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_INTERNAL_SHA256_HPP
+#define TAO_JSON_INTERNAL_SHA256_HPP
+
+// Implements RFC 6234, SHA-256
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <string>
+
+// RFC 6234, 3.d; see also http://stackoverflow.com/a/4209604/2073257
+#define ROR( x, N ) ( ( ( x ) >> ( N ) ) | ( ( x ) << ( 32 - ( N ) ) ) )
+
+// RFC 6234, 5.1
+#define CH( x, y, z ) ( ( ( x ) & ( y ) ) ^ ( ~( x ) & ( z ) ) )
+#define MAJ( x, y, z ) ( ( ( x ) & ( y ) ) ^ ( ( x ) & ( z ) ) ^ ( ( y ) & ( z ) ) )
+#define BSIG0( x ) ( ROR( x, 2 ) ^ ROR( x, 13 ) ^ ROR( x, 22 ) )
+#define BSIG1( x ) ( ROR( x, 6 ) ^ ROR( x, 11 ) ^ ROR( x, 25 ) )
+#define SSIG0( x ) ( ROR( x, 7 ) ^ ROR( x, 18 ) ^ ( ( x ) >> 3 ) )
+#define SSIG1( x ) ( ROR( x, 17 ) ^ ROR( x, 19 ) ^ ( ( x ) >> 10 ) )
+
+namespace tao::json::internal
+{
+   // RFC 6234, 5.1
+   // clang-format off
+   static std::uint32_t K[ 64 ] = {
+      0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
+      0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+      0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+      0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+      0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+      0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+      0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+      0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+      0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+      0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+      0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+      0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+      0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
+      0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+      0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+      0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+   };
+   // clang-format on
+
+   class sha256
+   {
+   private:
+      unsigned char M[ 64 ];
+      std::uint64_t size;
+
+      std::uint32_t H[ 8 ];
+
+      // RFC 6234, 6.2
+      void process() noexcept
+      {
+         std::uint32_t W[ 64 ];
+
+         // step 1
+         for( std::size_t t = 0, i = 0; t != 16; ++t, i += 4 ) {
+            W[ t ] = ( M[ i ] << 24 ) | ( M[ i + 1 ] << 16 ) | ( M[ i + 2 ] << 8 ) | ( M[ i + 3 ] );
+         }
+         for( std::size_t t = 16; t != 64; ++t ) {
+            W[ t ] = SSIG1( W[ t - 2 ] ) + W[ t - 7 ] + SSIG0( W[ t - 15 ] ) + W[ t - 16 ];
+         }
+
+         // step 2
+         std::uint32_t a, b, c, d, e, f, g, h;
+         a = H[ 0 ];
+         b = H[ 1 ];
+         c = H[ 2 ];
+         d = H[ 3 ];
+         e = H[ 4 ];
+         f = H[ 5 ];
+         g = H[ 6 ];
+         h = H[ 7 ];
+
+         // step 3
+         for( std::size_t t = 0; t != 64; ++t ) {
+            const std::uint32_t T1 = h + BSIG1( e ) + CH( e, f, g ) + K[ t ] + W[ t ];
+            const std::uint32_t T2 = BSIG0( a ) + MAJ( a, b, c );
+            h = g;
+            g = f;
+            f = e;
+            e = d + T1;
+            d = c;
+            c = b;
+            b = a;
+            a = T1 + T2;
+         }
+
+         // step 4
+         H[ 0 ] += a;
+         H[ 1 ] += b;
+         H[ 2 ] += c;
+         H[ 3 ] += d;
+         H[ 4 ] += e;
+         H[ 5 ] += f;
+         H[ 6 ] += g;
+         H[ 7 ] += h;
+      }
+
+   public:
+      sha256() noexcept
+      {
+         reset();
+      }
+
+      sha256( const sha256& ) = delete;
+      sha256( sha256&& ) = delete;
+
+      ~sha256() = default;
+
+      void operator=( const sha256& ) = delete;
+      void operator=( sha256&& ) = delete;
+
+      void reset() noexcept
+      {
+         size = 0;
+
+         // RFC 6234, 6.1
+         H[ 0 ] = 0x6a09e667;
+         H[ 1 ] = 0xbb67ae85;
+         H[ 2 ] = 0x3c6ef372;
+         H[ 3 ] = 0xa54ff53a;
+         H[ 4 ] = 0x510e527f;
+         H[ 5 ] = 0x9b05688c;
+         H[ 6 ] = 0x1f83d9ab;
+         H[ 7 ] = 0x5be0cd19;
+      }
+
+      void feed( const unsigned char c ) noexcept
+      {
+         M[ size++ % 64 ] = c;
+         if( ( size % 64 ) == 0 ) {
+            process();
+         }
+      }
+
+      void feed( const void* p, std::size_t s ) noexcept
+      {
+         auto* q = static_cast< const unsigned char* >( p );
+         while( s != 0 ) {
+            feed( *q++ );
+            --s;
+         }
+      }
+
+      void feed( const std::string_view v ) noexcept
+      {
+         feed( v.data(), v.size() );
+      }
+
+      // RFC 6234, 4.1
+      void store_unsafe( unsigned char* buffer ) noexcept
+      {
+         std::size_t i = size % 64;
+         if( i < 56 ) {
+            M[ i++ ] = 0x80;
+#if defined( __GNUC__ ) && ( __GNUC__ >= 9 )
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Waggressive-loop-optimizations"
+#endif
+            while( i < 56 ) {
+               M[ i++ ] = 0x00;
+            }
+#if defined( __GNUC__ ) && ( __GNUC__ >= 9 )
+#pragma GCC diagnostic pop
+#endif
+         }
+         else {
+            M[ i++ ] = 0x80;
+            while( i < 64 ) {
+               M[ i++ ] = 0x00;
+            }
+            process();
+            std::memset( M, 0, 56 );
+         }
+
+         size *= 8;
+
+         M[ 63 ] = static_cast< unsigned char >( size );
+         M[ 62 ] = static_cast< unsigned char >( size >> 8 );
+         M[ 61 ] = static_cast< unsigned char >( size >> 16 );
+         M[ 60 ] = static_cast< unsigned char >( size >> 24 );
+         M[ 59 ] = static_cast< unsigned char >( size >> 32 );
+         M[ 58 ] = static_cast< unsigned char >( size >> 40 );
+         M[ 57 ] = static_cast< unsigned char >( size >> 48 );
+         M[ 56 ] = static_cast< unsigned char >( size >> 56 );
+
+         process();
+
+         for( std::size_t j = 0; j < 4; ++j ) {
+            buffer[ j ] = ( H[ 0 ] >> ( 24 - j * 8 ) ) & 0xff;
+            buffer[ j + 4 ] = ( H[ 1 ] >> ( 24 - j * 8 ) ) & 0xff;
+            buffer[ j + 8 ] = ( H[ 2 ] >> ( 24 - j * 8 ) ) & 0xff;
+            buffer[ j + 12 ] = ( H[ 3 ] >> ( 24 - j * 8 ) ) & 0xff;
+            buffer[ j + 16 ] = ( H[ 4 ] >> ( 24 - j * 8 ) ) & 0xff;
+            buffer[ j + 20 ] = ( H[ 5 ] >> ( 24 - j * 8 ) ) & 0xff;
+            buffer[ j + 24 ] = ( H[ 6 ] >> ( 24 - j * 8 ) ) & 0xff;
+            buffer[ j + 28 ] = ( H[ 7 ] >> ( 24 - j * 8 ) ) & 0xff;
+         }
+      }
+
+      [[nodiscard]] std::string get()
+      {
+         std::string result( 32, '\0' );
+         store_unsafe( reinterpret_cast< unsigned char* >( result.data() ) );
+         return result;
+      }
+   };
+
+}  // namespace tao::json::internal
+
+#endif

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

@@ -0,0 +1,40 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_INTERNAL_SINGLE_HPP
+#define TAO_JSON_INTERNAL_SINGLE_HPP
+
+#include <utility>
+
+#include "../forward.hpp"
+
+#include "pair.hpp"
+
+namespace tao::json::internal
+{
+   template< template< typename... > class Traits >
+   struct single
+   {
+      mutable basic_value< Traits > value;
+
+      template< typename U >
+      single( U&& v )
+         : value( std::forward< U >( v ) )
+      {}
+
+      single( std::initializer_list< pair< Traits > >&& l )
+         : value( std::move( l ) )
+      {}
+
+      single( const std::initializer_list< pair< Traits > >& l )
+         : value( l )
+      {}
+
+      single( std::initializer_list< pair< Traits > >& l )
+         : value( l )
+      {}
+   };
+
+}  // namespace tao::json::internal
+
+#endif

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

@@ -0,0 +1,35 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_INTERNAL_STRING_T_HPP
+#define TAO_JSON_INTERNAL_STRING_T_HPP
+
+#include <string>
+#include <string_view>
+
+#include "../external/pegtl/internal/pegtl_string.hpp"
+
+namespace tao::json::internal
+{
+   template< char... Cs >
+   struct string_t
+      : pegtl::string< Cs... >
+   {
+      static constexpr const char value[] = { Cs..., 0 };
+
+      [[nodiscard]] static constexpr std::string_view as_string_view() noexcept
+      {
+         return std::string_view( value, sizeof...( Cs ) );
+      }
+
+      [[nodiscard]] static std::string as_string()
+      {
+         return std::string( value, sizeof...( Cs ) );
+      }
+   };
+
+}  // namespace tao::json::internal
+
+#define TAO_JSON_STRING_T( VaLue ) TAO_JSON_PEGTL_INTERNAL_STRING( tao::json::internal::string_t, VaLue )
+
+#endif

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

@@ -0,0 +1,113 @@
+// Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_INTERNAL_TYPE_TRAITS_HPP
+#define TAO_JSON_INTERNAL_TYPE_TRAITS_HPP
+
+#include <type_traits>
+#include <typeinfo>
+
+#include "../forward.hpp"
+
+namespace tao::json::internal
+{
+   template< typename... Ts >
+   struct type_list
+   {
+      static constexpr std::size_t size = sizeof...( Ts );
+   };
+
+   template< typename... >
+   struct merge_type_lists_t;
+
+   template< typename... Ts >
+   struct merge_type_lists_t< type_list< Ts... > >
+   {
+      using list = type_list< Ts... >;
+   };
+
+   template< typename... Vs, typename... Ws, typename... Rs >
+   struct merge_type_lists_t< type_list< Vs... >, type_list< Ws... >, Rs... >
+      : merge_type_lists_t< type_list< Vs..., Ws... >, Rs... >
+   {};
+
+   template< typename... Ts >
+   using merge_type_lists = typename merge_type_lists_t< Ts... >::list;
+
+   struct type_info_less
+   {
+      [[nodiscard]] bool operator()( const std::type_info* l, const std::type_info* r ) const
+      {
+         return l->before( *r );
+      }
+   };
+
+   template< typename... >
+   inline constexpr bool has_as_impl = false;
+
+   template< typename Trait, typename... Args >
+   inline constexpr bool has_as_impl< decltype( (void)Trait::as( std::declval< Args >()... ), void() ), Trait, Args... > = true;
+
+   template< typename Trait, typename Value, typename... With >
+   inline constexpr bool has_as = has_as_impl< void, Trait, const Value&, With&... >;
+
+   template< typename, template< typename... > typename, typename, typename... >
+   inline constexpr bool has_as_type_impl = false;
+
+   template< template< typename... > typename Traits, typename T, typename... Args >
+   inline constexpr bool has_as_type_impl< decltype( (void)Traits< T >::template as_type< Traits, T >( std::declval< Args >()... ), void() ), Traits, T, Args... > = true;
+
+   template< template< typename... > typename Traits, typename T, typename Value, typename... With >
+   inline constexpr bool has_as_type = has_as_type_impl< void, Traits, T, const Value&, With&... >;
+
+   template< typename... >
+   inline constexpr bool has_to_impl = false;
+
+   template< typename Trait, typename... Args >
+   inline constexpr bool has_to_impl< decltype( Trait::to( std::declval< Args >()... ), void() ), Trait, Args... > = true;
+
+   template< typename Trait, typename Value, typename... With >
+   inline constexpr bool has_to = has_to_impl< void, Trait, const Value&, With&... >;
+
+   template< template< typename... > class, typename, typename, typename = void >
+   inline constexpr bool has_consume_one = false;
+
+   template< template< typename... > class Traits, typename P, typename U >
+   inline constexpr bool has_consume_one< Traits, P, U, decltype( (void)Traits< U >::template consume< Traits >( std::declval< P& >() ), void() ) > = true;
+
+   template< template< typename... > class, typename, typename, typename = void >
+   inline constexpr bool has_consume_two = false;
+
+   template< template< typename... > class Traits, typename P, typename U >
+   inline constexpr bool has_consume_two< Traits, P, U, decltype( (void)Traits< U >::template consume< Traits >( std::declval< P& >(), std::declval< U& >() ), void() ) > = true;
+
+   template< template< typename... > class Traits, typename T, typename = void >
+   inline constexpr bool has_is_nothing = false;
+
+   template< template< typename... > class Traits, typename T >
+   inline constexpr bool has_is_nothing< Traits, T, decltype( (void)Traits< T >::template is_nothing< Traits >( std::declval< const T& >() ), void() ) > = true;
+
+   template< template< typename... > class Traits, typename T >
+   [[nodiscard]] std::enable_if_t< has_is_nothing< Traits, T >, bool > is_nothing( const T& t ) noexcept( noexcept( Traits< T >::template is_nothing< Traits >( t ) ) )
+   {
+      return Traits< T >::template is_nothing< Traits >( t );
+   }
+
+   template< template< typename... > class Traits, typename T >
+   [[nodiscard]] std::enable_if_t< !has_is_nothing< Traits, T >, bool > is_nothing( const T& /*unused*/ ) noexcept
+   {
+      return false;
+   }
+
+   template< template< typename... > class Traits, typename T, typename = void >
+   inline constexpr bool has_enable_implicit_constructor = false;
+
+   template< template< typename... > class Traits, typename T >
+   inline constexpr bool has_enable_implicit_constructor< Traits, T, decltype( Traits< T >::enable_implicit_constructor, void() ) > = true;
+
+   template< template< typename... > class Traits, typename T >
+   inline constexpr bool enable_implicit_constructor = Traits< std::conditional_t< has_enable_implicit_constructor< Traits, T >, T, void > >::enable_implicit_constructor;
+
+}  // namespace tao::json::internal
+
+#endif

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

@@ -0,0 +1,24 @@
+// Copyright (c) 2015-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_INTERNAL_UNESCAPE_ACTION_HPP
+#define TAO_JSON_INTERNAL_UNESCAPE_ACTION_HPP
+
+#include "../external/pegtl/contrib/unescape.hpp"
+#include "../external/pegtl/nothing.hpp"
+
+#include "grammar.hpp"
+
+namespace tao::json::internal
+{
+   // clang-format off
+   template< typename Rule > struct unescape_action : pegtl::nothing< Rule > {};
+
+   template<> struct unescape_action< rules::escaped_unicode > : pegtl::unescape::unescape_j {};
+   template<> struct unescape_action< rules::escaped_char > : pegtl::unescape::unescape_c< rules::escaped_char, '"', '\\', '/', '\b', '\f', '\n', '\r', '\t' > {};
+   template<> struct unescape_action< rules::unescaped > : pegtl::unescape::append_all {};
+   // clang-format on
+
+}  // namespace tao::json::internal
+
+#endif

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

@@ -0,0 +1,182 @@
+// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/json/
+
+#ifndef TAO_JSON_INTERNAL_URI_FRAGMENT_HPP
+#define TAO_JSON_INTERNAL_URI_FRAGMENT_HPP
+
+#include <stdexcept>
+#include <string_view>
+
+#include "../pointer.hpp"
+
+namespace tao::json::internal
+{
+   // clang-format off
+   const bool allowed_uri_fragment_characters[] = {
+      false, false, false, false, false, false, false, false, // 0
+      false, false, false, false, false, false, false, false,
+      false, false, false, false, false, false, false, false, // 16
+      false, false, false, false, false, false, false, false,
+      false, true,  false, false, true,  false, true,  true,  // 32
+      true,  true,  true,  true,  true,  true,  true,  true,
+      true,  true,  true,  true,  true,  true,  true,  true,  // 48
+      true,  true,  true,  true,  false, true,  false, true,
+      true,  true,  true,  true,  true,  true,  true,  true,  // 64
+      true,  true,  true,  true,  true,  true,  true,  true,
+      true,  true,  true,  true,  true,  true,  true,  true,  // 80
+      true,  true,  true,  false, false, false, false, true,
+      false, true,  true,  true,  true,  true,  true,  true,  // 96
+      true,  true,  true,  true,  true,  true,  true,  true,
+      true,  true,  true,  true,  true,  true,  true,  true,  // 112
+      true,  true,  true,  false, false, false, true,  false,
+      false, false, false, false, false, false, false, false, // 128
+      false, false, false, false, false, false, false, false,
+      false, false, false, false, false, false, false, false,
+      false, false, false, false, false, false, false, false,
+      false, false, false, false, false, false, false, false,
+      false, false, false, false, false, false, false, false,
+      false, false, false, false, false, false, false, false,
+      false, false, false, false, false, false, false, false,
+      false, false, false, false, false, false, false, false,
+      false, false, false, false, false, false, false, false,
+      false, false, false, false, false, false, false, false,
+      false, false, false, false, false, false, false, false,
+      false, false, false, false, false, false, false, false,
+      false, false, false, false, false, false, false, false,
+      false, false, false, false, false, false, false, false,
+      false, false, false, false, false, false, false, false
+   };
+   // clang-format on
+
+   [[nodiscard]] inline char xdigit_value( const char c )
+   {
+      // clang-format off
+      switch ( c ) {
+      case '0': return 0;
+      case '1': return 1;
+      case '2': return 2;
+      case '3': return 3;
+      case '4': return 4;
+      case '5': return 5;
+      case '6': return 6;
+      case '7': return 7;
+      case '8': return 8;
+      case '9': return 9;
+      case 'a': case 'A': return 10;
+      case 'b': case 'B': return 11;
+      case 'c': case 'C': return 12;
+      case 'd': case 'D': return 13;
+      case 'e': case 'E': return 14;
+      case 'f': case 'F': return 15;
+      default:
+         throw std::invalid_argument( "invalid URI Fragment escape sequence, '%' must be followed by two hexadecimal digits" );
+      }
+      // clang-format on
+   }
+
+   [[nodiscard]] inline pointer uri_fragment_to_pointer( const std::string_view v )
+   {
+      pointer result;
+      if( v.empty() || v[ 0 ] != '#' ) {
+         throw std::invalid_argument( "invalid URI Fragment value, must begin with '#'" );
+      }
+      if( v.size() > 1 ) {
+         const char* p = v.data() + 1;
+         const char* const e = v.data() + v.size();
+         if( *p++ != '/' ) {
+            throw std::invalid_argument( "invalid JSON Pointer value, must be empty or begin with '/'" );
+         }
+         std::string token;
+         while( p != e ) {
+            const char c = *p++;
+            switch( c ) {
+                  // clang-format off
+            case '!': case '$': case '&': case '\'': case '(': case ')': case '*': case '+': case ',': case '-': case '.':
+            case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
+            case ':': case ';': case '=': case '?': case '@':
+            case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': case 'H': case 'I': case 'J': case 'K': case 'L': case 'M':
+            case 'N': case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z':
+            case '_':
+            case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': case 'm':
+            case 'n': case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u': case 'v': case 'w': case 'x': case 'y': case 'z':
+                  // clang-format on
+                  token += c;
+                  continue;
+
+               case '%':
+                  if( p != e ) {
+                     const char h1 = xdigit_value( *p++ );
+                     if( p != e ) {
+                        const char h2 = xdigit_value( *p++ );
+                        token += static_cast< char >( h1 * 16 + h2 );
+                        continue;
+                     }
+                  }
+                  throw std::invalid_argument( "invalid URI Fragment escape sequence, '%' must be followed by two hexadecimal digits" );
+
+               case '~':
+                  if( p != e ) {
+                     switch( *p++ ) {
+                        case '0':
+                           token += '~';
+                           continue;
+                        case '1':
+                           token += '/';
+                           continue;
+                     }
+                  }
+                  throw std::invalid_argument( "invalid JSON Pointer escape sequence, '~' must be followed by '0' or '1'" );
+
+               case '/':
+                  result += std::move( token );
+                  token.clear();
+                  continue;
+
+               default:
+                  throw std::invalid_argument( "invalid URI Fragment character" );
+            }
+         }
+         result += std::move( token );
+      }
+      return result;
+   }
+
+   [[nodiscard]] inline std::string tokens_to_uri_fragment( std::vector< token >::const_iterator it, const std::vector< token >::const_iterator& end )
+   {
+      static const char* hex = "0123456789ABCDEF";
+
+      std::string result = "#";
+      while( it != end ) {
+         result += '/';
+         for( const unsigned char c : it->key() ) {
+            switch( c ) {
+               case '~':
+                  result += "~0";
+                  break;
+               case '/':
+                  result += "~1";
+                  break;
+               default:
+                  if( allowed_uri_fragment_characters[ c ] ) {
+                     result += c;
+                  }
+                  else {
+                     result += '%';
+                     result += hex[ c >> 4 ];
+                     result += hex[ c & 15 ];
+                  }
+            }
+         }
+         ++it;
+      }
+      return result;
+   }
+
+   [[nodiscard]] inline std::string to_uri_fragment( const pointer& p )
+   {
+      return tokens_to_uri_fragment( p.begin(), p.end() );
+   }
+
+}  // namespace tao::json::internal
+
+#endif