anchor.diff:     and @fun{attribute*}."
     `(invoke-with-namespace (lambda () ,@body) ,prefix ,uri))
   
  -(defun doctype (name public-id system-id &optional internal-subset)
  +(defun doctype (name public-id system-id &optional internal-subset &aux (sink *sink*))
     "@arg[name]{Element name, a string.}
      @arg[public-id]{String}
      @arg[system-id]{A system ID as a @class{puri:uri}.}
  
positive.code:            :value (rod value))
            (cdr *current-element*))))
  
  (defun cdata (data)
    "@arg[data]{String.}
     @return{undocumented}
  
  
negative.code: 
     Writes a doctype declaration to the current output sink, using the
     specified name, public ID, system ID, and optionally an internal subset."
    (sax:start-dtd sink name public-id system-id)
    (when internal-subset
      (sax:unparsed-internal-subset sink internal-subset))
    (sax:end-dtd sink))
  
  (defun maybe-emit-start-tag (&aux (current-element *current-element*))
    (when current-element
      ;; starting child node, need to emit opening tag of parent first:
      (destructuring-bind ((uri lname qname) &rest attributes) current-element
        (sax:start-element *sink* uri lname qname (nreverse attributes)))
      (setf *current-element* nil)))
  
  (defun invoke-with-namespace (fn prefix uri &aux (sink *sink*))
    (let ((*unparse-namespace-bindings*
           (acons prefix uri *unparse-namespace-bindings*))
          (*current-namespace-bindings*
           (acons prefix uri *current-namespace-bindings*)))
      (sax:start-prefix-mapping sink prefix uri)
      (multiple-value-prog1
          (funcall fn)
        (sax:end-prefix-mapping sink prefix))))
  
  (defun invoke-with-element (fn qname)
    (setf qname (rod qname))
  