anchor.diff:              string))))
   
   (defun format-text (control-string &rest args)
  -  (pprint-newline :mandatory *html*)
  +  (when *print-pretty*
  +    (terpri *html*))
     (let ((*depth* (1+ *depth*)))
       (fill-text (format nil "~?" control-string args) t))
     (values))
  
positive.code:   "Depth of the tag being output.")
  
  (defvar *pre* nil)
  
  (defun fast-format (stream control-string &rest args)
    "Like `format', but bind `*print-pretty*' to nil."
  
negative.code: 
  (defun format-attributes/inline (attrs &optional (stream *html*))
    (declare (stream stream))
    (let* ((seen '())
           (start-col *depth*)
           (fill *fill-column*)
           (goal (+ start-col fill)))
      ;; Ensure that the leftmost keyword has priority,
      ;; as in function lambda lists.
      (serapeum:fbind ((too-long?
                        (if *print-pretty*
                            (lambda (len)
                              (> (+ len (html-stream-column stream))
                                 goal))
                            (constantly nil))))
        (labels ((seen? (name)
                   (declare (optimize speed)
                            (symbol name))
                   (prog1 (member name seen)
                     (push name seen)))
                 (format-attr (attr value)
                   (unless (or (null value) (seen? attr))
                     (if (boolean? attr)
                         (let ((len (length (symbol-name attr))))
                           ;; No valid attribute is longer than 80. (I
                           ;; suppose a data attribute could be.)
                           (if (too-long? len)
                               (format stream "~%~V,0T~(~a~)" start-col attr)
                               (progn
                                 (format stream " ~(~a~)" attr))))
                         (let ((value (format-attribute-value value)))
                           (let ((len (1+ (length (symbol-name attr)))))
                             (if (too-long? len)
                                 (format stream "~%~V,0T~(~a~)=" start-col attr)
                                 (format stream " ~(~a~)=" attr)))
                           (format stream "~a" value)))))
                 (dynamic-attrs (attrs)
                   (doplist (a v attrs)
                     (format-attr a (escape-value v)))))
          (declare (inline seen? too-long?))
          (doplist (attr value attrs)
            (if (eql attr :attrs)
                (dynamic-attrs value)
                (format-attr attr value)))))))
  
  (defun format-attributes (attrs &optional (stream *html*))
    (declare (stream stream))
    (if (null attrs)
        (write-char #\> stream)
        (let ((seen '()))
          ;; Ensure that the leftmost keyword has priority,
          ;; as in function lambda lists.
          (pprint-logical-block (stream attrs)
  