{

if (!_unescaped)

{

if (is_type<block_quote_content_lines>())

{

// Trim leading and trailing empty lines

const auto isNonEmptyLine = [](const std::unique_ptr<ast_node>& child) noexcept {

return child->is_type<block_quote_line>();

};

const auto itrEndRev = std::make_reverse_iterator(

std::find_if(children.cbegin(), children.cend(), isNonEmptyLine));

const auto itrRev = std::find_if(children.crbegin(), itrEndRev, isNonEmptyLine);

std::vector<std::optional<std::pair<std::string_view, std::string_view>>> lines(

std::distance(itrRev, itrEndRev));

std::transform(itrRev,

itrEndRev,

lines.rbegin(),

[](const std::unique_ptr<ast_node>& child) noexcept {

return (child->is_type<block_quote_line>() && !child->children.empty()

&& child->children.front()->is_type<block_quote_empty_line>()

&& child->children.back()->is_type<block_quote_line_content>())

? std::make_optional(std::make_pair(child->children.front()->string_view(),

child->children.back()->unescaped_view()))

: std::nullopt;

});

// Calculate the common indent

const auto commonIndent = std::accumulate(lines.cbegin(),

lines.cend(),

std::optional<size_t> {},

[](auto value, const auto& line) noexcept {

if (line)

{

const auto indent = line->first.size();

if (!value || indent < *value)

{

value = indent;

}

}

return value;

});

const auto trimIndent = commonIndent ? *commonIndent : 0;

std::string joined;

if (!lines.empty())

{

joined.reserve(std::accumulate(lines.cbegin(),

lines.cend(),

size_t {},

[trimIndent](auto value, const auto& line) noexcept {

if (line)

{

value += line->first.size() - trimIndent;

value += line->second.size();

}

return value;

})

+ lines.size() - 1);

bool firstLine = true;

for (const auto& line : lines)

{

if (!firstLine)

{

joined.append(1, '\n');

}

if (line)

{

joined.append(line->first.substr(trimIndent));

joined.append(line->second);

}

firstLine = false;

}

}

_unescaped = std::make_unique<unescaped_t>(std::move(joined));

}

else if (children.size() > 1)

{

std::string joined;

joined.reserve(std::accumulate(children.cbegin(),

children.cend(),

size_t(0),

[](size_t total, const std::unique_ptr<ast_node>& child) {

return total + child->string_view().size();

}));

for (const auto& child : children)

{

joined.append(child->string_view());

}

_unescaped = std::make_unique<unescaped_t>(std::move(joined));

}

else if (!children.empty())

{

_unescaped = std::make_unique<unescaped_t>(children.front()->string_view());

}

else if (has_content() && is_type<escaped_unicode>())

{

const auto content = string_view();

memory_input<> in(content.data(), content.size(), "escaped unicode");

std::string utf8;

utf8.reserve((content.size() + 1) / 2);

unescape::unescape_j::apply(in, utf8);

_unescaped = std::make_unique<unescaped_t>(std::move(utf8));

}

else

{

_unescaped = std::make_unique<unescaped_t>(std::string_view {});

}

}

return std::visit(

[](const auto& value) noexcept {

return std::string_view { value };

},

*_unescaped);

{

basic_node_t::remove_content();

_unescaped.reset();

{

if (n->has_content())

{

const char ch = n->string_view().front();

switch (ch)

{

case '"':

n->unescaped_view("\""sv);

return;

case '\\':

n->unescaped_view("\\"sv);

return;

case '/':

n->unescaped_view("/"sv);

return;

case 'b':

n->unescaped_view("\b"sv);

return;

case 'f':

n->unescaped_view("\f"sv);

return;

case 'n':

n->unescaped_view("\n"sv);

return;

case 'r':

n->unescaped_view("\r"sv);

return;

case 't':

n->unescaped_view("\t"sv);

return;

default:

break;

}

}

throw parse_error("invalid escaped character sequence", n->begin());

{

explicit depth_guard(size_t & depth) noexcept

: _depth(depth)

{

++_depth;

}

~depth_guard()

{

--_depth;

}

depth_guard(depth_guard &&) noexcept = delete;

depth_guard(const depth_guard&) = delete;

depth_guard& operator=(depth_guard&&) noexcept = delete;

depth_guard& operator=(const depth_guard&) = delete;

size_t& _depth;

{

depth_guard guard(in.selectionSetDepth);

if (in.selectionSetDepth > in.depthLimit())

{

std::ostringstream oss;

oss << "Exceeded nested depth limit: " << in.depthLimit()

<< " for https://spec.graphql.org/October2021/#SelectionSet";

throw parse_error(oss.str(), in);

}

return tao::graphqlpeg::template match<Rule, A, M, Action, Control>(in, st...);

{

static const char* error_message;

template <typename Input, typename... State>

[[noreturn]] static void raise(const Input& in, State&&...)

{

throw parse_error(error_message, in);

}

{

template <typename Rule, bool, bool>

struct state_handler;

template <typename Rule>

using type = state_handler<Rule, parse_tree::internal::is_selected_node<Rule, Selector>,

parse_tree::internal::is_leaf<8, typename Rule::subs_t, Selector>>;

{

auto n = std::move(state.back());

state.pop_back();

for (auto& c : n->children)

{

state.back()->children.emplace_back(std::move(c));

}

{

state.emplace_back();

state.back()->template start<Rule>(in);

{

auto n = std::move(state.back());

state.pop_back();

n->template success<Rule>(in);

parse_tree::internal::transform<Selector<Rule>>(in, n);

if (n)

{

state.back()->children.emplace_back(std::move(n));

}

{

internal::ast_state state;

if (!tao::graphqlpeg::parse<Rule, Action, internal::make_control<Selector>::template type>(

std::forward<ParseInput>(in),

state))

{

return nullptr;

}

if (state.stack.size() != 1)

{

throw std::logic_error("Unexpected error parsing GraphQL");

}

return std::move(state.back());

{

template <typename... Args>

explicit depth_limit_input(size_t depthLimit, Args && ... args) noexcept

: ParseInput(std::forward<Args>(args)...)

, _depthLimit(depthLimit)

{

}

size_t depthLimit() const noexcept

{

return _depthLimit;

}

size_t selectionSetDepth = 0;

const size_t _depthLimit;