parindent on instaparse

instaparse.diff

diff --git a/runner/cljs/runner/runner.cljs b/runner/cljs/runner/runner.cljs
index e1b2f97..74bc9f6 100644
--- a/runner/cljs/runner/runner.cljs
+++ b/runner/cljs/runner/runner.cljs
@@ -1,13 +1,13 @@
 (ns instaparse.runner.runner
   (:require [cljs.nodejs :as nodejs]
-            [instaparse.abnf-test]
-            [instaparse.auto-flatten-seq-test]
-            [instaparse.core-test]
-            [instaparse.defparser-test]
-            [instaparse.grammars]
-            [instaparse.repeat-test]
-            [instaparse.specs]
-            [cljs.test :as test :refer-macros [run-tests]]))
+   [instaparse.abnf-test]
+   [instaparse.auto-flatten-seq-test]
+   [instaparse.core-test]
+   [instaparse.defparser-test]
+   [instaparse.grammars]
+   [instaparse.repeat-test]
+   [instaparse.specs]
+   [cljs.test :as test :refer-macros [run-tests]]))
 
 (nodejs/enable-util-print!)
 
diff --git a/src/instaparse/abnf.cljc b/src/instaparse/abnf.cljc
index a740413..3838f35 100644
--- a/src/instaparse/abnf.cljc
+++ b/src/instaparse/abnf.cljc
@@ -2,15 +2,15 @@
   "This is the context free grammar that recognizes ABNF notation."
   (:refer-clojure :exclude [cat])
   (:require [instaparse.transform :as t]
-            [instaparse.cfg :as cfg]
-            [instaparse.gll :as gll]
-            [instaparse.reduction :as red]
-            [instaparse.util :refer [throw-runtime-exception]]
-            [instaparse.combinators-source :refer
-             [Epsilon opt plus star rep alt ord cat string-ci string
-              string-ci regexp nt look neg hide hide-tag unicode-char]]
-            #?(:cljs [goog.string.format])
-            [clojure.walk :as walk])
+   [instaparse.cfg :as cfg]
+   [instaparse.gll :as gll]
+   [instaparse.reduction :as red]
+   [instaparse.util :refer [throw-runtime-exception]]
+   [instaparse.combinators-source :refer
+    [Epsilon opt plus star rep alt ord cat string-ci string
+     string-ci regexp nt look neg hide hide-tag unicode-char]]
+   #?(:cljs [goog.string.format])
+   [clojure.walk :as walk])
   #?(:cljs (:require-macros [instaparse.abnf :refer [precompile-cljs-grammar]])))
 
 (def ^:dynamic *case-insensitive*
@@ -204,17 +204,17 @@ regexp = #\"#'[^'\\\\]*(?:\\\\.[^'\\\\]*)*'\"
                  
    :repetition (fn 
                  ([repeat element]
-                   (cond
-                     (empty? repeat) (star element)
-                     (= (count repeat) 2) (rep (:low repeat) (:high repeat) element)
-                     (= (:low repeat) 1) (plus element)
-                     (= (:high repeat) 1) (opt element)
-                     :else (rep (or (:low repeat) 0)
-                                (or (:high repeat) #?(:clj Double/POSITIVE_INFINITY
-                                                      :cljs js/Infinity))
-                                element)))
+                  (cond
+                    (empty? repeat) (star element)
+                    (= (count repeat) 2) (rep (:low repeat) (:high repeat) element)
+                    (= (:low repeat) 1) (plus element)
+                    (= (:high repeat) 1) (opt element)
+                    :else (rep (or (:low repeat) 0)
+                               (or (:high repeat) #?(:clj Double/POSITIVE_INFINITY
+                                                     :cljs js/Infinity))
+                               element)))
                  ([element]
-                   element))
+                  element))
    :option opt
    :hide hide
    :look look
diff --git a/src/instaparse/auto_flatten_seq.cljc b/src/instaparse/auto_flatten_seq.cljc
index 7de638c..14b0bd9 100644
--- a/src/instaparse/auto_flatten_seq.cljc
+++ b/src/instaparse/auto_flatten_seq.cljc
@@ -78,164 +78,164 @@
          (flat-seq v (delve v [0]))
          nil))
   ([v index]
-    (lazy-seq
-      (cons (get-in v index) 
-            (when-let [next-index (advance v index)] 
-              (flat-seq v next-index))))))  
+   (lazy-seq
+     (cons (get-in v index) 
+           (when-let [next-index (advance v index)] 
+             (flat-seq v next-index))))))  
 
 #?(:clj
-(deftype AutoFlattenSeq [^PersistentVector v ^int premix-hashcode ^int hashcode
-                         ^int cnt ^boolean dirty
-                         ^:unsynchronized-mutable ^clojure.lang.ISeq cached-seq]
-  Object
-  (toString [self] (.toString (seq self)))
-  (hashCode [self] hashcode)
-  (equals [self other]
-    (and (instance? AutoFlattenSeq other)
-         (== hashcode (.hashcode ^AutoFlattenSeq other))
-         (== cnt (.cnt ^AutoFlattenSeq other))
-         (= dirty (.dirty ^AutoFlattenSeq other))
-         (= v (.v ^AutoFlattenSeq other))))
-  clojure.lang.IHashEq
-  (hasheq [self] hashcode)
-  java.util.Collection
-  (iterator [self]
-    (if-let [^java.util.Collection s (seq self)]
-      (.iterator s)
-      (let [^java.util.Collection e ()]
-        (.iterator e))))
-  (size [self]
-    cnt)
-  (toArray [self]
-    (let [^java.util.Collection s (seq self)]
-      (.toArray s)))
-  clojure.lang.Sequential
-  clojure.lang.ISeq
-  (equiv [self other]
-    (and (== hashcode (hash other))
-         (== cnt (count other))
-         (or (== cnt 0)
-             (= (seq self) other))))
-  (empty [self] (with-meta EMPTY (meta self))) 
-  (first [self] (first (seq self)))
-  (next [self] (next (seq self)))
-  (more [self] (rest (seq self)))
-  (cons [self obj]
-    (cons obj self))
-  ConjFlat
-  (conj-flat [self obj]
-    (cond
-      (nil? obj) self
-      (afs? obj)
-      (cond
-        (zero? cnt) obj
-        (<= (count obj) threshold)
-        (let [phc (hash-cat self obj)
-              new-cnt (+ cnt (count obj))]
-          (AutoFlattenSeq. (into v obj) phc (mix-collection-hash-bc phc new-cnt) new-cnt
-                           (or dirty (.dirty ^AutoFlattenSeq obj)) nil))
-        :else
-        (let [phc (hash-cat self obj)
-              new-cnt (+ cnt (count obj))]
-          (AutoFlattenSeq. (conj v obj) phc (mix-collection-hash-bc phc new-cnt) new-cnt
-                           true nil)))
-      :else 
-      (let [phc (hash-conj premix-hashcode obj)
-            new-cnt (inc cnt)]
-        (AutoFlattenSeq. (conj v obj) phc (mix-collection-hash-bc phc new-cnt) new-cnt dirty nil))))
-  (cached? [self] cached-seq)
-  clojure.lang.Counted
-  (count [self] cnt)
-  clojure.lang.ILookup
-  (valAt [self key]    
-    (.valAt v key))
-  (valAt [self key not-found]
-    (.valAt v key not-found))
-  clojure.lang.IObj
-  (withMeta [self metamap]
-    (AutoFlattenSeq. (with-meta v metamap) premix-hashcode hashcode cnt dirty nil))
-  clojure.lang.IMeta
-  (meta [self]
-    (meta v))
-  clojure.lang.Seqable
-  (seq [self]
-    (if cached-seq cached-seq
-      (do
-        (set! cached-seq (if dirty (flat-seq v) (seq v)))
-        cached-seq))))
-:cljs
-(deftype AutoFlattenSeq [^PersistentVector v ^number premix-hashcode ^number hashcode ^number cnt ^boolean dirty
-                         ^:unsynchronized-mutable ^ISeq cached-seq]
-  Object
-  (toString [self] (pr-str* (seq self)))
-  IHash
-  (-hash [self] hashcode)
-  ISequential
-  ISeq
-  (-first [self] (first (seq self)))
-  (-rest [self] (rest (seq self)))
-  IEquiv
-  (-equiv [self other]
-    (and ;(instance? AutoFlattenSeq other)
+   (deftype AutoFlattenSeq [^PersistentVector v ^int premix-hashcode ^int hashcode
+                            ^int cnt ^boolean dirty
+                            ^:unsynchronized-mutable ^clojure.lang.ISeq cached-seq]
+     Object
+     (toString [self] (.toString (seq self)))
+     (hashCode [self] hashcode)
+     (equals [self other]
+       (and (instance? AutoFlattenSeq other)
+            (== hashcode (.hashcode ^AutoFlattenSeq other))
+            (== cnt (.cnt ^AutoFlattenSeq other))
+            (= dirty (.dirty ^AutoFlattenSeq other))
+            (= v (.v ^AutoFlattenSeq other))))
+     clojure.lang.IHashEq
+     (hasheq [self] hashcode)
+     java.util.Collection
+     (iterator [self]
+       (if-let [^java.util.Collection s (seq self)]
+         (.iterator s)
+         (let [^java.util.Collection e ()]
+           (.iterator e))))
+     (size [self]
+       cnt)
+     (toArray [self]
+       (let [^java.util.Collection s (seq self)]
+         (.toArray s)))
+     clojure.lang.Sequential
+     clojure.lang.ISeq
+     (equiv [self other]
+       (and (== hashcode (hash other))
+            (== cnt (count other))
+            (or (== cnt 0)
+                (= (seq self) other))))
+     (empty [self] (with-meta EMPTY (meta self))) 
+     (first [self] (first (seq self)))
+     (next [self] (next (seq self)))
+     (more [self] (rest (seq self)))
+     (cons [self obj]
+       (cons obj self))
+     ConjFlat
+     (conj-flat [self obj]
+       (cond
+         (nil? obj) self
+         (afs? obj)
+         (cond
+           (zero? cnt) obj
+           (<= (count obj) threshold)
+           (let [phc (hash-cat self obj)
+                 new-cnt (+ cnt (count obj))]
+             (AutoFlattenSeq. (into v obj) phc (mix-collection-hash-bc phc new-cnt) new-cnt
+                              (or dirty (.dirty ^AutoFlattenSeq obj)) nil))
+           :else
+           (let [phc (hash-cat self obj)
+                 new-cnt (+ cnt (count obj))]
+             (AutoFlattenSeq. (conj v obj) phc (mix-collection-hash-bc phc new-cnt) new-cnt
+                              true nil)))
+         :else 
+         (let [phc (hash-conj premix-hashcode obj)
+               new-cnt (inc cnt)]
+           (AutoFlattenSeq. (conj v obj) phc (mix-collection-hash-bc phc new-cnt) new-cnt dirty nil))))
+     (cached? [self] cached-seq)
+     clojure.lang.Counted
+     (count [self] cnt)
+     clojure.lang.ILookup
+     (valAt [self key]    
+       (.valAt v key))
+     (valAt [self key not-found]
+       (.valAt v key not-found))
+     clojure.lang.IObj
+     (withMeta [self metamap]
+       (AutoFlattenSeq. (with-meta v metamap) premix-hashcode hashcode cnt dirty nil))
+     clojure.lang.IMeta
+     (meta [self]
+       (meta v))
+     clojure.lang.Seqable
+     (seq [self]
+       (if cached-seq cached-seq
+         (do
+           (set! cached-seq (if dirty (flat-seq v) (seq v)))
+           cached-seq))))
+   :cljs
+   (deftype AutoFlattenSeq [^PersistentVector v ^number premix-hashcode ^number hashcode ^number cnt ^boolean dirty
+                            ^:unsynchronized-mutable ^ISeq cached-seq]
+     Object
+     (toString [self] (pr-str* (seq self)))
+     IHash
+     (-hash [self] hashcode)
+     ISequential
+     ISeq
+     (-first [self] (first (seq self)))
+     (-rest [self] (rest (seq self)))
+     IEquiv
+     (-equiv [self other]
+       (and ;(instance? AutoFlattenSeq other)
          (= hashcode (hash other))
          (= cnt (count other))
          (or (= cnt 0)
              (= (seq self) other))))
-  ICollection
-  (-conj [self o] (cons o self))
-  IEmptyableCollection
-  (-empty [self] (with-meta EMPTY (meta self))) 
-  INext
-  (-next [self] (next (seq self)))
-  ConjFlat
-  (conj-flat [self obj]
-    (cond
-      (nil? obj) self
-      (afs? obj)
-      (cond
-        (zero? cnt) obj
-        (<= (count obj) threshold)
-        (let [phc (hash-cat self obj)
-              new-cnt (+ cnt (count obj))]
-          (AutoFlattenSeq. (into v obj) phc (mix-collection-hash phc new-cnt) new-cnt
-                           (or dirty (.-dirty ^AutoFlattenSeq obj)) nil))
-        :else
-        (let [phc (hash-cat self obj)
-              new-cnt (+ cnt (count obj))]
-          (AutoFlattenSeq. (conj v obj) phc (mix-collection-hash phc new-cnt) new-cnt
-                           true nil)))
-      :else
-      (let [phc (hash-conj premix-hashcode obj)
-            new-cnt (inc cnt)]
-        (AutoFlattenSeq. (conj v obj) phc (mix-collection-hash phc new-cnt) new-cnt dirty nil))))
-  (cached? [self] cached-seq)
-  ICounted
-  (-count [self] cnt)
-  ILookup
-  (-lookup [self key]
-    (-lookup v key))
-  (-lookup [self key not-found]
-    (-lookup v key not-found))
-  IWithMeta
-  (-with-meta [self metamap]
-    (AutoFlattenSeq. (with-meta v metamap) premix-hashcode hashcode cnt dirty nil))
-  IMeta
-  (-meta [self]
-    (meta v))
-  ISeqable
-  (-seq [self]
-    (if cached-seq cached-seq
-      (do
-        (set! cached-seq (if dirty (flat-seq v) (seq v)))
-        cached-seq)))))
+     ICollection
+     (-conj [self o] (cons o self))
+     IEmptyableCollection
+     (-empty [self] (with-meta EMPTY (meta self))) 
+     INext
+     (-next [self] (next (seq self)))
+     ConjFlat
+     (conj-flat [self obj]
+       (cond
+         (nil? obj) self
+         (afs? obj)
+         (cond
+           (zero? cnt) obj
+           (<= (count obj) threshold)
+           (let [phc (hash-cat self obj)
+                 new-cnt (+ cnt (count obj))]
+             (AutoFlattenSeq. (into v obj) phc (mix-collection-hash phc new-cnt) new-cnt
+                              (or dirty (.-dirty ^AutoFlattenSeq obj)) nil))
+           :else
+           (let [phc (hash-cat self obj)
+                 new-cnt (+ cnt (count obj))]
+             (AutoFlattenSeq. (conj v obj) phc (mix-collection-hash phc new-cnt) new-cnt
+                              true nil)))
+         :else
+         (let [phc (hash-conj premix-hashcode obj)
+               new-cnt (inc cnt)]
+           (AutoFlattenSeq. (conj v obj) phc (mix-collection-hash phc new-cnt) new-cnt dirty nil))))
+     (cached? [self] cached-seq)
+     ICounted
+     (-count [self] cnt)
+     ILookup
+     (-lookup [self key]
+       (-lookup v key))
+     (-lookup [self key not-found]
+       (-lookup v key not-found))
+     IWithMeta
+     (-with-meta [self metamap]
+       (AutoFlattenSeq. (with-meta v metamap) premix-hashcode hashcode cnt dirty nil))
+     IMeta
+     (-meta [self]
+       (meta v))
+     ISeqable
+     (-seq [self]
+       (if cached-seq cached-seq
+         (do
+           (set! cached-seq (if dirty (flat-seq v) (seq v)))
+           cached-seq)))))
 
 #?(:clj
    (defn- hash-cat ^long [^AutoFlattenSeq v1 ^AutoFlattenSeq v2]
      (let [c (count v2)
            e (int (expt 31 c))]
        (unchecked-add-int
-        (unchecked-multiply-int e (.premix-hashcode v1))
-        (unchecked-subtract-int (.premix-hashcode v2) e))))
+         (unchecked-multiply-int e (.premix-hashcode v1))
+         (unchecked-subtract-int (.premix-hashcode v2) e))))
    :cljs
    (defn- hash-cat ^number [^AutoFlattenSeq v1 ^AutoFlattenSeq v2]
      (let [c (count v2)
@@ -251,8 +251,8 @@
          (loop [acc (int 1) i (int 0)]
            (if (< i cnt)
              (recur (unchecked-add-int
-                     (unchecked-multiply-int thirty-one acc)
-                     (hash (v i)))
+                      (unchecked-multiply-int thirty-one acc)
+                      (hash (v i)))
                     (inc i))
              acc)))
        (hash v)))
@@ -311,195 +311,195 @@
   (^PersistentVector get-vec [self]))
 
 #?(:clj
-(deftype FlattenOnDemandVector [v   ; ref containing PersistentVector or nil 
-                                ^int hashcode
-                                ^int cnt
-                                flat] ; ref containing PersistentVector or nil                                
-  GetVec
-  (get-vec [self] 
-           (when (not @flat)             
-             (dosync
-               (when (not @flat)
-                 (ref-set flat (with-meta (flat-vec @v) (meta @v))) 
-                 (ref-set v nil)))) ; clear out v so it can be garbage collected
-           @flat)
+   (deftype FlattenOnDemandVector [v   ; ref containing PersistentVector or nil 
+                                   ^int hashcode
+                                   ^int cnt
+                                   flat] ; ref containing PersistentVector or nil                                
+     GetVec
+     (get-vec [self] 
+              (when (not @flat)             
+                (dosync
+                  (when (not @flat)
+                    (ref-set flat (with-meta (flat-vec @v) (meta @v))) 
+                    (ref-set v nil)))) ; clear out v so it can be garbage collected
+              @flat)
                     
-  Object
-  (toString [self] (.toString (get-vec self)))
-  (hashCode [self] hashcode)
-  (equals [self other]
-    (and (instance? FlattenOnDemandVector other)
-         (== hashcode (.hashcode ^FlattenOnDemandVector other))
-         (== cnt (.cnt ^FlattenOnDemandVector other))
-         (= v (.v ^FlattenOnDemandVector other))
-         (= flat (.flat ^FlattenOnDemandVector other))))
-  clojure.lang.IHashEq
-  (hasheq [self] hashcode)
-  java.util.Collection
-  (iterator [self]
-    (.iterator (get-vec self)))
-  (size [self]
-    cnt)
-  (toArray [self]
-    (.toArray (get-vec self)))
-  clojure.lang.IPersistentCollection
-  (equiv [self other]
-    (or 
-      (and (== hashcode (hash other))
-           (== cnt (count other))
-           (= (get-vec self) other))))
-  (empty [self] (with-meta [] (meta self))) 
-  clojure.lang.Counted
-  (count [self] cnt)
-  clojure.lang.IPersistentVector
-  (assoc [self i val]
-    (assoc (get-vec self) i val))
-  (assocN [self i val]
-    (.assocN (get-vec self) i val))
-  (length [self]
-    cnt)
-  (cons [self obj]
-    (conj (get-vec self) obj))
-  clojure.lang.IObj
-  (withMeta [self metamap]    
-    (if @flat
-      (FlattenOnDemandVector. (ref @v) hashcode cnt (ref (with-meta @flat metamap)))
-      (FlattenOnDemandVector. (ref (with-meta @v metamap)) hashcode cnt (ref @flat))))
-  clojure.lang.IMeta
-  (meta [self]
-    (if @flat (meta @flat) (meta @v)))
-  clojure.lang.Seqable
-  (seq [self]
-    (seq (get-vec self)))
-  clojure.lang.ILookup
-  (valAt [self key]
-    (.valAt (get-vec self) key))
-  (valAt [self key not-found]
-    (.valAt (get-vec self) key not-found))
-  clojure.lang.Indexed
-  (nth [self i]
-    (.nth (get-vec self) i))
-  (nth [self i not-found]
-    (.nth (get-vec self) i not-found))
-  clojure.lang.IFn
-  (invoke [self arg]
-    (.invoke (get-vec self) arg))
-  (applyTo [self arglist]
-    (.applyTo (get-vec self) arglist))
-  clojure.lang.Reversible
-  (rseq [self]
-    (if (pos? cnt)
-      (rseq (get-vec self))
-      nil))
-  clojure.lang.IPersistentStack
-  (peek [self] 
-    (peek (get-vec self)))
-  (pop [self] 
-    (pop (get-vec self)))
-  clojure.lang.Associative
-  (containsKey [self k]
-    (.containsKey (get-vec self) k))
-  (entryAt [self k]
-    (.entryAt (get-vec self) k))
-  IKVReduce
-  (kv-reduce [self f init]
-    (.kvreduce (get-vec self) f init))
-  java.lang.Comparable
-  (compareTo [self that]
-    (.compareTo (get-vec self) that))
-  java.util.List
-  (get [self i] (nth (get-vec self) i))
-  (indexOf [self o] (.indexOf (get-vec self) o))
-  (lastIndexOf [self o] (.lastIndexOf (get-vec self) o))
-  (listIterator [self]
-    (.listIterator (get-vec self) 0))
-  (listIterator [self i]
-    (.listIterator (get-vec self) i))
-  (subList [self a z]
-    (.subList (get-vec self) a z))
-  )
-:cljs
-(deftype FlattenOnDemandVector [v   ; atom containing PersistentVector or nil 
-                                ^number hashcode
-                                ^number cnt
-                                flat] ; atom containing PersistentVector or nil
-  GetVec
-  (get-vec [self] 
-    (when (not @flat)             
-      (swap! flat (fn [_] (with-meta (flat-vec @v) (meta @v))))
-      (swap! v (fn [_] nil))) ; clear out v so it can be garbage collected 
-    @flat)
+     Object
+     (toString [self] (.toString (get-vec self)))
+     (hashCode [self] hashcode)
+     (equals [self other]
+       (and (instance? FlattenOnDemandVector other)
+            (== hashcode (.hashcode ^FlattenOnDemandVector other))
+            (== cnt (.cnt ^FlattenOnDemandVector other))
+            (= v (.v ^FlattenOnDemandVector other))
+            (= flat (.flat ^FlattenOnDemandVector other))))
+     clojure.lang.IHashEq
+     (hasheq [self] hashcode)
+     java.util.Collection
+     (iterator [self]
+       (.iterator (get-vec self)))
+     (size [self]
+       cnt)
+     (toArray [self]
+       (.toArray (get-vec self)))
+     clojure.lang.IPersistentCollection
+     (equiv [self other]
+       (or 
+         (and (== hashcode (hash other))
+              (== cnt (count other))
+              (= (get-vec self) other))))
+     (empty [self] (with-meta [] (meta self))) 
+     clojure.lang.Counted
+     (count [self] cnt)
+     clojure.lang.IPersistentVector
+     (assoc [self i val]
+       (assoc (get-vec self) i val))
+     (assocN [self i val]
+       (.assocN (get-vec self) i val))
+     (length [self]
+       cnt)
+     (cons [self obj]
+       (conj (get-vec self) obj))
+     clojure.lang.IObj
+     (withMeta [self metamap]    
+       (if @flat
+         (FlattenOnDemandVector. (ref @v) hashcode cnt (ref (with-meta @flat metamap)))
+         (FlattenOnDemandVector. (ref (with-meta @v metamap)) hashcode cnt (ref @flat))))
+     clojure.lang.IMeta
+     (meta [self]
+       (if @flat (meta @flat) (meta @v)))
+     clojure.lang.Seqable
+     (seq [self]
+       (seq (get-vec self)))
+     clojure.lang.ILookup
+     (valAt [self key]
+       (.valAt (get-vec self) key))
+     (valAt [self key not-found]
+       (.valAt (get-vec self) key not-found))
+     clojure.lang.Indexed
+     (nth [self i]
+       (.nth (get-vec self) i))
+     (nth [self i not-found]
+       (.nth (get-vec self) i not-found))
+     clojure.lang.IFn
+     (invoke [self arg]
+       (.invoke (get-vec self) arg))
+     (applyTo [self arglist]
+       (.applyTo (get-vec self) arglist))
+     clojure.lang.Reversible
+     (rseq [self]
+       (if (pos? cnt)
+         (rseq (get-vec self))
+         nil))
+     clojure.lang.IPersistentStack
+     (peek [self] 
+       (peek (get-vec self)))
+     (pop [self] 
+       (pop (get-vec self)))
+     clojure.lang.Associative
+     (containsKey [self k]
+       (.containsKey (get-vec self) k))
+     (entryAt [self k]
+       (.entryAt (get-vec self) k))
+     IKVReduce
+     (kv-reduce [self f init]
+       (.kvreduce (get-vec self) f init))
+     java.lang.Comparable
+     (compareTo [self that]
+       (.compareTo (get-vec self) that))
+     java.util.List
+     (get [self i] (nth (get-vec self) i))
+     (indexOf [self o] (.indexOf (get-vec self) o))
+     (lastIndexOf [self o] (.lastIndexOf (get-vec self) o))
+     (listIterator [self]
+       (.listIterator (get-vec self) 0))
+     (listIterator [self i]
+       (.listIterator (get-vec self) i))
+     (subList [self a z]
+       (.subList (get-vec self) a z))
+     )
+   :cljs
+   (deftype FlattenOnDemandVector [v   ; atom containing PersistentVector or nil 
+                                   ^number hashcode
+                                   ^number cnt
+                                   flat] ; atom containing PersistentVector or nil
+     GetVec
+     (get-vec [self] 
+       (when (not @flat)             
+         (swap! flat (fn [_] (with-meta (flat-vec @v) (meta @v))))
+         (swap! v (fn [_] nil))) ; clear out v so it can be garbage collected 
+       @flat)
   
-  Object
-  (toString [self]
-    (pr-str* (get-vec self)))
-  IHash
-  (-hash [self] hashcode)
-  IEquiv
-  (-equiv [self other]
-    (or 
-     (and (= hashcode (hash other))
-          (= cnt (count other))
-          (= (get-vec self) other))))
-  IEmptyableCollection
-  (-empty [self] (with-meta [] (meta self))) 
-  ICounted
-  (-count [self] cnt)
-  IVector
-  (-assoc-n [self i val]
-    (-assoc-n (get-vec self) i val))
-  ICollection
-  (-conj [self obj]
-    (conj (get-vec self) obj))
-  IWithMeta
-  (-with-meta [self metamap]    
-    (if @flat
-      (FlattenOnDemandVector. (atom @v) hashcode cnt (atom (with-meta @flat metamap)))
-      (FlattenOnDemandVector. (atom (with-meta @v metamap)) hashcode cnt (atom @flat))))
-  IMeta
-  (-meta [self]
-    (if @flat (meta @flat) (meta @v)))
-  ISequential
-  ISeqable
-  (-seq [self]
-    (seq (get-vec self)))
-  ILookup
-  (-lookup [self key]
-    (-lookup (get-vec self) key))
-  (-lookup [self key not-found]
-    (-lookup (get-vec self) key not-found))
-  IIndexed
-  (-nth [self i]
-    (-nth (get-vec self) i))
-  (-nth [self i not-found]
-    (-nth (get-vec self) i not-found))
-  IFn
-  (-invoke [self arg]
-    (-invoke (get-vec self) arg))
-  (-invoke [self arg not-found]
-    (-invoke (get-vec self) arg not-found))
-  IReversible
-  (-rseq [self]
-    (if (pos? cnt)
-      (rseq (get-vec self))
-      nil))
-  IStack
-  (-peek [self] 
-    (-peek (get-vec self)))
-  (-pop [self] 
-    (-pop (get-vec self)))
-  IAssociative
-  (-assoc [self i val]
-    (assoc (get-vec self) i val))
-  (-contains-key? [self k]
-    (-contains-key? (get-vec self) k))
-  IKVReduce
-  (-kv-reduce [self f init]
-    (-kv-reduce (get-vec self) f init))
-  IComparable
-  (-compare [self that]
-    (-compare (get-vec self) that))
-  ))
+     Object
+     (toString [self]
+       (pr-str* (get-vec self)))
+     IHash
+     (-hash [self] hashcode)
+     IEquiv
+     (-equiv [self other]
+       (or 
+         (and (= hashcode (hash other))
+              (= cnt (count other))
+              (= (get-vec self) other))))
+     IEmptyableCollection
+     (-empty [self] (with-meta [] (meta self))) 
+     ICounted
+     (-count [self] cnt)
+     IVector
+     (-assoc-n [self i val]
+       (-assoc-n (get-vec self) i val))
+     ICollection
+     (-conj [self obj]
+       (conj (get-vec self) obj))
+     IWithMeta
+     (-with-meta [self metamap]    
+       (if @flat
+         (FlattenOnDemandVector. (atom @v) hashcode cnt (atom (with-meta @flat metamap)))
+         (FlattenOnDemandVector. (atom (with-meta @v metamap)) hashcode cnt (atom @flat))))
+     IMeta
+     (-meta [self]
+       (if @flat (meta @flat) (meta @v)))
+     ISequential
+     ISeqable
+     (-seq [self]
+       (seq (get-vec self)))
+     ILookup
+     (-lookup [self key]
+       (-lookup (get-vec self) key))
+     (-lookup [self key not-found]
+       (-lookup (get-vec self) key not-found))
+     IIndexed
+     (-nth [self i]
+       (-nth (get-vec self) i))
+     (-nth [self i not-found]
+       (-nth (get-vec self) i not-found))
+     IFn
+     (-invoke [self arg]
+       (-invoke (get-vec self) arg))
+     (-invoke [self arg not-found]
+       (-invoke (get-vec self) arg not-found))
+     IReversible
+     (-rseq [self]
+       (if (pos? cnt)
+         (rseq (get-vec self))
+         nil))
+     IStack
+     (-peek [self] 
+       (-peek (get-vec self)))
+     (-pop [self] 
+       (-pop (get-vec self)))
+     IAssociative
+     (-assoc [self i val]
+       (assoc (get-vec self) i val))
+     (-contains-key? [self k]
+       (-contains-key? (get-vec self) k))
+     IKVReduce
+     (-kv-reduce [self f init]
+       (-kv-reduce (get-vec self) f init))
+     IComparable
+     (-compare [self that]
+       (-compare (get-vec self) that))
+     ))
 
 #?(:cljs
    (extend-protocol IPrintWithWriter
@@ -514,15 +514,15 @@
       (vec (seq afs))
       #?(:clj
          (FlattenOnDemandVector.
-          (ref (.-v afs))
-          (.-hashcode afs)
-          (.-cnt afs)
-          (ref nil))
+           (ref (.-v afs))
+           (.-hashcode afs)
+           (.-cnt afs)
+           (ref nil))
          :cljs
          (FlattenOnDemandVector.
-          (atom (.-v afs))
-          (.-hashcode afs)
-          (.-cnt afs)
-          (atom nil))))
+           (atom (.-v afs))
+           (.-hashcode afs)
+           (.-cnt afs)
+           (atom nil))))
     :else
     (.-v afs)))
diff --git a/src/instaparse/cfg.cljc b/src/instaparse/cfg.cljc
index 36aabd8..7bb684b 100644
--- a/src/instaparse/cfg.cljc
+++ b/src/instaparse/cfg.cljc
@@ -4,13 +4,13 @@
   (:require [instaparse.combinators-source :refer
              [Epsilon opt plus star rep alt ord cat string-ci string
               string-ci regexp nt look neg hide hide-tag]]
-            [instaparse.reduction :refer [apply-standard-reductions]]
-            [instaparse.gll :refer [parse]]
-            [instaparse.util :refer [throw-illegal-argument-exception
-                                     throw-runtime-exception]]
-            [clojure.string :as str]
-            #?(:cljs [cljs.tools.reader :as reader])
-            #?(:cljs [cljs.tools.reader.reader-types :as readers])))
+   [instaparse.reduction :refer [apply-standard-reductions]]
+   [instaparse.gll :refer [parse]]
+   [instaparse.util :refer [throw-illegal-argument-exception
+                            throw-runtime-exception]]
+   [clojure.string :as str]
+   #?(:cljs [cljs.tools.reader :as reader])
+   #?(:cljs [cljs.tools.reader.reader-types :as readers])))
 
 (def ^:dynamic *case-insensitive-literals*
   "Sets whether all string literal terminals in a built grammar
@@ -78,87 +78,87 @@
            (neg (nt :epsilon))
            (regexp
              (regex-doc "[^, \\r\\t\\n<>(){}\\[\\]+*?:=|'\"#&!;./]+" "Non-terminal")))
-          :hide-nt (cat (hide (string "<"))
-                        opt-whitespace
-                        (nt :nt)
-                        opt-whitespace
-                        (hide (string ">")))
-          :alt-or-ord (hide-tag (alt (nt :alt) (nt :ord)))
-          :alt (cat (nt :cat)                           
-                    (star
-                      (cat
-                        opt-whitespace
-                        (hide (string "|"))
-                        opt-whitespace
-                        (nt :cat))))
-          :ord (cat (nt :cat)
-                    (plus
-                      (cat
-                        opt-whitespace
-                        (hide (string "/"))
-                        opt-whitespace
-                        (nt :cat))))
-          :paren (cat (hide (string "("))
-                      opt-whitespace
-                      (nt :alt-or-ord)
-                      opt-whitespace
-                      (hide (string ")")))
-          :hide (cat (hide (string "<"))
-                     opt-whitespace	
-                     (nt :alt-or-ord)
-                     opt-whitespace
-                     (hide (string ">")))
-          :cat (plus (cat
-                       opt-whitespace
-                       (alt (nt :factor) (nt :look) (nt :neg))
-                       opt-whitespace))
-          :string (alt
-                    (regexp single-quoted-string)
-                    (regexp double-quoted-string))
-          :regexp (alt
-                    (regexp single-quoted-regexp)
-                    (regexp double-quoted-regexp))
-          :opt (alt
-                 (cat (hide (string "["))
-                      opt-whitespace
-                      (nt :alt-or-ord)
-                      opt-whitespace
-                      (hide (string "]")))
-                 (cat (nt :factor)
-                      opt-whitespace
-                      (hide (string "?"))))
-          :star (alt
-                  (cat (hide (string "{"))
-                       opt-whitespace
-                       (nt :alt-or-ord)
-                       opt-whitespace
-                       (hide (string "}")))
-                  (cat (nt :factor)
-                       opt-whitespace
-                       (hide (string "*"))))
-          :plus (cat (nt :factor)
-                     opt-whitespace
-                     (hide (string "+")))
-          :look (cat (hide (string "&"))
-                     opt-whitespace
-                     (nt :factor))
-          :neg (cat (hide (string "!"))
-                    opt-whitespace
-                    (nt :factor))
-          :epsilon (alt (string "Epsilon")
-                        (string "epsilon")
-                        (string "EPSILON")
-                        (string "eps")
-                        (string "\u03b5"))
-          :factor (hide-tag (alt (nt :nt)
-                                 (nt :string)
-                                 (nt :regexp)
-                                 (nt :opt)     
-                                 (nt :star)
-                                 (nt :plus)
-                                 (nt :paren)
-                                 (nt :hide)
-                                 (nt :epsilon)))
+     :hide-nt (cat (hide (string "<"))
+                   opt-whitespace
+                   (nt :nt)
+                   opt-whitespace
+                   (hide (string ">")))
+     :alt-or-ord (hide-tag (alt (nt :alt) (nt :ord)))
+     :alt (cat (nt :cat)                           
+               (star
+                 (cat
+                   opt-whitespace
+                   (hide (string "|"))
+                   opt-whitespace
+                   (nt :cat))))
+     :ord (cat (nt :cat)
+               (plus
+                 (cat
+                   opt-whitespace
+                   (hide (string "/"))
+                   opt-whitespace
+                   (nt :cat))))
+     :paren (cat (hide (string "("))
+                 opt-whitespace
+                 (nt :alt-or-ord)
+                 opt-whitespace
+                 (hide (string ")")))
+     :hide (cat (hide (string "<"))
+                opt-whitespace	
+                (nt :alt-or-ord)
+                opt-whitespace
+                (hide (string ">")))
+     :cat (plus (cat
+                  opt-whitespace
+                  (alt (nt :factor) (nt :look) (nt :neg))
+                  opt-whitespace))
+     :string (alt
+               (regexp single-quoted-string)
+               (regexp double-quoted-string))
+     :regexp (alt
+               (regexp single-quoted-regexp)
+               (regexp double-quoted-regexp))
+     :opt (alt
+            (cat (hide (string "["))
+                 opt-whitespace
+                 (nt :alt-or-ord)
+                 opt-whitespace
+                 (hide (string "]")))
+            (cat (nt :factor)
+                 opt-whitespace
+                 (hide (string "?"))))
+     :star (alt
+             (cat (hide (string "{"))
+                  opt-whitespace
+                  (nt :alt-or-ord)
+                  opt-whitespace
+                  (hide (string "}")))
+             (cat (nt :factor)
+                  opt-whitespace
+                  (hide (string "*"))))
+     :plus (cat (nt :factor)
+                opt-whitespace
+                (hide (string "+")))
+     :look (cat (hide (string "&"))
+                opt-whitespace
+                (nt :factor))
+     :neg (cat (hide (string "!"))
+               opt-whitespace
+               (nt :factor))
+     :epsilon (alt (string "Epsilon")
+                   (string "epsilon")
+                   (string "EPSILON")
+                   (string "eps")
+                   (string "\u03b5"))
+     :factor (hide-tag (alt (nt :nt)
+                            (nt :string)
+                            (nt :regexp)
+                            (nt :opt)     
+                            (nt :star)
+                            (nt :plus)
+                            (nt :paren)
+                            (nt :hide)
+                            (nt :epsilon)))
      ;; extra entrypoint to be used by the ebnf combinator
      :rules-or-parser (hide-tag (alt (nt :rules) (nt :alt-or-ord)))}))
 
@@ -238,7 +238,7 @@
         (escape stripped)
         final-string
         (re-pattern remove-escaped-single-quotes)]
-;        (safe-read-regexp (str remove-escaped-single-quotes \"))]
+    ;        (safe-read-regexp (str remove-escaped-single-quotes \"))]
         
     final-string))
 
diff --git a/src/instaparse/combinators.cljc b/src/instaparse/combinators.cljc
index 964b6fd..52275fa 100644
--- a/src/instaparse/combinators.cljc
+++ b/src/instaparse/combinators.cljc
@@ -5,8 +5,8 @@
      :cljs (:require-macros
             [instaparse.macros :refer [defclone]]))
   (:require [instaparse.combinators-source :as c]
-            [instaparse.cfg :as cfg]
-            [instaparse.abnf :as abnf]))
+   [instaparse.cfg :as cfg]
+   [instaparse.abnf :as abnf]))
 
 ;; The actual source is in combinators-source.
 ;; This was necessary to avoid a cyclical dependency in the namespaces.
diff --git a/src/instaparse/combinators_source.cljc b/src/instaparse/combinators_source.cljc
index 974f50a..3c08adc 100644
--- a/src/instaparse/combinators_source.cljc
+++ b/src/instaparse/combinators_source.cljc
@@ -4,7 +4,7 @@
   (:require [instaparse.reduction :refer [singleton? red
                                           raw-non-terminal-reduction
                                           reduction-types]]
-            [instaparse.util :refer [throw-illegal-argument-exception #?(:cljs regexp-flags)]]))
+   [instaparse.util :refer [throw-illegal-argument-exception #?(:cljs regexp-flags)]]))
 
 ;; Ways to build parsers
 
@@ -44,12 +44,12 @@
 (defn ord "Ordered choice, i.e., parser1 / parser2"
   ([] Epsilon)
   ([parser1 & parsers]
-    (let [parsers (if (= parser1 Epsilon)
-                    (remove #{Epsilon} parsers)
-                    parsers)]
-      (if (seq parsers)
-        (ord2 parser1 (apply ord parsers))
-        parser1))))
+   (let [parsers (if (= parser1 Epsilon)
+                   (remove #{Epsilon} parsers)
+                   parsers)]
+     (if (seq parsers)
+       (ord2 parser1 (apply ord parsers))
+       parser1))))
 
 (defn cat "Concatenation, i.e., parser1 parser2 ..."
   [& parsers]
diff --git a/src/instaparse/core.cljc b/src/instaparse/core.cljc
index b88f951..657b574 100644
--- a/src/instaparse/core.cljc
+++ b/src/instaparse/core.cljc
@@ -1,20 +1,20 @@
 (ns instaparse.core
   (#?(:clj :require :cljs :require-macros)
-    [instaparse.macros :refer [defclone
-                               set-global-var!]])
+   [instaparse.macros :refer [defclone
+                              set-global-var!]])
   (:require [clojure.walk :as walk]
-            [instaparse.gll :as gll]
-            [instaparse.cfg :as cfg]
-            [instaparse.failure :as fail]
-            [instaparse.print :as print]
-            [instaparse.reduction :as red]
-            [instaparse.transform :as t]
-            [instaparse.abnf :as abnf]
-            [instaparse.repeat :as repeat]
-            [instaparse.combinators-source :as c]
-            [instaparse.line-col :as lc]
-            [instaparse.viz :as viz]
-            [instaparse.util :refer [throw-illegal-argument-exception]]))
+   [instaparse.gll :as gll]
+   [instaparse.cfg :as cfg]
+   [instaparse.failure :as fail]
+   [instaparse.print :as print]
+   [instaparse.reduction :as red]
+   [instaparse.transform :as t]
+   [instaparse.abnf :as abnf]
+   [instaparse.repeat :as repeat]
+   [instaparse.combinators-source :as c]
+   [instaparse.line-col :as lc]
+   [instaparse.viz :as viz]
+   [instaparse.util :refer [throw-illegal-argument-exception]]))
 
 (def ^:dynamic *default-output-format* :hiccup)
 (defn set-default-output-format!
@@ -136,27 +136,27 @@
          #?(:clj (gll/bind-trace trace?)))))
   
 (defrecord Parser [grammar start-production output-format]
-#?@(:clj
-    [clojure.lang.IFn
-     (invoke [parser text] (parse parser text))
-     (invoke [parser text key1 val1] (parse parser text key1 val1))
-     (invoke [parser text key1 val1 key2 val2] (parse parser text key1 val1 key2 val2))
-     (invoke [parser text key1 val1 key2 val2 key3 val3] (parse parser text key1 val1 key2 val2 key3 val3))
-     (applyTo [parser args] (apply parse parser args))]
-
-    :cljs
-    [IFn
-     (-invoke [parser text] (parse parser text))
-     (-invoke [parser text key1 val1] (parse parser text key1 val1))
-     (-invoke [parser text key1 val1 key2 val2] (parse parser text key1 val1 key2 val2))
-     (-invoke [parser text key1 val1 key2 val2 key3 val3] (parse parser text key1 val1 key2 val2 key3 val3))
-     (-invoke [parser text a b c d e f g h] (parse parser text a b c d e f g h))
-     (-invoke [parser text a b c d e f g h i j] (parse parser text a b c d e f g h i j))
-     (-invoke [parser text a b c d e f g h i j k l] (parse parser text a b c d e f g h i j k l))
-     (-invoke [parser text a b c d e f g h i j k l m n] (parse parser text a b c d e f g h i j k l m n))
-     (-invoke [parser text a b c d e f g h i j k l m n o p] (parse parser text a b c d e f g h i j k l m n o p))
-     (-invoke [parser text a b c d e f g h i j k l m n o p q r] (parse parser text a b c d e f g h i j k l m n o p))
-     (-invoke [parser text a b c d e f g h i j k l m n o p q r s more] (apply parse parser text a b c d e f g h i j k l m n o p q r s more))]))
+  #?@(:clj
+      [clojure.lang.IFn
+       (invoke [parser text] (parse parser text))
+       (invoke [parser text key1 val1] (parse parser text key1 val1))
+       (invoke [parser text key1 val1 key2 val2] (parse parser text key1 val1 key2 val2))
+       (invoke [parser text key1 val1 key2 val2 key3 val3] (parse parser text key1 val1 key2 val2 key3 val3))
+       (applyTo [parser args] (apply parse parser args))]
+
+      :cljs
+      [IFn
+       (-invoke [parser text] (parse parser text))
+       (-invoke [parser text key1 val1] (parse parser text key1 val1))
+       (-invoke [parser text key1 val1 key2 val2] (parse parser text key1 val1 key2 val2))
+       (-invoke [parser text key1 val1 key2 val2 key3 val3] (parse parser text key1 val1 key2 val2 key3 val3))
+       (-invoke [parser text a b c d e f g h] (parse parser text a b c d e f g h))
+       (-invoke [parser text a b c d e f g h i j] (parse parser text a b c d e f g h i j))
+       (-invoke [parser text a b c d e f g h i j k l] (parse parser text a b c d e f g h i j k l))
+       (-invoke [parser text a b c d e f g h i j k l m n] (parse parser text a b c d e f g h i j k l m n))
+       (-invoke [parser text a b c d e f g h i j k l m n o p] (parse parser text a b c d e f g h i j k l m n o p))
+       (-invoke [parser text a b c d e f g h i j k l m n o p q r] (parse parser text a b c d e f g h i j k l m n o p))
+       (-invoke [parser text a b c d e f g h i j k l m n o p q r s more] (apply parse parser text a b c d e f g h i j k l m n o p q r s more))]))
 
 #?(:clj
    (defmethod clojure.core/print-method Parser [x writer]
@@ -256,8 +256,8 @@
                (map->Parser parser))
              :cljs
              (throw-illegal-argument-exception
-              "Expected string, map, or vector as grammar specification, got "
-              (pr-str grammar-specification))))]
+               "Expected string, map, or vector as grammar specification, got "
+               (pr-str grammar-specification))))]
 
     (let [auto-whitespace (get options :auto-whitespace)
           ; auto-whitespace is keyword, parser, or nil
@@ -293,36 +293,36 @@
      (if (string? grammar)
        `(def ~name
           (map->Parser
-           ~(binding [abnf/*case-insensitive* (:instaparse.abnf/case-insensitive opts false)]
-              (let [macro-time-opts (select-keys opts [:input-format
-                                                       :output-format
-                                                       :string-ci
-                                                       :no-slurp])
-                    runtime-opts (dissoc opts :start)
-                    macro-time-parser (apply parser grammar (apply concat macro-time-opts))
-                    pre-processed-grammar (:grammar macro-time-parser)
-
-                    grammar-producing-code
-                    (->> pre-processed-grammar
-                         (walk/postwalk
-                           (fn [form]
-                             (cond
-                               ;; Lists cannot be evaluated verbatim
-                               (seq? form)
-                               (list* 'list form)
-
-                               ;; Regexp terminals are handled differently in cljs
-                               (= :regexp (:tag form))
-                               `(merge (c/regexp ~(str (:regexp form)))
-                                       ~(dissoc form :tag :regexp))
-
-                               :else form))))
-
-                    start-production
-                    (or (:start opts) (:start-production macro-time-parser))]
-                `(parser ~grammar-producing-code
-                         :start ~start-production
-                         ~@(apply concat runtime-opts))))))
+            ~(binding [abnf/*case-insensitive* (:instaparse.abnf/case-insensitive opts false)]
+               (let [macro-time-opts (select-keys opts [:input-format
+                                                        :output-format
+                                                        :string-ci
+                                                        :no-slurp])
+                     runtime-opts (dissoc opts :start)
+                     macro-time-parser (apply parser grammar (apply concat macro-time-opts))
+                     pre-processed-grammar (:grammar macro-time-parser)
+
+                     grammar-producing-code
+                     (->> pre-processed-grammar
+                          (walk/postwalk
+                            (fn [form]
+                              (cond
+                                ;; Lists cannot be evaluated verbatim
+                                (seq? form)
+                                (list* 'list form)
+
+                                ;; Regexp terminals are handled differently in cljs
+                                (= :regexp (:tag form))
+                                `(merge (c/regexp ~(str (:regexp form)))
+                                        ~(dissoc form :tag :regexp))
+
+                                :else form))))
+
+                     start-production
+                     (or (:start opts) (:start-production macro-time-parser))]
+                 `(parser ~grammar-producing-code
+                          :start ~start-production
+                          ~@(apply concat runtime-opts))))))
        `(def ~name (parser ~grammar ~@(apply concat opts))))))
         
 (defn failure?
diff --git a/src/instaparse/gll.cljc b/src/instaparse/gll.cljc
index 0290128..de9675c 100644
--- a/src/instaparse/gll.cljc
+++ b/src/instaparse/gll.cljc
@@ -5,37 +5,37 @@
    listeners and parse commands that are on the stack."
 
   (:require
-    ;; Incremental vector provides a more performant hashing strategy 
-    ;; for this use-case for vectors
-    ;; We use the auto flatten version
-    [instaparse.auto-flatten-seq :as afs]
+   ;; Incremental vector provides a more performant hashing strategy 
+   ;; for this use-case for vectors
+   ;; We use the auto flatten version
+   [instaparse.auto-flatten-seq :as afs]
 
-    ;; failure contains the augment-failure function, which is called to
-    ;; add enough information to the failure object for pretty printing 
-    [instaparse.failure :as fail]
+   ;; failure contains the augment-failure function, which is called to
+   ;; add enough information to the failure object for pretty printing 
+   [instaparse.failure :as fail]
 
-    ;; reduction contains code relating to reductions and flattening.
-    [instaparse.reduction :as red]
+   ;; reduction contains code relating to reductions and flattening.
+   [instaparse.reduction :as red]
 
-    ;; Two of the public combinators are needed.
-    [instaparse.combinators-source :refer [Epsilon nt]]
+   ;; Two of the public combinators are needed.
+   [instaparse.combinators-source :refer [Epsilon nt]]
 
-    ;; Need a way to convert parsers into strings for printing and error messages.
-    [instaparse.print :as print]
+   ;; Need a way to convert parsers into strings for printing and error messages.
+   [instaparse.print :as print]
 
-    ;; Utility to preserve RegExp flags
-    #?(:cljs
-       [instaparse.util :refer [regexp-flags]])
+   ;; Utility to preserve RegExp flags
+   #?(:cljs
+      [instaparse.util :refer [regexp-flags]])
 
-    ;; Unicode utilities for char-range
-    #?(:cljs
-       [goog.i18n.uChar :as u]))
+   ;; Unicode utilities for char-range
+   #?(:cljs
+      [goog.i18n.uChar :as u]))
 
   #?(:cljs
      (:use-macros
-       [instaparse.gll :only
-        [log profile dprintln dpprint success
-         attach-diagnostic-meta trace-or-false]])))
+      [instaparse.gll :only
+       [log profile dprintln dpprint success
+        attach-diagnostic-meta trace-or-false]])))
 
 ;; As of Java 7, strings no longer have fast substring operation,
 ;; so we use Segments instead, which implement the CharSequence
@@ -62,48 +62,48 @@
 ;;;;; SETUP DIAGNOSTIC MACROS AND VARS
 #?(:clj (do
 
-(defonce PRINT false)
-(defmacro dprintln [& body]  
-  (when PRINT `(println ~@body)))
-(defmacro dpprint [& body]  
-  (when PRINT `(clojure.pprint/pprint ~@body)))
-
-(defonce PROFILE false)
-(defmacro profile [& body]
-  (when PROFILE
-    `(do ~@body)))
-
-;; By default TRACE is set to false, and all these macros are used
-;; throughout the code to ensure there is absolutely no performance
-;; penalty from the tracing code.  Everything related to tracing
-;; is compiled away.
-;;
-;; We recompile this file with TRACE set to true to activate the
-;; tracing code.
-;;
-;; bind-trace is the one exception where we can't completely compile
-;; the new code away, because it is used in instaparse.core, which won't be
-;; recompiled.  Still, binding is a relatively slow operation, so by testing
-;; whether TRACE is true inside the expansion, we can at least avoid 
-;; the performance hit of binding every time.
-
-(defonce TRACE false)
-(def ^:dynamic *trace* false)
-(defmacro log [tramp & body]
-  (when TRACE
-    `(when (:trace? ~tramp) (println ~@body))))
-(defmacro attach-diagnostic-meta [f metadata]
-  (if TRACE
-    `(with-meta ~f ~metadata)
-    f))
-(defmacro bind-trace [trace? body]
-  `(if TRACE
-     (binding [*trace* ~trace?] ~body)
-          ~body))
-(defmacro trace-or-false []
-  (if TRACE '*trace* false))
-
-))
+          (defonce PRINT false)
+          (defmacro dprintln [& body]  
+            (when PRINT `(println ~@body)))
+          (defmacro dpprint [& body]  
+            (when PRINT `(clojure.pprint/pprint ~@body)))
+
+          (defonce PROFILE false)
+          (defmacro profile [& body]
+            (when PROFILE
+              `(do ~@body)))
+
+          ;; By default TRACE is set to false, and all these macros are used
+          ;; throughout the code to ensure there is absolutely no performance
+          ;; penalty from the tracing code.  Everything related to tracing
+          ;; is compiled away.
+          ;;
+          ;; We recompile this file with TRACE set to true to activate the
+          ;; tracing code.
+          ;;
+          ;; bind-trace is the one exception where we can't completely compile
+          ;; the new code away, because it is used in instaparse.core, which won't be
+          ;; recompiled.  Still, binding is a relatively slow operation, so by testing
+          ;; whether TRACE is true inside the expansion, we can at least avoid 
+          ;; the performance hit of binding every time.
+
+          (defonce TRACE false)
+          (def ^:dynamic *trace* false)
+          (defmacro log [tramp & body]
+            (when TRACE
+              `(when (:trace? ~tramp) (println ~@body))))
+          (defmacro attach-diagnostic-meta [f metadata]
+            (if TRACE
+              `(with-meta ~f ~metadata)
+              f))
+          (defmacro bind-trace [trace? body]
+            `(if TRACE
+               (binding [*trace* ~trace?] ~body)
+               ~body))
+          (defmacro trace-or-false []
+            (if TRACE '*trace* false))
+
+          ))
 
 ; In diagnostic messages, how many characters ahead do we want to show.
 (def ^:dynamic *diagnostic-char-lookahead* 10)
@@ -235,10 +235,10 @@
   ([grammar text segment] (make-tramp grammar text segment -1 nil))
   ([grammar text fail-index node-builder] (make-tramp grammar text (text->segment text) fail-index node-builder))
   ([grammar text segment fail-index node-builder]
-    (Tramp. grammar text segment
-            fail-index node-builder
-            (atom []) (atom []) (atom 0) (atom (sorted-map-by >)) 
-            (atom {}) (atom {}) (atom nil) (atom (Failure. 0 [])) (trace-or-false))))
+   (Tramp. grammar text segment
+           fail-index node-builder
+           (atom []) (atom []) (atom 0) (atom (sorted-map-by >)) 
+           (atom {}) (atom {}) (atom nil) (atom (Failure. 0 [])) (trace-or-false))))
   
 ; A Success record contains the result and the index to continue from
 (defn make-success [result index] {:result result :index index})
@@ -276,7 +276,7 @@
         f #(listener result)]
     (profile (add! :push-message))    
     #_(dprintln "push-message" i c @(:generation tramp) (count @(:stack tramp))
-             (count @(:next-stack tramp)))
+        (count @(:next-stack tramp)))
     #_(dprintln "push-message: listener result" listener result)
     (if (> c @(:generation tramp))
       (swap! (:next-stack tramp) conj f)
@@ -452,46 +452,46 @@
   "Executes the stack until exhausted"
   ([tramp] (run tramp nil))
   ([tramp found-result?] 
-    (let [stack (:stack tramp)]
-          ;_ (dprintln "run" found-result? (count @(:stack tramp)) (count @(:next-stack tramp)))]
-      (cond
-        @(:success tramp)
-        (do (log tramp "Successful parse.\nProfile: " @stats)
-          (cons (:result @(:success tramp))
-                (lazy-seq
-                  (do (reset! (:success tramp) nil)
-                    (run tramp true)))))
+   (let [stack (:stack tramp)]
+     ;_ (dprintln "run" found-result? (count @(:stack tramp)) (count @(:next-stack tramp)))]
+     (cond
+       @(:success tramp)
+       (do (log tramp "Successful parse.\nProfile: " @stats)
+         (cons (:result @(:success tramp))
+               (lazy-seq
+                 (do (reset! (:success tramp) nil)
+                   (run tramp true)))))
         
-        (pos? (count @stack))
-        (do ;(dprintln "stacks" (count @stack) (count @(:next-stack tramp)))
-          (step stack) (recur tramp found-result?))
-
-        (pos? (count @(:negative-listeners tramp)))
-        (let [[index listeners] (first @(:negative-listeners tramp))
-              listener (peek listeners)]
-          (log tramp (format "Exhausted results for %s at index %d (%s)"
-                             (print/combinators->str (((meta listener) :creator) 1))
-                             (((meta listener) :creator) 0)
-                             (string-context (:text tramp) 
-                                             (((meta listener) :creator) 0)))) 
-          (listener)
-          (if (= (count listeners) 1)
-            (swap! (:negative-listeners tramp) dissoc index)
-            (swap! (:negative-listeners tramp) update-in [index] pop))
-          (recur tramp found-result?))        
+       (pos? (count @stack))
+       (do ;(dprintln "stacks" (count @stack) (count @(:next-stack tramp)))
+         (step stack) (recur tramp found-result?))
+
+       (pos? (count @(:negative-listeners tramp)))
+       (let [[index listeners] (first @(:negative-listeners tramp))
+             listener (peek listeners)]
+         (log tramp (format "Exhausted results for %s at index %d (%s)"
+                            (print/combinators->str (((meta listener) :creator) 1))
+                            (((meta listener) :creator) 0)
+                            (string-context (:text tramp) 
+                                            (((meta listener) :creator) 0)))) 
+         (listener)
+         (if (= (count listeners) 1)
+           (swap! (:negative-listeners tramp) dissoc index)
+           (swap! (:negative-listeners tramp) update-in [index] pop))
+         (recur tramp found-result?))        
         
-        found-result?
-        (let [next-stack (:next-stack tramp)]
-          #_(dprintln "Swapping stacks" (count @(:stack tramp)) 
-                   (count @(:next-stack tramp)))
-          (reset! stack @next-stack) 
-          (reset! next-stack [])
-          (swap! (:generation tramp) inc)  
-          #_(dprintln "Swapped stacks" (count @(:stack tramp)) 
-                   (count @(:next-stack tramp)))          
-          (recur tramp nil))
+       found-result?
+       (let [next-stack (:next-stack tramp)]
+         #_(dprintln "Swapping stacks" (count @(:stack tramp)) 
+             (count @(:next-stack tramp)))
+         (reset! stack @next-stack) 
+         (reset! next-stack [])
+         (swap! (:generation tramp) inc)  
+         #_(dprintln "Swapped stacks" (count @(:stack tramp)) 
+             (count @(:next-stack tramp)))          
+         (recur tramp nil))
         
-        :else nil))))
+       :else nil))))
 
 ;; Listeners
 
@@ -517,9 +517,9 @@
 
 (defn CatListener [results-so-far parser-sequence node-key tramp]
   (dpprint {:tag :CatListener
-           :results-so-far results-so-far
-           :parser-sequence (map :tag parser-sequence)
-           :node-key [(node-key 0) (:tag (node-key 1))]})
+            :results-so-far results-so-far
+            :parser-sequence (map :tag parser-sequence)
+            :node-key [(node-key 0) (:tag (node-key 1))]})
   (fn [result] 
     (let [{parsed-result :result continue-index :index} result
           new-results-so-far (afs/conj-flat results-so-far parsed-result)]
@@ -529,10 +529,10 @@
         (success tramp node-key new-results-so-far continue-index)))))
 
 (defn CatFullListener [results-so-far parser-sequence node-key tramp]
-;  (dpprint {:tag :CatFullListener
-;           :results-so-far results-so-far
-;           :parser-sequence (map :tag parser-sequence)
-;           :node-key [(node-key 0) (:tag (node-key 1))]})
+  ;  (dpprint {:tag :CatFullListener
+  ;           :results-so-far results-so-far
+  ;           :parser-sequence (map :tag parser-sequence)
+  ;           :node-key [(node-key 0) (:tag (node-key 1))]})
   (fn [result] 
     (let [{parsed-result :result continue-index :index} result
           new-results-so-far (afs/conj-flat results-so-far parsed-result)]
diff --git a/src/instaparse/line_col.cljc b/src/instaparse/line_col.cljc
index 4bb29ab..b38cea7 100644
--- a/src/instaparse/line_col.cljc
+++ b/src/instaparse/line_col.cljc
@@ -1,6 +1,6 @@
 (ns instaparse.line-col
   (:require [instaparse.transform]
-            [instaparse.util :refer [throw-illegal-argument-exception]]))
+   [instaparse.util :refer [throw-illegal-argument-exception]]))
 
 ; Function to annotate parse-tree with line and column metadata.
 
diff --git a/src/instaparse/print.cljc b/src/instaparse/print.cljc
index 4694026..baef8f2 100644
--- a/src/instaparse/print.cljc
+++ b/src/instaparse/print.cljc
@@ -54,30 +54,30 @@
   "Stringifies a parser built from combinators"
   ([p] (combinators->str p false))
   ([{:keys [parser parser1 parser2 parsers tag] :as p} hidden?]
-    (if (and (not hidden?) (:hide p))
-      (str \< (combinators->str p true) \>)
-      (case tag
-        :epsilon "\u03b5"
-        :opt (str (paren-for-compound hidden? parser) "?")
-        :plus (str (paren-for-compound hidden? parser) "+")
-        :star (str (paren-for-compound hidden? parser) "*")
-        :rep (if (not= (:min p) (:max p))
-               (str (paren-for-compound hidden? parser) \{ 
-                    (:min p) \, (:max p) \})
-               (str (paren-for-compound hidden? parser) \{ 
-                    (:min p)\}))
-        :alt (str/join " | " (map (partial paren-for-tags #{:ord} hidden?) parsers))
-        :ord (str (paren-for-tags #{:alt} hidden? parser1)
-                  " / "
-                  (paren-for-tags #{:alt} hidden? parser2))
-        :cat (str/join " " (map (partial paren-for-tags #{:alt :ord} hidden?) parsers))
-        :string (with-out-str (pr (:string p)))
-        :string-ci (with-out-str (pr (:string p)))
-        :char (char-range->str p)
-        :regexp (regexp->str (:regexp p))
-        :nt (subs (str (:keyword p)) 1)
-        :look (str "&" (paren-for-compound hidden? parser))
-        :neg (str "!" (paren-for-compound hidden? parser))))))
+   (if (and (not hidden?) (:hide p))
+     (str \< (combinators->str p true) \>)
+     (case tag
+       :epsilon "\u03b5"
+       :opt (str (paren-for-compound hidden? parser) "?")
+       :plus (str (paren-for-compound hidden? parser) "+")
+       :star (str (paren-for-compound hidden? parser) "*")
+       :rep (if (not= (:min p) (:max p))
+              (str (paren-for-compound hidden? parser) \{ 
+                   (:min p) \, (:max p) \})
+              (str (paren-for-compound hidden? parser) \{ 
+                   (:min p)\}))
+       :alt (str/join " | " (map (partial paren-for-tags #{:ord} hidden?) parsers))
+       :ord (str (paren-for-tags #{:alt} hidden? parser1)
+                 " / "
+                 (paren-for-tags #{:alt} hidden? parser2))
+       :cat (str/join " " (map (partial paren-for-tags #{:alt :ord} hidden?) parsers))
+       :string (with-out-str (pr (:string p)))
+       :string-ci (with-out-str (pr (:string p)))
+       :char (char-range->str p)
+       :regexp (regexp->str (:regexp p))
+       :nt (subs (str (:keyword p)) 1)
+       :look (str "&" (paren-for-compound hidden? parser))
+       :neg (str "!" (paren-for-compound hidden? parser))))))
   
 (defn rule->str
   "Takes a non-terminal symbol and a parser built from combinators,
diff --git a/src/instaparse/reduction.cljc b/src/instaparse/reduction.cljc
index 04637a5..248279e 100644
--- a/src/instaparse/reduction.cljc
+++ b/src/instaparse/reduction.cljc
@@ -1,6 +1,6 @@
 (ns instaparse.reduction
   (:require [instaparse.auto-flatten-seq :as afs]
-            [instaparse.util :refer [throw-illegal-argument-exception]]))
+   [instaparse.util :refer [throw-illegal-argument-exception]]))
 
 ;; utilities
 
@@ -48,9 +48,9 @@
 (defn apply-standard-reductions 
   ([grammar] (apply-standard-reductions standard-non-terminal-reduction grammar))
   ([reduction-type grammar]
-    (if-let [reduction (reduction-types reduction-type)]
-      (into {} (for [[k v] grammar]
-                 (if (:red v) [k v]
-                   [k (assoc v :red (reduction k))])))
-      (throw-illegal-argument-exception
-        "Invalid output format " reduction-type ". Use :enlive or :hiccup."))))
+   (if-let [reduction (reduction-types reduction-type)]
+     (into {} (for [[k v] grammar]
+                (if (:red v) [k v]
+                  [k (assoc v :red (reduction k))])))
+     (throw-illegal-argument-exception
+       "Invalid output format " reduction-type ". Use :enlive or :hiccup."))))
diff --git a/src/instaparse/repeat.cljc b/src/instaparse/repeat.cljc
index b035201..8d98fc0 100644
--- a/src/instaparse/repeat.cljc
+++ b/src/instaparse/repeat.cljc
@@ -1,11 +1,11 @@
 (ns instaparse.repeat
   (:require [instaparse.gll :as gll
              #?@(:clj [:refer [profile]])]
-            [instaparse.combinators-source :as c]
-            [instaparse.auto-flatten-seq :as afs]
-            [instaparse.viz :as viz]
-            [instaparse.reduction :as red]
-            [instaparse.failure :as fail])
+   [instaparse.combinators-source :as c]
+   [instaparse.auto-flatten-seq :as afs]
+   [instaparse.viz :as viz]
+   [instaparse.reduction :as red]
+   [instaparse.failure :as fail])
   #?(:cljs
      (:require-macros [instaparse.gll :refer [profile]])))
 
@@ -19,12 +19,12 @@
 (defn get-end 
   (#?(:clj ^long [parse]
       :cljs ^number [parse])
-    (let [[start end] (viz/span parse)]
-      (if end (long end) (count parse))))
+   (let [[start end] (viz/span parse)]
+     (if end (long end) (count parse))))
   (#?(:clj ^long [parse ^long index]
       :cljs ^number [parse ^number index])
-    (let [[start end] (viz/span parse)]
-      (if end (long end) (+ index (count parse))))))
+   (let [[start end] (viz/span parse)]
+     (if end (long end) (+ index (count parse))))))
 
 (defn parse-from-index [grammar initial-parser text segment index]
   (let [tramp (gll/make-tramp grammar text segment)]
@@ -53,120 +53,120 @@
                                  
 (defn repeat-parse-hiccup 
   ([grammar initial-parser root-tag text segment]
-    (repeat-parse-hiccup grammar initial-parser root-tag text segment 0))
+   (repeat-parse-hiccup grammar initial-parser root-tag text segment 0))
   ([grammar initial-parser root-tag text segment index]
-    (let [length (count text)
-          first-result (parse-from-index grammar initial-parser text segment index)]
-      (loop [index (long index)
-             parses (afs/auto-flatten-seq [root-tag])
+   (let [length (count text)
+         first-result (parse-from-index grammar initial-parser text segment index)]
+     (loop [index (long index)
+            parses (afs/auto-flatten-seq [root-tag])
              
-             [parse end follow-ups :as selection]
-             (select-parse grammar initial-parser text segment index first-result)]
-        (cond
-          (nil? selection) failure-signal
-          (= index end) failure-signal
-          (nil? follow-ups) (gll/safe-with-meta
-                              (afs/convert-afs-to-vec 
-                                (afs/conj-flat parses parse))
-                              {:optimize :memory
-                               :instaparse.gll/start-index 0
-                               :instaparse.gll/end-index length})
-          :else (recur (long end)
-                       (afs/conj-flat parses parse)
-                       (select-parse grammar initial-parser text segment end follow-ups)))))))
+            [parse end follow-ups :as selection]
+            (select-parse grammar initial-parser text segment index first-result)]
+       (cond
+         (nil? selection) failure-signal
+         (= index end) failure-signal
+         (nil? follow-ups) (gll/safe-with-meta
+                             (afs/convert-afs-to-vec 
+                               (afs/conj-flat parses parse))
+                             {:optimize :memory
+                              :instaparse.gll/start-index 0
+                              :instaparse.gll/end-index length})
+         :else (recur (long end)
+                      (afs/conj-flat parses parse)
+                      (select-parse grammar initial-parser text segment end follow-ups)))))))
 
 (defn repeat-parse-enlive
   ([grammar initial-parser root-tag text segment]
-    (repeat-parse-enlive grammar initial-parser root-tag text segment 0))
+   (repeat-parse-enlive grammar initial-parser root-tag text segment 0))
   ([grammar initial-parser root-tag text segment index]
-    (let [length (count text)
-          first-result (parse-from-index grammar initial-parser text segment index)]
-      (loop [index (long index)
-             parses afs/EMPTY
+   (let [length (count text)
+         first-result (parse-from-index grammar initial-parser text segment index)]
+     (loop [index (long index)
+            parses afs/EMPTY
              
-             [parse end follow-ups :as selection]
-             (select-parse grammar initial-parser text segment index first-result)]
-        (cond
-          (nil? selection) failure-signal
-          (= index end) failure-signal          
-          (nil? follow-ups) (gll/safe-with-meta
-                              {:tag root-tag 
-                               :content (seq (afs/conj-flat parses parse))}
-                              {:optimize :memory
-                               :instaparse.gll/start-index 0
-                               :instaparse.gll/end-index length})
-          :else (recur (long end)
-                       (afs/conj-flat parses parse)
-                       (select-parse grammar initial-parser text segment end follow-ups)))))))
+            [parse end follow-ups :as selection]
+            (select-parse grammar initial-parser text segment index first-result)]
+       (cond
+         (nil? selection) failure-signal
+         (= index end) failure-signal          
+         (nil? follow-ups) (gll/safe-with-meta
+                             {:tag root-tag 
+                              :content (seq (afs/conj-flat parses parse))}
+                             {:optimize :memory
+                              :instaparse.gll/start-index 0
+                              :instaparse.gll/end-index length})
+         :else (recur (long end)
+                      (afs/conj-flat parses parse)
+                      (select-parse grammar initial-parser text segment end follow-ups)))))))
 
 (defn repeat-parse-no-tag 
   ([grammar initial-parser text segment]
-    (repeat-parse-no-tag grammar initial-parser text segment 0))
+   (repeat-parse-no-tag grammar initial-parser text segment 0))
   ([grammar initial-parser text segment index]
-    (let [length (count text)
-          first-result (parse-from-index grammar initial-parser text segment index)]
-      (loop [index (long index)
-             parses afs/EMPTY
+   (let [length (count text)
+         first-result (parse-from-index grammar initial-parser text segment index)]
+     (loop [index (long index)
+            parses afs/EMPTY
              
-             [parse end follow-ups :as selection]
-             (select-parse grammar initial-parser text segment index first-result)]
-        (cond
-          (nil? selection) failure-signal
-          (= index end) failure-signal          
-          (nil? follow-ups) (gll/safe-with-meta
-                              (afs/conj-flat parses parse)
-                              {:optimize :memory
-                               :instaparse.gll/start-index 0
-                               :instaparse.gll/end-index length})
-          :else (recur (long end)
-                       (afs/conj-flat parses parse)
-                       (select-parse grammar initial-parser text segment end follow-ups)))))))
+            [parse end follow-ups :as selection]
+            (select-parse grammar initial-parser text segment index first-result)]
+       (cond
+         (nil? selection) failure-signal
+         (= index end) failure-signal          
+         (nil? follow-ups) (gll/safe-with-meta
+                             (afs/conj-flat parses parse)
+                             {:optimize :memory
+                              :instaparse.gll/start-index 0
+                              :instaparse.gll/end-index length})
+         :else (recur (long end)
+                      (afs/conj-flat parses parse)
+                      (select-parse grammar initial-parser text segment end follow-ups)))))))
 
 (defn repeat-parse 
   ([grammar initial-parser output-format text] (repeat-parse-no-tag grammar initial-parser text (gll/text->segment text)))
   ([grammar initial-parser output-format root-tag text]
-    {:pre [(#{:hiccup :enlive} output-format)]} 
-    (cond
-      (= output-format :hiccup)
-      (repeat-parse-hiccup grammar initial-parser root-tag text (gll/text->segment text))
-      (= output-format :enlive)
-      (repeat-parse-enlive grammar initial-parser root-tag text (gll/text->segment text)))))
+   {:pre [(#{:hiccup :enlive} output-format)]} 
+   (cond
+     (= output-format :hiccup)
+     (repeat-parse-hiccup grammar initial-parser root-tag text (gll/text->segment text))
+     (= output-format :enlive)
+     (repeat-parse-enlive grammar initial-parser root-tag text (gll/text->segment text)))))
 
 (defn repeat-parse-with-header
   ([grammar header-parser repeating-parser output-format root-tag text]
-    (let [segment (gll/text->segment text)
-          length (count text)
-          header-results (parse-from-index grammar header-parser text segment 0)]
-      (if (or (empty? header-results)
-              (:hide header-parser))
-        failure-signal
-        (let [header-result (apply max-key get-end header-results)
-              end (get-end header-result)
-              repeat-result (repeat-parse-no-tag grammar (:parser repeating-parser) text segment end)
-              span-meta {:optimize :memory
-                         :instaparse.gll/start-index 0
-                         :instaparse.gll/end-index length}]
-          (if (or (instance? instaparse.gll.Failure repeat-result)
-                  (and (= (:tag repeating-parser) :star)
-                       (empty-result? repeat-result)))
-            failure-signal
-            (case output-format
-              :enlive
-              (gll/safe-with-meta
-                {:tag root-tag 
-                 :content
-                 (afs/conj-flat (afs/conj-flat afs/EMPTY header-result) repeat-result)}
-                span-meta)
-              :hiccup
-              (gll/safe-with-meta
-                (afs/convert-afs-to-vec 
-                  (afs/conj-flat (afs/conj-flat (afs/auto-flatten-seq [root-tag])
-                                                header-result) 
-                                 repeat-result))
-                span-meta)
-              (gll/safe-with-meta 
-                (afs/conj-flat (afs/conj-flat afs/EMPTY header-result) repeat-result)
-                span-meta))))))))
+   (let [segment (gll/text->segment text)
+         length (count text)
+         header-results (parse-from-index grammar header-parser text segment 0)]
+     (if (or (empty? header-results)
+             (:hide header-parser))
+       failure-signal
+       (let [header-result (apply max-key get-end header-results)
+             end (get-end header-result)
+             repeat-result (repeat-parse-no-tag grammar (:parser repeating-parser) text segment end)
+             span-meta {:optimize :memory
+                        :instaparse.gll/start-index 0
+                        :instaparse.gll/end-index length}]
+         (if (or (instance? instaparse.gll.Failure repeat-result)
+                 (and (= (:tag repeating-parser) :star)
+                      (empty-result? repeat-result)))
+           failure-signal
+           (case output-format
+             :enlive
+             (gll/safe-with-meta
+               {:tag root-tag 
+                :content
+                (afs/conj-flat (afs/conj-flat afs/EMPTY header-result) repeat-result)}
+               span-meta)
+             :hiccup
+             (gll/safe-with-meta
+               (afs/convert-afs-to-vec 
+                 (afs/conj-flat (afs/conj-flat (afs/auto-flatten-seq [root-tag])
+                                               header-result) 
+                                repeat-result))
+               span-meta)
+             (gll/safe-with-meta 
+               (afs/conj-flat (afs/conj-flat afs/EMPTY header-result) repeat-result)
+               span-meta))))))))
     
 (defn try-repeating-parse-strategy-with-header
   [grammar text start-production start-rule output-format]
@@ -213,7 +213,7 @@
           result))
       
       :else (try-repeating-parse-strategy-with-header 
-                grammar text start-production start-rule output-format))))
+              grammar text start-production start-rule output-format))))
 
 (defn used-memory-optimization? [tree]
   (= :memory (-> tree meta :optimize)))
\ No newline at end of file
diff --git a/src/instaparse/transform.cljc b/src/instaparse/transform.cljc
index 2e08979..7b124a9 100644
--- a/src/instaparse/transform.cljc
+++ b/src/instaparse/transform.cljc
@@ -1,7 +1,7 @@
 (ns instaparse.transform
   "Functions to transform parse trees"
   (:require [instaparse.gll]
-            [instaparse.util :refer [throw-illegal-argument-exception]]))
+   [instaparse.util :refer [throw-illegal-argument-exception]]))
 
 (defn map-preserving-meta [f l]
   (with-meta (map f l) (meta l)))
diff --git a/src/instaparse/util.cljc b/src/instaparse/util.cljc
index b0d1be8..af4a9e6 100644
--- a/src/instaparse/util.cljc
+++ b/src/instaparse/util.cljc
@@ -13,8 +13,8 @@
       throw))
 
 #?(:cljs
-    (defn regexp-flags [re]
-      (cond-> ""
-        (.-ignoreCase re) (str "i")
-        (.-multiline re) (str "m")
-        (.-unicode re) (str "u"))))
+   (defn regexp-flags [re]
+     (cond-> ""
+       (.-ignoreCase re) (str "i")
+       (.-multiline re) (str "m")
+       (.-unicode re) (str "u"))))
diff --git a/test/instaparse/abnf_test.cljc b/test/instaparse/abnf_test.cljc
index 87ee901..fe13024 100644
--- a/test/instaparse/abnf_test.cljc
+++ b/test/instaparse/abnf_test.cljc
@@ -1,14 +1,14 @@
 (ns instaparse.abnf-test
   (:require
-    #?(:clj  [instaparse.core :refer [parser parses defparser]]
-       :cljs [instaparse.core :refer [parser parses] :refer-macros [defparser]])
-    [instaparse.core-test :refer [parsers-similar?]]
-    [instaparse.combinators :refer [ebnf abnf]]
-    #?(:clj [clojure.test :refer [deftest are is]]
-       :cljs [cljs.test])
-    #?(:clj  [clojure.java.io :as io]))
+   #?(:clj  [instaparse.core :refer [parser parses defparser]]
+      :cljs [instaparse.core :refer [parser parses] :refer-macros [defparser]])
+   [instaparse.core-test :refer [parsers-similar?]]
+   [instaparse.combinators :refer [ebnf abnf]]
+   #?(:clj [clojure.test :refer [deftest are is]]
+      :cljs [cljs.test])
+   #?(:clj  [clojure.java.io :as io]))
   #?(:cljs (:require-macros
-             [cljs.test :refer [is are deftest]])))
+            [cljs.test :refer [is are deftest]])))
 
 (defparser uri-parser
   "test/data/abnf_uri.txt"
@@ -26,19 +26,19 @@
            uri-parser
            (binding [instaparse.abnf/*case-insensitive* true]
              (parser 
-              "test/data/abnf_uri.txt"
-              :input-format :abnf
-              :instaparse.abnf/case-insensitive true))
+               "test/data/abnf_uri.txt"
+               :input-format :abnf
+               :instaparse.abnf/case-insensitive true))
            (binding [instaparse.abnf/*case-insensitive* true]
              (parser 
-              (io/resource "data/abnf_uri.txt")
-              :input-format :abnf
-              :instaparse.abnf/case-insensitive true))
+               (io/resource "data/abnf_uri.txt")
+               :input-format :abnf
+               :instaparse.abnf/case-insensitive true))
            (binding [instaparse.abnf/*case-insensitive* true]
              (parser 
-              (slurp "test/data/abnf_uri.txt")
-              :input-format :abnf
-              :instaparse.abnf/case-insensitive true)))
+               (slurp "test/data/abnf_uri.txt")
+               :input-format :abnf
+               :instaparse.abnf/case-insensitive true)))
          "Verify that defparser, auto-slurp from string filename,
          auto-slurp from resource (URL), and manual slurp all return
          equivalent parsers.")))
@@ -210,9 +210,9 @@ to test the lookahead"
 
 (deftest abnf-combinator-test
   (let [p (parser (merge
-                   {:S (abnf "A / B")}
-                   (abnf "<A> = 1*'a'")
-                   {:B (abnf "'='")})
+                    {:S (abnf "A / B")}
+                    (abnf "<A> = 1*'a'")
+                    {:B (abnf "'='")})
                   :start :S)]
     (are [x y] (= y x)
       (p "aAaa")
diff --git a/test/instaparse/auto_flatten_seq_test.cljc b/test/instaparse/auto_flatten_seq_test.cljc
index bbc74ba..ee8533b 100644
--- a/test/instaparse/auto_flatten_seq_test.cljc
+++ b/test/instaparse/auto_flatten_seq_test.cljc
@@ -1,8 +1,8 @@
 (ns instaparse.auto-flatten-seq-test
   (:require
-    [instaparse.auto-flatten-seq :refer [auto-flatten-seq conj-flat convert-afs-to-vec]]
-    #?(:clj [clojure.test :refer [deftest are is]]
-       :cljs [cljs.test]))
+   [instaparse.auto-flatten-seq :refer [auto-flatten-seq conj-flat convert-afs-to-vec]]
+   #?(:clj [clojure.test :refer [deftest are is]]
+      :cljs [cljs.test]))
   #?(:cljs (:require-macros [cljs.test :refer [deftest are is]])))
 
 (defn rand-mutation [v iv]
diff --git a/test/instaparse/core_test.cljc b/test/instaparse/core_test.cljc
index a8ad3c5..414e428 100644
--- a/test/instaparse/core_test.cljc
+++ b/test/instaparse/core_test.cljc
@@ -1,21 +1,21 @@
 (ns instaparse.core-test
   #?(:clj (:refer-clojure :exclude [cat read-string]))
   (:require
-    #?(:clj  [clojure.test :refer [deftest are is]]
-       :cljs [cljs.test :as t])
-    #?(:clj  [clojure.edn :refer [read-string]]
-       :cljs [cljs.reader :refer [read-string]])
-    #?(:clj  [instaparse.core :as insta :refer [defparser]]
-       :cljs [instaparse.core :as insta :refer-macros [defparser]])
-    [instaparse.cfg :refer [ebnf]]
-    [instaparse.line-col :as lc]
-    [instaparse.combinators-source :refer [Epsilon opt plus star rep 
-                                           alt ord cat string-ci string
-                                           string-ci regexp nt look neg 
-                                           hide hide-tag]]
-    [clojure.walk :as walk])
+   #?(:clj  [clojure.test :refer [deftest are is]]
+      :cljs [cljs.test :as t])
+   #?(:clj  [clojure.edn :refer [read-string]]
+      :cljs [cljs.reader :refer [read-string]])
+   #?(:clj  [instaparse.core :as insta :refer [defparser]]
+      :cljs [instaparse.core :as insta :refer-macros [defparser]])
+   [instaparse.cfg :refer [ebnf]]
+   [instaparse.line-col :as lc]
+   [instaparse.combinators-source :refer [Epsilon opt plus star rep 
+                                          alt ord cat string-ci string
+                                          string-ci regexp nt look neg 
+                                          hide hide-tag]]
+   [clojure.walk :as walk])
   #?(:cljs (:require-macros
-             [cljs.test :refer [is are deftest run-tests]])))
+            [cljs.test :refer [is are deftest run-tests]])))
 
 (defn parsers-similar?
   "Tests if parsers are equal."
@@ -30,8 +30,8 @@
                   (instance? instaparse.core.Parser form)
                   (into {} form)
                   (instance? #?(:clj java.util.regex.Pattern
-                                  :cljs js/RegExp)
-                               form)
+                                :cljs js/RegExp)
+                    form)
                   [::regex (str form)]
                   :else
                   form))))
@@ -366,7 +366,7 @@
      Double = #'[0-9]+\\.[0-9]*|\\.[0-9]+';
      <ConstExpr> = Int | Double;
      Input = ConstExpr <ws> ConstExpr;"
-     :start :Input))
+    :start :Input))
 
 (def case-insensitive-regexp
   (insta/parser
@@ -379,25 +379,25 @@
      [:AB [:A "a" "a" "a" "a" "a"] [:B "b" "b" "b"]]
      [:AB [:A "a" "a" "a" "a"] [:B "b" "b"]]]
     
-#?@(:clj [(as-and-bs (StringBuilder. "aaaaabbbaaaabb"))
-          [:S
-           [:AB [:A "a" "a" "a" "a" "a"] [:B "b" "b" "b"]]
-           [:AB [:A "a" "a" "a" "a"] [:B "b" "b"]]]])
+    #?@(:clj [(as-and-bs (StringBuilder. "aaaaabbbaaaabb"))
+              [:S
+               [:AB [:A "a" "a" "a" "a" "a"] [:B "b" "b" "b"]]
+               [:AB [:A "a" "a" "a" "a"] [:B "b" "b"]]]])
     
     (as-and-bs "aaaaabbbaaaabb")
     (as-and-bs "aaaaabbbaaaabb" :optimize :memory)
     
     (as-and-bs-enlive "aaaaabbbaaaabb")
     '{:tag :S,
-     :content
-     ({:tag :AB,
-       :content
-       ({:tag :A, :content ("a" "a" "a" "a" "a")}
+      :content
+      ({:tag :AB,
+        :content
+        ({:tag :A, :content ("a" "a" "a" "a" "a")}
          {:tag :B, :content ("b" "b" "b")})}
        {:tag :AB,
-      :content
-      ({:tag :A, :content ("a" "a" "a" "a")}
-        {:tag :B, :content ("b" "b")})})}
+        :content
+        ({:tag :A, :content ("a" "a" "a" "a")}
+         {:tag :B, :content ("b" "b")})})}
     
     (as-and-bs-enlive "aaaaabbbaaaabb")
     (as-and-bs-enlive "aaaaabbbaaaabb" :optimize :memory)
@@ -454,7 +454,7 @@
 
     (insta/transform
       {:num read-string
-      :plus +}
+       :plus +}
       (addition-e "1+2+3+4+5"))
     15    
     
@@ -499,7 +499,7 @@
     
     (insta/parses 
       (insta/parser 
-         "Regex = (CharNonRange | Range) +
+        "Regex = (CharNonRange | Range) +
           Range = Char <'-'> Char
           CharNonRange = Char ! ('-' Char)
           Char = #'[-x]' | 'c' (! 'd') 'x'")
@@ -518,9 +518,9 @@
 
     (insta/parses ambiguous-tokenizer "defn my cond")
     '([:sentence
-      [:identifier "defn"]
-      [:identifier "my"]
-      [:identifier "cond"]]
+       [:identifier "defn"]
+       [:identifier "my"]
+       [:identifier "cond"]]
       [:sentence [:keyword "defn"] [:identifier "my"] [:identifier "cond"]]
       [:sentence [:identifier "defn"] [:identifier "my"] [:keyword "cond"]]
       [:sentence [:keyword "defn"] [:identifier "my"] [:keyword "cond"]])
@@ -547,9 +547,9 @@
     (words-and-numbers-one-character-at-a-time "abc 123 def" :optimize :memory)   
 
     (insta/transform 
-     {:word str, 
-      :number (comp read-string str)}
-     (words-and-numbers-one-character-at-a-time "abc 123 def"))
+      {:word str, 
+       :number (comp read-string str)}
+      (words-and-numbers-one-character-at-a-time "abc 123 def"))
     [:sentence "abc" 123 "def"]
     
     (->> (words-and-numbers-enlive "abc 123 def")
@@ -576,9 +576,9 @@
     (arithmetic "1-2/(3-4)+5*6" :optimize :memory)        
     
     (->> (arithmetic "1-2/(3-4)+5*6")
-     (insta/transform
-       {:add +, :sub -, :mul *, :div /, 
-        :number read-string :expr identity}))
+      (insta/transform
+        {:add +, :sub -, :mul *, :div /, 
+         :number read-string :expr identity}))
     33
     
     (paren-ab-hide-both-tags "(aba)")
@@ -612,7 +612,7 @@
     ((insta/parser "S = ('a'?)+") "" :optimize :memory)    
     
     ((insta/parser
-     "a = b c .
+       "a = b c .
       b = 'b' .
       c = 'c' .") "bc")
     [:a [:b "b"] [:c "c"]]
diff --git a/test/instaparse/defparser_test.cljc b/test/instaparse/defparser_test.cljc
index 6246f0b..1c561b8 100644
--- a/test/instaparse/defparser_test.cljc
+++ b/test/instaparse/defparser_test.cljc
@@ -1,11 +1,11 @@
 (ns instaparse.defparser-test
   (:require
-    #?(:clj  [clojure.test :as t :refer [deftest are is]]
-       :cljs [cljs.test :as t :refer-macros [deftest are is]])
-    #?(:clj  [instaparse.core :as insta :refer [defparser]]
-       :cljs [instaparse.core :as insta :refer-macros [defparser]])
-    [instaparse.combinators :as c]
-    [instaparse.core-test :refer [parsers-similar?]]))
+   #?(:clj  [clojure.test :as t :refer [deftest are is]]
+      :cljs [cljs.test :as t :refer-macros [deftest are is]])
+   #?(:clj  [instaparse.core :as insta :refer [defparser]]
+      :cljs [instaparse.core :as insta :refer-macros [defparser]])
+   [instaparse.combinators :as c]
+   [instaparse.core-test :refer [parsers-similar?]]))
 
 (defparser p1 "S = #'a' | 'b'")
 
diff --git a/test/instaparse/grammars.cljc b/test/instaparse/grammars.cljc
index 82dc9b1..78ba482 100644
--- a/test/instaparse/grammars.cljc
+++ b/test/instaparse/grammars.cljc
@@ -2,15 +2,15 @@
   #?(:clj (:refer-clojure :exclude [cat]))
   (:require #?(:clj  [clojure.test :refer [deftest are]]
                :cljs [cljs.test :as t])
-            [instaparse.reduction :refer [apply-standard-reductions]]
-            [instaparse.combinators :refer [Epsilon opt plus 
-                                            star rep alt ord 
-                                            cat string string-ci 
-                                            regexp nt look neg 
-                                            hide hide-tag
-                                            ebnf abnf]]
-            [instaparse.gll :as gll]
-            [instaparse.core :as insta])
+   [instaparse.reduction :refer [apply-standard-reductions]]
+   [instaparse.combinators :refer [Epsilon opt plus 
+                                   star rep alt ord 
+                                   cat string string-ci 
+                                   regexp nt look neg 
+                                   hide hide-tag
+                                   ebnf abnf]]
+   [instaparse.gll :as gll]
+   [instaparse.core :as insta])
   #?(:cljs (:require-macros [cljs.test :refer [is are deftest run-tests testing]])))
 
 (defn- parse [grammar start text]
@@ -40,8 +40,8 @@
                        (cat (string "b") (nt :s))
                        Epsilon)})
 (def grammar10 {:s (alt (cat (nt :s) (string "a") )
-                       (cat (nt :s) (string "b") )
-                       Epsilon)})
+                     (cat (nt :s) (string "b") )
+                     Epsilon)})
 (def grammar11 {:s (alt (cat (nt :s) (string "a")) (string "a"))})
 (def grammar12 {:s (alt (nt :a) (nt :a) (nt :a))
                 :a (alt (cat (nt :s) (string "a")) (string "a"))})
@@ -54,10 +54,10 @@
                             (cat (string "(") (nt :s) (string ")"))
                             (cat (nt :s) (nt :s)))})
 (def non-ll-grammar {:s (alt (nt :a) (nt :b))
-                      :a (alt (cat (string "a") (nt :a) (string "b"))
-                              Epsilon)
-                      :b (alt (cat (string "a") (nt :b) (string "bb"))
-                              Epsilon)})
+                     :a (alt (cat (string "a") (nt :a) (string "b"))
+                             Epsilon)
+                     :b (alt (cat (string "a") (nt :b) (string "bb"))
+                             Epsilon)})
 (def grammar14 {:s (cat (opt (string "a")) (string "b"))})
 (def grammar15 {:s (cat (opt (string "a")) (opt (string "b")))})
 (def grammar16 {:s (plus (string "a"))})
diff --git a/test/instaparse/repeat_test.cljc b/test/instaparse/repeat_test.cljc
index 4a79538..2eff067 100644
--- a/test/instaparse/repeat_test.cljc
+++ b/test/instaparse/repeat_test.cljc
@@ -1,12 +1,12 @@
 (ns instaparse.repeat-test
   (:require #?(:clj  [clojure.test :refer [deftest are]]
                :cljs [cljs.test :as t])
-            [instaparse.core :as insta]
-            [instaparse.repeat :as repeat])
+   [instaparse.core :as insta]
+   [instaparse.repeat :as repeat])
   #?(:cljs (:require-macros [cljs.test :refer [are deftest]])))
 
 (def user-parser
-"content = user-block*
+  "content = user-block*
 user-block = (user before-section after-section < blank-line* >)
 user = prefix separator number separator name newline
 before-section = < before > lines error-line*
@@ -37,8 +37,8 @@ number = #'[0-9]+'
              tree3 (parser-enlive text)
              tree4 (parser-enlive text :optimize :memory)]
          (and (= tree1 tree2) (= tree3 tree4)
-            (= optimize? (repeat/used-memory-optimization? tree2))
-            (= optimize? (repeat/used-memory-optimization? tree4))))
+           (= optimize? (repeat/used-memory-optimization? tree2))
+           (= optimize? (repeat/used-memory-optimization? tree4))))
        
        ;user-parser text true
        "S = 'ab'*" "ababab" true