anchor.diff:  (defclass javascript-backend () ())
   
   (defmethod translate-expression ((backend javascript-backend) expr)
  -  (flet ((symbol-from-key (key)
  -           (or (find-symbol (symbol-name key)
  -                            '#:closure-template)
  -               (error "Bad keyword ~A" key))))
  -    (if (and (consp expr)
  -             (symbolp (car expr)))
  -        (let ((key (car expr)))
  -          (case key
  -            (rem (cons 'ps:% (translate-expression backend
  -                                                   (cdr expr))))
  -            (:round (translate-expression backend
  +  (if (and (consp expr)
  +           (symbolp (car expr)))
  +      (let ((key (car expr)))
  +        (case key
  +          (rem (cons 'ps:% (translate-expression backend
  +                                                 (cdr expr))))
  +          (:round (translate-expression backend
                                           (cons 'round-closure-template
                                                 (cdr expr))))
  -            (:variable (if (find (second expr) *local-variables* :test #'string=)
  -                           (make-symbol (symbol-name (second expr)))
  -                           `(ps:@ $data$ ,(make-symbol (string-upcase (second expr))))))
  -            (getf `(,@(translate-expression backend
  -                                            (second expr) )
  -                      ,(make-symbol (string-upcase (third expr)))))
  -            (otherwise (cons (or (find-symbol (symbol-name key)
  -                                              '#:closure-template)
  -                                 (error "Bad keyword ~A" key))
  -                             (iter (for item in (cdr expr))
  -                                   (when item
  -                                     (collect (translate-expression backend item))))))))
  -          expr)))
  +          (:variable (if (find (second expr) *local-variables* :test #'string=)
  +                         (make-symbol (symbol-name (second expr)))
  +                         `(ps:@ $data$ ,(make-symbol (string-upcase (second expr))))))
  +          (getf `(,@(translate-expression backend
  +                                          (second expr) )
  +                    ,(make-symbol (string-upcase (third expr)))))
  +          (otherwise (cons (or (find-symbol (symbol-name key)
  +                                            '#:closure-template)
  +                               (error "Bad keyword ~A" key))
  +                           (iter (for item in (cdr expr))
  +                                 (when item
  +                                   (collect (translate-expression backend item))))))))
  +      expr))
   
   (defparameter *js-print-target* '$template-output$)
   
  
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
  