anchor.diff:               ,body)
              $template-output$))))
   
  -;; (defmethod translate-named-item ((backend javascript-backend) (item (eql 'closure-template.parser:foreach)) args)
  -;;   (let* ((loop-var (make-symbol (string-upcase (second (first (first args))))))
  -;;          (*local-variables* (cons loop-var
  -;;                                   *local-variables*))
  -;;          (seq-expr (translate-expression backend (second (first args)))))
  -;;     (let ((seqvar (gensym "$G")))
  -;;       `(let ((,seqvar ,seq-expr))
  -;;          (if ,seqvar
  -;;                (loop
  -;;                   for ,loop-var in ,seqvar                  
  -;;                   do ,(translate-item backend
  -;;                                       (second args)))
  -;;              ,(if (third args)
  -;;                   (translate-item backend
  -;;                                   (third args))))))))
  +  
  +(defmethod translate-named-item ((backend javascript-backend) (item (eql 'closure-template.parser:foreach)) args)
  +  (let* ((loop-var (make-symbol (string-upcase (second (first (first args))))))
  +         (*local-variables* (cons loop-var
  +                                  *local-variables*))
  +         (seq-expr (translate-expression backend (second (first args))))
  +         (seqvar (loop-sequence-symbol loop-var))
  +         (counter (loop-variable-counter-symbol loop-var)))
  +    `(let ((,seqvar ,seq-expr))
  +       (if ,seqvar
  +           (progn
  +             (defvar ,counter 0)
  +             (dolist (,loop-var ,seqvar)
  +               ,(translate-item backend
  +                                (second args))
  +               (incf ,counter)))
  +           ,(if (third args)
  +                (translate-item backend
  +                                (third args)))))))
   
   (defmethod translate-named-item ((backend javascript-backend) (item (eql 'closure-template.parser:if-tag)) args)
     "Full copy from common-lisp-backend"
  
positive.code:            (defvar $data$ (or $$data$$ (ps:create)))
             (defvar $template-output$ "")
             (macrolet ((has-data () '(if $$data$$ t))
                        (round-closure-template (number &optional digits-after-point)
                          `(if ,digits-after-point
                               (let ((factor (expt 10.0 ,digits-after-point)))
  
negative.code:                        (collect (translate-item backend
                                                  fun))))))
  
  (defun loop-variable-counter-symbol (loop-var)
    (make-symbol (format nil "~A-COUNTER" loop-var)))
  
  (defun loop-sequence-symbol (loop-var)
    (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 (translate-item backend
  