kakoune

Fork of kakoune, an acceptable text editor
git clone git://git.laack.co/kakoune.git
Log | Files | Refs

selectors.cc (46379B)


      1 #include "selectors.hh"
      2 
      3 #include "buffer_utils.hh"
      4 #include "context.hh"
      5 #include "event_manager.hh"
      6 #include "flags.hh"
      7 #include "option_manager.hh"
      8 #include "option_types.hh"
      9 #include "regex.hh"
     10 #include "selection.hh"
     11 #include "string.hh"
     12 #include "unit_tests.hh"
     13 #include "utf8_iterator.hh"
     14 
     15 #include <algorithm>
     16 
     17 namespace Kakoune
     18 {
     19 
     20 using Utf8Iterator = utf8::iterator<BufferIterator>;
     21 
     22 namespace
     23 {
     24 
     25 Selection utf8_range(const BufferIterator& first, const BufferIterator& last)
     26 {
     27     return {first.coord(), last.coord()};
     28 }
     29 
     30 Selection utf8_range(const Utf8Iterator& first, const Utf8Iterator& last)
     31 {
     32     return {first.base().coord(), last.base().coord()};
     33 }
     34 
     35 ConstArrayView<Codepoint> get_extra_word_chars(const Context& context)
     36 {
     37     return context.options()["extra_word_chars"].get<Vector<Codepoint, MemoryDomain::Options>>();
     38 }
     39 
     40 }
     41 
     42 Selection keep_direction(Selection res, const Selection& ref)
     43 {
     44     if ((res.cursor() < res.anchor()) != (ref.cursor() < ref.anchor()))
     45         std::swap<BufferCoord>(res.cursor(), res.anchor());
     46     return res;
     47 }
     48 
     49 template<WordType word_type>
     50 Optional<Selection>
     51 select_to_next_word(const Context& context, const Selection& selection)
     52 {
     53     auto extra_word_chars = get_extra_word_chars(context);
     54     auto& buffer = context.buffer();
     55     Utf8Iterator begin{buffer.iterator_at(selection.cursor()), buffer};
     56     if (begin+1 == buffer.end())
     57         return {};
     58     if (categorize<word_type>(*begin, extra_word_chars) !=
     59         categorize<word_type>(*(begin+1), extra_word_chars))
     60         ++begin;
     61 
     62     if (not skip_while(begin, buffer.end(),
     63                        [](Codepoint c) { return is_eol(c); }))
     64         return {};
     65     Utf8Iterator end = begin+1;
     66 
     67     auto is_word = [&](Codepoint c) { return Kakoune::is_word<word_type>(c, extra_word_chars); };
     68     auto is_punctuation = [&](Codepoint c) { return Kakoune::is_punctuation(c, extra_word_chars); };
     69 
     70     if (is_word(*begin))
     71         skip_while(end, buffer.end(), is_word);
     72     else if (is_punctuation(*begin))
     73         skip_while(end, buffer.end(), is_punctuation);
     74 
     75     skip_while(end, buffer.end(), is_horizontal_blank);
     76 
     77     return utf8_range(begin, end-1);
     78 }
     79 template Optional<Selection> select_to_next_word<WordType::Word>(const Context&, const Selection&);
     80 template Optional<Selection> select_to_next_word<WordType::WORD>(const Context&, const Selection&);
     81 
     82 template<WordType word_type>
     83 Optional<Selection>
     84 select_to_next_word_end(const Context& context, const Selection& selection)
     85 {
     86     auto extra_word_chars = get_extra_word_chars(context);
     87     auto& buffer = context.buffer();
     88     Utf8Iterator begin{buffer.iterator_at(selection.cursor()), buffer};
     89     if (begin+1 == buffer.end())
     90         return {};
     91     if (categorize<word_type>(*begin, extra_word_chars) !=
     92         categorize<word_type>(*(begin+1), extra_word_chars))
     93         ++begin;
     94 
     95     if (not skip_while(begin, buffer.end(),
     96                        [](Codepoint c) { return is_eol(c); }))
     97         return {};
     98     Utf8Iterator end = begin;
     99     skip_while(end, buffer.end(), is_horizontal_blank);
    100 
    101     auto is_word = [&](Codepoint c) { return Kakoune::is_word<word_type>(c, extra_word_chars); };
    102     auto is_punctuation = [&](Codepoint c) { return Kakoune::is_punctuation(c, extra_word_chars); };
    103 
    104     if (is_word(*end))
    105         skip_while(end, buffer.end(), is_word);
    106     else if (is_punctuation(*end))
    107         skip_while(end, buffer.end(), is_punctuation);
    108 
    109     return utf8_range(begin, end-1);
    110 }
    111 template Optional<Selection> select_to_next_word_end<WordType::Word>(const Context&, const Selection&);
    112 template Optional<Selection> select_to_next_word_end<WordType::WORD>(const Context&, const Selection&);
    113 
    114 template<WordType word_type>
    115 Optional<Selection>
    116 select_to_previous_word(const Context& context, const Selection& selection)
    117 {
    118     auto extra_word_chars = get_extra_word_chars(context);
    119     auto& buffer = context.buffer();
    120     Utf8Iterator begin{buffer.iterator_at(selection.cursor()), buffer};
    121     if (begin == buffer.begin())
    122         return {};
    123     if (categorize<word_type>(*begin, extra_word_chars) !=
    124         categorize<word_type>(*(begin-1), extra_word_chars))
    125         --begin;
    126 
    127     skip_while_reverse(begin, buffer.begin(), [](Codepoint c){ return is_eol(c); });
    128     Utf8Iterator end = begin;
    129 
    130     auto is_word = [&](Codepoint c) { return Kakoune::is_word<word_type>(c, extra_word_chars); };
    131     auto is_punctuation = [&](Codepoint c) { return Kakoune::is_punctuation(c, extra_word_chars); };
    132 
    133     bool with_end = skip_while_reverse(end, buffer.begin(), is_horizontal_blank);
    134     if (is_word(*end))
    135         with_end = skip_while_reverse(end, buffer.begin(), is_word);
    136     else if (is_punctuation(*end))
    137         with_end = skip_while_reverse(end, buffer.begin(), is_punctuation);
    138 
    139     return utf8_range(begin, with_end ? end : end+1);
    140 }
    141 template Optional<Selection> select_to_previous_word<WordType::Word>(const Context&, const Selection&);
    142 template Optional<Selection> select_to_previous_word<WordType::WORD>(const Context&, const Selection&);
    143 
    144 template<WordType word_type>
    145 Optional<Selection> select_word(const Context& context, const Selection& selection, int count, ObjectFlags flags)
    146 {
    147     auto extra_word_chars = get_extra_word_chars(context);
    148     auto& buffer = context.buffer();
    149 
    150     auto is_word = [&](Codepoint c) { return Kakoune::is_word<word_type>(c, extra_word_chars); };
    151 
    152     Utf8Iterator first{buffer.iterator_at(selection.cursor()), buffer};
    153     if (not is_word(*first))
    154         return {};
    155 
    156     Utf8Iterator last = first;
    157     if (flags & ObjectFlags::ToBegin)
    158     {
    159         skip_while_reverse(first, buffer.begin(), is_word);
    160         if (not is_word(*first))
    161             ++first;
    162     }
    163     if (flags & ObjectFlags::ToEnd)
    164     {
    165         skip_while(last, buffer.end(), is_word);
    166         if (not (flags & ObjectFlags::Inner))
    167             skip_while(last, buffer.end(), is_horizontal_blank);
    168         --last;
    169     }
    170     return (flags & ObjectFlags::ToEnd) ? utf8_range(first, last)
    171                                         : utf8_range(last, first);
    172 }
    173 template Optional<Selection> select_word<WordType::Word>(const Context&, const Selection&, int, ObjectFlags);
    174 template Optional<Selection> select_word<WordType::WORD>(const Context&, const Selection&, int, ObjectFlags);
    175 
    176 template<bool only_move>
    177 Optional<Selection> select_to_line_end(const Context& context, const Selection& selection)
    178 {
    179     auto& buffer = context.buffer();
    180     BufferCoord begin = selection.cursor();
    181     LineCount line = begin.line;
    182     BufferCoord end = utf8::previous(buffer.iterator_at({line, buffer[line].length() - 1}),
    183                                      buffer.iterator_at(line)).coord();
    184     if (end < begin) // Do not go backward when cursor is on eol
    185         end = begin;
    186     return Selection{only_move ? end : begin, {end, max_non_eol_column}};
    187 }
    188 template Optional<Selection> select_to_line_end<false>(const Context&, const Selection&);
    189 template Optional<Selection> select_to_line_end<true>(const Context&, const Selection&);
    190 
    191 template<bool only_move>
    192 Optional<Selection> select_to_line_begin(const Context&, const Selection& selection)
    193 {
    194     BufferCoord begin = selection.cursor();
    195     BufferCoord end = begin.line;
    196     return Selection{only_move ? end : begin, end};
    197 }
    198 template Optional<Selection> select_to_line_begin<false>(const Context&, const Selection&);
    199 template Optional<Selection> select_to_line_begin<true>(const Context&, const Selection&);
    200 
    201 Optional<Selection> select_to_first_non_blank(const Context& context, const Selection& selection)
    202 {
    203     auto& buffer = context.buffer();
    204     auto it = buffer.iterator_at(selection.cursor().line);
    205     skip_while(it, buffer.iterator_at(selection.cursor().line+1),
    206                is_horizontal_blank);
    207     return {it.coord()};
    208 }
    209 
    210 template<bool forward>
    211 Optional<Selection> select_matching(const Context& context, const Selection& selection)
    212 {
    213     auto& buffer = context.buffer();
    214     auto& matching_pairs = context.options()["matching_pairs"].get<Vector<Codepoint, MemoryDomain::Options>>();
    215     Utf8Iterator it{buffer.iterator_at(selection.cursor()), buffer};
    216     auto match = matching_pairs.end();
    217 
    218     if (forward) while (it != buffer.end())
    219     {
    220         match = find(matching_pairs, *it);
    221         if (match != matching_pairs.end())
    222             break;
    223         ++it;
    224     }
    225     else while (true)
    226     {
    227         match = find(matching_pairs, *it);
    228         if (match != matching_pairs.end()
    229             or it == buffer.begin())
    230             break;
    231         --it;
    232     }
    233 
    234     if (match == matching_pairs.end())
    235         return {};
    236 
    237     Utf8Iterator begin = it;
    238 
    239     if (((match - matching_pairs.begin()) % 2) == 0)
    240     {
    241         int level = 0;
    242         const Codepoint opening = *match;
    243         const Codepoint closing = *(match+1);
    244         while (it != buffer.end())
    245         {
    246             if (*it == opening)
    247                 ++level;
    248             else if (*it == closing and --level == 0)
    249                 return utf8_range(begin, it);
    250             ++it;
    251         }
    252     }
    253     else
    254     {
    255         int level = 0;
    256         const Codepoint opening = *(match-1);
    257         const Codepoint closing = *match;
    258         while (true)
    259         {
    260             if (*it == closing)
    261                 ++level;
    262             else if (*it == opening and --level == 0)
    263                 return utf8_range(begin, it);
    264             if (it == buffer.begin())
    265                 break;
    266             --it;
    267         }
    268     }
    269     return {};
    270 }
    271 template Optional<Selection>
    272 select_matching<true>(const Context& context, const Selection& selection);
    273 template Optional<Selection>
    274 select_matching<false>(const Context& context, const Selection& selection);
    275 
    276 template<typename Iterator, typename Container>
    277 Optional<std::pair<Iterator, Iterator>>
    278 find_opening(Iterator pos, const Container& container,
    279              const Regex& opening, const Regex& closing,
    280              int level, bool nestable)
    281 {
    282     MatchResults<Iterator> res;
    283     // When on the token of a non-nestable block, we want to consider it opening
    284     if (nestable and
    285         backward_regex_search(container.begin(), pos,
    286                               container.begin(), container.end(), res, closing,
    287                               RegexExecFlags::None, EventManager::handle_urgent_events) and
    288         res[0].second == pos)
    289         pos = res[0].first;
    290 
    291     using RegexIt = RegexIterator<Iterator, RegexMode::Backward, const Regex, void (*)()>;
    292     for (auto&& match : RegexIt{container.begin(), pos, container.begin(), container.end(), opening,
    293                                 RegexExecFlags::None, EventManager::handle_urgent_events})
    294     {
    295         if (nestable)
    296         {
    297             for (auto m [[maybe_unused]] : RegexIt{match[0].second, pos, container.begin(), container.end(), closing,
    298                                                    RegexExecFlags::None, EventManager::handle_urgent_events})
    299                 ++level;
    300         }
    301 
    302         if (not nestable or level == 0)
    303             return match[0];
    304         pos = match[0].first;
    305         --level;
    306     }
    307     return {};
    308 }
    309 
    310 template<typename Iterator, typename Container>
    311 Optional<std::pair<Iterator, Iterator>>
    312 find_closing(Iterator pos, const Container& container,
    313              const Regex& opening, const Regex& closing,
    314              int level, bool nestable)
    315 {
    316     for (auto match : RegexIterator{pos, container.end(), container.begin(), container.end(), closing,
    317                                     RegexExecFlags::None, EventManager::handle_urgent_events})
    318     {
    319         if (nestable)
    320         {
    321             for (auto m [[maybe_unused]] : RegexIterator{pos, match[0].first, container.begin(), container.end(), opening,
    322                                                          RegexExecFlags::None, EventManager::handle_urgent_events})
    323                 ++level;
    324         }
    325 
    326         if (not nestable or level == 0)
    327             return match[0];
    328         pos = match[0].second;
    329         --level;
    330     }
    331     return {};
    332 }
    333 
    334 template<typename Container, typename Iterator>
    335 Optional<std::pair<Iterator, Iterator>>
    336 find_surrounding(const Container& container, Iterator pos,
    337                  const Regex& opening, const Regex& closing,
    338                  ObjectFlags flags, int level)
    339 {
    340     auto empty = [](const std::pair<Iterator, Iterator>& m) { return m.first == m.second; };
    341     const bool nestable = opening != closing;
    342     auto first = pos;
    343     auto last = pos;
    344     if (flags & ObjectFlags::ToBegin)
    345     {
    346         if (auto res = find_opening(first+1, container, opening, closing, level, nestable))
    347         {
    348             first = (flags & ObjectFlags::Inner) ? res->second : res->first;
    349             if (flags & ObjectFlags::ToEnd) // ensure we find the matching end
    350             {
    351                 last = empty(*res) ? std::next(res->second) : res->second;
    352                 level = 0;
    353             }
    354         }
    355         else
    356             return {};
    357     }
    358     else if (MatchResults<Iterator> res;
    359              regex_search(pos, container.end(), container.begin(), container.end(), res, opening,
    360                           RegexExecFlags::None, EventManager::handle_urgent_events) and
    361              res[0].first == pos) // Skip opening match if pos lies on it
    362         last = empty(res[0]) ? std::next(res[0].second) : res[0].second;
    363 
    364     if (flags & ObjectFlags::ToEnd)
    365     {
    366         if (auto res = find_closing(last, container, opening, closing, level, nestable))
    367             last = utf8::previous((flags & ObjectFlags::Inner) ? res->first : res->second,
    368                                   container.begin());
    369         else
    370             return {};
    371     }
    372     if (first > last)
    373         return {};
    374 
    375     return std::pair<Iterator, Iterator>{first, last};
    376 }
    377 
    378 Optional<Selection>
    379 select_surrounding(const Context& context, const Selection& selection,
    380                    const Regex& opening, const Regex& closing, int level,
    381                    ObjectFlags flags)
    382 {
    383     auto& buffer = context.buffer();
    384     auto pos = buffer.iterator_at(selection.cursor());
    385 
    386     auto res = find_surrounding(buffer, pos, opening, closing, flags, level);
    387 
    388     // If the ends we're changing didn't move, find the parent
    389     if (res and not (flags & ObjectFlags::Inner) and
    390         (res->first.coord() == selection.min() or not (flags & ObjectFlags::ToBegin)) and
    391         (res->second.coord() == selection.max() or not (flags & ObjectFlags::ToEnd)))
    392         res = find_surrounding(buffer, pos, opening, closing, flags, level+1);
    393 
    394     if (res)
    395         return (flags & ObjectFlags::ToEnd) ? utf8_range(res->first, res->second)
    396                                             : utf8_range(res->second, res->first);
    397     return {};
    398 }
    399 
    400 Optional<Selection>
    401 select_to(const Context& context, const Selection& selection,
    402           Codepoint c, int count, bool inclusive)
    403 {
    404     auto& buffer = context.buffer();
    405     Utf8Iterator begin{buffer.iterator_at(selection.cursor()), buffer};
    406     Utf8Iterator end = begin;
    407     do
    408     {
    409         ++end;
    410         skip_while(end, buffer.end(), [c](Codepoint cur) { return cur != c; });
    411         if (end == buffer.end())
    412             return {};
    413     }
    414     while (--count > 0);
    415 
    416     return utf8_range(begin, inclusive ? end : end-1);
    417 }
    418 
    419 Optional<Selection>
    420 select_to_reverse(const Context& context, const Selection& selection,
    421                   Codepoint c, int count, bool inclusive)
    422 {
    423     auto& buffer = context.buffer();
    424 
    425     // if we are selecting backwards from the beginning of the buffer,
    426     // there is nothing more that can be selected.
    427     if (selection.cursor() == buffer.begin())
    428         return {};
    429 
    430     Utf8Iterator begin{buffer.iterator_at(selection.cursor()), buffer};
    431     Utf8Iterator end = begin;
    432     do
    433     {
    434         --end;
    435         if (skip_while_reverse(end, buffer.begin(),
    436                                [c](Codepoint cur) { return cur != c; }))
    437             return {};
    438     }
    439     while (--count > 0);
    440 
    441     return utf8_range(begin, inclusive ? end : end+1);
    442 }
    443 
    444 Optional<Selection>
    445 select_number(const Context& context, const Selection& selection,
    446               int count, ObjectFlags flags)
    447 {
    448     auto is_number = [&](char c) {
    449         return (c >= '0' and c <= '9') or
    450                (not (flags & ObjectFlags::Inner) and c == '.');
    451     };
    452 
    453     auto& buffer = context.buffer();
    454     BufferIterator first = buffer.iterator_at(selection.cursor());
    455     BufferIterator last = first;
    456 
    457     if (not is_number(*first) and *first != '-')
    458         return {};
    459 
    460     if (flags & ObjectFlags::ToBegin)
    461     {
    462         skip_while_reverse(first, buffer.begin(), is_number);
    463         if (not is_number(*first) and *first != '-' and
    464             first+1 != buffer.end())
    465             ++first;
    466     }
    467 
    468     if (flags & ObjectFlags::ToEnd)
    469     {
    470         if (*last == '-')
    471             ++last;
    472         skip_while(last, buffer.end(), is_number);
    473         if (last != buffer.begin())
    474             --last;
    475     }
    476 
    477     return (flags & ObjectFlags::ToEnd) ? Selection{first.coord(), last.coord()}
    478                                         : Selection{last.coord(), first.coord()};
    479 }
    480 
    481 Optional<Selection>
    482 select_sentence(const Context& context, const Selection& selection,
    483                 int count, ObjectFlags flags)
    484 {
    485     auto is_end_of_sentence = [](char c) {
    486         return c == '.' or c == ';' or c == '!' or c == '?';
    487     };
    488 
    489     auto& buffer = context.buffer();
    490     BufferIterator first = buffer.iterator_at(selection.cursor());
    491     BufferIterator last;
    492 
    493     for (int i = 0; i <= count; ++i)
    494     {
    495         if (not (flags & ObjectFlags::ToEnd) and first != buffer.begin())
    496         {
    497             BufferIterator prev_non_blank = first-1;
    498             skip_while_reverse(prev_non_blank, buffer.begin(),
    499                                [](char c) { return is_horizontal_blank(c) or is_eol(c); });
    500             if (is_end_of_sentence(*prev_non_blank))
    501                 first = prev_non_blank;
    502         }
    503 
    504         if (i == 0)
    505             last = first;
    506 
    507         if (flags & ObjectFlags::ToBegin)
    508         {
    509             bool saw_non_blank = false;
    510             while (first != buffer.begin())
    511             {
    512                 char cur = *first;
    513                 char prev = *(first-1);
    514                 if (not is_horizontal_blank(cur))
    515                     saw_non_blank = true;
    516                 if (is_eol(prev) and is_eol(cur) and first + 1 != buffer.end())
    517                 {
    518                     ++first;
    519                     break;
    520                 }
    521                 else if (is_end_of_sentence(prev))
    522                 {
    523                     if (saw_non_blank)
    524                         break;
    525                     else if (flags & ObjectFlags::ToEnd)
    526                         last = first-1;
    527                 }
    528                 --first;
    529             }
    530             skip_while(first, buffer.end(), is_horizontal_blank);
    531         }
    532         if (flags & ObjectFlags::ToEnd)
    533         {
    534             while (last != buffer.end())
    535             {
    536                 char cur = *last;
    537                 if (is_end_of_sentence(cur) or
    538                     (is_eol(cur) and (last+1 == buffer.end() or is_eol(*(last+1)))))
    539                     break;
    540                 ++last;
    541             }
    542             if (not (flags & ObjectFlags::Inner) and last != buffer.end())
    543             {
    544                 ++last;
    545                 skip_while(last, buffer.end(), is_horizontal_blank);
    546                 --last;
    547             }
    548         }
    549     }
    550     return (flags & ObjectFlags::ToEnd) ? Selection{first.coord(), last.coord()}
    551                                         : Selection{last.coord(), first.coord()};
    552 }
    553 
    554 Optional<Selection>
    555 select_paragraph(const Context& context, const Selection& selection,
    556                  int count, ObjectFlags flags)
    557 {
    558     auto& buffer = context.buffer();
    559     BufferIterator first = buffer.iterator_at(selection.cursor());
    560     BufferIterator last;
    561 
    562     for (int i = 0; i <= count; ++i)
    563     {
    564         if (not (flags & ObjectFlags::ToEnd) and first.coord() > BufferCoord{0,1} and
    565             is_eol(*(first-1)) and first-1 != buffer.begin() and is_eol(*(first-2)))
    566             --first;
    567         else if ((flags & ObjectFlags::ToEnd) and
    568                  first != buffer.begin() and (first+1) != buffer.end() and
    569                  is_eol(*(first-1)) and is_eol(*first))
    570             ++first;
    571         if (i == 0)
    572             last = first;
    573 
    574         if ((flags & ObjectFlags::ToBegin) and first != buffer.begin())
    575         {
    576             skip_while_reverse(first, buffer.begin(),
    577                                [](Codepoint c){ return is_eol(c); });
    578             if (flags & ObjectFlags::ToEnd)
    579                 last = first;
    580             while (first != buffer.begin())
    581             {
    582                 char cur = *first;
    583                 char prev = *(first-1);
    584                 if (is_eol(prev) and is_eol(cur))
    585                 {
    586                     ++first;
    587                     break;
    588                 }
    589                 --first;
    590             }
    591         }
    592         if (flags & ObjectFlags::ToEnd)
    593         {
    594             if (last != buffer.end() and is_eol(*last))
    595                 ++last;
    596             while (last != buffer.end())
    597             {
    598                 if (last != buffer.begin() and is_eol(*last) and is_eol(*(last-1)))
    599                 {
    600                     if (not (flags & ObjectFlags::Inner))
    601                         skip_while(last, buffer.end(),
    602                                    [](Codepoint c){ return is_eol(c); });
    603                     break;
    604                 }
    605                 ++last;
    606             }
    607             --last;
    608         }
    609     }
    610     return (flags & ObjectFlags::ToEnd) ? Selection{first.coord(), last.coord()}
    611                                         : Selection{last.coord(), first.coord()};
    612 }
    613 
    614 Optional<Selection>
    615 select_whitespaces(const Context& context, const Selection& selection,
    616                    int count, ObjectFlags flags)
    617 {
    618     auto is_whitespace = [&](char c) {
    619         return c == ' ' or c == '\t' or
    620             (not (flags & ObjectFlags::Inner) and c == '\n');
    621     };
    622     auto& buffer = context.buffer();
    623     BufferIterator first = buffer.iterator_at(selection.cursor());
    624     BufferIterator last  = first;
    625 
    626     if (not is_whitespace(*first))
    627         return {};
    628 
    629     if (flags & ObjectFlags::ToBegin)
    630     {
    631         if (is_whitespace(*first))
    632         {
    633             skip_while_reverse(first, buffer.begin(), is_whitespace);
    634             if (not is_whitespace(*first))
    635                 ++first;
    636         }
    637     }
    638     if (flags & ObjectFlags::ToEnd)
    639     {
    640         if (is_whitespace(*last))
    641         {
    642             skip_while(last, buffer.end(), is_whitespace);
    643             --last;
    644         }
    645     }
    646     return (flags & ObjectFlags::ToEnd) ? Selection{first.coord(), last.coord()}
    647                                         : Selection{last.coord(), first.coord()};
    648 }
    649 
    650 Optional<Selection>
    651 select_indent(const Context& context, const Selection& selection,
    652               int count, ObjectFlags flags)
    653 {
    654     auto get_indent = [](StringView str, int tabstop) {
    655         CharCount indent = 0;
    656         for (auto& c : str)
    657         {
    658             if (c == ' ')
    659                 ++indent;
    660             else if (c =='\t')
    661                 indent = (indent / tabstop + 1) * tabstop;
    662             else
    663                 break;
    664         }
    665         return indent;
    666     };
    667 
    668     auto get_current_indent = [&](const Buffer& buffer, LineCount line, int tabstop)
    669     {
    670         for (auto l = line; l >= 0; --l)
    671             if (buffer[l] != "\n"_sv)
    672                 return get_indent(buffer[l], tabstop);
    673         for (auto l = line+1; l < buffer.line_count(); ++l)
    674             if (buffer[l] != "\n"_sv)
    675                 return get_indent(buffer[l], tabstop);
    676         return 0_char;
    677     };
    678 
    679     auto is_only_whitespaces = [](StringView str) {
    680         auto it = str.begin();
    681         skip_while(it, str.end(),
    682                    [](char c){ return c == ' ' or c == '\t' or c == '\n'; });
    683         return it == str.end();
    684     };
    685 
    686     const bool to_begin = flags & ObjectFlags::ToBegin;
    687     const bool to_end   = flags & ObjectFlags::ToEnd;
    688 
    689     auto& buffer = context.buffer();
    690     int tabstop = context.options()["tabstop"].get<int>();
    691     auto pos = selection.cursor();
    692     const LineCount line = pos.line;
    693     const auto indent = get_current_indent(buffer, line, tabstop);
    694 
    695     LineCount begin_line = line - 1;
    696     if (to_begin)
    697     {
    698         while (begin_line >= 0 and (buffer[begin_line] == "\n"_sv or
    699                                     get_indent(buffer[begin_line], tabstop) >= indent))
    700             --begin_line;
    701     }
    702     ++begin_line;
    703     LineCount end_line = line + 1;
    704     if (to_end)
    705     {
    706         const LineCount end = buffer.line_count();
    707         while (end_line < end and (buffer[end_line] == "\n"_sv or
    708                                    get_indent(buffer[end_line], tabstop) >= indent))
    709             ++end_line;
    710     }
    711     --end_line;
    712     // remove only whitespaces lines in inner mode
    713     if (flags & ObjectFlags::Inner)
    714     {
    715         while (begin_line < end_line and
    716                is_only_whitespaces(buffer[begin_line]))
    717             ++begin_line;
    718         while (begin_line < end_line and
    719                is_only_whitespaces(buffer[end_line]))
    720             --end_line;
    721     }
    722 
    723     auto first = to_begin ? begin_line : pos;
    724     auto last = to_end ? BufferCoord{end_line, buffer[end_line].length() - 1} : pos;
    725     return to_end ? Selection{first, last} : Selection{last, first};
    726 }
    727 
    728 Optional<Selection>
    729 select_argument(const Context& context, const Selection& selection,
    730                 int level, ObjectFlags flags)
    731 {
    732     enum Class { None, Opening, Closing, Delimiter };
    733     auto classify = [](Codepoint c) {
    734         switch (c)
    735         {
    736         case '(': case '[': case '{': return Opening;
    737         case ')': case ']': case '}': return Closing;
    738         case ',': case ';': return Delimiter;
    739         default: return None;
    740         }
    741     };
    742 
    743     auto& buffer = context.buffer();
    744     BufferIterator pos = buffer.iterator_at(selection.cursor());
    745     switch (classify(*pos))
    746     {
    747         //case Closing: if (pos+1 != buffer.end()) ++pos; break;
    748         case Opening:
    749         case Delimiter: if (pos != buffer.begin()) --pos; break;
    750         default: break;
    751     };
    752 
    753     bool first_arg = false;
    754     BufferIterator begin = pos;
    755     for (int lev = level; begin != buffer.begin(); --begin)
    756     {
    757         Class c = classify(*begin);
    758         if (c == Closing)
    759             ++lev;
    760         else if (c == Opening and (lev-- == 0))
    761         {
    762             first_arg = true;
    763             ++begin;
    764             break;
    765         }
    766         else if (c == Delimiter and lev == 0)
    767         {
    768             ++begin;
    769             break;
    770         }
    771     }
    772 
    773     bool last_arg = false;
    774     BufferIterator end = pos;
    775     for (int lev = level; end != buffer.end(); ++end)
    776     {
    777         Class c = classify(*end);
    778         if (c == Opening)
    779             ++lev;
    780         else if (end != pos and c == Closing and (lev-- == 0))
    781         {
    782             last_arg = true;
    783             --end;
    784             break;
    785         }
    786         else if (c == Delimiter and lev == 0)
    787         {
    788             // include whitespaces *after* the delimiter only for first argument
    789             if (first_arg and not (flags & ObjectFlags::Inner))
    790             {
    791                 while (end + 1 != buffer.end() and is_blank(*(end+1)))
    792                     ++end;
    793             }
    794             break;
    795         }
    796     }
    797 
    798     if (flags & ObjectFlags::Inner)
    799     {
    800         if (not last_arg)
    801             --end;
    802         skip_while(begin, end, is_blank);
    803         skip_while_reverse(end, begin, is_blank);
    804     }
    805     // get starting delimiter for non inner last arg
    806     else if (not first_arg and last_arg and begin != buffer.begin())
    807         --begin;
    808 
    809     if (end == buffer.end())
    810         --end;
    811 
    812     if (flags & ObjectFlags::ToBegin and not (flags & ObjectFlags::ToEnd))
    813         return Selection{pos.coord(), begin.coord()};
    814     return Selection{(flags & ObjectFlags::ToBegin ? begin : pos).coord(),
    815                      end.coord()};
    816 }
    817 
    818 Vector<Selection> for_each_sel(const Context& context, auto&& callback)
    819 {
    820     auto& buffer = context.buffer();
    821     Vector<Selection> res;
    822     for (auto& sel : context.selections())
    823         callback(res, buffer.iterator_at(sel.min()), buffer.iterator_at(buffer.char_next(sel.max())));
    824     if (res.empty())
    825         throw runtime_error("nothing selected");
    826     return res;
    827 }
    828 
    829 template<WordType word_type>
    830 Vector<Selection> select_nested_words(const Context& context, int count, ObjectFlags flags)
    831 {
    832     auto is_word = [extra_word_chars=get_extra_word_chars(context)](Codepoint c) { return Kakoune::is_word<word_type>(c, extra_word_chars); };
    833     auto is_not_word = [&](Codepoint c) { return not is_word(c); };
    834 
    835     return for_each_sel(context, [&](Vector<Selection>& res, BufferIterator beg, BufferIterator end) {
    836         for (auto it = Utf8Iterator{beg, context.buffer()}; it != end; )
    837         {
    838             if (not skip_while(it, end, is_not_word))
    839                 break;
    840             auto start = it;
    841             skip_while(it, end, is_word);
    842             if (not (flags & ObjectFlags::Inner))
    843                 skip_while(it, end, is_horizontal_blank);
    844             res.push_back({start.base().coord(), context.buffer().char_prev(it.base().coord())});
    845         }
    846     });
    847 }
    848 template Vector<Selection> select_nested_words<Word>(const Context& context, int count, ObjectFlags flags);
    849 template Vector<Selection> select_nested_words<WORD>(const Context& context, int count, ObjectFlags flags);
    850 
    851 Vector<Selection> select_nested_numbers(const Context& context, int count, ObjectFlags flags)
    852 {
    853     auto is_digit = [](char c) { return c >= '0' and c <= '9'; };
    854     auto is_number = [&](char c) { return is_digit(c) or (not (flags & ObjectFlags::Inner) and c == '.'); };
    855 
    856     return for_each_sel(context, [&](Vector<Selection>& res, BufferIterator it, BufferIterator end) {
    857         while (it != end)
    858         {
    859             if (not skip_while(it, end, [&](char c) { return not (c == '-' or is_number(c)); }))
    860                 break;
    861 
    862             auto start = it;
    863             if (*it == '-')
    864                 ++it;
    865             skip_while(it, end, is_number);
    866             if (it == start)
    867                 ++it;
    868             else if (std::find_if(start, it, is_digit) != it)
    869                 res.push_back({start.coord(), context.buffer().char_prev(it.coord())});
    870         }
    871     });
    872 }
    873 
    874 Vector<Selection> select_nested_sentences(const Context& context, int count, ObjectFlags flags)
    875 {
    876     auto is_end_of_sentence = [](char c) { return c == '.' or c == ';' or c == '!' or c == '?'; };
    877 
    878     return for_each_sel(context, [&](Vector<Selection>& res, BufferIterator it, BufferIterator end) {
    879         while (it != end)
    880         {
    881             if (not skip_while(it, end, [](char c) { return c == ' ' or c == '\n' or c == '\t'; }))
    882                 break;
    883             auto start = it;
    884             it = std::find_if(it, end, is_end_of_sentence);
    885             if (it != end)
    886             {
    887                 ++it;
    888                 if (not (flags & ObjectFlags::Inner))
    889                     skip_while(it, end, [](char c) { return c == ' '; });
    890             }
    891             res.push_back({start.coord(), context.buffer().char_prev(it.coord())});
    892         }
    893     });
    894 }
    895 
    896 Vector<Selection> select_nested_paragraphs(const Context& context, int count, ObjectFlags flags)
    897 {
    898     auto is_eol = [](char c) { return c == '\n'; };
    899 
    900     return for_each_sel(context, [&](Vector<Selection>& res, BufferIterator it, BufferIterator end) {
    901         while (it != end)
    902         {
    903             auto start = std::find_if(it, end, [&](char c) {return not is_eol(c); });
    904             int consecutive_eols = 0;
    905             for (it = start; it != end; ++it)
    906             {
    907                 if (is_eol(*it))
    908                 {
    909                     ++consecutive_eols;
    910                     if (consecutive_eols == 2 and (flags & ObjectFlags::Inner))
    911                         break;
    912                 }
    913                 else if (consecutive_eols >= 2)
    914                     break;
    915                 else
    916                     consecutive_eols = 0;
    917             }
    918             res.push_back({start.coord(), context.buffer().char_prev(it.coord())});
    919         }
    920     });
    921 }
    922 
    923 Vector<Selection> select_nested_whitespaces(const Context& context, int count, ObjectFlags flags)
    924 {
    925     auto is_whitespace = [&](char c) { return c == ' ' or c == '\t' or (not (flags & ObjectFlags::Inner) and c == '\n'); };
    926 
    927     return for_each_sel(context, [&](Vector<Selection>& res, BufferIterator it, BufferIterator end) {
    928         while (it != end)
    929         {
    930             if (not skip_while(it, end, [&](char c) { return not is_whitespace(c); }))
    931                 break;
    932             auto start = it;
    933             skip_while(it, end, is_whitespace);
    934             res.push_back({start.coord(), context.buffer().char_prev(it.coord())});
    935         }
    936     });
    937 }
    938 
    939 Vector<Selection> select_nested_indents(const Context& context, int count, ObjectFlags flags)
    940 {
    941     throw runtime_error("nested indents are not implemented");
    942 }
    943 
    944 Vector<Selection> select_nested_arguments(const Context& context, int count, ObjectFlags flags)
    945 {
    946     auto is_whitespace = [&](char c) { return c == ' ' or c == '\t' or c == '\n'; };
    947     const bool inner = (flags & ObjectFlags::Inner);
    948     auto& buffer = context.buffer();
    949 
    950     return for_each_sel(context, [&](Vector<Selection>& res, BufferIterator it, BufferIterator end) {
    951         auto start = it;
    952         int level = 0;
    953         while (it != end)
    954         {
    955             switch(*it)
    956             {
    957                 case '(': case '[': case '{': ++level; ++it; break;
    958                 case ')': case ']': case '}': --level; ++it; break;
    959                 case ',': case ';':
    960                     if (level == 0)
    961                     {
    962                         res.push_back({start.coord(), inner ? buffer.char_prev(it.coord()) : it.coord()});
    963                         ++it;
    964                         while (inner and it != end and is_whitespace(*it))
    965                             ++it;
    966                         start = it;
    967                         break;
    968                     }
    969                     [[fallthrough]];
    970                 default: ++it; break;
    971             }
    972         }
    973         if (start != it)
    974             res.push_back({start.coord(), context.buffer().char_prev(it.coord())});
    975     });
    976 }
    977 
    978 Vector<Selection> regex_select_nested(const Context& context, const Regex& opening, const Regex& closing, int count, ObjectFlags flags)
    979 {
    980     kak_assert(opening != closing);
    981     auto& buffer = context.buffer();
    982     const bool inner = (flags & ObjectFlags::Inner);
    983 
    984     return for_each_sel(context, [&](Vector<Selection>& res, BufferIterator beg, BufferIterator end) {
    985         RegexIterator opening_matches{beg, end, buffer.begin(), buffer.end(), opening, RegexExecFlags::None, EventManager::handle_urgent_events};
    986         RegexIterator closing_matches{beg, end, buffer.begin(), buffer.end(), closing, RegexExecFlags::None, EventManager::handle_urgent_events};
    987         auto opening_it = opening_matches.begin(), closing_it = closing_matches.begin();
    988         auto opening_end = opening_matches.end(),  closing_end = closing_matches.end();
    989 
    990         Optional<BufferIterator> start;
    991         int level = -count - 1;
    992         while (opening_it != opening_end and closing_it != closing_end)
    993         {
    994             while (opening_it != opening_end and (closing_it == closing_end or (*opening_it)[0].first < (*closing_it)[0].first))
    995             {
    996                 if (++level == 0)
    997                     start = inner ? (*opening_it)[0].second : (*opening_it)[0].first;
    998                 ++opening_it;
    999             }
   1000             while (closing_it != closing_end and (opening_it == opening_end or (*closing_it)[0].first < (*opening_it)[0].first))
   1001             {
   1002                 if (level-- == 0 and start)
   1003                 {
   1004                     auto end_coord = buffer.char_prev((inner ? (*closing_it)[0].first : (*closing_it)[0].second).coord());
   1005                     if (start->coord() <= end_coord)
   1006                         res.push_back({start->coord(), end_coord});
   1007                     start.reset();
   1008                 }
   1009                 ++closing_it;
   1010             }
   1011         }
   1012         if (start)
   1013             res.push_back({start->coord(), buffer.char_prev(end.coord())});
   1014     });
   1015 }
   1016 
   1017 Vector<Selection> regex_select_nested(const Context& context, const Regex& delimiter, ObjectFlags flags)
   1018 {
   1019     auto& buffer = context.buffer();
   1020     const bool inner = (flags & ObjectFlags::Inner);
   1021 
   1022     return for_each_sel(context, [&](Vector<Selection>& res, BufferIterator beg, BufferIterator end) {
   1023         Optional<BufferIterator> start;
   1024         for (auto m : RegexIterator{beg, end, buffer.begin(), buffer.end(),
   1025                                     delimiter, RegexExecFlags::None, EventManager::handle_urgent_events})
   1026         {
   1027             if (not start)
   1028                 start = inner ? m[0].second : m[0].first;
   1029             else
   1030             {
   1031                 auto end_coord = buffer.char_prev((inner ? m[0].first : m[0].second).coord());
   1032                 if (start->coord() <= end_coord)
   1033                     res.push_back({start->coord(), end_coord});
   1034                 start.reset();
   1035             }
   1036         }
   1037         if (start)
   1038             res.push_back({start->coord(), buffer.char_prev(end.coord())});
   1039     });
   1040 }
   1041 
   1042 Optional<Selection>
   1043 select_lines(const Context& context, const Selection& selection)
   1044 {
   1045     auto& buffer = context.buffer();
   1046     BufferCoord anchor = selection.anchor();
   1047     BufferCoord cursor = selection.cursor();
   1048     BufferCoord& to_line_start = anchor <= cursor ? anchor : cursor;
   1049     BufferCoord& to_line_end = anchor <= cursor ? cursor : anchor;
   1050 
   1051     to_line_start.column = 0;
   1052     to_line_end.column = buffer[to_line_end.line].length()-1;
   1053 
   1054     return Selection{anchor, {cursor, max_column}};
   1055 }
   1056 
   1057 Optional<Selection>
   1058 trim_partial_lines(const Context& context, const Selection& selection)
   1059 {
   1060     auto& buffer = context.buffer();
   1061     BufferCoord anchor = selection.anchor();
   1062     BufferCoord cursor = selection.cursor();
   1063     BufferCoord& to_line_start = anchor <= cursor ? anchor : cursor;
   1064     BufferCoord& to_line_end = anchor <= cursor ? cursor : anchor;
   1065 
   1066     if (to_line_start.column != 0)
   1067         to_line_start = to_line_start.line+1;
   1068     if (to_line_end.column != buffer[to_line_end.line].length()-1)
   1069     {
   1070         if (to_line_end.line == 0)
   1071             return {};
   1072 
   1073         auto prev_line = to_line_end.line-1;
   1074         to_line_end = BufferCoord{ prev_line, buffer[prev_line].length()-1 };
   1075     }
   1076 
   1077     if (to_line_start > to_line_end)
   1078         return {};
   1079 
   1080     return Selection{anchor, {cursor, max_column}};
   1081 }
   1082 
   1083 static RegexExecFlags
   1084 match_flags(const Buffer& buf, const BufferIterator& begin, const BufferIterator& end)
   1085 {
   1086     return match_flags(is_bol(begin.coord()), is_eol(buf, end.coord()),
   1087                        is_bow(buf, begin.coord()), is_eow(buf, end.coord()));
   1088 }
   1089 
   1090 static bool find_next(const Buffer& buffer, const BufferIterator& pos,
   1091                       MatchResults<BufferIterator>& matches,
   1092                       const Regex& ex, bool& wrapped)
   1093 {
   1094     if (pos != buffer.end() and
   1095         regex_search(pos, buffer.end(), buffer.begin(), buffer.end(),
   1096                      matches, ex, match_flags(buffer, pos, buffer.end()),
   1097                      EventManager::handle_urgent_events))
   1098         return true;
   1099     wrapped = true;
   1100     return regex_search(buffer.begin(), buffer.end(), buffer.begin(), buffer.end(),
   1101                         matches, ex, match_flags(buffer, buffer.begin(), buffer.end()),
   1102                         EventManager::handle_urgent_events);
   1103 }
   1104 
   1105 static bool find_prev(const Buffer& buffer, const BufferIterator& pos,
   1106                       MatchResults<BufferIterator>& matches,
   1107                       const Regex& ex, bool& wrapped)
   1108 {
   1109     if (pos != buffer.begin() and
   1110         backward_regex_search(buffer.begin(), pos, buffer.begin(), buffer.end(),
   1111                               matches, ex,
   1112                               match_flags(buffer, buffer.begin(), pos) |
   1113                               RegexExecFlags::NotInitialNull,
   1114                               EventManager::handle_urgent_events))
   1115         return true;
   1116     wrapped = true;
   1117     return backward_regex_search(buffer.begin(), buffer.end(), buffer.begin(), buffer.end(),
   1118                                  matches, ex,
   1119                                  match_flags(buffer, buffer.begin(), buffer.end()) |
   1120                                  RegexExecFlags::NotInitialNull,
   1121                                  EventManager::handle_urgent_events);
   1122 }
   1123 
   1124 Selection find_next_match(const Context& context, const Selection& sel, const Regex& regex, RegexMode mode, bool& wrapped)
   1125 {
   1126     kak_assert(is_direction(mode));
   1127     const bool forward = mode & RegexMode::Forward;
   1128     auto& buffer = context.buffer();
   1129     MatchResults<BufferIterator> matches;
   1130     auto pos = buffer.iterator_at(forward ? sel.max() : sel.min());
   1131     wrapped = false;
   1132     const bool found = forward ?
   1133         find_next(buffer, utf8::next(pos, buffer.end()), matches, regex, wrapped)
   1134       : find_prev(buffer, pos, matches, regex, wrapped);
   1135 
   1136     if (not found or matches[0].first == buffer.end())
   1137         throw runtime_error(format("no matches found: '{}'", regex.str()));
   1138 
   1139     CaptureList captures;
   1140     for (const auto& match : matches)
   1141         captures.push_back(buffer.string(match.first.coord(), match.second.coord()));
   1142 
   1143     auto begin = matches[0].first, end = matches[0].second;
   1144     end = (begin == end) ? end : utf8::previous(end, begin);
   1145     if (not forward)
   1146         std::swap(begin, end);
   1147 
   1148     return {begin.coord(), end.coord(), std::move(captures)};
   1149 }
   1150 
   1151 Vector<Selection> select_matches(const Buffer& buffer, ConstArrayView<Selection> selections, const Regex& regex, int capture_idx)
   1152 {
   1153     const int mark_count = (int)regex.mark_count();
   1154     if (capture_idx < 0 or capture_idx > mark_count)
   1155         throw runtime_error("invalid capture number");
   1156 
   1157     Vector<Selection> result;
   1158     ThreadedRegexVM<BufferIterator, RegexMode::Forward | RegexMode::Search> vm{*regex.impl()};
   1159     for (auto& sel : selections)
   1160     {
   1161         auto sel_beg = buffer.iterator_at(sel.min());
   1162         auto sel_end = utf8::next(buffer.iterator_at(sel.max()), buffer.end());
   1163 
   1164         for (auto&& match : RegexIterator{sel_beg, sel_end, vm, match_flags(buffer, sel_beg, sel_end),
   1165                                           EventManager::handle_urgent_events})
   1166         {
   1167             auto capture = match[capture_idx];
   1168             if (not capture.matched or capture.first == sel_end)
   1169                 continue;
   1170 
   1171             CaptureList captures;
   1172             captures.reserve(mark_count);
   1173             for (const auto& submatch : match)
   1174                 captures.push_back(buffer.string(submatch.first.coord(),
   1175                                                  submatch.second.coord()));
   1176 
   1177             auto begin = capture.first, end = capture.second;
   1178             result.push_back(
   1179                 keep_direction({ begin.coord(),
   1180                                  (begin == end ? end : utf8::previous(end, begin)).coord(),
   1181                                  std::move(captures) }, sel));
   1182         }
   1183     }
   1184     if (result.empty())
   1185         throw runtime_error("nothing selected");
   1186 
   1187     std::sort(result.begin(), result.end(), compare_selections);
   1188     return result;
   1189 }
   1190 
   1191 Vector<Selection> split_on_matches(const Buffer& buffer, ConstArrayView<Selection> selections, const Regex& regex, int capture_idx)
   1192 {
   1193     if (capture_idx < 0 or capture_idx > (int)regex.mark_count())
   1194         throw runtime_error("invalid capture number");
   1195 
   1196     Vector<Selection> result;
   1197     auto buf_end = buffer.end();
   1198     ThreadedRegexVM<BufferIterator, RegexMode::Forward | RegexMode::Search> vm{*regex.impl()};
   1199     for (auto& sel : selections)
   1200     {
   1201         auto sel_begin = buffer.iterator_at(sel.min());
   1202         auto begin = sel_begin;
   1203         auto sel_end = utf8::next(buffer.iterator_at(sel.max()), buf_end);
   1204 
   1205         for (auto&& match : RegexIterator{begin, sel_end, vm, match_flags(buffer, begin, sel_end)})
   1206         {
   1207             auto capture = match[capture_idx];
   1208             BufferIterator end = capture.first;
   1209             if (end == buf_end)
   1210                 continue;
   1211 
   1212             if (end != sel_begin)
   1213             {
   1214                 auto sel_end = (begin == end) ? end : utf8::previous(end, begin);
   1215                 result.push_back(keep_direction({ begin.coord(), sel_end.coord() }, sel));
   1216             }
   1217             begin = capture.second;
   1218         }
   1219         if (begin.coord() <= sel.max())
   1220             result.push_back(keep_direction({ begin.coord(), sel.max() }, sel));
   1221     }
   1222     if (result.empty())
   1223         throw runtime_error("nothing selected");
   1224     return result;
   1225 }
   1226 
   1227 UnitTest test_find_surrounding{[]()
   1228 {
   1229     StringView s = "{foo [bar { baz[] }]}";
   1230     auto check_equal = [&](const char* pos, StringView opening, StringView closing,
   1231                            ObjectFlags flags, int level, StringView expected) {
   1232         auto res = find_surrounding(s, pos,
   1233                                     Regex{"\\Q" + opening, RegexCompileFlags::Backward},
   1234                                     Regex{"\\Q" + closing, RegexCompileFlags::Backward},
   1235                                     flags, level);
   1236         kak_assert((not res) == expected.empty());
   1237         if (not res)
   1238             return;
   1239         auto min = std::min(res->first, res->second),
   1240              max = std::max(res->first, res->second);
   1241         kak_assert(StringView{min, max+1} == expected);
   1242     };
   1243 
   1244     check_equal(s.begin() + 13, '{', '}', ObjectFlags::ToBegin | ObjectFlags::ToEnd, 0, "{ baz[] }");
   1245     check_equal(s.begin() + 13, '[', ']', ObjectFlags::ToBegin | ObjectFlags::ToEnd | ObjectFlags::Inner, 0, "bar { baz[] }");
   1246     check_equal(s.begin() + 5, '[', ']', ObjectFlags::ToBegin | ObjectFlags::ToEnd, 0, "[bar { baz[] }]");
   1247     check_equal(s.begin() + 10, '{', '}', ObjectFlags::ToBegin | ObjectFlags::ToEnd, 0, "{ baz[] }");
   1248     check_equal(s.begin() + 16, '[', ']', ObjectFlags::ToBegin | ObjectFlags::ToEnd | ObjectFlags::Inner, 0, "");
   1249     check_equal(s.begin() + 18, '[', ']', ObjectFlags::ToBegin | ObjectFlags::ToEnd, 0, "[bar { baz[] }]");
   1250     check_equal(s.begin() + 6, '[', ']', ObjectFlags::ToBegin, 0, "[b");
   1251 
   1252     s = "[*][] foo";
   1253     kak_assert(not find_surrounding(s, s.begin() + 6,
   1254                                     Regex{"\\Q[", RegexCompileFlags::Backward},
   1255                                     Regex{"\\Q]", RegexCompileFlags::Backward},
   1256                                     ObjectFlags::ToBegin, 0));
   1257 
   1258     s = "begin foo begin bar end end";
   1259     check_equal(s.begin() + 6, "begin", "end", ObjectFlags::ToBegin | ObjectFlags::ToEnd, 0, s);
   1260     check_equal(s.begin() + 22, "begin", "end", ObjectFlags::ToBegin | ObjectFlags::ToEnd, 0, "begin bar end");
   1261 }};
   1262 
   1263 }