           (load-stream repl-env f res))))))
 
 (defn- wrap-fn [form]
-  (cond (and (seq? form) (= 'ns (first form))) identity
-        ('#{*1 *2 *3 *e} form) (fn [x] `(cljs.core.pr-str ~x))
-        :else (fn [x] `(cljs.core.pr-str
-                         (try
-                           (let [ret# ~x]
-                             (set! *3 *2)
-                             (set! *2 *1)
-                             (set! *1 ret#)
-                             ret#)
-                           (catch :default e#
-                             (set! *e e#)
-                             (throw e#)))))))
+  (cond
+    (and (seq? form) (= 'ns (first form))) identity
+    ('#{*1 *2 *3 *e} form) (fn [x] `(cljs.core.pr-str ~x))
+    :else
+    (fn [x]
+      `(cljs.core.pr-str
+         (try
+           (let [ret# ~x]
+             (set! *3 *2)
+             (set! *2 *1)
+             (set! *1 ret#)
+             ret#)
+           (catch :default e#
+             (set! *e e#)
+             (throw e#)))))))
 
 (defn- eval-cljs
   "Given a REPL evaluation environment, an analysis environment, and a

             is-special-fn? (set (keys special-fns))
             request-prompt (Object.)
             request-exit (Object.)
             read-error (Object.)
             opts (if-let [merge-opts (:merge-opts (-setup repl-env opts))]
                    (merge opts merge-opts)
                    opts)]
         (comp/with-core-cljs opts
           (fn []
             (when analyze-path

  supporting .unread and collapsing all of CR, LF, and CRLF to a single
  \\newline."
  [s]
  (loop [c (readers/read-char s)]
    (case c
      \newline :line-start
      nil :stream-end
      \; (do (readers/read-line s) :line-start)
      (if (or (Character/isWhitespace c) (identical? c \,))
        (recur (readers/read-char s))
        (do (readers/unread s c) :body)))))

(defn repl-read
  "Default :read hook for repl. Reads from *in* which must either be an
