anchor.diff:                               (progn (incf tind twhite)
                                       (incf eind ewhite)))))))))
   
  +    ;; Also in lisp
       (defun find-excerpt-position (tdat excerpt &optional (offset 0))
         (dotimes (i (length (@ tdat text)))
           (let ((loc (excerpt-here? tdat excerpt i)))
  
positive.code:       (and (has-excerpt-p opin)
             (not (equal null (@ opin 'text-position 0)))))
  
      ;; End target.lisp
  
      (defun focus-p (props?)
        (if (and (@ props? focus) (not-empty (@ props? focus)))
            (eql (list-last (@ props? tree-address) (list-last (@ props? focus))))
            t))
  
      (defun focus-parent-p (props?)
        (let ((fparent (getprop (chain (@ props? focus) (slice -2)) 0)))
          (when (eql (list-last (@ props? tree-address) fparent))
            (getprop (@ props? opinion-store) fparent)))
        (when
            (eql (list-last (@ props? tree-address)) fparent)))
  
      (defun immediate-children-ids (id opinstore)
        (if id
            (let ((len (@ (getprop opinstore id) 'tree-address length)))
              (collecting
                (dolist (itm (all-descendant-ids id opinstore))
                  (when (eq (1+ len) (@ (getprop opinstore itm) 'tree-address length))
                    (collect itm)))))
            (collecting
              (do-keyvalue (k opin opinstore)
                (when (eq 1 (@ opin 'tree-address length))
                  (collect (@ opin id)))))))
  
      (defun all-descendant-ids (id opinstore)
        (if id
            (let* ((trad (@ (getprop opinstore id) 'tree-address))
                   (len (@ trad length)))
              (collecting
                (do-keyvalue (k opin opinstore)
                  (when (< len (@ opin 'tree-address length))
                    (when (array-equal trad (chain (@ opin 'tree-address) (slice 0 len)))
                      (collect (@ opin id)))))))
            (chain -object (keys opinstore))))
  
  
      ))
  
  
negative.code:         (when pos
            (list (elt pos 0) (+ (elt pos 0) (elt pos 1))))))
  
      (defun rebreak (text)
        (chain (collecting
                 (dolist (string (chain text (split #\linefeed)))
                   (collect string)
                   (collect (psx (:br :key (unique-id))))))
               (slice 0 -1)))
  
      (defun %overlap-p (start1 end1 start2 end2)
        (not (or (> start1 end2) (> start2 end1))))
  