anchor.diff:  
   
   (defun compile-node (parsed-node)
  -  (cond ((atom parsed-node) parsed-node)
  -	((injectedp parsed-node) (unwrap-injected parsed-node))
  -	(t (destructuring-bind (&key type props children) parsed-node
  -	     (let ((type-sym (make-symbol (string type)))
  -		   (props-form (cond ((and (null children) (null props)) nil)
  -				     ((null props) (list nil))
  -				     (t `((create ,@props)))))
  -		   (children-form (cond ((null children) nil)
  -					((rest children) (list (list 'array)))
  -					(t (list nil)))))
  -	       (values (if (dom-type-p type)
  +  (if (psx-atom-p parsed-node)
  +      parsed-node
  +      (destructuring-bind (&key type props children) parsed-node
  +	(let ((type-sym (make-symbol (string type)))
  +	      (props-form (cond ((and (null children) (null props)) nil)
  +				((null props) (list nil))
  +				(t `((create ,@props)))))
  +	      (children-form (cond ((null children) nil)
  +				   ((rest children) (list (list 'array)))
  +				   (t (list nil)))))
  +	  (values (if (dom-type-p type)
   			   `(chain React DOM (,type-sym ,@props-form ,@children-form))
   			   `(chain React (create-element ,type-sym ,@props-form ,@children-form)))
  -		       children))))))
  +		  children)))))
   
   (defun push-compiled-child (child compiled-node)
     (let* ((children-cell (last (first (last compiled-node))))
  
positive.code: 		
  
  (defun parse-node (node)
    (if (atom-or-injected-p node)
        node
        (multiple-value-bind (props children) (parse-props (rest node))
  	(list :type (first node)
  
negative.code: 
  (defparameter *injected-sym* 'with-ps)
  
  (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))
  	    value))))
  
  (defun parse-props (form)
    (loop
  