move static files into static sub-dir, refactor nix a bit

8 files changed, 1322 insertions, 0 deletions

diff --git a/static/src/assets/viz/2/clojure/set.cljs b/static/src/assets/viz/2/clojure/set.cljs
new file mode 100644
index 0000000..b9ba41f
--- /dev/null
+++ b/static/src/assets/viz/2/clojure/set.cljs
@@ -0,0 +1,161 @@
+;   Copyright (c) Rich Hickey. All rights reserved.
+;   The use and distribution terms for this software are covered by the
+;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+;   which can be found in the file epl-v10.html at the root of this distribution.
+;   By using this software in any fashion, you are agreeing to be bound by
+;   the terms of this license.
+;   You must not remove this notice, or any other, from this software.
+
+(ns ^{:doc "Set operations such as union/intersection."
+       :author "Rich Hickey"}
+       clojure.set)
+
+(defn- bubble-max-key [k coll]
+  "Move a maximal element of coll according to fn k (which returns a number) 
+   to the front of coll."
+  (let [max (apply max-key k coll)]
+    (cons max (remove #(identical? max %) coll))))
+
+(defn union
+  "Return a set that is the union of the input sets"
+  ([] #{})
+  ([s1] s1)
+  ([s1 s2]
+     (if (< (count s1) (count s2))
+       (reduce conj s2 s1)
+       (reduce conj s1 s2)))
+  ([s1 s2 & sets]
+     (let [bubbled-sets (bubble-max-key count (conj sets s2 s1))]
+       (reduce into (first bubbled-sets) (rest bubbled-sets)))))
+
+(defn intersection
+  "Return a set that is the intersection of the input sets"
+  ([s1] s1)
+  ([s1 s2]
+     (if (< (count s2) (count s1))
+       (recur s2 s1)
+       (reduce (fn [result item]
+                   (if (contains? s2 item)
+		     result
+                     (disj result item)))
+	       s1 s1)))
+  ([s1 s2 & sets] 
+     (let [bubbled-sets (bubble-max-key #(- (count %)) (conj sets s2 s1))]
+       (reduce intersection (first bubbled-sets) (rest bubbled-sets)))))
+
+(defn difference
+  "Return a set that is the first set without elements of the remaining sets"
+  ([s1] s1)
+  ([s1 s2] 
+     (if (< (count s1) (count s2))
+       (reduce (fn [result item] 
+                   (if (contains? s2 item) 
+                     (disj result item) 
+                     result))
+               s1 s1)
+       (reduce disj s1 s2)))
+  ([s1 s2 & sets] 
+     (reduce difference s1 (conj sets s2))))
+
+
+(defn select
+  "Returns a set of the elements for which pred is true"
+  [pred xset]
+    (reduce (fn [s k] (if (pred k) s (disj s k)))
+            xset xset))
+
+(defn project
+  "Returns a rel of the elements of xrel with only the keys in ks"
+  [xrel ks]
+    (set (map #(select-keys % ks) xrel)))
+
+(defn rename-keys
+  "Returns the map with the keys in kmap renamed to the vals in kmap"
+  [map kmap]
+    (reduce
+     (fn [m [old new]]
+       (if (contains? map old)
+         (assoc m new (get map old))
+         m))
+     (apply dissoc map (keys kmap)) kmap))
+
+(defn rename
+  "Returns a rel of the maps in xrel with the keys in kmap renamed to the vals in kmap"
+  [xrel kmap]
+    (set (map #(rename-keys % kmap) xrel)))
+
+(defn index
+  "Returns a map of the distinct values of ks in the xrel mapped to a
+  set of the maps in xrel with the corresponding values of ks."
+  [xrel ks]
+    (reduce
+     (fn [m x]
+       (let [ik (select-keys x ks)]
+         (assoc m ik (conj (get m ik #{}) x))))
+     {} xrel))
+   
+(defn map-invert
+  "Returns the map with the vals mapped to the keys."
+  [m] (reduce (fn [m [k v]] (assoc m v k)) {} m))
+
+(defn join
+  "When passed 2 rels, returns the rel corresponding to the natural
+  join. When passed an additional keymap, joins on the corresponding
+  keys."
+  ([xrel yrel] ;natural join
+   (if (and (seq xrel) (seq yrel))
+     (let [ks (intersection (set (keys (first xrel))) (set (keys (first yrel))))
+           [r s] (if (<= (count xrel) (count yrel))
+                   [xrel yrel]
+                   [yrel xrel])
+           idx (index r ks)]
+       (reduce (fn [ret x]
+                 (let [found (idx (select-keys x ks))]
+                   (if found
+                     (reduce #(conj %1 (merge %2 x)) ret found)
+                     ret)))
+               #{} s))
+     #{}))
+  ([xrel yrel km] ;arbitrary key mapping
+   (let [[r s k] (if (<= (count xrel) (count yrel))
+                   [xrel yrel (map-invert km)]
+                   [yrel xrel km])
+         idx (index r (vals k))]
+     (reduce (fn [ret x]
+               (let [found (idx (rename-keys (select-keys x (keys k)) k))]
+                 (if found
+                   (reduce #(conj %1 (merge %2 x)) ret found)
+                   ret)))
+             #{} s))))
+
+(defn subset? 
+  "Is set1 a subset of set2?"
+  [set1 set2]
+  (and (<= (count set1) (count set2))
+       (every? #(contains? set2 %) set1)))
+
+(defn superset? 
+  "Is set1 a superset of set2?"
+  [set1 set2]
+  (and (>= (count set1) (count set2))
+       (every? #(contains? set1 %) set2)))
+
+(comment
+(refer 'set)
+(def xs #{{:a 11 :b 1 :c 1 :d 4}
+         {:a 2 :b 12 :c 2 :d 6}
+         {:a 3 :b 3 :c 3 :d 8 :f 42}})
+
+(def ys #{{:a 11 :b 11 :c 11 :e 5}
+         {:a 12 :b 11 :c 12 :e 3}
+         {:a 3 :b 3 :c 3 :e 7 }})
+
+(join xs ys)
+(join xs (rename ys {:b :yb :c :yc}) {:a :a})
+
+(union #{:a :b :c} #{:c :d :e })
+(difference #{:a :b :c} #{:c :d :e})
+(intersection #{:a :b :c} #{:c :d :e})
+
+(index ys [:b]))
+
diff --git a/static/src/assets/viz/2/clojure/set.cljs.cache.json b/static/src/assets/viz/2/clojure/set.cljs.cache.json
new file mode 100644
index 0000000..f2332c0
--- /dev/null
+++ b/static/src/assets/viz/2/clojure/set.cljs.cache.json
@@ -0,0 +1 @@
+["^ ","~:rename-macros",["^ "],"~:renames",["^ "],"~:externs",["^ ","~$Error",["^ "]],"~:use-macros",["^ "],"~:excludes",["~#set",[]],"~:name","~$clojure.set","~:imports",null,"~:requires",null,"~:cljs.spec/speced-vars",[],"~:uses",null,"~:defs",["^ ","~$union",["^ ","~:protocol-inline",null,"~:meta",["^ ","~:file","/home/mediocregopher/src/viz/out/clojure/set.cljs","~:line",19,"~:column",7,"~:end-line",19,"~:end-column",12,"~:arglists",["~#list",["~$quote",["^G",[[],["~$s1"],["^I","~$s2"],["^I","^J","~$&","~$sets"]]]]],"~:doc","Return a set that is the union of the input sets","~:top-fn",["^ ","~:variadic?",true,"~:max-fixed-arity",2,"~:method-params",["^G",[[],["^I"],["^I","^J"]]],"^F",["^G",[[],["^I"],["^I","^J"],["^I","^J","~$&","^K"]]],"~:arglists-meta",["^G",[null,null,null,null]]]],"^7","~$clojure.set/union","^A","out/clojure/set.cljs","^E",12,"^M",["^ ","^N",true,"^O",2,"^P",["^G",[[],["^I"],["^I","^J"]]],"^F",["^G",[[],["^I"],["^I","^J"],["^I","^J","~$&","^K"]]],"^Q",["^G",[null,null,null,null]]],"^P",["^G",[[],["^I"],["^I","^J"]]],"~:protocol-impl",null,"^Q",["^G",[null,null,null,null]],"^C",1,"^N",true,"^B",19,"^D",19,"^O",2,"~:fn-var",true,"^F",["^G",[[],["^I"],["^I","^J"],["^I","^J","~$&","^K"]]],"^L","Return a set that is the union of the input sets"],"~$map-invert",["^ ","^?",null,"^@",["^ ","^A","/home/mediocregopher/src/viz/out/clojure/set.cljs","^B",97,"^C",7,"^D",97,"^E",17,"^F",["^G",["^H",["^G",[["~$m"]]]]],"^L","Returns the map with the vals mapped to the keys."],"^7","~$clojure.set/map-invert","^A","out/clojure/set.cljs","^E",17,"^P",["^G",[["~$m"]]],"^S",null,"^Q",["^G",[null,null]],"^C",1,"^N",false,"^B",97,"~:ret-tag","~$any","^D",97,"^O",1,"^T",true,"^F",["^G",["^H",["^G",[["~$m"]]]]],"^L","Returns the map with the vals mapped to the keys."],"~$join",["^ ","^?",null,"^@",["^ ","^A","/home/mediocregopher/src/viz/out/clojure/set.cljs","^B",101,"^C",7,"^D",101,"^E",11,"^F",["^G",["^H",["^G",[["~$xrel","~$yrel"],["^Z","^[","~$km"]]]]],"^L","When passed 2 rels, returns the rel corresponding to the natural\n  join. When passed an additional keymap, joins on the corresponding\n  keys.","^M",["^ ","^N",false,"^O",3,"^P",["^G",[["^Z","^["],["^Z","^[","^10"]]],"^F",["^G",[["^Z","^["],["^Z","^[","^10"]]],"^Q",["^G",[null,null]]]],"^7","~$clojure.set/join","^A","out/clojure/set.cljs","^E",11,"^M",["^ ","^N",false,"^O",3,"^P",["^G",[["^Z","^["],["^Z","^[","^10"]]],"^F",["^G",[["^Z","^["],["^Z","^[","^10"]]],"^Q",["^G",[null,null]]],"^P",["^G",[["^Z","^["],["^Z","^[","^10"]]],"^S",null,"^Q",["^G",[null,null]],"^C",1,"^N",false,"^B",101,"^D",101,"^O",3,"^T",true,"^F",["^G",[["^Z","^["],["^Z","^[","^10"]]],"^L","When passed 2 rels, returns the rel corresponding to the natural\n  join. When passed an additional keymap, joins on the corresponding\n  keys."],"~$select",["^ ","^?",null,"^@",["^ ","^A","/home/mediocregopher/src/viz/out/clojure/set.cljs","^B",61,"^C",7,"^D",61,"^E",13,"^F",["^G",["^H",["^G",[["~$pred","~$xset"]]]]],"^L","Returns a set of the elements for which pred is true"],"^7","~$clojure.set/select","^A","out/clojure/set.cljs","^E",13,"^P",["^G",[["^13","^14"]]],"^S",null,"^Q",["^G",[null,null]],"^C",1,"^N",false,"^B",61,"^W","^X","^D",61,"^O",2,"^T",true,"^F",["^G",["^H",["^G",[["^13","^14"]]]]],"^L","Returns a set of the elements for which pred is true"],"~$intersection",["^ ","^?",null,"^@",["^ ","^A","/home/mediocregopher/src/viz/out/clojure/set.cljs","^B",31,"^C",7,"^D",31,"^E",19,"^F",["^G",["^H",["^G",[["^I"],["^I","^J"],["^I","^J","~$&","^K"]]]]],"^L","Return a set that is the intersection of the input sets","^M",["^ ","^N",true,"^O",2,"^P",["^G",[["^I"],["^I","^J"]]],"^F",["^G",[["^I"],["^I","^J"],["^I","^J","~$&","^K"]]],"^Q",["^G",[null,null,null]]]],"^7","~$clojure.set/intersection","^A","out/clojure/set.cljs","^E",19,"^M",["^ ","^N",true,"^O",2,"^P",["^G",[["^I"],["^I","^J"]]],"^F",["^G",[["^I"],["^I","^J"],["^I","^J","~$&","^K"]]],"^Q",["^G",[null,null,null]]],"^P",["^G",[["^I"],["^I","^J"]]],"^S",null,"^Q",["^G",[null,null,null]],"^C",1,"^N",true,"^B",31,"^D",31,"^O",2,"^T",true,"^F",["^G",[["^I"],["^I","^J"],["^I","^J","~$&","^K"]]],"^L","Return a set that is the intersection of the input sets"],"~$superset?",["^ ","^?",null,"^@",["^ ","^A","/home/mediocregopher/src/viz/out/clojure/set.cljs","^B",137,"^C",7,"^D",137,"^E",16,"^F",["^G",["^H",["^G",[["~$set1","~$set2"]]]]],"^L","Is set1 a superset of set2?"],"^7","~$clojure.set/superset?","^A","out/clojure/set.cljs","^E",16,"^P",["^G",[["^19","^1:"]]],"^S",null,"^Q",["^G",[null,null]],"^C",1,"^N",false,"^B",137,"^W","~$boolean","^D",137,"^O",2,"^T",true,"^F",["^G",["^H",["^G",[["^19","^1:"]]]]],"^L","Is set1 a superset of set2?"],"~$index",["^ ","^?",null,"^@",["^ ","^A","/home/mediocregopher/src/viz/out/clojure/set.cljs","^B",87,"^C",7,"^D",87,"^E",12,"^F",["^G",["^H",["^G",[["^Z","~$ks"]]]]],"^L","Returns a map of the distinct values of ks in the xrel mapped to a\n  set of the maps in xrel with the corresponding values of ks."],"^7","~$clojure.set/index","^A","out/clojure/set.cljs","^E",12,"^P",["^G",[["^Z","^1>"]]],"^S",null,"^Q",["^G",[null,null]],"^C",1,"^N",false,"^B",87,"^W","^X","^D",87,"^O",2,"^T",true,"^F",["^G",["^H",["^G",[["^Z","^1>"]]]]],"^L","Returns a map of the distinct values of ks in the xrel mapped to a\n  set of the maps in xrel with the corresponding values of ks."],"~$bubble-max-key",["^ ","^?",null,"^@",["^ ","^A","/home/mediocregopher/src/viz/out/clojure/set.cljs","^B",13,"^C",8,"^D",13,"^E",22,"~:private",true,"^F",["^G",["^H",["^G",[["~$k","~$coll"]]]]]],"^1A",true,"^7","~$clojure.set/bubble-max-key","^A","out/clojure/set.cljs","^E",22,"^P",["^G",[["~$k","^1B"]]],"^S",null,"^Q",["^G",[null,null]],"^C",1,"^N",false,"^B",13,"^W","~$cljs.core/Cons","^D",13,"^O",2,"^T",true,"^F",["^G",["^H",["^G",[["~$k","^1B"]]]]]],"~$subset?",["^ ","^?",null,"^@",["^ ","^A","/home/mediocregopher/src/viz/out/clojure/set.cljs","^B",131,"^C",7,"^D",131,"^E",14,"^F",["^G",["^H",["^G",[["^19","^1:"]]]]],"^L","Is set1 a subset of set2?"],"^7","~$clojure.set/subset?","^A","out/clojure/set.cljs","^E",14,"^P",["^G",[["^19","^1:"]]],"^S",null,"^Q",["^G",[null,null]],"^C",1,"^N",false,"^B",131,"^W","^1<","^D",131,"^O",2,"^T",true,"^F",["^G",["^H",["^G",[["^19","^1:"]]]]],"^L","Is set1 a subset of set2?"],"~$rename",["^ ","^?",null,"^@",["^ ","^A","/home/mediocregopher/src/viz/out/clojure/set.cljs","^B",82,"^C",7,"^D",82,"^E",13,"^F",["^G",["^H",["^G",[["^Z","~$kmap"]]]]],"^L","Returns a rel of the maps in xrel with the keys in kmap renamed to the vals in kmap"],"^7","~$clojure.set/rename","^A","out/clojure/set.cljs","^E",13,"^P",["^G",[["^Z","^1H"]]],"^S",null,"^Q",["^G",[null,null]],"^C",1,"^N",false,"^B",82,"^W",["^6",["~$clj","^X","~$cljs.core/ISet","~$cljs.core/MetaFn","~$clj-nil"]],"^D",82,"^O",2,"^T",true,"^F",["^G",["^H",["^G",[["^Z","^1H"]]]]],"^L","Returns a rel of the maps in xrel with the keys in kmap renamed to the vals in kmap"],"~$rename-keys",["^ ","^?",null,"^@",["^ ","^A","/home/mediocregopher/src/viz/out/clojure/set.cljs","^B",72,"^C",7,"^D",72,"^E",18,"^F",["^G",["^H",["^G",[["~$map","^1H"]]]]],"^L","Returns the map with the keys in kmap renamed to the vals in kmap"],"^7","~$clojure.set/rename-keys","^A","out/clojure/set.cljs","^E",18,"^P",["^G",[["^1O","^1H"]]],"^S",null,"^Q",["^G",[null,null]],"^C",1,"^N",false,"^B",72,"^W","^X","^D",72,"^O",2,"^T",true,"^F",["^G",["^H",["^G",[["^1O","^1H"]]]]],"^L","Returns the map with the keys in kmap renamed to the vals in kmap"],"~$project",["^ ","^?",null,"^@",["^ ","^A","/home/mediocregopher/src/viz/out/clojure/set.cljs","^B",67,"^C",7,"^D",67,"^E",14,"^F",["^G",["^H",["^G",[["^Z","^1>"]]]]],"^L","Returns a rel of the elements of xrel with only the keys in ks"],"^7","~$clojure.set/project","^A","out/clojure/set.cljs","^E",14,"^P",["^G",[["^Z","^1>"]]],"^S",null,"^Q",["^G",[null,null]],"^C",1,"^N",false,"^B",67,"^W",["^6",["^1J","^X","^1K","^1L","^1M"]],"^D",67,"^O",2,"^T",true,"^F",["^G",["^H",["^G",[["^Z","^1>"]]]]],"^L","Returns a rel of the elements of xrel with only the keys in ks"],"~$difference",["^ ","^?",null,"^@",["^ ","^A","/home/mediocregopher/src/viz/out/clojure/set.cljs","^B",46,"^C",7,"^D",46,"^E",17,"^F",["^G",["^H",["^G",[["^I"],["^I","^J"],["^I","^J","~$&","^K"]]]]],"^L","Return a set that is the first set without elements of the remaining sets","^M",["^ ","^N",true,"^O",2,"^P",["^G",[["^I"],["^I","^J"]]],"^F",["^G",[["^I"],["^I","^J"],["^I","^J","~$&","^K"]]],"^Q",["^G",[null,null,null]]]],"^7","~$clojure.set/difference","^A","out/clojure/set.cljs","^E",17,"^M",["^ ","^N",true,"^O",2,"^P",["^G",[["^I"],["^I","^J"]]],"^F",["^G",[["^I"],["^I","^J"],["^I","^J","~$&","^K"]]],"^Q",["^G",[null,null,null]]],"^P",["^G",[["^I"],["^I","^J"]]],"^S",null,"^Q",["^G",[null,null,null]],"^C",1,"^N",true,"^B",46,"^D",46,"^O",2,"^T",true,"^F",["^G",[["^I"],["^I","^J"],["^I","^J","~$&","^K"]]],"^L","Return a set that is the first set without elements of the remaining sets"]],"~:cljs.spec/registry-ref",[],"~:require-macros",null,"^L","Set operations such as union/intersection."]
\ No newline at end of file
diff --git a/static/src/assets/viz/2/clojure/set.js b/static/src/assets/viz/2/clojure/set.js
new file mode 100644
index 0000000..3be3f0b
--- /dev/null
+++ b/static/src/assets/viz/2/clojure/set.js
@@ -0,0 +1,391 @@
+// Compiled by ClojureScript 1.10.439 {}
+goog.provide('clojure.set');
+goog.require('cljs.core');
+clojure.set.bubble_max_key = (function clojure$set$bubble_max_key(k,coll){
+
+var max = cljs.core.apply.call(null,cljs.core.max_key,k,coll);
+return cljs.core.cons.call(null,max,cljs.core.remove.call(null,((function (max){
+return (function (p1__2145_SHARP_){
+return (max === p1__2145_SHARP_);
+});})(max))
+,coll));
+});
+/**
+ * Return a set that is the union of the input sets
+ */
+clojure.set.union = (function clojure$set$union(var_args){
+var G__2150 = arguments.length;
+switch (G__2150) {
+case 0:
+return clojure.set.union.cljs$core$IFn$_invoke$arity$0();
+
+break;
+case 1:
+return clojure.set.union.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
+
+break;
+case 2:
+return clojure.set.union.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
+
+break;
+default:
+var args_arr__4662__auto__ = [];
+var len__4641__auto___2152 = arguments.length;
+var i__4642__auto___2153 = (0);
+while(true){
+if((i__4642__auto___2153 < len__4641__auto___2152)){
+args_arr__4662__auto__.push((arguments[i__4642__auto___2153]));
+
+var G__2154 = (i__4642__auto___2153 + (1));
+i__4642__auto___2153 = G__2154;
+continue;
+} else {
+}
+break;
+}
+
+var argseq__4663__auto__ = (new cljs.core.IndexedSeq(args_arr__4662__auto__.slice((2)),(0),null));
+return clojure.set.union.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4663__auto__);
+
+}
+});
+
+clojure.set.union.cljs$core$IFn$_invoke$arity$0 = (function (){
+return cljs.core.PersistentHashSet.EMPTY;
+});
+
+clojure.set.union.cljs$core$IFn$_invoke$arity$1 = (function (s1){
+return s1;
+});
+
+clojure.set.union.cljs$core$IFn$_invoke$arity$2 = (function (s1,s2){
+if((cljs.core.count.call(null,s1) < cljs.core.count.call(null,s2))){
+return cljs.core.reduce.call(null,cljs.core.conj,s2,s1);
+} else {
+return cljs.core.reduce.call(null,cljs.core.conj,s1,s2);
+}
+});
+
+clojure.set.union.cljs$core$IFn$_invoke$arity$variadic = (function (s1,s2,sets){
+var bubbled_sets = clojure.set.bubble_max_key.call(null,cljs.core.count,cljs.core.conj.call(null,sets,s2,s1));
+return cljs.core.reduce.call(null,cljs.core.into,cljs.core.first.call(null,bubbled_sets),cljs.core.rest.call(null,bubbled_sets));
+});
+
+/** @this {Function} */
+clojure.set.union.cljs$lang$applyTo = (function (seq2147){
+var G__2148 = cljs.core.first.call(null,seq2147);
+var seq2147__$1 = cljs.core.next.call(null,seq2147);
+var G__2149 = cljs.core.first.call(null,seq2147__$1);
+var seq2147__$2 = cljs.core.next.call(null,seq2147__$1);
+var self__4628__auto__ = this;
+return self__4628__auto__.cljs$core$IFn$_invoke$arity$variadic(G__2148,G__2149,seq2147__$2);
+});
+
+clojure.set.union.cljs$lang$maxFixedArity = (2);
+
+/**
+ * Return a set that is the intersection of the input sets
+ */
+clojure.set.intersection = (function clojure$set$intersection(var_args){
+var G__2160 = arguments.length;
+switch (G__2160) {
+case 1:
+return clojure.set.intersection.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
+
+break;
+case 2:
+return clojure.set.intersection.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
+
+break;
+default:
+var args_arr__4662__auto__ = [];
+var len__4641__auto___2162 = arguments.length;
+var i__4642__auto___2163 = (0);
+while(true){
+if((i__4642__auto___2163 < len__4641__auto___2162)){
+args_arr__4662__auto__.push((arguments[i__4642__auto___2163]));
+
+var G__2164 = (i__4642__auto___2163 + (1));
+i__4642__auto___2163 = G__2164;
+continue;
+} else {
+}
+break;
+}
+
+var argseq__4663__auto__ = (new cljs.core.IndexedSeq(args_arr__4662__auto__.slice((2)),(0),null));
+return clojure.set.intersection.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4663__auto__);
+
+}
+});
+
+clojure.set.intersection.cljs$core$IFn$_invoke$arity$1 = (function (s1){
+return s1;
+});
+
+clojure.set.intersection.cljs$core$IFn$_invoke$arity$2 = (function (s1,s2){
+while(true){
+if((cljs.core.count.call(null,s2) < cljs.core.count.call(null,s1))){
+var G__2165 = s2;
+var G__2166 = s1;
+s1 = G__2165;
+s2 = G__2166;
+continue;
+} else {
+return cljs.core.reduce.call(null,((function (s1,s2){
+return (function (result,item){
+if(cljs.core.contains_QMARK_.call(null,s2,item)){
+return result;
+} else {
+return cljs.core.disj.call(null,result,item);
+}
+});})(s1,s2))
+,s1,s1);
+}
+break;
+}
+});
+
+clojure.set.intersection.cljs$core$IFn$_invoke$arity$variadic = (function (s1,s2,sets){
+var bubbled_sets = clojure.set.bubble_max_key.call(null,(function (p1__2155_SHARP_){
+return (- cljs.core.count.call(null,p1__2155_SHARP_));
+}),cljs.core.conj.call(null,sets,s2,s1));
+return cljs.core.reduce.call(null,clojure.set.intersection,cljs.core.first.call(null,bubbled_sets),cljs.core.rest.call(null,bubbled_sets));
+});
+
+/** @this {Function} */
+clojure.set.intersection.cljs$lang$applyTo = (function (seq2157){
+var G__2158 = cljs.core.first.call(null,seq2157);
+var seq2157__$1 = cljs.core.next.call(null,seq2157);
+var G__2159 = cljs.core.first.call(null,seq2157__$1);
+var seq2157__$2 = cljs.core.next.call(null,seq2157__$1);
+var self__4628__auto__ = this;
+return self__4628__auto__.cljs$core$IFn$_invoke$arity$variadic(G__2158,G__2159,seq2157__$2);
+});
+
+clojure.set.intersection.cljs$lang$maxFixedArity = (2);
+
+/**
+ * Return a set that is the first set without elements of the remaining sets
+ */
+clojure.set.difference = (function clojure$set$difference(var_args){
+var G__2171 = arguments.length;
+switch (G__2171) {
+case 1:
+return clojure.set.difference.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
+
+break;
+case 2:
+return clojure.set.difference.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
+
+break;
+default:
+var args_arr__4662__auto__ = [];
+var len__4641__auto___2173 = arguments.length;
+var i__4642__auto___2174 = (0);
+while(true){
+if((i__4642__auto___2174 < len__4641__auto___2173)){
+args_arr__4662__auto__.push((arguments[i__4642__auto___2174]));
+
+var G__2175 = (i__4642__auto___2174 + (1));
+i__4642__auto___2174 = G__2175;
+continue;
+} else {
+}
+break;
+}
+
+var argseq__4663__auto__ = (new cljs.core.IndexedSeq(args_arr__4662__auto__.slice((2)),(0),null));
+return clojure.set.difference.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__4663__auto__);
+
+}
+});
+
+clojure.set.difference.cljs$core$IFn$_invoke$arity$1 = (function (s1){
+return s1;
+});
+
+clojure.set.difference.cljs$core$IFn$_invoke$arity$2 = (function (s1,s2){
+if((cljs.core.count.call(null,s1) < cljs.core.count.call(null,s2))){
+return cljs.core.reduce.call(null,(function (result,item){
+if(cljs.core.contains_QMARK_.call(null,s2,item)){
+return cljs.core.disj.call(null,result,item);
+} else {
+return result;
+}
+}),s1,s1);
+} else {
+return cljs.core.reduce.call(null,cljs.core.disj,s1,s2);
+}
+});
+
+clojure.set.difference.cljs$core$IFn$_invoke$arity$variadic = (function (s1,s2,sets){
+return cljs.core.reduce.call(null,clojure.set.difference,s1,cljs.core.conj.call(null,sets,s2));
+});
+
+/** @this {Function} */
+clojure.set.difference.cljs$lang$applyTo = (function (seq2168){
+var G__2169 = cljs.core.first.call(null,seq2168);
+var seq2168__$1 = cljs.core.next.call(null,seq2168);
+var G__2170 = cljs.core.first.call(null,seq2168__$1);
+var seq2168__$2 = cljs.core.next.call(null,seq2168__$1);
+var self__4628__auto__ = this;
+return self__4628__auto__.cljs$core$IFn$_invoke$arity$variadic(G__2169,G__2170,seq2168__$2);
+});
+
+clojure.set.difference.cljs$lang$maxFixedArity = (2);
+
+/**
+ * Returns a set of the elements for which pred is true
+ */
+clojure.set.select = (function clojure$set$select(pred,xset){
+return cljs.core.reduce.call(null,(function (s,k){
+if(cljs.core.truth_(pred.call(null,k))){
+return s;
+} else {
+return cljs.core.disj.call(null,s,k);
+}
+}),xset,xset);
+});
+/**
+ * Returns a rel of the elements of xrel with only the keys in ks
+ */
+clojure.set.project = (function clojure$set$project(xrel,ks){
+return cljs.core.set.call(null,cljs.core.map.call(null,(function (p1__2176_SHARP_){
+return cljs.core.select_keys.call(null,p1__2176_SHARP_,ks);
+}),xrel));
+});
+/**
+ * Returns the map with the keys in kmap renamed to the vals in kmap
+ */
+clojure.set.rename_keys = (function clojure$set$rename_keys(map,kmap){
+return cljs.core.reduce.call(null,(function (m,p__2177){
+var vec__2178 = p__2177;
+var old = cljs.core.nth.call(null,vec__2178,(0),null);
+var new$ = cljs.core.nth.call(null,vec__2178,(1),null);
+if(cljs.core.contains_QMARK_.call(null,map,old)){
+return cljs.core.assoc.call(null,m,new$,cljs.core.get.call(null,map,old));
+} else {
+return m;
+}
+}),cljs.core.apply.call(null,cljs.core.dissoc,map,cljs.core.keys.call(null,kmap)),kmap);
+});
+/**
+ * Returns a rel of the maps in xrel with the keys in kmap renamed to the vals in kmap
+ */
+clojure.set.rename = (function clojure$set$rename(xrel,kmap){
+return cljs.core.set.call(null,cljs.core.map.call(null,(function (p1__2181_SHARP_){
+return clojure.set.rename_keys.call(null,p1__2181_SHARP_,kmap);
+}),xrel));
+});
+/**
+ * Returns a map of the distinct values of ks in the xrel mapped to a
+ *   set of the maps in xrel with the corresponding values of ks.
+ */
+clojure.set.index = (function clojure$set$index(xrel,ks){
+return cljs.core.reduce.call(null,(function (m,x){
+var ik = cljs.core.select_keys.call(null,x,ks);
+return cljs.core.assoc.call(null,m,ik,cljs.core.conj.call(null,cljs.core.get.call(null,m,ik,cljs.core.PersistentHashSet.EMPTY),x));
+}),cljs.core.PersistentArrayMap.EMPTY,xrel);
+});
+/**
+ * Returns the map with the vals mapped to the keys.
+ */
+clojure.set.map_invert = (function clojure$set$map_invert(m){
+return cljs.core.reduce.call(null,(function (m__$1,p__2182){
+var vec__2183 = p__2182;
+var k = cljs.core.nth.call(null,vec__2183,(0),null);
+var v = cljs.core.nth.call(null,vec__2183,(1),null);
+return cljs.core.assoc.call(null,m__$1,v,k);
+}),cljs.core.PersistentArrayMap.EMPTY,m);
+});
+/**
+ * When passed 2 rels, returns the rel corresponding to the natural
+ *   join. When passed an additional keymap, joins on the corresponding
+ *   keys.
+ */
+clojure.set.join = (function clojure$set$join(var_args){
+var G__2191 = arguments.length;
+switch (G__2191) {
+case 2:
+return clojure.set.join.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
+
+break;
+case 3:
+return clojure.set.join.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));
+
+break;
+default:
+throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));
+
+}
+});
+
+clojure.set.join.cljs$core$IFn$_invoke$arity$2 = (function (xrel,yrel){
+if(((cljs.core.seq.call(null,xrel)) && (cljs.core.seq.call(null,yrel)))){
+var ks = clojure.set.intersection.call(null,cljs.core.set.call(null,cljs.core.keys.call(null,cljs.core.first.call(null,xrel))),cljs.core.set.call(null,cljs.core.keys.call(null,cljs.core.first.call(null,yrel))));
+var vec__2192 = (((cljs.core.count.call(null,xrel) <= cljs.core.count.call(null,yrel)))?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [xrel,yrel], null):new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [yrel,xrel], null));
+var r = cljs.core.nth.call(null,vec__2192,(0),null);
+var s = cljs.core.nth.call(null,vec__2192,(1),null);
+var idx = clojure.set.index.call(null,r,ks);
+return cljs.core.reduce.call(null,((function (ks,vec__2192,r,s,idx){
+return (function (ret,x){
+var found = idx.call(null,cljs.core.select_keys.call(null,x,ks));
+if(cljs.core.truth_(found)){
+return cljs.core.reduce.call(null,((function (found,ks,vec__2192,r,s,idx){
+return (function (p1__2186_SHARP_,p2__2187_SHARP_){
+return cljs.core.conj.call(null,p1__2186_SHARP_,cljs.core.merge.call(null,p2__2187_SHARP_,x));
+});})(found,ks,vec__2192,r,s,idx))
+,ret,found);
+} else {
+return ret;
+}
+});})(ks,vec__2192,r,s,idx))
+,cljs.core.PersistentHashSet.EMPTY,s);
+} else {
+return cljs.core.PersistentHashSet.EMPTY;
+}
+});
+
+clojure.set.join.cljs$core$IFn$_invoke$arity$3 = (function (xrel,yrel,km){
+var vec__2195 = (((cljs.core.count.call(null,xrel) <= cljs.core.count.call(null,yrel)))?new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [xrel,yrel,clojure.set.map_invert.call(null,km)], null):new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [yrel,xrel,km], null));
+var r = cljs.core.nth.call(null,vec__2195,(0),null);
+var s = cljs.core.nth.call(null,vec__2195,(1),null);
+var k = cljs.core.nth.call(null,vec__2195,(2),null);
+var idx = clojure.set.index.call(null,r,cljs.core.vals.call(null,k));
+return cljs.core.reduce.call(null,((function (vec__2195,r,s,k,idx){
+return (function (ret,x){
+var found = idx.call(null,clojure.set.rename_keys.call(null,cljs.core.select_keys.call(null,x,cljs.core.keys.call(null,k)),k));
+if(cljs.core.truth_(found)){
+return cljs.core.reduce.call(null,((function (found,vec__2195,r,s,k,idx){
+return (function (p1__2188_SHARP_,p2__2189_SHARP_){
+return cljs.core.conj.call(null,p1__2188_SHARP_,cljs.core.merge.call(null,p2__2189_SHARP_,x));
+});})(found,vec__2195,r,s,k,idx))
+,ret,found);
+} else {
+return ret;
+}
+});})(vec__2195,r,s,k,idx))
+,cljs.core.PersistentHashSet.EMPTY,s);
+});
+
+clojure.set.join.cljs$lang$maxFixedArity = 3;
+
+/**
+ * Is set1 a subset of set2?
+ */
+clojure.set.subset_QMARK_ = (function clojure$set$subset_QMARK_(set1,set2){
+return (((cljs.core.count.call(null,set1) <= cljs.core.count.call(null,set2))) && (cljs.core.every_QMARK_.call(null,(function (p1__2199_SHARP_){
+return cljs.core.contains_QMARK_.call(null,set2,p1__2199_SHARP_);
+}),set1)));
+});
+/**
+ * Is set1 a superset of set2?
+ */
+clojure.set.superset_QMARK_ = (function clojure$set$superset_QMARK_(set1,set2){
+return (((cljs.core.count.call(null,set1) >= cljs.core.count.call(null,set2))) && (cljs.core.every_QMARK_.call(null,(function (p1__2200_SHARP_){
+return cljs.core.contains_QMARK_.call(null,set1,p1__2200_SHARP_);
+}),set2)));
+});
+
+//# sourceMappingURL=set.js.map
diff --git a/static/src/assets/viz/2/clojure/set.js.map b/static/src/assets/viz/2/clojure/set.js.map
new file mode 100644
index 0000000..c385760
--- /dev/null
+++ b/static/src/assets/viz/2/clojure/set.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"\/home\/mediocregopher\/src\/viz\/out\/clojure\/set.js","sources":["set.cljs"],"lineCount":391,"mappings":"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","names":["clojure.set\/bubble-max-key","cljs.core\/apply","cljs.core\/max-key","k","coll","cljs.core\/cons","max","cljs.core\/remove","p1__2145#","G__2150","clojure.set\/union","i__4642__auto__","len__4641__auto__","args-arr__4662__auto__","cljs.core\/IndexedSeq","argseq__4663__auto__","cljs.core\/first","seq2147","cljs.core\/next","self__4628__auto__","G__2148","G__2149","s1","cljs.core\/count","s2","cljs.core\/reduce","cljs.core\/conj","sets","cljs.core\/into","bubbled-sets","cljs.core\/rest","G__2160","clojure.set\/intersection","seq2157","G__2158","G__2159","cljs.core\/contains?","item","result","cljs.core\/disj","p1__2155#","G__2171","clojure.set\/difference","seq2168","G__2169","G__2170","clojure.set\/select","pred","s","xset","clojure.set\/project","cljs.core\/set","cljs.core\/map","p1__2176#","cljs.core\/select-keys","ks","xrel","clojure.set\/rename-keys","p__2177","cljs.core\/nth","vec__2178","map","old","cljs.core\/assoc","m","new","cljs.core\/get","cljs.core\/dissoc","cljs.core\/keys","kmap","clojure.set\/rename","p1__2181#","clojure.set\/index","x","ik","clojure.set\/map-invert","p__2182","vec__2183","v","G__2191","clojure.set\/join","js\/Error","cljs.core\/seq","yrel","vec__2192","r","idx","found","p1__2186#","p2__2187#","cljs.core\/merge","ret","vec__2195","km","cljs.core\/vals","p1__2188#","p2__2189#","clojure.set\/subset?","set1","set2","cljs.core\/every?","p1__2199#","clojure.set\/superset?","p1__2200#"]}
\ No newline at end of file
diff --git a/static/src/assets/viz/2/clojure/string.cljs b/static/src/assets/viz/2/clojure/string.cljs
new file mode 100644
index 0000000..26f63f2
--- /dev/null
+++ b/static/src/assets/viz/2/clojure/string.cljs
@@ -0,0 +1,289 @@
+;   Copyright (c) Rich Hickey. All rights reserved.
+;   The use and distribution terms for this software are covered by the
+;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+;   which can be found in the file epl-v10.html at the root of this distribution.
+;   By using this software in any fashion, you are agreeing to be bound by
+;   the terms of this license.
+;   You must not remove this notice, or any other, from this software.
+
+(ns clojure.string
+  (:refer-clojure :exclude [replace reverse])
+  (:require [goog.string :as gstring])
+  (:import [goog.string StringBuffer]))
+
+(defn- seq-reverse
+  [coll]
+  (reduce conj () coll))
+
+(def ^:private re-surrogate-pair
+  (js/RegExp. "([\\uD800-\\uDBFF])([\\uDC00-\\uDFFF])" "g"))
+
+(defn reverse
+  "Returns s with its characters reversed."
+  [s]
+  (-> (.replace s re-surrogate-pair "$2$1")
+      (.. (split "") (reverse) (join ""))))
+
+(defn- replace-all
+  [s re replacement]
+  (let [r (js/RegExp. (.-source re)
+                      (cond-> "g"
+                        (.-ignoreCase re) (str "i")
+                        (.-multiline re) (str "m")
+                        (.-unicode re) (str "u")))]
+    (.replace s r replacement)))
+
+(defn- replace-with
+  [f]
+  (fn [& args]
+    (let [matches (drop-last 2 args)]
+      (if (= (count matches) 1)
+        (f (first matches))
+        (f (vec matches))))))
+
+(defn replace
+  "Replaces all instance of match with replacement in s.
+
+   match/replacement can be:
+
+   string / string
+   pattern / (string or function of match).
+
+   See also replace-first.
+
+   The replacement is literal (i.e. none of its characters are treated
+   specially) for all cases above except pattern / string.
+
+   For pattern / string, $1, $2, etc. in the replacement string are
+   substituted with the string that matched the corresponding
+   parenthesized group in the pattern.
+
+   Example:
+   (clojure.string/replace \"Almost Pig Latin\" #\"\\b(\\w)(\\w+)\\b\" \"$2$1ay\")
+   -> \"lmostAay igPay atinLay\""
+  [s match replacement]
+  (cond
+    (string? match)
+    (.replace s (js/RegExp. (gstring/regExpEscape match) "g") replacement)
+
+    (instance? js/RegExp match)
+    (if (string? replacement)
+      (replace-all s match replacement)
+      (replace-all s match (replace-with replacement)))
+
+    :else (throw (str "Invalid match arg: " match))))
+
+(defn replace-first
+  "Replaces the first instance of match with replacement in s.
+
+   match/replacement can be:
+
+   string / string
+   pattern / (string or function of match).
+
+   See also replace.
+
+   The replacement is literal (i.e. none of its characters are treated
+   specially) for all cases above except pattern / string.
+
+   For pattern / string, $1, $2, etc. in the replacement string are
+   substituted with the string that matched the corresponding
+   parenthesized group in the pattern.
+
+   Example:
+   (clojure.string/replace-first \"swap first two words\"
+                                 #\"(\\w+)(\\s+)(\\w+)\" \"$3$2$1\")
+   -> \"first swap two words\""
+  [s match replacement]
+  (.replace s match replacement))
+
+(defn join
+  "Returns a string of all elements in coll, as returned by (seq coll),
+  separated by an optional separator."
+  ([coll]
+   (loop [sb (StringBuffer.) coll (seq coll)]
+     (if-not (nil? coll)
+       (recur (. sb (append (str (first coll)))) (next coll))
+       (.toString sb))))
+  ([separator coll]
+   (loop [sb (StringBuffer.) coll (seq coll)]
+     (if-not (nil? coll)
+       (do
+         (. sb (append (str (first coll))))
+         (let [coll (next coll)]
+           (when-not (nil? coll)
+             (. sb (append separator)))
+           (recur sb coll)))
+       (.toString sb)))))
+
+(defn upper-case
+  "Converts string to all upper-case."
+  [s]
+  (.toUpperCase s))
+
+(defn lower-case
+  "Converts string to all lower-case."
+  [s]
+  (.toLowerCase s))
+
+(defn capitalize
+  "Converts first character of the string to upper-case, all other
+  characters to lower-case."
+  [s]
+  (gstring/capitalize s))
+
+;; The JavaScript split function takes a limit argument but the return
+;; value is not the same as the Java split function.
+;;
+;; Java: (.split "a-b-c" #"-" 2) => ["a" "b-c"]
+;; JavaScript: (.split "a-b-c" #"-" 2) => ["a" "b"]
+;;
+;; For consistency, the three arg version has been implemented to
+;; mimic Java's behavior.
+
+(defn- pop-last-while-empty
+  [v]
+  (loop [v v]
+    (if (identical? "" (peek v))
+      (recur (pop v))
+      v)))
+
+(defn- discard-trailing-if-needed
+  [limit v]
+  (if (and (== 0 limit) (< 1 (count v)))
+    (pop-last-while-empty v)
+    v))
+
+(defn- split-with-empty-regex
+  [s limit]
+  (if (or (<= limit 0) (>= limit (+ 2 (count s))))
+    (conj (vec (cons "" (map str (seq s)))) "")
+    (condp == limit
+      1 (vector s)
+      2 (vector "" s)
+      (let [c (- limit 2)]
+        (conj (vec (cons "" (subvec (vec (map str (seq s))) 0 c))) (subs s c))))))
+
+(defn split
+  "Splits string on a regular expression. Optional argument limit is
+  the maximum number of splits. Not lazy. Returns vector of the splits."
+  ([s re]
+     (split s re 0))
+    ([s re limit]
+     (discard-trailing-if-needed limit
+       (if (identical? "/(?:)/" (str re))
+         (split-with-empty-regex s limit)
+         (if (< limit 1)
+           (vec (.split (str s) re))
+           (loop [s s
+                  limit limit
+                  parts []]
+             (if (== 1 limit)
+               (conj parts s)
+               (let [m (re-find re s)]
+                 (if-not (nil? m)
+                   (let [index (.indexOf s m)]
+                     (recur (.substring s (+ index (count m)))
+                       (dec limit)
+                       (conj parts (.substring s 0 index))))
+                   (conj parts s))))))))))
+
+(defn split-lines
+  "Splits s on \\n or \\r\\n."
+  [s]
+  (split s #"\n|\r\n"))
+
+(defn trim
+  "Removes whitespace from both ends of string."
+  [s]
+  (gstring/trim s))
+
+(defn triml
+  "Removes whitespace from the left side of string."
+  [s]
+  (gstring/trimLeft s))
+
+(defn trimr
+  "Removes whitespace from the right side of string."
+  [s]
+  (gstring/trimRight s))
+
+(defn trim-newline
+  "Removes all trailing newline \\n or return \\r characters from
+  string.  Similar to Perl's chomp."
+  [s]
+  (loop [index (.-length s)]
+    (if (zero? index)
+      ""
+      (let [ch (get s (dec index))]
+        (if (or (identical? \newline ch)
+                (identical? \return ch))
+          (recur (dec index))
+          (.substring s 0 index))))))
+
+(defn ^boolean blank?
+  "True is s is nil, empty, or contains only whitespace."
+  [s]
+  (gstring/isEmptySafe s))
+
+(defn escape
+  "Return a new string, using cmap to escape each character ch
+   from s as follows:
+
+   If (cmap ch) is nil, append ch to the new string.
+   If (cmap ch) is non-nil, append (str (cmap ch)) instead."
+  [s cmap]
+  (let [buffer (StringBuffer.)
+        length (.-length s)]
+    (loop [index 0]
+      (if (== length index)
+        (. buffer (toString))
+        (let [ch (.charAt s index)
+              replacement (get cmap ch)]
+          (if-not (nil? replacement)
+            (.append buffer (str replacement))
+            (.append buffer ch))
+          (recur (inc index)))))))
+
+(defn index-of
+  "Return index of value (string or char) in s, optionally searching
+  forward from from-index or nil if not found."
+  ([s value]
+   (let [result (.indexOf s value)]
+     (if (neg? result)
+       nil
+       result)))
+  ([s value from-index]
+   (let [result (.indexOf s value from-index)]
+     (if (neg? result)
+       nil
+       result))))
+
+(defn last-index-of
+  "Return last index of value (string or char) in s, optionally
+  searching backward from from-index or nil if not found."
+  ([s value]
+   (let [result (.lastIndexOf s value)]
+     (if (neg? result)
+       nil
+       result)))
+  ([s value from-index]
+   (let [result (.lastIndexOf s value from-index)]
+     (if (neg? result)
+       nil
+       result))))
+
+(defn ^boolean starts-with?
+  "True if s starts with substr."
+  [s substr]
+  (gstring/startsWith s substr))
+
+(defn ^boolean ends-with?
+  "True if s ends with substr."
+  [s substr]
+  (gstring/endsWith s substr))
+
+(defn ^boolean includes?
+  "True if s includes substr."
+  [s substr]
+  (gstring/contains s substr))
diff --git a/static/src/assets/viz/2/clojure/string.cljs.cache.json b/static/src/assets/viz/2/clojure/string.cljs.cache.json
new file mode 100644
index 0000000..534c7f8
--- /dev/null
+++ b/static/src/assets/viz/2/clojure/string.cljs.cache.json
@@ -0,0 +1 @@
+["^ ","~:rename-macros",["^ "],"~:renames",["^ "],"~:externs",["^ ","~$RegExp",["^ "],"~$Error",["^ "]],"~:use-macros",["^ "],"~:excludes",["~#set",["~$reverse","~$replace"]],"~:name","~$clojure.string","~:imports",["^ ","~$StringBuffer","~$goog.string.StringBuffer"],"~:requires",["^ ","~$gstring","~$goog.string","^A","^A","^=","^>"],"~:cljs.spec/speced-vars",[],"~:uses",null,"~:defs",["^ ","~$ends-with?",["^ ","~:protocol-inline",null,"~:meta",["^ ","~:file","/home/mediocregopher/src/viz/out/clojure/string.cljs","~:line",281,"~:column",16,"~:end-line",281,"~:end-column",26,"~:tag","~$boolean","~:arglists",["~#list",["~$quote",["^P",[["~$s","~$substr"]]]]],"~:doc","True if s ends with substr."],"^:","~$clojure.string/ends-with?","^H","out/clojure/string.cljs","^L",26,"~:method-params",["^P",[["~$s","^R"]]],"~:protocol-impl",null,"~:arglists-meta",["^P",[null,null]],"^J",1,"~:variadic?",false,"^I",281,"~:ret-tag","^N","^K",281,"~:max-fixed-arity",2,"^M","^N","~:fn-var",true,"^O",["^P",["^Q",["^P",[["~$s","^R"]]]]],"^S","True if s ends with substr."],"~$seq-reverse",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",14,"^J",8,"^K",14,"^L",19,"~:private",true,"^O",["^P",["^Q",["^P",[["~$coll"]]]]]],"^11",true,"^:","~$clojure.string/seq-reverse","^H","out/clojure/string.cljs","^L",19,"^U",["^P",[["^12"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",14,"^Y","~$any","^K",14,"^Z",1,"^[",true,"^O",["^P",["^Q",["^P",[["^12"]]]]]],"~$replace-with",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",36,"^J",8,"^K",36,"^L",20,"^11",true,"^O",["^P",["^Q",["^P",[["~$f"]]]]]],"^11",true,"^:","~$clojure.string/replace-with","^H","out/clojure/string.cljs","^L",20,"^U",["^P",[["~$f"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",36,"^Y","~$function","^K",36,"^Z",1,"^[",true,"^O",["^P",["^Q",["^P",[["~$f"]]]]]],"~$capitalize",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",129,"^J",7,"^K",129,"^L",17,"^O",["^P",["^Q",["^P",[["~$s"]]]]],"^S","Converts first character of the string to upper-case, all other\n  characters to lower-case."],"^:","~$clojure.string/capitalize","^H","out/clojure/string.cljs","^L",17,"^U",["^P",[["~$s"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",129,"^Y","^14","^K",129,"^Z",1,"^[",true,"^O",["^P",["^Q",["^P",[["~$s"]]]]],"^S","Converts first character of the string to upper-case, all other\n  characters to lower-case."],"^8",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",21,"^J",7,"^K",21,"^L",14,"^O",["^P",["^Q",["^P",[["~$s"]]]]],"^S","Returns s with its characters reversed."],"^:","~$clojure.string/reverse","^H","out/clojure/string.cljs","^L",14,"^U",["^P",[["~$s"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",21,"^Y","^14","^K",21,"^Z",1,"^[",true,"^O",["^P",["^Q",["^P",[["~$s"]]]]],"^S","Returns s with its characters reversed."],"~$join",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",100,"^J",7,"^K",100,"^L",11,"^O",["^P",["^Q",["^P",[["^12"],["~$separator","^12"]]]]],"^S","Returns a string of all elements in coll, as returned by (seq coll),\n  separated by an optional separator.","~:top-fn",["^ ","^X",false,"^Z",2,"^U",["^P",[["^12"],["^1<","^12"]]],"^O",["^P",[["^12"],["^1<","^12"]]],"^W",["^P",[null,null]]]],"^:","~$clojure.string/join","^H","out/clojure/string.cljs","^L",11,"^1=",["^ ","^X",false,"^Z",2,"^U",["^P",[["^12"],["^1<","^12"]]],"^O",["^P",[["^12"],["^1<","^12"]]],"^W",["^P",[null,null]]],"^U",["^P",[["^12"],["^1<","^12"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",100,"^K",100,"^Z",2,"^[",true,"^O",["^P",[["^12"],["^1<","^12"]]],"^S","Returns a string of all elements in coll, as returned by (seq coll),\n  separated by an optional separator."],"~$replace-first",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",76,"^J",7,"^K",76,"^L",20,"^O",["^P",["^Q",["^P",[["~$s","~$match","~$replacement"]]]]],"^S","Replaces the first instance of match with replacement in s.\n\n   match/replacement can be:\n\n   string / string\n   pattern / (string or function of match).\n\n   See also replace.\n\n   The replacement is literal (i.e. none of its characters are treated\n   specially) for all cases above except pattern / string.\n\n   For pattern / string, $1, $2, etc. in the replacement string are\n   substituted with the string that matched the corresponding\n   parenthesized group in the pattern.\n\n   Example:\n   (clojure.string/replace-first \"swap first two words\"\n                                 #\"(\\w+)(\\s+)(\\w+)\" \"$3$2$1\")\n   -> \"first swap two words\""],"^:","~$clojure.string/replace-first","^H","out/clojure/string.cljs","^L",20,"^U",["^P",[["~$s","^1@","^1A"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",76,"^Y","^14","^K",76,"^Z",3,"^[",true,"^O",["^P",["^Q",["^P",[["~$s","^1@","^1A"]]]]],"^S","Replaces the first instance of match with replacement in s.\n\n   match/replacement can be:\n\n   string / string\n   pattern / (string or function of match).\n\n   See also replace.\n\n   The replacement is literal (i.e. none of its characters are treated\n   specially) for all cases above except pattern / string.\n\n   For pattern / string, $1, $2, etc. in the replacement string are\n   substituted with the string that matched the corresponding\n   parenthesized group in the pattern.\n\n   Example:\n   (clojure.string/replace-first \"swap first two words\"\n                                 #\"(\\w+)(\\s+)(\\w+)\" \"$3$2$1\")\n   -> \"first swap two words\""],"~$starts-with?",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",276,"^J",16,"^K",276,"^L",28,"^M","^N","^O",["^P",["^Q",["^P",[["~$s","^R"]]]]],"^S","True if s starts with substr."],"^:","~$clojure.string/starts-with?","^H","out/clojure/string.cljs","^L",28,"^U",["^P",[["~$s","^R"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",276,"^Y","^N","^K",276,"^Z",2,"^M","^N","^[",true,"^O",["^P",["^Q",["^P",[["~$s","^R"]]]]],"^S","True if s starts with substr."],"~$escape",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",229,"^J",7,"^K",229,"^L",13,"^O",["^P",["^Q",["^P",[["~$s","~$cmap"]]]]],"^S","Return a new string, using cmap to escape each character ch\n   from s as follows:\n\n   If (cmap ch) is nil, append ch to the new string.\n   If (cmap ch) is non-nil, append (str (cmap ch)) instead."],"^:","~$clojure.string/escape","^H","out/clojure/string.cljs","^L",13,"^U",["^P",[["~$s","^1F"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",229,"^Y","^14","^K",229,"^Z",2,"^[",true,"^O",["^P",["^Q",["^P",[["~$s","^1F"]]]]],"^S","Return a new string, using cmap to escape each character ch\n   from s as follows:\n\n   If (cmap ch) is nil, append ch to the new string.\n   If (cmap ch) is non-nil, append (str (cmap ch)) instead."],"~$replace-all",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",27,"^J",8,"^K",27,"^L",19,"^11",true,"^O",["^P",["^Q",["^P",[["~$s","~$re","^1A"]]]]]],"^11",true,"^:","~$clojure.string/replace-all","^H","out/clojure/string.cljs","^L",19,"^U",["^P",[["~$s","^1I","^1A"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",27,"^Y","^14","^K",27,"^Z",3,"^[",true,"^O",["^P",["^Q",["^P",[["~$s","^1I","^1A"]]]]]],"~$discard-trailing-if-needed",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",151,"^J",8,"^K",151,"^L",34,"^11",true,"^O",["^P",["^Q",["^P",[["~$limit","~$v"]]]]]],"^11",true,"^:","~$clojure.string/discard-trailing-if-needed","^H","out/clojure/string.cljs","^L",34,"^U",["^P",[["^1L","~$v"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",151,"^Y",["^7",[null,"^14"]],"^K",151,"^Z",2,"^[",true,"^O",["^P",["^Q",["^P",[["^1L","~$v"]]]]]],"~$last-index-of",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",262,"^J",7,"^K",262,"^L",20,"^O",["^P",["^Q",["^P",[["~$s","~$value"],["~$s","^1O","~$from-index"]]]]],"^S","Return last index of value (string or char) in s, optionally\n  searching backward from from-index or nil if not found.","^1=",["^ ","^X",false,"^Z",3,"^U",["^P",[["~$s","^1O"],["~$s","^1O","^1P"]]],"^O",["^P",[["~$s","^1O"],["~$s","^1O","^1P"]]],"^W",["^P",[null,null]]]],"^:","~$clojure.string/last-index-of","^H","out/clojure/string.cljs","^L",20,"^1=",["^ ","^X",false,"^Z",3,"^U",["^P",[["~$s","^1O"],["~$s","^1O","^1P"]]],"^O",["^P",[["~$s","^1O"],["~$s","^1O","^1P"]]],"^W",["^P",[null,null]]],"^U",["^P",[["~$s","^1O"],["~$s","^1O","^1P"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",262,"^K",262,"^Z",3,"^[",true,"^O",["^P",[["~$s","^1O"],["~$s","^1O","^1P"]]],"^S","Return last index of value (string or char) in s, optionally\n  searching backward from from-index or nil if not found."],"~$pop-last-while-empty",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",144,"^J",8,"^K",144,"^L",28,"^11",true,"^O",["^P",["^Q",["^P",[["~$v"]]]]]],"^11",true,"^:","~$clojure.string/pop-last-while-empty","^H","out/clojure/string.cljs","^L",28,"^U",["^P",[["~$v"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",144,"^K",144,"^Z",1,"^[",true,"^O",["^P",["^Q",["^P",[["~$v"]]]]]],"~$includes?",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",286,"^J",16,"^K",286,"^L",25,"^M","^N","^O",["^P",["^Q",["^P",[["~$s","^R"]]]]],"^S","True if s includes substr."],"^:","~$clojure.string/includes?","^H","out/clojure/string.cljs","^L",25,"^U",["^P",[["~$s","^R"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",286,"^Y","^N","^K",286,"^Z",2,"^M","^N","^[",true,"^O",["^P",["^Q",["^P",[["~$s","^R"]]]]],"^S","True if s includes substr."],"^9",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",44,"^J",7,"^K",44,"^L",14,"^O",["^P",["^Q",["^P",[["~$s","^1@","^1A"]]]]],"^S","Replaces all instance of match with replacement in s.\n\n   match/replacement can be:\n\n   string / string\n   pattern / (string or function of match).\n\n   See also replace-first.\n\n   The replacement is literal (i.e. none of its characters are treated\n   specially) for all cases above except pattern / string.\n\n   For pattern / string, $1, $2, etc. in the replacement string are\n   substituted with the string that matched the corresponding\n   parenthesized group in the pattern.\n\n   Example:\n   (clojure.string/replace \"Almost Pig Latin\" #\"\\b(\\w)(\\w+)\\b\" \"$2$1ay\")\n   -> \"lmostAay igPay atinLay\""],"^:","~$clojure.string/replace","^H","out/clojure/string.cljs","^L",14,"^U",["^P",[["~$s","^1@","^1A"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",44,"^Y","^14","^K",44,"^Z",3,"^[",true,"^O",["^P",["^Q",["^P",[["~$s","^1@","^1A"]]]]],"^S","Replaces all instance of match with replacement in s.\n\n   match/replacement can be:\n\n   string / string\n   pattern / (string or function of match).\n\n   See also replace-first.\n\n   The replacement is literal (i.e. none of its characters are treated\n   specially) for all cases above except pattern / string.\n\n   For pattern / string, $1, $2, etc. in the replacement string are\n   substituted with the string that matched the corresponding\n   parenthesized group in the pattern.\n\n   Example:\n   (clojure.string/replace \"Almost Pig Latin\" #\"\\b(\\w)(\\w+)\\b\" \"$2$1ay\")\n   -> \"lmostAay igPay atinLay\""],"~$split-lines",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",191,"^J",7,"^K",191,"^L",18,"^O",["^P",["^Q",["^P",[["~$s"]]]]],"^S","Splits s on \\n or \\r\\n."],"^:","~$clojure.string/split-lines","^H","out/clojure/string.cljs","^L",18,"^U",["^P",[["~$s"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",191,"^Y","^14","^K",191,"^Z",1,"^[",true,"^O",["^P",["^Q",["^P",[["~$s"]]]]],"^S","Splits s on \\n or \\r\\n."],"~$lower-case",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",124,"^J",7,"^K",124,"^L",17,"^O",["^P",["^Q",["^P",[["~$s"]]]]],"^S","Converts string to all lower-case."],"^:","~$clojure.string/lower-case","^H","out/clojure/string.cljs","^L",17,"^U",["^P",[["~$s"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",124,"^Y","^14","^K",124,"^Z",1,"^[",true,"^O",["^P",["^Q",["^P",[["~$s"]]]]],"^S","Converts string to all lower-case."],"~$trim-newline",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",211,"^J",7,"^K",211,"^L",19,"^O",["^P",["^Q",["^P",[["~$s"]]]]],"^S","Removes all trailing newline \\n or return \\r characters from\n  string.  Similar to Perl's chomp."],"^:","~$clojure.string/trim-newline","^H","out/clojure/string.cljs","^L",19,"^U",["^P",[["~$s"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",211,"^Y",["^7",["^14","~$string"]],"^K",211,"^Z",1,"^[",true,"^O",["^P",["^Q",["^P",[["~$s"]]]]],"^S","Removes all trailing newline \\n or return \\r characters from\n  string.  Similar to Perl's chomp."],"~$upper-case",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",119,"^J",7,"^K",119,"^L",17,"^O",["^P",["^Q",["^P",[["~$s"]]]]],"^S","Converts string to all upper-case."],"^:","~$clojure.string/upper-case","^H","out/clojure/string.cljs","^L",17,"^U",["^P",[["~$s"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",119,"^Y","^14","^K",119,"^Z",1,"^[",true,"^O",["^P",["^Q",["^P",[["~$s"]]]]],"^S","Converts string to all upper-case."],"~$split",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",167,"^J",7,"^K",167,"^L",12,"^O",["^P",["^Q",["^P",[["~$s","^1I"],["~$s","^1I","^1L"]]]]],"^S","Splits string on a regular expression. Optional argument limit is\n  the maximum number of splits. Not lazy. Returns vector of the splits.","^1=",["^ ","^X",false,"^Z",3,"^U",["^P",[["~$s","^1I"],["~$s","^1I","^1L"]]],"^O",["^P",[["~$s","^1I"],["~$s","^1I","^1L"]]],"^W",["^P",[null,null]]]],"^:","~$clojure.string/split","^H","out/clojure/string.cljs","^L",12,"^1=",["^ ","^X",false,"^Z",3,"^U",["^P",[["~$s","^1I"],["~$s","^1I","^1L"]]],"^O",["^P",[["~$s","^1I"],["~$s","^1I","^1L"]]],"^W",["^P",[null,null]]],"^U",["^P",[["~$s","^1I"],["~$s","^1I","^1L"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",167,"^K",167,"^Z",3,"^[",true,"^O",["^P",[["~$s","^1I"],["~$s","^1I","^1L"]]],"^S","Splits string on a regular expression. Optional argument limit is\n  the maximum number of splits. Not lazy. Returns vector of the splits."],"~$trimr",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",206,"^J",7,"^K",206,"^L",12,"^O",["^P",["^Q",["^P",[["~$s"]]]]],"^S","Removes whitespace from the right side of string."],"^:","~$clojure.string/trimr","^H","out/clojure/string.cljs","^L",12,"^U",["^P",[["~$s"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",206,"^Y","^14","^K",206,"^Z",1,"^[",true,"^O",["^P",["^Q",["^P",[["~$s"]]]]],"^S","Removes whitespace from the right side of string."],"~$index-of",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",248,"^J",7,"^K",248,"^L",15,"^O",["^P",["^Q",["^P",[["~$s","^1O"],["~$s","^1O","^1P"]]]]],"^S","Return index of value (string or char) in s, optionally searching\n  forward from from-index or nil if not found.","^1=",["^ ","^X",false,"^Z",3,"^U",["^P",[["~$s","^1O"],["~$s","^1O","^1P"]]],"^O",["^P",[["~$s","^1O"],["~$s","^1O","^1P"]]],"^W",["^P",[null,null]]]],"^:","~$clojure.string/index-of","^H","out/clojure/string.cljs","^L",15,"^1=",["^ ","^X",false,"^Z",3,"^U",["^P",[["~$s","^1O"],["~$s","^1O","^1P"]]],"^O",["^P",[["~$s","^1O"],["~$s","^1O","^1P"]]],"^W",["^P",[null,null]]],"^U",["^P",[["~$s","^1O"],["~$s","^1O","^1P"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",248,"^K",248,"^Z",3,"^[",true,"^O",["^P",[["~$s","^1O"],["~$s","^1O","^1P"]]],"^S","Return index of value (string or char) in s, optionally searching\n  forward from from-index or nil if not found."],"~$trim",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",196,"^J",7,"^K",196,"^L",11,"^O",["^P",["^Q",["^P",[["~$s"]]]]],"^S","Removes whitespace from both ends of string."],"^:","~$clojure.string/trim","^H","out/clojure/string.cljs","^L",11,"^U",["^P",[["~$s"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",196,"^Y","^14","^K",196,"^Z",1,"^[",true,"^O",["^P",["^Q",["^P",[["~$s"]]]]],"^S","Removes whitespace from both ends of string."],"~$triml",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",201,"^J",7,"^K",201,"^L",12,"^O",["^P",["^Q",["^P",[["~$s"]]]]],"^S","Removes whitespace from the left side of string."],"^:","~$clojure.string/triml","^H","out/clojure/string.cljs","^L",12,"^U",["^P",[["~$s"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",201,"^Y","^14","^K",201,"^Z",1,"^[",true,"^O",["^P",["^Q",["^P",[["~$s"]]]]],"^S","Removes whitespace from the left side of string."],"~$blank?",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",224,"^J",16,"^K",224,"^L",22,"^M","^N","^O",["^P",["^Q",["^P",[["~$s"]]]]],"^S","True is s is nil, empty, or contains only whitespace."],"^:","~$clojure.string/blank?","^H","out/clojure/string.cljs","^L",22,"^U",["^P",[["~$s"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",224,"^Y","^N","^K",224,"^Z",1,"^M","^N","^[",true,"^O",["^P",["^Q",["^P",[["~$s"]]]]],"^S","True is s is nil, empty, or contains only whitespace."],"~$re-surrogate-pair",["^ ","^:","~$clojure.string/re-surrogate-pair","^H","out/clojure/string.cljs","^I",18,"^J",1,"^K",18,"^L",33,"^11",true,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",18,"^J",16,"^K",18,"^L",33,"^11",true],"^M","~$js/RegExp"],"~$split-with-empty-regex",["^ ","^F",null,"^G",["^ ","^H","/home/mediocregopher/src/viz/out/clojure/string.cljs","^I",157,"^J",8,"^K",157,"^L",30,"^11",true,"^O",["^P",["^Q",["^P",[["~$s","^1L"]]]]]],"^11",true,"^:","~$clojure.string/split-with-empty-regex","^H","out/clojure/string.cljs","^L",30,"^U",["^P",[["~$s","^1L"]]],"^V",null,"^W",["^P",[null,null]],"^J",1,"^X",false,"^I",157,"^Y",["^7",["^14","~$cljs.core/PersistentVector"]],"^K",157,"^Z",2,"^[",true,"^O",["^P",["^Q",["^P",[["~$s","^1L"]]]]]]],"~:cljs.spec/registry-ref",[],"~:require-macros",null,"~:cljs.analyzer/constants",["^ ","~:seen",["^7",["~:else"]],"~:order",["^2J"]],"^S",null]
\ No newline at end of file
diff --git a/static/src/assets/viz/2/clojure/string.js b/static/src/assets/viz/2/clojure/string.js
new file mode 100644
index 0000000..acd3456
--- /dev/null
+++ b/static/src/assets/viz/2/clojure/string.js
@@ -0,0 +1,477 @@
+// Compiled by ClojureScript 1.10.439 {}
+goog.provide('clojure.string');
+goog.require('cljs.core');
+goog.require('goog.string');
+goog.require('goog.string.StringBuffer');
+clojure.string.seq_reverse = (function clojure$string$seq_reverse(coll){
+return cljs.core.reduce.call(null,cljs.core.conj,cljs.core.List.EMPTY,coll);
+});
+clojure.string.re_surrogate_pair = (new RegExp("([\\uD800-\\uDBFF])([\\uDC00-\\uDFFF])","g"));
+/**
+ * Returns s with its characters reversed.
+ */
+clojure.string.reverse = (function clojure$string$reverse(s){
+return s.replace(clojure.string.re_surrogate_pair,"$2$1").split("").reverse().join("");
+});
+clojure.string.replace_all = (function clojure$string$replace_all(s,re,replacement){
+var r = (new RegExp(re.source,(function (){var G__1125 = "g";
+var G__1125__$1 = (cljs.core.truth_(re.ignoreCase)?[cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__1125),"i"].join(''):G__1125);
+var G__1125__$2 = (cljs.core.truth_(re.multiline)?[cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__1125__$1),"m"].join(''):G__1125__$1);
+if(cljs.core.truth_(re.unicode)){
+return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__1125__$2),"u"].join('');
+} else {
+return G__1125__$2;
+}
+})()));
+return s.replace(r,replacement);
+});
+clojure.string.replace_with = (function clojure$string$replace_with(f){
+return (function() { 
+var G__1126__delegate = function (args){
+var matches = cljs.core.drop_last.call(null,(2),args);
+if(cljs.core._EQ_.call(null,cljs.core.count.call(null,matches),(1))){
+return f.call(null,cljs.core.first.call(null,matches));
+} else {
+return f.call(null,cljs.core.vec.call(null,matches));
+}
+};
+var G__1126 = function (var_args){
+var args = null;
+if (arguments.length > 0) {
+var G__1127__i = 0, G__1127__a = new Array(arguments.length -  0);
+while (G__1127__i < G__1127__a.length) {G__1127__a[G__1127__i] = arguments[G__1127__i + 0]; ++G__1127__i;}
+  args = new cljs.core.IndexedSeq(G__1127__a,0,null);
+} 
+return G__1126__delegate.call(this,args);};
+G__1126.cljs$lang$maxFixedArity = 0;
+G__1126.cljs$lang$applyTo = (function (arglist__1128){
+var args = cljs.core.seq(arglist__1128);
+return G__1126__delegate(args);
+});
+G__1126.cljs$core$IFn$_invoke$arity$variadic = G__1126__delegate;
+return G__1126;
+})()
+;
+});
+/**
+ * Replaces all instance of match with replacement in s.
+ * 
+ * match/replacement can be:
+ * 
+ * string / string
+ * pattern / (string or function of match).
+ * 
+ * See also replace-first.
+ * 
+ * The replacement is literal (i.e. none of its characters are treated
+ * specially) for all cases above except pattern / string.
+ * 
+ * For pattern / string, $1, $2, etc. in the replacement string are
+ * substituted with the string that matched the corresponding
+ * parenthesized group in the pattern.
+ * 
+ * Example:
+ * (clojure.string/replace "Almost Pig Latin" #"\b(\w)(\w+)\b" "$2$1ay")
+ * -> "lmostAay igPay atinLay"
+ */
+clojure.string.replace = (function clojure$string$replace(s,match,replacement){
+if(typeof match === 'string'){
+return s.replace((new RegExp(goog.string.regExpEscape(match),"g")),replacement);
+} else {
+if((match instanceof RegExp)){
+if(typeof replacement === 'string'){
+return clojure.string.replace_all.call(null,s,match,replacement);
+} else {
+return clojure.string.replace_all.call(null,s,match,clojure.string.replace_with.call(null,replacement));
+}
+} else {
+throw ["Invalid match arg: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(match)].join('');
+
+}
+}
+});
+/**
+ * Replaces the first instance of match with replacement in s.
+ * 
+ * match/replacement can be:
+ * 
+ * string / string
+ * pattern / (string or function of match).
+ * 
+ * See also replace.
+ * 
+ * The replacement is literal (i.e. none of its characters are treated
+ * specially) for all cases above except pattern / string.
+ * 
+ * For pattern / string, $1, $2, etc. in the replacement string are
+ * substituted with the string that matched the corresponding
+ * parenthesized group in the pattern.
+ * 
+ * Example:
+ * (clojure.string/replace-first "swap first two words"
+ *                               #"(\w+)(\s+)(\w+)" "$3$2$1")
+ * -> "first swap two words"
+ */
+clojure.string.replace_first = (function clojure$string$replace_first(s,match,replacement){
+return s.replace(match,replacement);
+});
+/**
+ * Returns a string of all elements in coll, as returned by (seq coll),
+ *   separated by an optional separator.
+ */
+clojure.string.join = (function clojure$string$join(var_args){
+var G__1130 = arguments.length;
+switch (G__1130) {
+case 1:
+return clojure.string.join.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
+
+break;
+case 2:
+return clojure.string.join.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
+
+break;
+default:
+throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));
+
+}
+});
+
+clojure.string.join.cljs$core$IFn$_invoke$arity$1 = (function (coll){
+var sb = (new goog.string.StringBuffer());
+var coll__$1 = cljs.core.seq.call(null,coll);
+while(true){
+if((!((coll__$1 == null)))){
+var G__1132 = sb.append(cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.first.call(null,coll__$1)));
+var G__1133 = cljs.core.next.call(null,coll__$1);
+sb = G__1132;
+coll__$1 = G__1133;
+continue;
+} else {
+return sb.toString();
+}
+break;
+}
+});
+
+clojure.string.join.cljs$core$IFn$_invoke$arity$2 = (function (separator,coll){
+var sb = (new goog.string.StringBuffer());
+var coll__$1 = cljs.core.seq.call(null,coll);
+while(true){
+if((!((coll__$1 == null)))){
+sb.append(cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.first.call(null,coll__$1)));
+
+var coll__$2 = cljs.core.next.call(null,coll__$1);
+if((coll__$2 == null)){
+} else {
+sb.append(separator);
+}
+
+var G__1134 = sb;
+var G__1135 = coll__$2;
+sb = G__1134;
+coll__$1 = G__1135;
+continue;
+} else {
+return sb.toString();
+}
+break;
+}
+});
+
+clojure.string.join.cljs$lang$maxFixedArity = 2;
+
+/**
+ * Converts string to all upper-case.
+ */
+clojure.string.upper_case = (function clojure$string$upper_case(s){
+return s.toUpperCase();
+});
+/**
+ * Converts string to all lower-case.
+ */
+clojure.string.lower_case = (function clojure$string$lower_case(s){
+return s.toLowerCase();
+});
+/**
+ * Converts first character of the string to upper-case, all other
+ *   characters to lower-case.
+ */
+clojure.string.capitalize = (function clojure$string$capitalize(s){
+return goog.string.capitalize(s);
+});
+clojure.string.pop_last_while_empty = (function clojure$string$pop_last_while_empty(v){
+var v__$1 = v;
+while(true){
+if(("" === cljs.core.peek.call(null,v__$1))){
+var G__1136 = cljs.core.pop.call(null,v__$1);
+v__$1 = G__1136;
+continue;
+} else {
+return v__$1;
+}
+break;
+}
+});
+clojure.string.discard_trailing_if_needed = (function clojure$string$discard_trailing_if_needed(limit,v){
+if(((((0) === limit)) && (((1) < cljs.core.count.call(null,v))))){
+return clojure.string.pop_last_while_empty.call(null,v);
+} else {
+return v;
+}
+});
+clojure.string.split_with_empty_regex = (function clojure$string$split_with_empty_regex(s,limit){
+if((((limit <= (0))) || ((limit >= ((2) + cljs.core.count.call(null,s)))))){
+return cljs.core.conj.call(null,cljs.core.vec.call(null,cljs.core.cons.call(null,"",cljs.core.map.call(null,cljs.core.str,cljs.core.seq.call(null,s)))),"");
+} else {
+var pred__1137 = cljs.core._EQ__EQ_;
+var expr__1138 = limit;
+if(cljs.core.truth_(pred__1137.call(null,(1),expr__1138))){
+return (new cljs.core.PersistentVector(null,1,(5),cljs.core.PersistentVector.EMPTY_NODE,[s],null));
+} else {
+if(cljs.core.truth_(pred__1137.call(null,(2),expr__1138))){
+return (new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,["",s],null));
+} else {
+var c = (limit - (2));
+return cljs.core.conj.call(null,cljs.core.vec.call(null,cljs.core.cons.call(null,"",cljs.core.subvec.call(null,cljs.core.vec.call(null,cljs.core.map.call(null,cljs.core.str,cljs.core.seq.call(null,s))),(0),c))),cljs.core.subs.call(null,s,c));
+}
+}
+}
+});
+/**
+ * Splits string on a regular expression. Optional argument limit is
+ *   the maximum number of splits. Not lazy. Returns vector of the splits.
+ */
+clojure.string.split = (function clojure$string$split(var_args){
+var G__1141 = arguments.length;
+switch (G__1141) {
+case 2:
+return clojure.string.split.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
+
+break;
+case 3:
+return clojure.string.split.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));
+
+break;
+default:
+throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));
+
+}
+});
+
+clojure.string.split.cljs$core$IFn$_invoke$arity$2 = (function (s,re){
+return clojure.string.split.call(null,s,re,(0));
+});
+
+clojure.string.split.cljs$core$IFn$_invoke$arity$3 = (function (s,re,limit){
+return clojure.string.discard_trailing_if_needed.call(null,limit,((("/(?:)/" === cljs.core.str.cljs$core$IFn$_invoke$arity$1(re)))?clojure.string.split_with_empty_regex.call(null,s,limit):(((limit < (1)))?cljs.core.vec.call(null,cljs.core.str.cljs$core$IFn$_invoke$arity$1(s).split(re)):(function (){var s__$1 = s;
+var limit__$1 = limit;
+var parts = cljs.core.PersistentVector.EMPTY;
+while(true){
+if(((1) === limit__$1)){
+return cljs.core.conj.call(null,parts,s__$1);
+} else {
+var m = cljs.core.re_find.call(null,re,s__$1);
+if((!((m == null)))){
+var index = s__$1.indexOf(m);
+var G__1143 = s__$1.substring((index + cljs.core.count.call(null,m)));
+var G__1144 = (limit__$1 - (1));
+var G__1145 = cljs.core.conj.call(null,parts,s__$1.substring((0),index));
+s__$1 = G__1143;
+limit__$1 = G__1144;
+parts = G__1145;
+continue;
+} else {
+return cljs.core.conj.call(null,parts,s__$1);
+}
+}
+break;
+}
+})())));
+});
+
+clojure.string.split.cljs$lang$maxFixedArity = 3;
+
+/**
+ * Splits s on \n or \r\n.
+ */
+clojure.string.split_lines = (function clojure$string$split_lines(s){
+return clojure.string.split.call(null,s,/\n|\r\n/);
+});
+/**
+ * Removes whitespace from both ends of string.
+ */
+clojure.string.trim = (function clojure$string$trim(s){
+return goog.string.trim(s);
+});
+/**
+ * Removes whitespace from the left side of string.
+ */
+clojure.string.triml = (function clojure$string$triml(s){
+return goog.string.trimLeft(s);
+});
+/**
+ * Removes whitespace from the right side of string.
+ */
+clojure.string.trimr = (function clojure$string$trimr(s){
+return goog.string.trimRight(s);
+});
+/**
+ * Removes all trailing newline \n or return \r characters from
+ *   string.  Similar to Perl's chomp.
+ */
+clojure.string.trim_newline = (function clojure$string$trim_newline(s){
+var index = s.length;
+while(true){
+if((index === (0))){
+return "";
+} else {
+var ch = cljs.core.get.call(null,s,(index - (1)));
+if(((("\n" === ch)) || (("\r" === ch)))){
+var G__1146 = (index - (1));
+index = G__1146;
+continue;
+} else {
+return s.substring((0),index);
+}
+}
+break;
+}
+});
+/**
+ * True is s is nil, empty, or contains only whitespace.
+ */
+clojure.string.blank_QMARK_ = (function clojure$string$blank_QMARK_(s){
+return goog.string.isEmptySafe(s);
+});
+/**
+ * Return a new string, using cmap to escape each character ch
+ * from s as follows:
+ * 
+ * If (cmap ch) is nil, append ch to the new string.
+ * If (cmap ch) is non-nil, append (str (cmap ch)) instead.
+ */
+clojure.string.escape = (function clojure$string$escape(s,cmap){
+var buffer = (new goog.string.StringBuffer());
+var length = s.length;
+var index = (0);
+while(true){
+if((length === index)){
+return buffer.toString();
+} else {
+var ch = s.charAt(index);
+var replacement = cljs.core.get.call(null,cmap,ch);
+if((!((replacement == null)))){
+buffer.append(cljs.core.str.cljs$core$IFn$_invoke$arity$1(replacement));
+} else {
+buffer.append(ch);
+}
+
+var G__1147 = (index + (1));
+index = G__1147;
+continue;
+}
+break;
+}
+});
+/**
+ * Return index of value (string or char) in s, optionally searching
+ *   forward from from-index or nil if not found.
+ */
+clojure.string.index_of = (function clojure$string$index_of(var_args){
+var G__1149 = arguments.length;
+switch (G__1149) {
+case 2:
+return clojure.string.index_of.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
+
+break;
+case 3:
+return clojure.string.index_of.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));
+
+break;
+default:
+throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));
+
+}
+});
+
+clojure.string.index_of.cljs$core$IFn$_invoke$arity$2 = (function (s,value){
+var result = s.indexOf(value);
+if((result < (0))){
+return null;
+} else {
+return result;
+}
+});
+
+clojure.string.index_of.cljs$core$IFn$_invoke$arity$3 = (function (s,value,from_index){
+var result = s.indexOf(value,from_index);
+if((result < (0))){
+return null;
+} else {
+return result;
+}
+});
+
+clojure.string.index_of.cljs$lang$maxFixedArity = 3;
+
+/**
+ * Return last index of value (string or char) in s, optionally
+ *   searching backward from from-index or nil if not found.
+ */
+clojure.string.last_index_of = (function clojure$string$last_index_of(var_args){
+var G__1152 = arguments.length;
+switch (G__1152) {
+case 2:
+return clojure.string.last_index_of.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
+
+break;
+case 3:
+return clojure.string.last_index_of.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));
+
+break;
+default:
+throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));
+
+}
+});
+
+clojure.string.last_index_of.cljs$core$IFn$_invoke$arity$2 = (function (s,value){
+var result = s.lastIndexOf(value);
+if((result < (0))){
+return null;
+} else {
+return result;
+}
+});
+
+clojure.string.last_index_of.cljs$core$IFn$_invoke$arity$3 = (function (s,value,from_index){
+var result = s.lastIndexOf(value,from_index);
+if((result < (0))){
+return null;
+} else {
+return result;
+}
+});
+
+clojure.string.last_index_of.cljs$lang$maxFixedArity = 3;
+
+/**
+ * True if s starts with substr.
+ */
+clojure.string.starts_with_QMARK_ = (function clojure$string$starts_with_QMARK_(s,substr){
+return goog.string.startsWith(s,substr);
+});
+/**
+ * True if s ends with substr.
+ */
+clojure.string.ends_with_QMARK_ = (function clojure$string$ends_with_QMARK_(s,substr){
+return goog.string.endsWith(s,substr);
+});
+/**
+ * True if s includes substr.
+ */
+clojure.string.includes_QMARK_ = (function clojure$string$includes_QMARK_(s,substr){
+return goog.string.contains(s,substr);
+});
+
+//# sourceMappingURL=string.js.map
diff --git a/static/src/assets/viz/2/clojure/string.js.map b/static/src/assets/viz/2/clojure/string.js.map
new file mode 100644
index 0000000..2270a89
--- /dev/null
+++ b/static/src/assets/viz/2/clojure/string.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"\/home\/mediocregopher\/src\/viz\/out\/clojure\/string.js","sources":["string.cljs"],"lineCount":477,"mappings":"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\/B,AAAA,+CAAA,\/CAAMiD;;AAAN,AAwBA;;;6BAAA,7BAAMK,kEAEH;AAFH,AAGE,wCAAA,jCAACL,+BAAMjD;;AAET;;;sBAAA,tBAAMuD,oDAEH;AAFH,AAGE,OAACC,iBAAaxD;;AAEhB;;;uBAAA,vBAAMyD,sDAEH;AAFH,AAGE,OAACC,qBAAiB1D;;AAEpB;;;uBAAA,vBAAM2D,sDAEH;AAFH,AAGE,OAACC,sBAAkB5D;;AAErB;;;;8BAAA,9BAAM6D,oEAGH;AAHH,AAIE,IAAO,QAAM,AAAU7D;;AAAvB,AACE,GAAI,WAAA,VAAOqD;AAAX;;AAEE,IAAM,KAAG,AAACS,wBAAI9D,EAAE,SAAA,RAAKqD;AAArB,AACE,GAAI,EAAI,CAAA,SAAqBU,SACrB,CAAA,SAAoBA;AAC1B,cAAO,SAAA,RAAKV;;;;AACZ,mBAAA,ZAAYrD,gBAAIqD;;;;;;AAE1B;;;8BAAA,9BAAeW,oEAEZ;AAFH,AAGE,OAACC,wBAAoBjE;;AAEvB;;;;;;;wBAAA,xBAAMkE,wDAMH,EAAE;AANL,AAOE,IAAM,SAAO,KAAA,AAAA5C;IACP,SAAO,AAAUtB;AADvB,AAEE,YAAA,RAAO;;AAAP,AACE,GAAI,CAAImE,WAAOd;AACb,OAAGe;;AACH,IAAM,KAAG,AAASpE,SAAEqD;IACd,cAAY,AAACS,wBAAIO,KAAKN;AAD5B,AAEE,GAAA,GAAQ,gBAAA,fAAM1D;AACZ,AAAS+D,cAAO,4CAAK\/D;;AACrB,AAAS+D,cAAOL;;;AAClB,cAAO,SAAA,RAAKV;;;;;;;AAEtB,AAAA;;;;0BAAA,kCAAA,5DAAMkB;AAAN,AAAA,IAAA,UAAA,AAAA;AAAA,AAAA,QAAAD;KAAA;AAAA,OAAAC,sDAAA,CAAA,UAAA,MAAA,CAAA,UAAA;;;KAAA;AAAA,OAAAA,sDAAA,CAAA,UAAA,MAAA,CAAA,UAAA,MAAA,CAAA,UAAA;;;;AAAA,MAAA,KAAAlD,MAAA,CAAA,8DAAA,AAAA;;;;;AAAA,AAAA,wDAAA,xDAAMkD,mEAGF,EAAE;AAHN,AAIG,IAAM,SAAO,AAAUvE,UAAEwE;AAAzB,AACE,GAAI,UAAA,TAAMC;AAAV;;AAEEA;;;;AAPP,AAAA,wDAAA,xDAAMF,mEAQF,EAAE,MAAM;AARZ,AASG,IAAM,SAAO,AAAUvE,UAAEwE,MAAME;AAA\/B,AACE,GAAI,UAAA,TAAMD;AAAV;;AAEEA;;;;AAZP,AAAA,kDAAA,lDAAMF;;AAAN,AAcA,AAAA;;;;+BAAA,uCAAA,tEAAMK;AAAN,AAAA,IAAA,UAAA,AAAA;AAAA,AAAA,QAAAD;KAAA;AAAA,OAAAC,2DAAA,CAAA,UAAA,MAAA,CAAA,UAAA;;;KAAA;AAAA,OAAAA,2DAAA,CAAA,UAAA,MAAA,CAAA,UAAA,MAAA,CAAA,UAAA;;;;AAAA,MAAA,KAAAvD,MAAA,CAAA,8DAAA,AAAA;;;;;AAAA,AAAA,6DAAA,7DAAMuD,wEAGF,EAAE;AAHN,AAIG,IAAM,SAAO,AAAc5E,cAAEwE;AAA7B,AACE,GAAI,UAAA,TAAMC;AAAV;;AAEEA;;;;AAPP,AAAA,6DAAA,7DAAMG,wEAQF,EAAE,MAAM;AARZ,AASG,IAAM,SAAO,AAAc5E,cAAEwE,MAAME;AAAnC,AACE,GAAI,UAAA,TAAMD;AAAV;;AAEEA;;;;AAZP,AAAA,uDAAA,vDAAMG;;AAAN,AAcA;;;oCAAA,pCAAeC,gFAEZ,EAAE;AAFL,AAGE,OAACC,uBAAmB9E,EAAE+E;;AAExB;;;kCAAA,lCAAeC,4EAEZ,EAAE;AAFL,AAGE,OAACC,qBAAiBjF,EAAE+E;;AAEtB;;;iCAAA,jCAAeG,0EAEZ,EAAE;AAFL,AAGE,OAACC,qBAAiBnF,EAAE+E","names":["clojure.string\/seq-reverse","cljs.core\/reduce","cljs.core\/conj","coll","clojure.string\/re-surrogate-pair","js\/RegExp","clojure.string\/reverse","s","clojure.string\/replace-all","re","G__1125","r","replacement","clojure.string\/replace-with","cljs.core\/drop-last","args","cljs.core\/=","cljs.core\/count","matches","f","cljs.core\/first","cljs.core\/vec","clojure.string\/replace","match","goog.string\/regExpEscape","clojure.string\/replace-first","G__1130","clojure.string\/join","js\/Error","goog\/string","cljs.core\/seq","sb","cljs.core\/next","separator","clojure.string\/upper-case","clojure.string\/lower-case","clojure.string\/capitalize","goog.string\/capitalize","clojure.string\/pop-last-while-empty","v","cljs.core\/peek","cljs.core\/pop","clojure.string\/discard-trailing-if-needed","limit","clojure.string\/split-with-empty-regex","cljs.core\/cons","cljs.core\/map","cljs.core\/str","pred__1137","expr__1138","cljs.core\/==","cljs.core\/PersistentVector","cljs.core\/subvec","c","cljs.core\/subs","G__1141","clojure.string\/split","parts","cljs.core\/re-find","m","index","clojure.string\/split-lines","clojure.string\/trim","goog.string\/trim","clojure.string\/triml","goog.string\/trimLeft","clojure.string\/trimr","goog.string\/trimRight","clojure.string\/trim-newline","cljs.core\/get","ch","clojure.string\/blank?","goog.string\/isEmptySafe","clojure.string\/escape","length","buffer","cmap","G__1149","clojure.string\/index-of","value","result","from-index","G__1152","clojure.string\/last-index-of","clojure.string\/starts-with?","goog.string\/startsWith","substr","clojure.string\/ends-with?","goog.string\/endsWith","clojure.string\/includes?","goog.string\/contains"]}
\ No newline at end of file