anchor.diff:  
   == Zero width assertions
   
  -Assertions do not consume any character, but will prevent the regex
  -from matching if they are not fulfilled.
  +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 new line
  -      character, or at the subject begin (except if specified that the
  -      subject begin is not a start of line).
  -* `$` matches at the end of a line, that is just before a new line, or
  -      at the subject end (except if specified that the subject's end
  +* `^` 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, when one of the previous character
  -       and current character is a word character, and the other is not.
  -* `\B` matches at a non word boundary, when both the previous character
  -       and the current character are word, or are not.
  -* `\A` matches at the subject string begin.
  -* `\z` matches at the subject string end.
  -* `\K` matches anything, and resets the start position of the capture
  -       group 0 to the current position.
  +* `\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
  +* `(?=...)` 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 sequence of literals,
  -character classes or any-character (`.`); Quantifiers are not supported.
  +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
  
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: Some modifiers can control the matching behavior of the atoms following
  them:
  
  * `(?i)` starts case-insensitive matching.
  * `(?I)` starts case-sensitive matching (default).
  * `(?s)` allows `.` to match newlines (default).
  * `(?S)` prevents `.` from matching newlines.
  
  == Quoting
  
  