 
 (defmethod parse 'ns
   [_ env [_ name & args] _]
-  (let [{requires :require requires-macros :require-macros :as params}
+  (let [excludes
+        (reduce (fn [s [k exclude xs]]
+                  (if (= k :refer-clojure)
+                    (do
+                      (assert (= exclude :exclude) "Only [:refer-clojure :exclude [names]] form supported")
+                      (into s xs))
+                    s))
+                #{} args)
+        {requires :require requires-macros :require-macros :as params}
         (reduce (fn [m [k & libs]]
                   (assoc m k (into {}
                                    (map (fn [[lib as alias]]
                                           (assert (and alias (= :as as)) "Only [lib.ns :as alias] form supported")
                                           [alias lib])
                                         libs))))
-                {} args)]
+                {} (remove (fn [[r]] (= r :refer-clojure)) args))]
     (set! *cljs-ns* name)
     (require 'cljs.core)
     (doseq [nsym (vals requires-macros)]
       (clojure.core/require nsym))
     (swap! namespaces #(-> %
                            (assoc-in [name :name] name)
+                           (assoc-in [name :excludes] excludes)
                            (assoc-in [name :requires] requires)
                            (assoc-in [name :requires-macros]
                                      (into {} (map (fn [[alias nsym]]
                                                      [alias (find-ns nsym)])
                                                    requires-macros)))))
-    {:env env :op :ns :name name :requires requires :requires-macros requires-macros}))
+    {:env env :op :ns :name name :requires requires
+     :requires-macros requires-macros :excludes excludes}))
 
 (defmethod parse 'deftype*
   [_ env [_ tsym fields] _]

                      sym))))

         :else
         (let [full-ns (if (get (:defs (@namespaces 'cljs.core)) sym)
                         'cljs.core
                         (-> env :ns :name))]
           (confirm-var-exists env full-ns sym)


         :else
         (munge (symbol (str
                         (if (core-name? env sym)
                           'cljs.core
                           (-> env :ns :name))
                         "." (munge (name sym))))))]
