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

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

@@ -1,63 +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_UINT64_HPP
-#define TAO_JSON_PEGTL_CONTRIB_UINT64_HPP
-
-#include "../config.hpp"
-#include "../internal/result_on_found.hpp"
-#include "../internal/rules.hpp"
-
-#include "internal/peek_mask_uint.hpp"
-#include "internal/peek_uint.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE
-{
-   namespace uint64_be
-   {
-      // clang-format off
-      struct any : internal::any< internal::peek_uint64_be > {};
-
-      template< std::uint64_t... Cs > struct not_one : internal::one< internal::result_on_found::failure, internal::peek_uint64_be, Cs... > {};
-      template< std::uint64_t Lo, std::uint64_t Hi > struct not_range : internal::range< internal::result_on_found::failure, internal::peek_uint64_be, Lo, Hi > {};
-      template< std::uint64_t... Cs > struct one : internal::one< internal::result_on_found::success, internal::peek_uint64_be, Cs... > {};
-      template< std::uint64_t Lo, std::uint64_t Hi > struct range : internal::range< internal::result_on_found::success, internal::peek_uint64_be, Lo, Hi > {};
-      template< std::uint64_t... Cs > struct ranges : internal::ranges< internal::peek_uint64_be, Cs... > {};
-      template< std::uint64_t... Cs > struct string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_uint64_be, Cs >... > {};
-
-
-      template< std::uint64_t M, std::uint64_t... Cs > struct mask_not_one : internal::one< internal::result_on_found::failure, internal::peek_mask_uint64_be< M >, Cs... > {};
-      template< std::uint64_t M, std::uint64_t Lo, std::uint64_t Hi > struct mask_not_range : internal::range< internal::result_on_found::failure, internal::peek_mask_uint64_be< M >, Lo, Hi > {};
-      template< std::uint64_t M, std::uint64_t... Cs > struct mask_one : internal::one< internal::result_on_found::success, internal::peek_mask_uint64_be< M >, Cs... > {};
-      template< std::uint64_t M, std::uint64_t Lo, std::uint64_t Hi > struct mask_range : internal::range< internal::result_on_found::success, internal::peek_mask_uint64_be< M >, Lo, Hi > {};
-      template< std::uint64_t M, std::uint64_t... Cs > struct mask_ranges : internal::ranges< internal::peek_mask_uint64_be< M >, Cs... > {};
-      template< std::uint64_t M, std::uint64_t... Cs > struct mask_string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_mask_uint64_be< M >, Cs >... > {};
-      // clang-format on
-
-   }  // namespace uint64_be
-
-   namespace uint64_le
-   {
-      // clang-format off
-      struct any : internal::any< internal::peek_uint64_le > {};
-
-      template< std::uint64_t... Cs > struct not_one : internal::one< internal::result_on_found::failure, internal::peek_uint64_le, Cs... > {};
-      template< std::uint64_t Lo, std::uint64_t Hi > struct not_range : internal::range< internal::result_on_found::failure, internal::peek_uint64_le, Lo, Hi > {};
-      template< std::uint64_t... Cs > struct one : internal::one< internal::result_on_found::success, internal::peek_uint64_le, Cs... > {};
-      template< std::uint64_t Lo, std::uint64_t Hi > struct range : internal::range< internal::result_on_found::success, internal::peek_uint64_le, Lo, Hi > {};
-      template< std::uint64_t... Cs > struct ranges : internal::ranges< internal::peek_uint64_le, Cs... > {};
-      template< std::uint64_t... Cs > struct string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_uint64_le, Cs >... > {};
-
-      template< std::uint64_t M, std::uint64_t... Cs > struct mask_not_one : internal::one< internal::result_on_found::failure, internal::peek_mask_uint64_le< M >, Cs... > {};
-      template< std::uint64_t M, std::uint64_t Lo, std::uint64_t Hi > struct mask_not_range : internal::range< internal::result_on_found::failure, internal::peek_mask_uint64_le< M >, Lo, Hi > {};
-      template< std::uint64_t M, std::uint64_t... Cs > struct mask_one : internal::one< internal::result_on_found::success, internal::peek_mask_uint64_le< M >, Cs... > {};
-      template< std::uint64_t M, std::uint64_t Lo, std::uint64_t Hi > struct mask_range : internal::range< internal::result_on_found::success, internal::peek_mask_uint64_le< M >, Lo, Hi > {};
-      template< std::uint64_t M, std::uint64_t... Cs > struct mask_ranges : internal::ranges< internal::peek_mask_uint64_le< M >, Cs... > {};
-      template< std::uint64_t M, std::uint64_t... Cs > struct mask_string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_mask_uint64_le< M >, Cs >... > {};
-      // clang-format on
-
-   }  // namespace uint64_le
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE
-
-#endif

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

@@ -1,36 +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_UINT8_HPP
-#define TAO_JSON_PEGTL_CONTRIB_UINT8_HPP
-
-#include "../config.hpp"
-#include "../internal/result_on_found.hpp"
-#include "../internal/rules.hpp"
-
-#include "internal/peek_mask_uint8.hpp"
-#include "internal/peek_uint8.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE::uint8
-{
-   // clang-format off
-   struct any : internal::any< internal::peek_uint8 > {};
-
-   template< std::uint8_t... Cs > struct not_one : internal::one< internal::result_on_found::failure, internal::peek_uint8, Cs... > {};
-   template< std::uint8_t Lo, std::uint8_t Hi > struct not_range : internal::range< internal::result_on_found::failure, internal::peek_uint8, Lo, Hi > {};
-   template< std::uint8_t... Cs > struct one : internal::one< internal::result_on_found::success, internal::peek_uint8, Cs... > {};
-   template< std::uint8_t Lo, std::uint8_t Hi > struct range : internal::range< internal::result_on_found::success, internal::peek_uint8, Lo, Hi > {};
-   template< std::uint8_t... Cs > struct ranges : internal::ranges< internal::peek_uint8, Cs... > {};
-   template< std::uint8_t... Cs > struct string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_uint8, Cs >... > {};
-
-   template< std::uint8_t M, std::uint8_t... Cs > struct mask_not_one : internal::one< internal::result_on_found::failure, internal::peek_mask_uint8< M >, Cs... > {};
-   template< std::uint8_t M, std::uint8_t Lo, std::uint8_t Hi > struct mask_not_range : internal::range< internal::result_on_found::failure, internal::peek_mask_uint8< M >, Lo, Hi > {};
-   template< std::uint8_t M, std::uint8_t... Cs > struct mask_one : internal::one< internal::result_on_found::success, internal::peek_mask_uint8< M >, Cs... > {};
-   template< std::uint8_t M, std::uint8_t Lo, std::uint8_t Hi > struct mask_range : internal::range< internal::result_on_found::success, internal::peek_mask_uint8< M >, Lo, Hi > {};
-   template< std::uint8_t M, std::uint8_t... Cs > struct mask_ranges : internal::ranges< internal::peek_mask_uint8< M >, Cs... > {};
-   template< std::uint8_t M, std::uint8_t... Cs > struct mask_string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_mask_uint8< M >, Cs >... > {};
-   // clang-format on
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE::uint8
-
-#endif

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

@@ -1,199 +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_UNESCAPE_HPP
-#define TAO_JSON_PEGTL_CONTRIB_UNESCAPE_HPP
-
-#include <cassert>
-#include <string>
-
-#include "../ascii.hpp"
-#include "../config.hpp"
-#include "../parse_error.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE::unescape
-{
-   // Utility functions for the unescape actions.
-
-   [[nodiscard]] inline bool utf8_append_utf32( std::string& string, const unsigned utf32 )
-   {
-      if( utf32 <= 0x7f ) {
-         string += char( utf32 & 0xff );
-         return true;
-      }
-      if( utf32 <= 0x7ff ) {
-         char tmp[] = { char( ( ( utf32 & 0x7c0 ) >> 6 ) | 0xc0 ),
-                        char( ( ( utf32 & 0x03f ) ) | 0x80 ) };
-         string.append( tmp, sizeof( tmp ) );
-         return true;
-      }
-      if( utf32 <= 0xffff ) {
-         if( utf32 >= 0xd800 && utf32 <= 0xdfff ) {
-            // nope, this is a UTF-16 surrogate
-            return false;
-         }
-         char tmp[] = { char( ( ( utf32 & 0xf000 ) >> 12 ) | 0xe0 ),
-                        char( ( ( utf32 & 0x0fc0 ) >> 6 ) | 0x80 ),
-                        char( ( ( utf32 & 0x003f ) ) | 0x80 ) };
-         string.append( tmp, sizeof( tmp ) );
-         return true;
-      }
-      if( utf32 <= 0x10ffff ) {
-         char tmp[] = { char( ( ( utf32 & 0x1c0000 ) >> 18 ) | 0xf0 ),
-                        char( ( ( utf32 & 0x03f000 ) >> 12 ) | 0x80 ),
-                        char( ( ( utf32 & 0x000fc0 ) >> 6 ) | 0x80 ),
-                        char( ( ( utf32 & 0x00003f ) ) | 0x80 ) };
-         string.append( tmp, sizeof( tmp ) );
-         return true;
-      }
-      return false;
-   }
-
-   // This function MUST only be called for characters matching TAO_JSON_PEGTL_NAMESPACE::ascii::xdigit!
-   template< typename I >
-   [[nodiscard]] I unhex_char( const char c )
-   {
-      switch( c ) {
-         case '0':
-         case '1':
-         case '2':
-         case '3':
-         case '4':
-         case '5':
-         case '6':
-         case '7':
-         case '8':
-         case '9':
-            return I( c - '0' );
-         case 'a':
-         case 'b':
-         case 'c':
-         case 'd':
-         case 'e':
-         case 'f':
-            return I( c - 'a' + 10 );
-         case 'A':
-         case 'B':
-         case 'C':
-         case 'D':
-         case 'E':
-         case 'F':
-            return I( c - 'A' + 10 );
-         default:                                                      // LCOV_EXCL_LINE
-            throw std::runtime_error( "invalid character in unhex" );  // LCOV_EXCL_LINE
-      }
-   }
-
-   template< typename I >
-   [[nodiscard]] I unhex_string( const char* begin, const char* end )
-   {
-      I r = 0;
-      while( begin != end ) {
-         r <<= 4;
-         r += unhex_char< I >( *begin++ );
-      }
-      return r;
-   }
-
-   // Actions for common unescape situations.
-
-   struct append_all
-   {
-      template< typename ActionInput >
-      static void apply( const ActionInput& in, std::string& s )
-      {
-         s.append( in.begin(), in.size() );
-      }
-   };
-
-   // This action MUST be called for a character matching T which MUST be TAO_JSON_PEGTL_NAMESPACE::one< ... >.
-   template< typename T, char... Rs >
-   struct unescape_c
-   {
-      template< typename ActionInput >
-      static void apply( const ActionInput& in, std::string& s )
-      {
-         assert( in.size() == 1 );
-         s += apply_one( in, static_cast< const T* >( nullptr ) );
-      }
-
-      template< typename ActionInput, char... Qs >
-      [[nodiscard]] static char apply_one( const ActionInput& in, const one< Qs... >* /*unused*/ )
-      {
-         static_assert( sizeof...( Qs ) == sizeof...( Rs ), "size mismatch between escaped characters and their mappings" );
-         return apply_two( in, { Qs... }, { Rs... } );
-      }
-
-      template< typename ActionInput >
-      [[nodiscard]] static char apply_two( const ActionInput& in, const std::initializer_list< char >& q, const std::initializer_list< char >& r )
-      {
-         const char c = *in.begin();
-         for( std::size_t i = 0; i < q.size(); ++i ) {
-            if( *( q.begin() + i ) == c ) {
-               return *( r.begin() + i );
-            }
-         }
-         throw parse_error( "invalid character in unescape", in );  // LCOV_EXCL_LINE
-      }
-   };
-
-   // See src/example/pegtl/unescape.cpp for why the following two actions
-   // skip the first input character. They also MUST be called
-   // with non-empty matched inputs!
-
-   struct unescape_u
-   {
-      template< typename ActionInput >
-      static void apply( const ActionInput& in, std::string& s )
-      {
-         assert( !in.empty() );  // First character MUST be present, usually 'u' or 'U'.
-         if( !utf8_append_utf32( s, unhex_string< unsigned >( in.begin() + 1, in.end() ) ) ) {
-            throw parse_error( "invalid escaped unicode code point", in );
-         }
-      }
-   };
-
-   struct unescape_x
-   {
-      template< typename ActionInput >
-      static void apply( const ActionInput& in, std::string& s )
-      {
-         assert( !in.empty() );  // First character MUST be present, usually 'x'.
-         s += unhex_string< char >( in.begin() + 1, in.end() );
-      }
-   };
-
-   // The unescape_j action is similar to unescape_u, however unlike
-   // unescape_u it
-   // (a) assumes exactly 4 hexdigits per escape sequence,
-   // (b) accepts multiple consecutive escaped 16-bit values.
-   // When applied to more than one escape sequence, unescape_j
-   // translates UTF-16 surrogate pairs in the input into a single
-   // UTF-8 sequence in s, as required for JSON by RFC 8259.
-
-   struct unescape_j
-   {
-      template< typename ActionInput >
-      static void apply( const ActionInput& in, std::string& s )
-      {
-         assert( ( ( in.size() + 1 ) % 6 ) == 0 );  // Expects multiple "\\u1234", starting with the first "u".
-         for( const char* b = in.begin() + 1; b < in.end(); b += 6 ) {
-            const auto c = unhex_string< unsigned >( b, b + 4 );
-            if( ( 0xd800 <= c ) && ( c <= 0xdbff ) && ( b + 6 < in.end() ) ) {
-               const auto d = unhex_string< unsigned >( b + 6, b + 10 );
-               if( ( 0xdc00 <= d ) && ( d <= 0xdfff ) ) {
-                  b += 6;
-                  (void)utf8_append_utf32( s, ( ( ( c & 0x03ff ) << 10 ) | ( d & 0x03ff ) ) + 0x10000 );
-                  continue;
-               }
-            }
-            if( !utf8_append_utf32( s, c ) ) {
-               throw parse_error( "invalid escaped unicode code point", in );
-            }
-         }
-      }
-   };
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE::unescape
-
-#endif

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

@@ -1,106 +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_URI_HPP
-#define TAO_JSON_PEGTL_CONTRIB_URI_HPP
-
-#include <cstdint>
-
-#include "../ascii.hpp"
-#include "../config.hpp"
-#include "../rules.hpp"
-#include "../utf8.hpp"
-
-#include "abnf.hpp"
-#include "integer.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE::uri
-{
-   // URI grammar according to RFC 3986.
-
-   // This grammar is a direct PEG translation of the original URI grammar.
-   // It should be considered experimental -- in case of any issues, in particular
-   // missing rules for attached actions, please contact the developers.
-
-   // Note that this grammar has multiple top-level rules.
-
-   using dot = one< '.' >;
-   using colon = one< ':' >;
-
-   // clang-format off
-   struct dec_octet : maximum_rule< std::uint8_t > {};
-
-   struct IPv4address : seq< dec_octet, dot, dec_octet, dot, dec_octet, dot, dec_octet > {};
-
-   struct h16 : rep_min_max< 1, 4, abnf::HEXDIG > {};
-   struct ls32 : sor< seq< h16, colon, h16 >, IPv4address > {};
-
-   struct dcolon : two< ':' > {};
-
-   struct IPv6address : sor< seq<                                               rep< 6, h16, colon >, ls32 >,
-                             seq<                                       dcolon, rep< 5, h16, colon >, ls32 >,
-                             seq< opt< h16                           >, dcolon, rep< 4, h16, colon >, ls32 >,
-                             seq< opt< h16,     opt<    colon, h16 > >, dcolon, rep< 3, h16, colon >, ls32 >,
-                             seq< opt< h16, rep_opt< 2, colon, h16 > >, dcolon, rep< 2, h16, colon >, ls32 >,
-                             seq< opt< h16, rep_opt< 3, colon, h16 > >, dcolon,         h16, colon,   ls32 >,
-                             seq< opt< h16, rep_opt< 4, colon, h16 > >, dcolon,                       ls32 >,
-                             seq< opt< h16, rep_opt< 5, colon, h16 > >, dcolon,                       h16  >,
-                             seq< opt< h16, rep_opt< 6, colon, h16 > >, dcolon                             > > {};
-
-   struct gen_delims : one< ':', '/', '?', '#', '[', ']', '@' > {};
-   struct sub_delims : one< '!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=' > {};
-
-   struct unreserved : sor< abnf::ALPHA, abnf::DIGIT, one< '-', '.', '_', '~' > > {};
-   struct reserved : sor< gen_delims, sub_delims > {};
-
-   struct IPvFuture : if_must< one< 'v', 'V' >, plus< abnf::HEXDIG >, dot, plus< sor< unreserved, sub_delims, colon > > > {};
-
-   struct IP_literal : if_must< one< '[' >, sor< IPvFuture, IPv6address >, one< ']' > > {};
-
-   struct pct_encoded : if_must< one< '%' >, abnf::HEXDIG, abnf::HEXDIG > {};
-   struct pchar : sor< unreserved, pct_encoded, sub_delims, one< ':', '@' > > {};
-
-   struct query : star< sor< pchar, one< '/', '?' > > > {};
-   struct fragment : star< sor< pchar, one< '/', '?' > > > {};
-
-   struct segment : star< pchar > {};
-   struct segment_nz : plus< pchar > {};
-   struct segment_nz_nc : plus< sor< unreserved, pct_encoded, sub_delims, one< '@' > > > {}; // non-zero-length segment without any colon ":"
-
-   struct path_abempty : star< one< '/' >, segment > {};
-   struct path_absolute : seq< one< '/' >, opt< segment_nz, star< one< '/' >, segment > > > {};
-   struct path_noscheme : seq< segment_nz_nc, star< one< '/' >, segment > > {};
-   struct path_rootless : seq< segment_nz, star< one< '/' >, segment > > {};
-   struct path_empty : success {};
-
-   struct path : sor< path_noscheme,     // begins with a non-colon segment
-                      path_rootless,     // begins with a segment
-                      path_absolute,     // begins with "/" but not "//"
-                      path_abempty > {}; // begins with "/" or is empty
-
-   struct reg_name : star< sor< unreserved, pct_encoded, sub_delims > > {};
-
-   struct port : star< abnf::DIGIT > {};
-   struct host : sor< IP_literal, IPv4address, reg_name > {};
-   struct userinfo : star< sor< unreserved, pct_encoded, sub_delims, colon > > {};
-   struct opt_userinfo : opt< userinfo, one< '@' > > {};
-   struct authority : seq< opt_userinfo, host, opt< colon, port > > {};
-
-   struct scheme : seq< abnf::ALPHA, star< sor< abnf::ALPHA, abnf::DIGIT, one< '+', '-', '.' > > > > {};
-
-   using dslash = two< '/' >;
-   using opt_query = opt_must< one< '?' >, query >;
-   using opt_fragment = opt_must< one< '#' >, fragment >;
-
-   struct hier_part : sor< if_must< dslash, authority, path_abempty >, path_rootless, path_absolute, path_empty > {};
-   struct relative_part : sor< if_must< dslash, authority, path_abempty >, path_noscheme, path_absolute, path_empty > {};
-   struct relative_ref : seq< relative_part, opt_query, opt_fragment > {};
-
-   struct URI : seq< scheme, one< ':' >, hier_part, opt_query, opt_fragment > {};
-   struct URI_reference : sor< URI, relative_ref > {};
-   struct absolute_URI : seq< scheme, one< ':' >, hier_part, opt_query > {};
-   // clang-format on
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE::uri
-
-#endif

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

@@ -1,49 +0,0 @@
-// Copyright (c) 2015-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
-
-#ifndef TAO_JSON_PEGTL_CONTRIB_UTF16_HPP
-#define TAO_JSON_PEGTL_CONTRIB_UTF16_HPP
-
-#include "../config.hpp"
-#include "../internal/result_on_found.hpp"
-#include "../internal/rules.hpp"
-
-#include "internal/peek_utf16.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE
-{
-   namespace utf16_be
-   {
-      // clang-format off
-      struct any : internal::any< internal::peek_utf16_be > {};
-      struct bom : internal::one< internal::result_on_found::success, internal::peek_utf16_be, 0xfeff > {};
-      template< char32_t... Cs > struct not_one : internal::one< internal::result_on_found::failure, internal::peek_utf16_be, Cs... > {};
-      template< char32_t Lo, char32_t Hi > struct not_range : internal::range< internal::result_on_found::failure, internal::peek_utf16_be, Lo, Hi > {};
-      template< char32_t... Cs > struct one : internal::one< internal::result_on_found::success, internal::peek_utf16_be, Cs... > {};
-      template< char32_t Lo, char32_t Hi > struct range : internal::range< internal::result_on_found::success, internal::peek_utf16_be, Lo, Hi > {};
-      template< char32_t... Cs > struct ranges : internal::ranges< internal::peek_utf16_be, Cs... > {};
-      template< char32_t... Cs > struct string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_utf16_be, Cs >... > {};
-      // clang-format on
-
-   }  // namespace utf16_be
-
-   namespace utf16_le
-   {
-      // clang-format off
-      struct any : internal::any< internal::peek_utf16_le > {};
-      struct bom : internal::one< internal::result_on_found::success, internal::peek_utf16_le, 0xfeff > {};
-      template< char32_t... Cs > struct not_one : internal::one< internal::result_on_found::failure, internal::peek_utf16_le, Cs... > {};
-      template< char32_t Lo, char32_t Hi > struct not_range : internal::range< internal::result_on_found::failure, internal::peek_utf16_le, Lo, Hi > {};
-      template< char32_t... Cs > struct one : internal::one< internal::result_on_found::success, internal::peek_utf16_le, Cs... > {};
-      template< char32_t Lo, char32_t Hi > struct range : internal::range< internal::result_on_found::success, internal::peek_utf16_le, Lo, Hi > {};
-      template< char32_t... Cs > struct ranges : internal::ranges< internal::peek_utf16_le, Cs... > {};
-      template< char32_t... Cs > struct string : internal::seq< internal::one< internal::result_on_found::success, internal::peek_utf16_le, Cs >... > {};
-      // clang-format on
-
-   }  // namespace utf16_le
-
-   namespace utf16 = TAO_JSON_PEGTL_NATIVE_UTF16;
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE
-
-#endif