       (with-meta nseg {:name (+ name rname)})
       nseg)))
 
-(defn update-result
-  "Helper for decode. Take an internal source map representation
-   organized as nested sorted maps mapping file, line, and column
-   and update it based on a segment map and generated line number."
+(defn update-reverse-result
+  "Helper for decode-reverse. Take a reverse source map and
+  update it with a segment map."
   [result segmap gline]
   (let [{:keys [gcol source line col name]} segmap
         d {:gline gline

            (sorted-map)))))

(defn decode-reverse
  "Convert a v3 source map JSON object into a nested sorted map 
   organized as file, line, and column that maps ClojureScript
   source locations to the generated JavaScript."
  ([source-map]
     (decode (aget source-map "mappings") source-map))
  ([mappings source-map]
     (let [sources (aget source-map "sources")
           relseg-init [0 0 0 0 0]

                         (let [seg (first segs)
                               nrelseg (seg-combine (base64-vlq/decode seg) relseg)]
                           (recur (next segs) nrelseg
                             (update-reverse-result result (seg->map nrelseg source-map) gline)))
                         [result relseg]))))]
             (recur (inc gline) (next lines) (assoc relseg 0 0) result))
           result)))))

(defn update-result
  "Helper for decode. Take a source map and update it based on a
  segment map."
  [result segmap gline]
  (let [{:keys [gcol source line col name]} segmap
        d {:line col
           :col  line
           :source source}
        d (if name (assoc d :name name) d)]
    (update-in result [gline]
      (fnil (fn [m]
              (update-in m [gcol]
                (fnil #(conj % d) [])))
            (sorted-map)))))

(defn decode
  "Convert a v3 source map JSON object into a source map mapping
  generated JavaScript source locations to the original
  ClojureScript."
  ([source-map]
     (decode (aget source-map "mappings") source-map))
  ([mappings source-map]
     (let [sources (aget source-map "sources")
           relseg-init [0 0 0 0 0]
           lines (seq (string/split mappings #";"))]
       (loop [gline 0 lines lines relseg relseg-init result {}]
         (if lines
           (let [line (first lines)
                 [result relseg]
                 (if (string/blank? line)
                   [result relseg]
                   (let [segs (seq (string/split line #","))]
                     (loop [segs segs relseg relseg result result]
                       (if segs
                         (let [seg (first segs)
                               nrelseg (seg-combine (base64-vlq/decode seg) relseg)]
                           (recur (next segs) nrelseg
                             (update-result result (seg->map nrelseg source-map) gline)))
                         [result relseg]))))]
             (recur (inc gline) (next lines) (assoc relseg 0 0) result))
