anchor.diff:    `(define-transpiler-std-macro *js-transpiler* ,@x))
   
   (defun transpiler-obfuscate-arguments (tr x)
  -  (dolist (i (argument-expand 'unnamed-js-function x nil nil))
  -    (transpiler-obfuscate-symbol *js-transpiler* i)))
  +  (dolist (i (argument-expand 'anonymous-function x nil nil))
  +    (transpiler-obfuscate-symbol tr i)))
   
  +;; (FUNCTION symbol | lambda-expression)
  +;; Add symbol to list of wanted functions or obfuscate arguments of
  +;; LAMBDA-expression.
  +;; XXX Wouldn't this obfuscate the arguments over and over again?
   (define-js-std-macro function (x)
     (unless x
       (error "FUNCTION expects a symbol or form"))
  
positive.code:       (transpiler-obfuscate-arguments *js-transpiler* x.))
    `(function ,x))
  
  (define-js-std-macro defun (name args &rest body)
    (print `(defun ,name))
    (let n (%defun-name name)
      (transpiler-obfuscate-symbol *js-transpiler* n)
      (unless (in? n 'apply)
        (acons! n args (transpiler-function-args tr)))
      `(progn
         (%var ,n)
         (%setq ,n
  
negative.code: 				         .body
  				         body))))))
  
  (define-js-std-macro defun (name args &rest body)
    `(progn
       (js-defun ,name ,args ,@body)
  	 (%setq (%slot-value ,(%defun-name name) tre-args) ',args)))
  
  (define-js-std-macro defmacro (name &rest x)
    (print `(defmacro ,name ))
    (eval (transpiler-macroexpand *js-transpiler*
  								`(define-js-std-macro ,name ,@x)))
    nil)
  
  (define-js-std-macro defvar (name val)
  