anchor.diff:      (alexandria:when-let ((result (match-pattern-1 lexer #\?)))
         (return-from match-pattern `(lem-vi-mode.ex-command:search-backward ,result)))))
   
  +(defun parse-ex-offset (lexer)
  +  (skip-whitespace lexer)
  +  (unless (end-of-string-p lexer)
  +    (cond ((accept lexer #\+)
  +           (alexandria:when-let ((number (match-number lexer)))
  +             `(lem-vi-mode.ex-command:offset-line ,number)))
  +          ((accept lexer #\-)
  +           (alexandria:when-let ((number (match-number lexer)))
  +             `(lem-vi-mode.ex-command:offset-line ,(- number)))))))
  +
   (defun parse-ex-line (lexer)
     (skip-whitespace lexer)
     (unless (end-of-string-p lexer)
  
positive.code:     (when range
        `(lem-vi-mode.ex-command:range . ,(nreverse range)))))
  
  (defun parse-ex (lexer)
    (let ((range (parse-ex-range lexer)))
      ))
  
negative.code:             ((accept lexer #\')
               (prog1 `(lem-vi-mode.ex-command:marker ,(lookahead lexer))
                 (lexer-forward lexer)))
              ((match-pattern lexer))
              ((parse-ex-offset lexer))))))
  
  (defun parse-ex-range-element (lexer)
    (let ((lines (loop
                   :for line := (parse-ex-line lexer)
                   :while line
                   :collect line)))
      (if (null (rest lines))
          (first lines)
          `(progn . ,lines))))
  
  (defun delimiter (lexer)
    (unless (end-of-string-p lexer)
  