anchor.diff:  
   (defparameter *injected-sym* 'with-ps)
   
  -(defun injectedp (node)
  -  (and (listp node)
  -       (eql (first node) *injected-sym*)))
  -
  -(defun unwrap-injected (injected)
  -  (cadr injected))
  -
  -(defun atom-or-injected-p (form)
  -  (or (atom form) (injectedp form)))
  +(defun psx-atom-p (form)
  +  "Is value atomic--i.e. non-traversable."
  +  (not (and (listp form)
  +	    (keywordp (first form)))))
   
   (defun parse-prop (prop value)
     (let ((jsx-prop (or (getf *prop-synonyms* prop) prop)))
       (when (or (not (find jsx-prop *binary-props*)) value)
         (list (make-symbol (string jsx-prop))
  -	    (if (injectedp value)
  -		(unwrap-injected value)
  -		value)))))
  +	    value))))
   
   (defun parse-props (form)
     (loop
  
positive.code: 	 (if (null root)
  	     (setf root branch)
  	     (push branch (getf parent :children)))
  	 (when (not (atom-or-injected-p parsed-node))
  	   (mapcar (lambda (child) (list child branch))
  		   (getf parsed-node :children)))))
       tree)
  
negative.code: 	   do (push child stack))))
  
  (defun make-branch (parsed-node)
    (if (psx-atom-p parsed-node)
        parsed-node
        (list :type (getf parsed-node :type)
  	    :props (getf parsed-node :props)
  