anchor.diff:  (defmethod tree-recompute-extent :around ((record compound-output-record))
     (with-bounding-rectangle* (old-x1 old-y1 old-x2 old-y2) record
       (call-next-method)
  -    (with-bounding-rectangle* (x1 y1 x2 y2)
  -        record
  -      (let ((parent (output-record-parent record)))
  -        (when (and parent
  -                   (not (and (= old-x1 x1)
  -                             (= old-y1 y1)
  -                             (= old-x2 x2)
  -                             (= old-y2 y2))))
  +    (with-bounding-rectangle* (x1 y1 x2 y2) record
  +      (when-let ((parent (output-record-parent record)))
  +        (when (not (and (= old-x1 x1)
  +                        (= old-y1 y1)
  +                        (= old-x2 x2)
  +                        (= old-y2 y2)))
             (recompute-extent-for-changed-child parent record
                                                 old-x1 old-y1
                                                 old-x2 old-y2)))))
  
positive.code:   (bounding-rectangle* record))
  
  (defmethod tree-recompute-extent-aux ((record compound-output-record))
    (let ((new-x1 0)
          (new-y1 0)
          (new-x2 0)
          (new-y2 0)
          (first-time t))
      (map-over-output-records
       (lambda (child)
         (if first-time
             (progn
               (multiple-value-setq (new-x1 new-y1 new-x2 new-y2)
                 (tree-recompute-extent-aux child))
               (setq first-time nil))
             (multiple-value-bind (cx1 cy1 cx2 cy2)
                 (tree-recompute-extent-aux child)
               (minf new-x1 cx1)
               (minf new-y1 cy1)
               (maxf new-x2 cx2)
               (maxf new-y2 cy2))))
       record)
      (with-slots (x y) record
        (if first-time			;No children
            (bounding-rectangle* record)
            (progn
              (setf  x new-x1 y new-y1)
              (setf (rectangle-edges* record)
                    (values new-x1 new-y1 new-x2 new-y2)))))))
  
  (defmethod recompute-extent-for-changed-child
      ((record compound-output-record) changed-child
  
negative.code:   "Applies FUNCTION to children, overlapping REGION, in the order they
  were added."
    (declare (ignore x-offset y-offset))
    (let ((function (alexandria:ensure-function function)))
      (loop with children = (output-record-children record)
            for child across children
            when (region-intersects-region-p region child)
            do (apply function child function-args))))
  
  ;;; tree output recording
  
  