anchor.diff:    (make-symbol (format nil "~A-SEQ" loop-var)))
   
   (defmethod translate-named-item ((backend javascript-backend) (item (eql 'closure-template.parser:template)) args)
  -  (let* ((*template-variables* nil)
  -         (body (let ((*autoescape* (if (find :autoescape (cdar args))
  +  (let* ((body (let ((*autoescape* (if (find :autoescape (cdar args))
                                          (getf (cdar args) :autoescape)
                                          *autoescape*)))
                    (translate-item backend
                                    (cdr args)))))
       `(setf (,@*js-namespace* ,(js-string-to-symbol (caar args)))
  -         (lambda ($$data$$)
  +         (lambda ($$data$$ $$template-output$$)
              (defvar $data$ (or $$data$$ (ps:create)))
  -           (defvar $template-output$ "")
  +           (defvar $template-output$
  +             (or $$template-output$$ (array)))
              (macrolet ((has-data () '(if $$data$$ t))
                         (index (var) `,(js-loop-variable-counter-symbol var))
                         (is-first (var) `(= 0 (index ,var)))
  
positive.code:                                                     `(when (= (ps:typeof ,part) "undefined")
                                                         (setf ,part (ps:create)))
                                                      `(when (= (ps:typeof ,part) "undefined")
                                                         (defvar ,part (ps:create)))))))))
                   (iter (for fun in (cdr args))
                         (collect (translate-item backend
                                                  fun))))))
  
negative.code:                                (/ (round (* ,number factor)) factor))
                               (round ,number))))             
               ,body)
             (unless $$template-output$$
               (funcall (ps:@ $template-output$ join) ""))))))
  
  (defmethod translate-named-item ((backend javascript-backend) (item (eql 'closure-template.parser:with)) args)
    (let ((*local-variables* *local-variables*))
  