anchor.diff:  Some modifiers can control the matching behavior of the atoms following
   them:
   
  -* `(?i)` enables case-insensitive matching
  -* `(?I)` disables case-insensitive matching (default)
  -* `(?s)` enables dot-matches-newline (default)
  -* `(?S)` disables dot-matches-newline
  +* `(?i)` starts case-insensitive matching.
  +* `(?I)` starts case-sensitive matching (default).
  +* `(?s)` allows `.` to match newlines (default).
  +* `(?S)` prevents `.` from matching newlines.
   
   == Quoting
   
  
positive.code: = Regex
  
  == Regex Syntax
  
  Kakoune regex syntax is based on the ECMAScript syntax, as defined by the
  ECMA-262 standard (see <<Compatibility>>).
  
  Kakoune's regex always run on Unicode codepoint sequences, not on bytes.
  
  == Literals
  
  Every character except the syntax characters `\^$.*+?[]{}|().` match
  themselves. Syntax characters can be escaped with a backslash so `\$`
  will match a literal `$` and `\\` will match a literal `\`.
  
  Some literals are available as escape sequences:
  
  * `\f` matches the form feed character.
  * `\n` matches the line feed character.
  * `\r` matches the carriage return character.
  * `\t` matches the tabulation character.
  * `\v` matches the vertical tabulation character.
  * `\0` matches the null character.
  * `\cX` matches the control-X character (X can be in `[A-Za-z]`).
  * `\xXX` matches the character whose codepoint is XX (in hexadecimal).
  * `\uXXXXXX` matches the character whose codepoint is XXXXXX (in hexadecimal).
  
  == Character classes
  
  
negative.code: 
  == Zero width assertions
  
  Assertions do not consume any character, but they will prevent the regex
  from matching if not fulfilled.
  
  * `^` matches at the start of a line; that is, just after a newline
        character, or at the subject's beginning (unless it is specified
        that the subject's beginning is not a start of line).
  * `$` matches at the end of a line; that is, just before a newline, or
        at the subject end (unless it is specified that the subject's end
        is not an end of line).
  * `\b` matches at a word boundary; which is to say that between the
         previous character and the current character, one is a word
         character, and the other is not.
  * `\B` matches at a non-word boundary; meaning, when both the previous
         character and the current character are word characters, or both
         are not.
  * `\A` matches at the subject string's beginning.
  * `\z` matches at the subject string's end.
  * `\K` matches anything, and resets the start position of capture group
         0 to the current position.
  
  More complex assertions can be expressed with lookarounds:
  
  * `(?=...)` is a lookahead; it will match if its content matches the
              text following the current position.
  * `(?!...)` is a negative lookahead; it will match if its content does
              not match the text following the current position.
  * `(?<=...)` is a lookbehind; it will match if its content matches
               the text preceding the current position.
  * `(?<!...)` is a negative lookbehind; it will match if its content does
               not match the text preceding the current position.
  
  For performance reasons, lookaround contents must be a sequence of
  literals, character classes, or any character (`.`); quantifiers are not
  supported.
  
  For example, `(?<!bar)(?=foo).` will match any character which is not
  preceded by `bar` and where `foo` matches from the current position
  