couchbase 3.2.0 → 3.3.0

data/ext/third_party/json/include/tao/json/jaxn/internal/grammar.hpp

@@ -1,375 +0,0 @@
-// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/json/
-
-#ifndef TAO_JSON_JAXN_INTERNAL_GRAMMAR_HPP
-#define TAO_JSON_JAXN_INTERNAL_GRAMMAR_HPP
-
-#include <cctype>
-
-#include "../../external/pegtl.hpp"
-#include "../../external/pegtl/contrib/abnf.hpp"
-
-namespace tao::json::jaxn::internal
-{
-   // clang-format off
-   namespace rules
-   {
-      using namespace pegtl;
-
-      struct line_comment_char : sor< one< '\t' >, utf8::ranges< 0x20, 0x7E, 0x80, 0x10FFFF > > {};
-      struct line_comment : seq< one< '/' >, until< eolf, must< line_comment_char > > > {};
-
-      struct block_comment_char : sor< one< '\t' >, utf8::ranges< 0x20, 0x7E, 0x80, 0x10FFFF >, eol > {};
-      struct end_block_comment : until< pegtl::string< '*', '/' >, must< block_comment_char > > {};
-      struct block_comment : if_must< one< '*' >, end_block_comment > {};
-
-      struct comment : sor< line_comment, block_comment > {};
-
-      struct ws : sor< one< ' ', '\t', '\n', '\r' >, seq< one< '#' >, until< eolf > >, if_must< one< '/' >, comment > > {};
-
-      template< typename R, typename P = ws >
-      using padr = pegtl::internal::seq< R, pegtl::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 element_separator : padr< one< ',' > > {};
-      struct value_concat : pad< one< '+' >, ws > {};
-
-      struct kw_false : pegtl::string< 'f', 'a', 'l', 's', 'e' > {};
-      struct kw_null : pegtl::string< 'n', 'u', 'l', 'l' > {};
-      struct kw_true : pegtl::string< 't', 'r', 'u', 'e' > {};
-
-      struct kw_nan : pegtl::string< 'N', 'a', 'N' > {};
-
-      template< bool NEG >
-      struct kw_infinity : pegtl::string< 'I', 'n', 'f', 'i', 'n', 'i', 't', 'y' > {};
-
-      template< bool NEG >
-      struct hexnum : plus< abnf::HEXDIG > {};
-
-      struct digits : plus< abnf::DIGIT > {};
-
-      struct esign : one< '-', '+' > {};
-
-      struct edigits : digits {};
-      struct fdigits : digits {};
-      struct idigits : digits {};
-
-      struct exp : seq< one< 'e', 'E' >, opt< esign >, must< edigits > > {};
-      struct frac0 : seq< one< '.' >, opt< fdigits > > {};
-      struct frac1 : if_must< one< '.' >, fdigits > {};
-
-      template< bool NEG >
-      struct number : seq< sor< seq< idigits, opt< frac0 > >, frac1 >, opt< exp > > {};
-
-      struct xdigit : abnf::HEXDIG {};
-      struct escaped_unicode_code_point_content : seq< one< '{' >, plus< xdigit > > {};
-      struct escaped_unicode_code_point : seq< one< 'u' >, escaped_unicode_code_point_content, one< '}' > > {};
-      struct escaped_unicode : list< seq< one< 'u' >, rep< 4, xdigit > >, one< '\\' > > {};
-
-      struct escaped_char : one< '"', '\'', '\\', '/', 'b', 'f', 'n', 'r', 't', 'v', '0' > {};
-      struct escaped : sor< escaped_char, escaped_unicode_code_point, escaped_unicode > {};
-
-      template< char D >
-      struct unescaped
-      {
-         using rule_t = unescaped;
-         using subs_t = pegtl::empty_list;
-
-         template< typename Input >
-         [[nodiscard]] static bool match( Input& in )
-         {
-            bool result = false;
-            while( const auto t = pegtl::internal::peek_utf8::peek( in ) ) {
-               if( ( 0x20 <= t.data ) && ( t.data != '\\' ) && ( t.data != D ) && ( t.data != 0x7F ) ) {
-                  in.bump_in_this_line( t.size );
-                  result = true;
-               }
-               else {
-                  break;
-               }
-            }
-            return result;
-         }
-      };
-
-      template< char D >
-      struct chars : if_then_else< one< '\\' >, must< escaped >, unescaped< D > > {};
-
-      template< char D >
-      struct qstring_content : until< at< one< D > >, must< chars< D > > > {};
-
-      template< char D >
-      struct qstring : seq< one< D >, must< qstring_content< D > >, any > {};
-
-      template< char D >
-      struct mchars_non_eol
-      {
-         using rule_t = mchars_non_eol;
-         using subs_t = pegtl::empty_list;
-
-         template< typename Input >
-         [[nodiscard]] static bool match( Input& in )
-         {
-            bool result = false;
-            while( const auto t = pegtl::internal::peek_utf8::peek( in ) ) {
-               if( ( ( 0x20 <= t.data ) && ( t.data != D ) && ( t.data != 0x7F ) ) || ( t.data == '\t' ) ) {
-                  in.bump_in_this_line( t.size );
-                  result = true;
-               }
-               else {
-                  break;
-               }
-            }
-            return result;
-         }
-      };
-
-      template< char D >
-      struct mchars : sor< mchars_non_eol< D >, one< D >, eol > {};
-
-      template< char D >
-      struct mqstring_content : until< at< three< D > >, must< mchars< D > > > {};
-
-      template< char D >
-      struct mqstring : seq< three< D >, opt< eol >, must< mqstring_content< D > >, any, any, any > {};
-
-      struct string_fragment : sor< mqstring< '"' >, mqstring< '\'' >, qstring< '"' >, qstring< '\'' > > {};
-
-      struct string : list_must< string_fragment, value_concat > {};
-
-      struct binary_prefix : one< '$' > {};
-
-      struct bescaped_hexcode : seq< one< 'x' >, rep< 2, must< xdigit > > > {};
-
-      struct bescaped_char : one< '"', '\'', '\\', '/', 'b', 'f', 'n', 'r', 't', 'v', '0' > {};
-      struct bescaped : sor< bescaped_char, bescaped_hexcode > {};
-
-      template< char D >
-      struct bunescaped
-      {
-         using rule_t = bunescaped;
-         using subs_t = pegtl::empty_list;
-
-         template< typename Input >
-         [[nodiscard]] static bool match( Input& in )
-         {
-            bool result = false;
-
-            while( !in.empty() ) {
-               const auto t = in.peek_char();
-               if( ( 0x20 <= t ) && ( t <= 0x7E ) && ( t != '\\' ) && ( t != D ) ) {
-                  in.bump_in_this_line( 1 );
-                  result = true;
-                  continue;
-               }
-               return result;
-            }
-            throw pegtl::parse_error( "invalid character in binary string", in );
-         }
-      };
-
-      template< char D >
-      struct bchars : if_then_else< one< '\\' >, must< bescaped >, bunescaped< D > > {};
-
-      template< char D >
-      struct bqstring_content : until< at< one< D > >, must< bchars< D > > > {};
-
-      template< char D >
-      struct bqstring : seq< one< D >, must< bqstring_content< D > >, any > {};
-
-      struct bstring : sor< bqstring< '"' >, bqstring< '\'' > > {};
-
-      struct bbyte : rep< 2, abnf::HEXDIG > {};
-
-      struct bpart : plus< bbyte > {};
-
-      struct bdirect : list_must< bpart, one< '.' > > {};
-
-      struct binary_fragment : seq< binary_prefix, opt< sor< bstring, bdirect > > > {};
-
-      struct binary : list_must< binary_fragment, value_concat > {};
-
-      struct value;
-
-      struct array_element;
-      struct array_content : opt< list_tail< array_element, element_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 key : string {};
-
-      struct mkey : sor< key, identifier > {};
-      struct member : if_must< mkey, name_separator, value > {};
-      struct object_content : opt< list_tail< 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;
-      };
-
-      template< bool NEG >
-      struct zero : one< '0' > {};
-
-      struct sor_value
-      {
-         using rule_t = sor_value;
-         using subs_t = pegtl::type_list< string, number< false >, object, array, kw_false, kw_true, kw_null >;
-
-         template< typename Rule,
-                   apply_mode A,
-                   template< typename... > class Action,
-                   template< typename... > class Control,
-                   typename Input,
-                   typename... States >
-         [[nodiscard]] static bool match_must( Input& in, States&&... st )
-         {
-            return Control< must< Rule > >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... );
-         }
-
-         template< bool NEG,
-                   apply_mode A,
-                   rewind_mode M,
-                   template< typename... > class Action,
-                   template< typename... > class Control,
-                   typename Input,
-                   typename... States >
-         [[nodiscard]] static bool match_zero( Input& in, States&&... st )
-         {
-            if( in.size( 2 ) > 1 ) {
-               switch( in.peek_char( 1 ) ) {
-               case '.':
-               case 'e':
-               case 'E':
-                  return Control< number< NEG > >::template match< A, M, Action, Control >( in, st... );
-
-               case 'x':
-               case 'X':
-                  in.bump_in_this_line( 2 );
-                  return Control< must< hexnum< NEG > > >::template match< A, M, Action, Control >( in, st... );
-
-               case '0':
-               case '1':
-               case '2':
-               case '3':
-               case '4':
-               case '5':
-               case '6':
-               case '7':
-               case '8':
-               case '9':
-                  throw pegtl::parse_error( "invalid leading zero", in );
-               }
-            }
-            return Control< zero< NEG > >::template match< A, M, Action, Control >( in, st... );
-         }
-
-         template< bool NEG,
-                   apply_mode A,
-                   rewind_mode M,
-                   template< typename... > class Action,
-                   template< typename... > class Control,
-                   typename Input,
-                   typename... States >
-         [[nodiscard]] static bool match_number( Input& in, States&&... st )
-         {
-            switch( in.peek_char() ) {
-            case 'N':
-               return Control< must< kw_nan > >::template match< A, M, Action, Control >( in, st... );
-
-            case 'I':
-               return Control< must< kw_infinity< NEG > > >::template match< A, M, Action, Control >( in, st... );
-
-            case '0':
-               if( !match_zero< NEG, A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
-                  throw pegtl::parse_error( "incomplete number", in );
-               }
-               return true;
-
-            default:
-               return Control< number< NEG > >::template match< A, M, Action, Control >( in, st... );
-            }
-         }
-
-         template< apply_mode A,
-                   rewind_mode M,
-                   template< typename... > class Action,
-                   template< typename... > class Control,
-                   typename Input,
-                   typename... States >
-         [[nodiscard]] static bool match_impl( Input& in, States&&... st )
-         {
-            switch( in.peek_char() ) {
-            case '{': return Control< object >::template match< A, M, Action, Control >( in, st... );
-            case '[': return Control< array >::template match< A, M, Action, Control >( in, st... );
-            case 'n': return Control< kw_null >::template match< A, M, Action, Control >( in, st... );
-            case 't': return Control< kw_true >::template match< A, M, Action, Control >( in, st... );
-            case 'f': return Control< kw_false >::template match< A, M, Action, Control >( in, st... );
-
-            case '"':
-            case '\'':
-               return Control< string >::template match< A, M, Action, Control >( in, st... );
-
-            case '$':
-               return Control< binary >::template match< A, M, Action, Control >( in, st... );
-
-            case '+':
-               in.bump_in_this_line();
-               if( in.empty() || !match_number< false, A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
-                  throw pegtl::parse_error( "incomplete number", in );
-               }
-               return true;
-
-            case '-':
-               in.bump_in_this_line();
-               if( in.empty() || !match_number< true, A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
-                  throw pegtl::parse_error( "incomplete number", in );
-               }
-               return true;
-
-            default:
-               return match_number< false, A, M, Action, Control >( in, st... );
-            }
-         }
-
-         template< apply_mode A,
-                   rewind_mode M,
-                   template< typename... > class Action,
-                   template< typename... > class Control,
-                   typename Input,
-                   typename... States >
-         [[nodiscard]] static bool match( Input& in, States&&... st )
-         {
-            if( in.size( 2 ) && match_impl< A, M, Action, Control >( in, st... ) ) {
-               in.discard();
-               return true;
-            }
-            return false;
-         }
-      };
-
-      struct value : padr< sor_value > {};
-      struct array_element : value {};
-
-      struct text : seq< star< ws >, value > {};
-
-   }  // namespace rules
-
-   struct grammar : pegtl::must< rules::text, pegtl::eof > {};
-   struct embedded : pegtl::must< rules::sor_value > {};
-   // clang-format on
-
-}  // namespace tao::json::jaxn::internal
-
-#endif

data/ext/third_party/json/include/tao/json/jaxn/internal/integer.hpp

@@ -1,255 +0,0 @@
-// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/json/
-
-#ifndef TAO_JSON_JAXN_INTERNAL_INTEGER_HPP
-#define TAO_JSON_JAXN_INTERNAL_INTEGER_HPP
-
-#include <cassert>
-#include <cstdint>
-#include <cstdlib>
-
-#include <string_view>
-#include <type_traits>
-
-#include "../../external/pegtl.hpp"
-#include "../../external/pegtl/contrib/integer.hpp"
-
-#include "../../internal/parse_util.hpp"
-
-namespace tao::json::jaxn::internal::integer
-{
-   struct unsigned_rule
-      : pegtl::if_then_else< pegtl::one< '0' >, pegtl::if_then_else< pegtl::one< 'x' >, pegtl::plus< pegtl::xdigit >, pegtl::not_at< pegtl::digit > >, pegtl::plus< pegtl::digit > >
-   {
-      // Unsigned hex or dec integer, no leading zeros for dec.
-   };
-
-   struct signed_rule
-      : pegtl::seq< pegtl::opt< pegtl::one< '-', '+' > >, unsigned_rule >
-   {
-      // Signed hex or dec integer, no leading zeros for dec.
-   };
-
-   [[nodiscard]] constexpr bool is_hex_digit( const char c ) noexcept
-   {
-      // We don't use std::isxdigit() because it might
-      // return true for other values on MS platforms?
-
-      return ( ( '0' <= c ) && ( c <= '9' ) ) || ( ( 'a' <= c ) && ( c <= 'f' ) ) || ( ( 'A' <= c ) && ( c <= 'F' ) );
-   }
-
-   template< typename Integer, Integer Maximum = ( std::numeric_limits< Integer >::max )() >
-   [[nodiscard]] constexpr bool accumulate_hex_digit( Integer& result, const char xdigit ) noexcept
-   {
-      // Assumes that xdigit is an xdigit as per is_hex_digit(); returns false on overflow.
-
-      static_assert( std::is_integral_v< Integer > );
-
-      constexpr Integer cutoff = Maximum / 16;
-      constexpr Integer cutlim = Maximum % 16;
-
-      const Integer c = json::internal::hex_char_to_integer< Integer >( xdigit );
-
-      if( ( result > cutoff ) || ( ( result == cutoff ) && ( c > cutlim ) ) ) {
-         return false;
-      }
-      result *= 16;
-      result += c;
-      return true;
-   }
-
-   template< typename Integer, Integer Maximum = ( std::numeric_limits< Integer >::max )() >
-   [[nodiscard]] constexpr bool accumulate_hex_digits( Integer& result, const std::string_view input ) noexcept
-   {
-      // Assumes input is a non-empty sequence of hex-digits; returns false on overflow.
-
-      for( const auto c : input ) {
-         if( !accumulate_hex_digit< Integer, Maximum >( result, c ) ) {
-            return false;
-         }
-      }
-      return true;
-   }
-
-   template< typename Integer, Integer Maximum = ( std::numeric_limits< Integer >::max )() >
-   [[nodiscard]] constexpr bool convert_hex_positive( Integer& result, const std::string_view input ) noexcept
-   {
-      // Assumes result == 0 and that input is a non-empty sequence of hex-digits; returns false on overflow.
-
-      static_assert( std::is_integral_v< Integer > );
-      return accumulate_hex_digits< Integer, Maximum >( result, input );
-   }
-
-   template< typename Signed >
-   [[nodiscard]] constexpr bool convert_hex_negative( Signed& result, const std::string_view input ) noexcept
-   {
-      // Assumes result == 0 and that input is a non-empty sequence of hex-digits; returns false on overflow.
-
-      static_assert( std::is_signed_v< Signed > );
-      using Unsigned = std::make_unsigned_t< Signed >;
-      constexpr Unsigned maximum = static_cast< Unsigned >( ( std::numeric_limits< Signed >::max )() ) + 1;
-      Unsigned temporary = 0;
-      if( accumulate_hex_digits< Unsigned, maximum >( temporary, input ) ) {
-         result = static_cast< Signed >( ~temporary ) + 1;
-         return true;
-      }
-      return false;
-   }
-
-   template< typename Unsigned, Unsigned Maximum = ( std::numeric_limits< Unsigned >::max )() >
-   [[nodiscard]] constexpr bool convert_hex_unsigned( Unsigned& result, const std::string_view input ) noexcept
-   {
-      // Assumes result == 0 and that input is a non-empty sequence of hex-digits; returns false on overflow.
-
-      static_assert( std::is_unsigned_v< Unsigned > );
-      return accumulate_hex_digits< Unsigned, Maximum >( result, input );
-   }
-
-   template< typename Signed >
-   [[nodiscard]] constexpr bool convert_hex_signed( Signed& result, const std::string_view input ) noexcept
-   {
-      // Assumes result == 0 and that input is an optional sign followed by a "0x" and a non-empty sequence of hex-digits; returns false on overflow.
-
-      static_assert( std::is_signed_v< Signed > );
-      if( input[ 0 ] == '-' ) {
-         return convert_hex_negative< Signed >( result, std::string_view( input.data() + 3, input.size() - 3 ) );
-      }
-      const auto offset = unsigned( input[ 0 ] == '+' ) + 2;  // The "0x" prefix has length 2.
-      return convert_hex_positive< Signed >( result, std::string_view( input.data() + offset, input.size() - offset ) );
-   }
-
-   using unsigned_dec_action = pegtl::unsigned_action;
-
-   struct unsigned_hex_action
-   {
-      // Assumes that 'in' contains a non-empty sequence of ASCII hex-digits with "0x" prefix.
-
-      template< typename Input >
-      static auto apply( const Input& in, std::uint64_t& st )
-      {
-         auto sv = in.string_view();
-         sv.remove_prefix( 2 );
-         if( !convert_hex_unsigned( st, sv ) ) {
-            throw pegtl::parse_error( "unsigned hex integer overflow", in );
-         }
-      }
-   };
-
-   template< typename Rule >
-   struct unsigned_action_action
-      : pegtl::nothing< Rule >
-   {};
-
-   template<>
-   struct unsigned_action_action< pegtl::plus< pegtl::digit > >
-      : unsigned_dec_action
-   {};
-
-   template<>
-   struct unsigned_action_action< pegtl::plus< pegtl::xdigit > >
-   {
-      template< typename Input, typename Unsigned >
-      static void apply( const Input& in, Unsigned& st )
-      {
-         if( !convert_hex_unsigned( st, in.string_view() ) ) {
-            throw pegtl::parse_error( "unsigned hex integer overflow", in );
-         }
-      }
-   };
-
-   struct unsigned_rule_with_action
-   {
-      using rule_t = unsigned_rule_with_action;
-      using subs_t = pegtl::empty_list;
-
-      template< pegtl::apply_mode,
-                pegtl::rewind_mode,
-                template< typename... >
-                class Action,
-                template< typename... >
-                class Control,
-                typename Input >
-      [[nodiscard]] static auto match( Input& in, std::uint64_t& st )
-      {
-         return pegtl::parse< unsigned_rule, unsigned_action_action >( in, st );  // Throws on overflow.
-      }
-   };
-
-   using signed_dec_action = pegtl::signed_action;
-
-   struct signed_hex_action
-   {
-      // Assumes that 'in' contains a non-empty sequence of ASCII hex-digits,
-      // with optional leading sign before the "0x" prefix; when there is a
-      // sign, in.size() must be >= 4.
-
-      template< typename Input >
-      static auto apply( const Input& in, std::int64_t& st )
-      {
-         if( !convert_hex_signed( st, in.string_view() ) ) {
-            throw pegtl::parse_error( "signed hex integer overflow", in );
-         }
-      }
-   };
-
-   template< typename Rule >
-   struct signed_action_action
-      : pegtl::nothing< Rule >
-   {};
-
-   template<>
-   struct signed_action_action< pegtl::one< '-', '+' > >
-   {
-      template< typename Input, typename Signed >
-      static void apply( const Input& in, bool& negative, Signed& /*unused*/ )
-      {
-         negative = ( in.peek_char() == '-' );  // TODO: Optimise with custom rule to prevent building marker and action_input for single char?
-      }
-   };
-
-   template<>
-   struct signed_action_action< pegtl::plus< pegtl::digit > >
-   {
-      template< typename Input, typename Signed >
-      static void apply( const Input& in, const bool negative, Signed& st )
-      {
-         if( !( negative ? pegtl::internal::convert_negative< Signed >( st, in.string_view() ) : pegtl::internal::convert_positive< Signed >( st, in.string_view() ) ) ) {
-            throw pegtl::parse_error( "signed dec integer overflow", in );
-         }
-      }
-   };
-
-   template<>
-   struct signed_action_action< pegtl::plus< pegtl::xdigit > >
-   {
-      template< typename Input, typename Signed >
-      static void apply( const Input& in, const bool negative, Signed& st )
-      {
-         if( !( negative ? convert_hex_negative< Signed >( st, in.string_view() ) : convert_hex_positive< Signed >( st, in.string_view() ) ) ) {
-            throw pegtl::parse_error( "signed hex integer overflow", in );
-         }
-      }
-   };
-
-   struct signed_rule_with_action
-   {
-      using rule_t = signed_rule_with_action;
-      using subs_t = pegtl::empty_list;
-
-      template< pegtl::apply_mode,
-                pegtl::rewind_mode,
-                template< typename... >
-                class Action,
-                template< typename... >
-                class Control,
-                typename Input >
-      [[nodiscard]] static auto match( Input& in, std::int64_t& st )
-      {
-         bool negative = false;                                                         // Superfluous initialisation.
-         return pegtl::parse< signed_rule, signed_action_action >( in, negative, st );  // Throws on overflow.
-      }
-   };
-
-}  // namespace tao::json::jaxn::internal::integer
-
-#endif

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

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

data/ext/third_party/json/include/tao/json/jaxn/is_identifier.hpp

@@ -1,27 +0,0 @@
-// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/json/
-
-#ifndef TAO_JSON_JAXN_IS_IDENTIFIER_HPP
-#define TAO_JSON_JAXN_IS_IDENTIFIER_HPP
-
-#include <cctype>
-#include <string_view>
-
-namespace tao::json::jaxn
-{
-   [[nodiscard]] inline bool is_identifier( const std::string_view v ) noexcept
-   {
-      if( v.empty() || ( std::isdigit( v[ 0 ] ) != 0 ) ) {
-         return false;
-      }
-      for( const auto c : v ) {
-         if( ( std::isalnum( c ) == 0 ) && ( c != '_' ) ) {
-            return false;
-         }
-      }
-      return true;
-   }
-
-}  // namespace tao::json::jaxn
-
-#endif