anchor.diff:  a literal. That quoted sequence will continue until either the end of
   the regex, or the appearance of `\E`.
   
  -For example `.\Q.^$\E$` will match any character followed by the literal
  -string `.^$` followed by an end of line.
  +For example, `.\Q.^$\E$` will match any character followed by the
  +literal string `.^$`, followed by an end of line.
   
   == Compatibility
   
  -The syntax tries to follow the ECMAScript regex syntax as defined by
  -https://www.ecma-international.org/ecma-262/8.0/ some divergences
  -exists for ease of use or performance reasons:
  +Kakoune's syntax tries to follow the ECMAScript regex syntax, as defined
  +by <https://www.ecma-international.org/ecma-262/8.0/>; some divergence
  +exists for ease of use, or performance reasons:
   
  -* lookarounds are not arbitrary, but lookbehind is supported.
  +* Lookarounds are not arbitrary, but lookbehind is supported.
   * `\K`, `\Q..\E`, `\A`, `\h` and `\z` are added.
  -* Stricter handling of escaping, as we introduce additional
  -  escapes, identity escapes like `\X` with X a non-special character
  +* Stricter handling of escaping, as we introduce additional escapes;
  +  identity escapes like `\X` with `X` being a non-special character
     are not accepted, to avoid confusions between `\h` meaning literal
     `h` in ECMAScript, and horizontal blank in Kakoune.
  -* `\uXXXXXX` uses 6 digits to cover all of unicode, instead of relying
  +* `\uXXXXXX` uses 6 digits to cover all of Unicode, instead of relying
     on ECMAScript UTF-16 surrogate pairs with 4 digits.
  
positive.code: 
  == Quantifier
  
  Literals, Character classes, Any characters and groups can be followed
  by a quantifier, which specifies the number of times they can match.
  
  * `?` matches zero or one times.
  * `*` matches zero or more times.
  * `+` matches one or more times.
  * `{n}` matches exactly n times.
  * `{n,}` matches n or more times.
  * `{n,m}` matches n to m times.
  * `{,m}` matches zero to m times.
  
  By default, quantifiers are *greedy*, which means they will prefer to
  match more characters if possible. Suffixing a quantifier with `?` will
  
negative.code: Literals match themselves, including syntax characters, so `^`
  does not need to be escaped in a character class. `[\*+]` matches both
  the `\*` character and the `+` character. Literal escape sequences are
  supported, so `[\n\r]` matches both the newline and carriage return
  characters.
  
  The `]` character needs to be escaped for it to match a literal `]`
  instead of closing the character class.
  
  Character ranges are written as `<start character>-<end character>`, so
  `[A-Z]` matches all uppercase basic letters. `[A-Z0-9]` will match all
  uppercase basic letters and all basic digits.
  
  The `-` characters in a character class that are not specifying a
  range are treated as literal `-`, so `[A-Z-+]` matches all upper case
  