Added compiled JavaScript to repository for GitHub pages

This feels like a mistake...

resources/public/js/compiled/out/clojure/data.cljs

@@ -0,0 +1,162 @@
+;   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 
+  ^{:author "Stuart Halloway",
+    :doc "Non-core data functions."}
+  clojure.data
+  (:require [clojure.set :as set]))
+
+(declare diff)
+
+(defn- atom-diff
+  "Internal helper for diff."
+  [a b]
+  (if (= a b) [nil nil a] [a b nil]))
+
+;; for big things a sparse vector class would be better
+(defn- vectorize
+  "Convert an associative-by-numeric-index collection into
+   an equivalent vector, with nil for any missing keys"
+  [m]
+  (when (seq m)
+    (reduce
+     (fn [result [k v]] (assoc result k v))
+     (vec (repeat (apply max (keys m))  nil))
+     m)))
+
+(defn- diff-associative-key
+  "Diff associative things a and b, comparing only the key k."
+  [a b k]
+  (let [va (get a k)
+        vb (get b k)
+        [a* b* ab] (diff va vb)
+        in-a (contains? a k)
+        in-b (contains? b k)
+        same (and in-a in-b
+                  (or (not (nil? ab))
+                      (and (nil? va) (nil? vb))))]
+    [(when (and in-a (or (not (nil? a*)) (not same))) {k a*})
+     (when (and in-b (or (not (nil? b*)) (not same))) {k b*})
+     (when same {k ab})
+     ]))
+
+(defn- diff-associative
+  "Diff associative things a and b, comparing only keys in ks (if supplied)."
+  ([a b]
+     (diff-associative a b (set/union (keys a) (keys b))))
+  ([a b ks]
+     (reduce
+      (fn [diff1 diff2]
+        (doall (map merge diff1 diff2)))
+      [nil nil nil]
+      (map
+       (partial diff-associative-key a b)
+       ks))))
+
+(defn- diff-sequential
+  [a b]
+  (vec (map vectorize (diff-associative
+                       (if (vector? a) a (vec a))
+                       (if (vector? b) b (vec b))
+                       (range (max (count a) (count b)))))))
+
+(defn- diff-set
+  [a b]
+  [(not-empty (set/difference a b))
+   (not-empty (set/difference b a))
+   (not-empty (set/intersection a b))])
+
+(defprotocol EqualityPartition
+  "Implementation detail. Subject to change."
+  (equality-partition [x] "Implementation detail. Subject to change."))
+
+(defprotocol Diff
+  "Implementation detail. Subject to change."
+  (diff-similar [a b] "Implementation detail. Subject to change."))
+
+(extend-protocol EqualityPartition
+  nil
+  (equality-partition [x] :atom)
+
+  string
+  (equality-partition [x] :atom)
+
+  number
+  (equality-partition [x] :atom)
+
+  array
+  (equality-partition [x] :sequential)
+
+  function
+  (equality-partition [x] :atom)
+
+  boolean
+  (equality-partition [x] :atom)
+
+  default
+  (equality-partition [x]
+    (cond
+     (satisfies? IMap x) :map
+     (satisfies? ISet x) :set
+     (satisfies? ISequential x) :sequential
+     :default :atom)))
+
+(extend-protocol Diff
+  nil
+  (diff-similar [a b]
+    (atom-diff a b))
+
+  string
+  (diff-similar [a b]
+    (atom-diff a b))
+
+  number
+  (diff-similar [a b]
+    (atom-diff a b))
+
+  array
+  (diff-similar [a b]
+    (diff-sequential a b))
+
+  function
+  (diff-similar [a b]
+    (atom-diff a b))
+
+  boolean
+  (diff-similar [a b]
+    (atom-diff a b))
+
+  default
+  (diff-similar [a b]
+    ((case (equality-partition a)
+       :atom atom-diff
+       :set diff-set
+       :sequential diff-sequential
+       :map diff-associative)
+     a b)))
+
+(defn diff
+  "Recursively compares a and b, returning a tuple of
+  [things-only-in-a things-only-in-b things-in-both].
+  Comparison rules:
+
+  * For equal a and b, return [nil nil a].
+  * Maps are subdiffed where keys match and values differ.
+  * Sets are never subdiffed.
+  * All sequential things are treated as associative collections
+    by their indexes, with results returned as vectors.
+  * Everything else (including strings!) is treated as
+    an atom and compared for equality."
+  [a b]
+  (if (= a b)
+    [nil nil a]
+    (if (= (equality-partition a) (equality-partition b))
+      (diff-similar a b)
+      (atom-diff a b))))
+  

resources/public/js/compiled/out/clojure/data.js

@@ -0,0 +1,302 @@
+// Compiled by ClojureScript 1.9.229 {}
+goog.provide('clojure.data');
+goog.require('cljs.core');
+goog.require('clojure.set');
+/**
+ * Internal helper for diff.
+ */
+clojure.data.atom_diff = (function clojure$data$atom_diff(a,b){
+if(cljs.core._EQ_.call(null,a,b)){
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,null,a], null);
+} else {
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [a,b,null], null);
+}
+});
+/**
+ * Convert an associative-by-numeric-index collection into
+ * an equivalent vector, with nil for any missing keys
+ */
+clojure.data.vectorize = (function clojure$data$vectorize(m){
+if(cljs.core.seq.call(null,m)){
+return cljs.core.reduce.call(null,(function (result,p__41009){
+var vec__41010 = p__41009;
+var k = cljs.core.nth.call(null,vec__41010,(0),null);
+var v = cljs.core.nth.call(null,vec__41010,(1),null);
+return cljs.core.assoc.call(null,result,k,v);
+}),cljs.core.vec.call(null,cljs.core.repeat.call(null,cljs.core.apply.call(null,cljs.core.max,cljs.core.keys.call(null,m)),null)),m);
+} else {
+return null;
+}
+});
+/**
+ * Diff associative things a and b, comparing only the key k.
+ */
+clojure.data.diff_associative_key = (function clojure$data$diff_associative_key(a,b,k){
+var va = cljs.core.get.call(null,a,k);
+var vb = cljs.core.get.call(null,b,k);
+var vec__41016 = clojure.data.diff.call(null,va,vb);
+var a_STAR_ = cljs.core.nth.call(null,vec__41016,(0),null);
+var b_STAR_ = cljs.core.nth.call(null,vec__41016,(1),null);
+var ab = cljs.core.nth.call(null,vec__41016,(2),null);
+var in_a = cljs.core.contains_QMARK_.call(null,a,k);
+var in_b = cljs.core.contains_QMARK_.call(null,b,k);
+var same = (in_a) && (in_b) && ((!((ab == null))) || (((va == null)) && ((vb == null))));
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [(((in_a) && ((!((a_STAR_ == null))) || (!(same))))?cljs.core.PersistentArrayMap.fromArray([k,a_STAR_], true, false):null),(((in_b) && ((!((b_STAR_ == null))) || (!(same))))?cljs.core.PersistentArrayMap.fromArray([k,b_STAR_], true, false):null),((same)?cljs.core.PersistentArrayMap.fromArray([k,ab], true, false):null)], null);
+});
+/**
+ * Diff associative things a and b, comparing only keys in ks (if supplied).
+ */
+clojure.data.diff_associative = (function clojure$data$diff_associative(var_args){
+var args41019 = [];
+var len__26205__auto___41022 = arguments.length;
+var i__26206__auto___41023 = (0);
+while(true){
+if((i__26206__auto___41023 < len__26205__auto___41022)){
+args41019.push((arguments[i__26206__auto___41023]));
+
+var G__41024 = (i__26206__auto___41023 + (1));
+i__26206__auto___41023 = G__41024;
+continue;
+} else {
+}
+break;
+}
+
+var G__41021 = args41019.length;
+switch (G__41021) {
+case 2:
+return clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
+
+break;
+case 3:
+return clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));
+
+break;
+default:
+throw (new Error([cljs.core.str("Invalid arity: "),cljs.core.str(args41019.length)].join('')));
+
+}
+});
+
+clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$2 = (function (a,b){
+return clojure.data.diff_associative.call(null,a,b,clojure.set.union.call(null,cljs.core.keys.call(null,a),cljs.core.keys.call(null,b)));
+});
+
+clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$3 = (function (a,b,ks){
+return cljs.core.reduce.call(null,(function (diff1,diff2){
+return cljs.core.doall.call(null,cljs.core.map.call(null,cljs.core.merge,diff1,diff2));
+}),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,null,null], null),cljs.core.map.call(null,cljs.core.partial.call(null,clojure.data.diff_associative_key,a,b),ks));
+});
+
+clojure.data.diff_associative.cljs$lang$maxFixedArity = 3;
+
+clojure.data.diff_sequential = (function clojure$data$diff_sequential(a,b){
+return cljs.core.vec.call(null,cljs.core.map.call(null,clojure.data.vectorize,clojure.data.diff_associative.call(null,((cljs.core.vector_QMARK_.call(null,a))?a:cljs.core.vec.call(null,a)),((cljs.core.vector_QMARK_.call(null,b))?b:cljs.core.vec.call(null,b)),cljs.core.range.call(null,(function (){var x__25461__auto__ = cljs.core.count.call(null,a);
+var y__25462__auto__ = cljs.core.count.call(null,b);
+return ((x__25461__auto__ > y__25462__auto__) ? x__25461__auto__ : y__25462__auto__);
+})()))));
+});
+clojure.data.diff_set = (function clojure$data$diff_set(a,b){
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.not_empty.call(null,clojure.set.difference.call(null,a,b)),cljs.core.not_empty.call(null,clojure.set.difference.call(null,b,a)),cljs.core.not_empty.call(null,clojure.set.intersection.call(null,a,b))], null);
+});
+
+/**
+ * Implementation detail. Subject to change.
+ * @interface
+ */
+clojure.data.EqualityPartition = function(){};
+
+/**
+ * Implementation detail. Subject to change.
+ */
+clojure.data.equality_partition = (function clojure$data$equality_partition(x){
+if((!((x == null))) && (!((x.clojure$data$EqualityPartition$equality_partition$arity$1 == null)))){
+return x.clojure$data$EqualityPartition$equality_partition$arity$1(x);
+} else {
+var x__25793__auto__ = (((x == null))?null:x);
+var m__25794__auto__ = (clojure.data.equality_partition[goog.typeOf(x__25793__auto__)]);
+if(!((m__25794__auto__ == null))){
+return m__25794__auto__.call(null,x);
+} else {
+var m__25794__auto____$1 = (clojure.data.equality_partition["_"]);
+if(!((m__25794__auto____$1 == null))){
+return m__25794__auto____$1.call(null,x);
+} else {
+throw cljs.core.missing_protocol.call(null,"EqualityPartition.equality-partition",x);
+}
+}
+}
+});
+
+
+/**
+ * Implementation detail. Subject to change.
+ * @interface
+ */
+clojure.data.Diff = function(){};
+
+/**
+ * Implementation detail. Subject to change.
+ */
+clojure.data.diff_similar = (function clojure$data$diff_similar(a,b){
+if((!((a == null))) && (!((a.clojure$data$Diff$diff_similar$arity$2 == null)))){
+return a.clojure$data$Diff$diff_similar$arity$2(a,b);
+} else {
+var x__25793__auto__ = (((a == null))?null:a);
+var m__25794__auto__ = (clojure.data.diff_similar[goog.typeOf(x__25793__auto__)]);
+if(!((m__25794__auto__ == null))){
+return m__25794__auto__.call(null,a,b);
+} else {
+var m__25794__auto____$1 = (clojure.data.diff_similar["_"]);
+if(!((m__25794__auto____$1 == null))){
+return m__25794__auto____$1.call(null,a,b);
+} else {
+throw cljs.core.missing_protocol.call(null,"Diff.diff-similar",a);
+}
+}
+}
+});
+
+(clojure.data.EqualityPartition["null"] = true);
+
+(clojure.data.equality_partition["null"] = (function (x){
+return new cljs.core.Keyword(null,"atom","atom",-397043653);
+}));
+
+(clojure.data.EqualityPartition["string"] = true);
+
+(clojure.data.equality_partition["string"] = (function (x){
+return new cljs.core.Keyword(null,"atom","atom",-397043653);
+}));
+
+(clojure.data.EqualityPartition["number"] = true);
+
+(clojure.data.equality_partition["number"] = (function (x){
+return new cljs.core.Keyword(null,"atom","atom",-397043653);
+}));
+
+(clojure.data.EqualityPartition["array"] = true);
+
+(clojure.data.equality_partition["array"] = (function (x){
+return new cljs.core.Keyword(null,"sequential","sequential",-1082983960);
+}));
+
+(clojure.data.EqualityPartition["function"] = true);
+
+(clojure.data.equality_partition["function"] = (function (x){
+return new cljs.core.Keyword(null,"atom","atom",-397043653);
+}));
+
+(clojure.data.EqualityPartition["boolean"] = true);
+
+(clojure.data.equality_partition["boolean"] = (function (x){
+return new cljs.core.Keyword(null,"atom","atom",-397043653);
+}));
+
+(clojure.data.EqualityPartition["_"] = true);
+
+(clojure.data.equality_partition["_"] = (function (x){
+if(((!((x == null)))?((((x.cljs$lang$protocol_mask$partition0$ & (1024))) || (x.cljs$core$IMap$))?true:(((!x.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMap,x):false)):cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMap,x))){
+return new cljs.core.Keyword(null,"map","map",1371690461);
+} else {
+if(((!((x == null)))?((((x.cljs$lang$protocol_mask$partition0$ & (4096))) || (x.cljs$core$ISet$))?true:(((!x.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISet,x):false)):cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISet,x))){
+return new cljs.core.Keyword(null,"set","set",304602554);
+} else {
+if(((!((x == null)))?((((x.cljs$lang$protocol_mask$partition0$ & (16777216))) || (x.cljs$core$ISequential$))?true:(((!x.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISequential,x):false)):cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISequential,x))){
+return new cljs.core.Keyword(null,"sequential","sequential",-1082983960);
+} else {
+return new cljs.core.Keyword(null,"atom","atom",-397043653);
+
+}
+}
+}
+}));
+(clojure.data.Diff["null"] = true);
+
+(clojure.data.diff_similar["null"] = (function (a,b){
+return clojure.data.atom_diff.call(null,a,b);
+}));
+
+(clojure.data.Diff["string"] = true);
+
+(clojure.data.diff_similar["string"] = (function (a,b){
+return clojure.data.atom_diff.call(null,a,b);
+}));
+
+(clojure.data.Diff["number"] = true);
+
+(clojure.data.diff_similar["number"] = (function (a,b){
+return clojure.data.atom_diff.call(null,a,b);
+}));
+
+(clojure.data.Diff["array"] = true);
+
+(clojure.data.diff_similar["array"] = (function (a,b){
+return clojure.data.diff_sequential.call(null,a,b);
+}));
+
+(clojure.data.Diff["function"] = true);
+
+(clojure.data.diff_similar["function"] = (function (a,b){
+return clojure.data.atom_diff.call(null,a,b);
+}));
+
+(clojure.data.Diff["boolean"] = true);
+
+(clojure.data.diff_similar["boolean"] = (function (a,b){
+return clojure.data.atom_diff.call(null,a,b);
+}));
+
+(clojure.data.Diff["_"] = true);
+
+(clojure.data.diff_similar["_"] = (function (a,b){
+return (function (){var G__41029 = (((clojure.data.equality_partition.call(null,a) instanceof cljs.core.Keyword))?clojure.data.equality_partition.call(null,a).fqn:null);
+switch (G__41029) {
+case "atom":
+return clojure.data.atom_diff;
+
+break;
+case "set":
+return clojure.data.diff_set;
+
+break;
+case "sequential":
+return clojure.data.diff_sequential;
+
+break;
+case "map":
+return clojure.data.diff_associative;
+
+break;
+default:
+throw (new Error([cljs.core.str("No matching clause: "),cljs.core.str(clojure.data.equality_partition.call(null,a))].join('')));
+
+}
+})().call(null,a,b);
+}));
+/**
+ * Recursively compares a and b, returning a tuple of
+ *   [things-only-in-a things-only-in-b things-in-both].
+ *   Comparison rules:
+ * 
+ *   * For equal a and b, return [nil nil a].
+ *   * Maps are subdiffed where keys match and values differ.
+ *   * Sets are never subdiffed.
+ *   * All sequential things are treated as associative collections
+ *  by their indexes, with results returned as vectors.
+ *   * Everything else (including strings!) is treated as
+ *  an atom and compared for equality.
+ */
+clojure.data.diff = (function clojure$data$diff(a,b){
+if(cljs.core._EQ_.call(null,a,b)){
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,null,a], null);
+} else {
+if(cljs.core._EQ_.call(null,clojure.data.equality_partition.call(null,a),clojure.data.equality_partition.call(null,b))){
+return clojure.data.diff_similar.call(null,a,b);
+} else {
+return clojure.data.atom_diff.call(null,a,b);
+}
+}
+});
+
+//# sourceMappingURL=data.js.map?rel=1603199211133

resources/public/js/compiled/out/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]))
+

resources/public/js/compiled/out/clojure/set.js

@@ -0,0 +1,400 @@
+// Compiled by ClojureScript 1.9.229 {}
+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__40932_SHARP_){
+return (max === p1__40932_SHARP_);
+});})(max))
+,coll));
+});
+/**
+ * Return a set that is the union of the input sets
+ */
+clojure.set.union = (function clojure$set$union(var_args){
+var args40933 = [];
+var len__26205__auto___40939 = arguments.length;
+var i__26206__auto___40940 = (0);
+while(true){
+if((i__26206__auto___40940 < len__26205__auto___40939)){
+args40933.push((arguments[i__26206__auto___40940]));
+
+var G__40941 = (i__26206__auto___40940 + (1));
+i__26206__auto___40940 = G__40941;
+continue;
+} else {
+}
+break;
+}
+
+var G__40938 = args40933.length;
+switch (G__40938) {
+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 argseq__26224__auto__ = (new cljs.core.IndexedSeq(args40933.slice((2)),(0),null));
+return clojure.set.union.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__26224__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));
+});
+
+clojure.set.union.cljs$lang$applyTo = (function (seq40934){
+var G__40935 = cljs.core.first.call(null,seq40934);
+var seq40934__$1 = cljs.core.next.call(null,seq40934);
+var G__40936 = cljs.core.first.call(null,seq40934__$1);
+var seq40934__$2 = cljs.core.next.call(null,seq40934__$1);
+return clojure.set.union.cljs$core$IFn$_invoke$arity$variadic(G__40935,G__40936,seq40934__$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 args40944 = [];
+var len__26205__auto___40950 = arguments.length;
+var i__26206__auto___40951 = (0);
+while(true){
+if((i__26206__auto___40951 < len__26205__auto___40950)){
+args40944.push((arguments[i__26206__auto___40951]));
+
+var G__40952 = (i__26206__auto___40951 + (1));
+i__26206__auto___40951 = G__40952;
+continue;
+} else {
+}
+break;
+}
+
+var G__40949 = args40944.length;
+switch (G__40949) {
+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 argseq__26224__auto__ = (new cljs.core.IndexedSeq(args40944.slice((2)),(0),null));
+return clojure.set.intersection.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__26224__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__40954 = s2;
+var G__40955 = s1;
+s1 = G__40954;
+s2 = G__40955;
+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__40943_SHARP_){
+return (- cljs.core.count.call(null,p1__40943_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));
+});
+
+clojure.set.intersection.cljs$lang$applyTo = (function (seq40945){
+var G__40946 = cljs.core.first.call(null,seq40945);
+var seq40945__$1 = cljs.core.next.call(null,seq40945);
+var G__40947 = cljs.core.first.call(null,seq40945__$1);
+var seq40945__$2 = cljs.core.next.call(null,seq40945__$1);
+return clojure.set.intersection.cljs$core$IFn$_invoke$arity$variadic(G__40946,G__40947,seq40945__$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 args40956 = [];
+var len__26205__auto___40962 = arguments.length;
+var i__26206__auto___40963 = (0);
+while(true){
+if((i__26206__auto___40963 < len__26205__auto___40962)){
+args40956.push((arguments[i__26206__auto___40963]));
+
+var G__40964 = (i__26206__auto___40963 + (1));
+i__26206__auto___40963 = G__40964;
+continue;
+} else {
+}
+break;
+}
+
+var G__40961 = args40956.length;
+switch (G__40961) {
+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 argseq__26224__auto__ = (new cljs.core.IndexedSeq(args40956.slice((2)),(0),null));
+return clojure.set.difference.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__26224__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));
+});
+
+clojure.set.difference.cljs$lang$applyTo = (function (seq40957){
+var G__40958 = cljs.core.first.call(null,seq40957);
+var seq40957__$1 = cljs.core.next.call(null,seq40957);
+var G__40959 = cljs.core.first.call(null,seq40957__$1);
+var seq40957__$2 = cljs.core.next.call(null,seq40957__$1);
+return clojure.set.difference.cljs$core$IFn$_invoke$arity$variadic(G__40958,G__40959,seq40957__$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__40966_SHARP_){
+return cljs.core.select_keys.call(null,p1__40966_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__40971){
+var vec__40972 = p__40971;
+var old = cljs.core.nth.call(null,vec__40972,(0),null);
+var new$ = cljs.core.nth.call(null,vec__40972,(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__40975_SHARP_){
+return clojure.set.rename_keys.call(null,p1__40975_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__40980){
+var vec__40981 = p__40980;
+var k = cljs.core.nth.call(null,vec__40981,(0),null);
+var v = cljs.core.nth.call(null,vec__40981,(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 args40988 = [];
+var len__26205__auto___40997 = arguments.length;
+var i__26206__auto___40998 = (0);
+while(true){
+if((i__26206__auto___40998 < len__26205__auto___40997)){
+args40988.push((arguments[i__26206__auto___40998]));
+
+var G__40999 = (i__26206__auto___40998 + (1));
+i__26206__auto___40998 = G__40999;
+continue;
+} else {
+}
+break;
+}
+
+var G__40990 = args40988.length;
+switch (G__40990) {
+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([cljs.core.str("Invalid arity: "),cljs.core.str(args40988.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__40991 = (((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__40991,(0),null);
+var s = cljs.core.nth.call(null,vec__40991,(1),null);
+var idx = clojure.set.index.call(null,r,ks);
+return cljs.core.reduce.call(null,((function (ks,vec__40991,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__40991,r,s,idx){
+return (function (p1__40984_SHARP_,p2__40985_SHARP_){
+return cljs.core.conj.call(null,p1__40984_SHARP_,cljs.core.merge.call(null,p2__40985_SHARP_,x));
+});})(found,ks,vec__40991,r,s,idx))
+,ret,found);
+} else {
+return ret;
+}
+});})(ks,vec__40991,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__40994 = (((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__40994,(0),null);
+var s = cljs.core.nth.call(null,vec__40994,(1),null);
+var k = cljs.core.nth.call(null,vec__40994,(2),null);
+var idx = clojure.set.index.call(null,r,cljs.core.vals.call(null,k));
+return cljs.core.reduce.call(null,((function (vec__40994,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__40994,r,s,k,idx){
+return (function (p1__40986_SHARP_,p2__40987_SHARP_){
+return cljs.core.conj.call(null,p1__40986_SHARP_,cljs.core.merge.call(null,p2__40987_SHARP_,x));
+});})(found,vec__40994,r,s,k,idx))
+,ret,found);
+} else {
+return ret;
+}
+});})(vec__40994,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__41001_SHARP_){
+return cljs.core.contains_QMARK_.call(null,set2,p1__41001_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__41002_SHARP_){
+return cljs.core.contains_QMARK_.call(null,set1,p1__41002_SHARP_);
+}),set2));
+});
+
+//# sourceMappingURL=set.js.map?rel=1603199211023

resources/public/js/compiled/out/clojure/string.cljs

@@ -0,0 +1,258 @@
+;   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]
+  (.replace s (js/RegExp. (.-source re) "g") 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)."
+  [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)."
+  [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]
+  (if (< (count s) 2)
+    (upper-case s)
+    (str (upper-case (subs s 0 1))
+         (lower-case (subs s 1)))))
+
+;; 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))

resources/public/js/compiled/out/clojure/string.js

@@ -0,0 +1,505 @@
+// Compiled by ClojureScript 1.9.229 {}
+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){
+return s.replace((new RegExp(re.source,"g")),replacement);
+});
+clojure.string.replace_with = (function clojure$string$replace_with(f){
+return (function() { 
+var G__38949__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__38949 = function (var_args){
+var args = null;
+if (arguments.length > 0) {
+var G__38950__i = 0, G__38950__a = new Array(arguments.length -  0);
+while (G__38950__i < G__38950__a.length) {G__38950__a[G__38950__i] = arguments[G__38950__i + 0]; ++G__38950__i;}
+  args = new cljs.core.IndexedSeq(G__38950__a,0);
+} 
+return G__38949__delegate.call(this,args);};
+G__38949.cljs$lang$maxFixedArity = 0;
+G__38949.cljs$lang$applyTo = (function (arglist__38951){
+var args = cljs.core.seq(arglist__38951);
+return G__38949__delegate(args);
+});
+G__38949.cljs$core$IFn$_invoke$arity$variadic = G__38949__delegate;
+return G__38949;
+})()
+;
+});
+/**
+ * Replaces all instance of match with replacement in s.
+ * match/replacement can be:
+ * 
+ * string / string
+ * pattern / (string or function of match).
+ */
+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 [cljs.core.str("Invalid match arg: "),cljs.core.str(match)].join('');
+
+}
+}
+});
+/**
+ * Replaces the first instance of match with replacement in s.
+ * match/replacement can be:
+ * 
+ * string / string
+ * pattern / (string or function of match).
+ */
+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 args38952 = [];
+var len__26205__auto___38955 = arguments.length;
+var i__26206__auto___38956 = (0);
+while(true){
+if((i__26206__auto___38956 < len__26205__auto___38955)){
+args38952.push((arguments[i__26206__auto___38956]));
+
+var G__38957 = (i__26206__auto___38956 + (1));
+i__26206__auto___38956 = G__38957;
+continue;
+} else {
+}
+break;
+}
+
+var G__38954 = args38952.length;
+switch (G__38954) {
+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([cljs.core.str("Invalid arity: "),cljs.core.str(args38952.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__38959 = sb.append([cljs.core.str(cljs.core.first.call(null,coll__$1))].join(''));
+var G__38960 = cljs.core.next.call(null,coll__$1);
+sb = G__38959;
+coll__$1 = G__38960;
+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.first.call(null,coll__$1))].join(''));
+
+var coll__$2 = cljs.core.next.call(null,coll__$1);
+if((coll__$2 == null)){
+} else {
+sb.append(separator);
+}
+
+var G__38961 = sb;
+var G__38962 = coll__$2;
+sb = G__38961;
+coll__$1 = G__38962;
+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){
+if((cljs.core.count.call(null,s) < (2))){
+return clojure.string.upper_case.call(null,s);
+} else {
+return [cljs.core.str(clojure.string.upper_case.call(null,cljs.core.subs.call(null,s,(0),(1)))),cljs.core.str(clojure.string.lower_case.call(null,cljs.core.subs.call(null,s,(1))))].join('');
+}
+});
+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__38963 = cljs.core.pop.call(null,v__$1);
+v__$1 = G__38963;
+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__38967 = cljs.core._EQ__EQ_;
+var expr__38968 = limit;
+if(cljs.core.truth_(pred__38967.call(null,(1),expr__38968))){
+return (new cljs.core.PersistentVector(null,1,(5),cljs.core.PersistentVector.EMPTY_NODE,[s],null));
+} else {
+if(cljs.core.truth_(pred__38967.call(null,(2),expr__38968))){
+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 args38970 = [];
+var len__26205__auto___38973 = arguments.length;
+var i__26206__auto___38974 = (0);
+while(true){
+if((i__26206__auto___38974 < len__26205__auto___38973)){
+args38970.push((arguments[i__26206__auto___38974]));
+
+var G__38975 = (i__26206__auto___38974 + (1));
+i__26206__auto___38974 = G__38975;
+continue;
+} else {
+}
+break;
+}
+
+var G__38972 = args38970.length;
+switch (G__38972) {
+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([cljs.core.str("Invalid arity: "),cljs.core.str(args38970.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(re)].join('')))?clojure.string.split_with_empty_regex.call(null,s,limit):(((limit < (1)))?cljs.core.vec.call(null,[cljs.core.str(s)].join('').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__38977 = s__$1.substring((index + cljs.core.count.call(null,m)));
+var G__38978 = (limit__$1 - (1));
+var G__38979 = cljs.core.conj.call(null,parts,s__$1.substring((0),index));
+s__$1 = G__38977;
+limit__$1 = G__38978;
+parts = G__38979;
+continue;
+} else {
+return cljs.core.conj.call(null,parts,s__$1);
+}
+}
+break;
+}
+})())));
+});
+
+clojure.string.split.cljs$lang$maxFixedArity = 3;
+
+/**
+ * Splits s on 
+ *  or 
+ * .
+ */
+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__38980 = (index - (1));
+index = G__38980;
+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(replacement)].join(''));
+} else {
+buffer.append(ch);
+}
+
+var G__38981 = (index + (1));
+index = G__38981;
+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 args38982 = [];
+var len__26205__auto___38985 = arguments.length;
+var i__26206__auto___38986 = (0);
+while(true){
+if((i__26206__auto___38986 < len__26205__auto___38985)){
+args38982.push((arguments[i__26206__auto___38986]));
+
+var G__38987 = (i__26206__auto___38986 + (1));
+i__26206__auto___38986 = G__38987;
+continue;
+} else {
+}
+break;
+}
+
+var G__38984 = args38982.length;
+switch (G__38984) {
+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([cljs.core.str("Invalid arity: "),cljs.core.str(args38982.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 args38989 = [];
+var len__26205__auto___38992 = arguments.length;
+var i__26206__auto___38993 = (0);
+while(true){
+if((i__26206__auto___38993 < len__26205__auto___38992)){
+args38989.push((arguments[i__26206__auto___38993]));
+
+var G__38994 = (i__26206__auto___38993 + (1));
+i__26206__auto___38993 = G__38994;
+continue;
+} else {
+}
+break;
+}
+
+var G__38991 = args38989.length;
+switch (G__38991) {
+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([cljs.core.str("Invalid arity: "),cljs.core.str(args38989.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?rel=1603199207238

resources/public/js/compiled/out/clojure/walk.cljs

@@ -0,0 +1,96 @@
+;   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.
+
+;;; walk.cljs - generic tree walker with replacement
+
+;; by Stuart Sierra
+;; Jul5 17, 2011
+
+;; CHANGE LOG:
+;;
+;; * July 17, 2011: Port to ClojureScript
+;; 
+;; * December 15, 2008: replaced 'walk' with 'prewalk' & 'postwalk'
+;;
+;; * December 9, 2008: first version
+
+
+(ns 
+  ^{:author "Stuart Sierra",
+     :doc "This file defines a generic tree walker for Clojure data
+structures.  It takes any data structure (list, vector, map, set,
+seq), calls a function on every element, and uses the return value
+of the function in place of the original.  This makes it fairly
+easy to write recursive search-and-replace functions, as shown in
+the examples.
+
+Note: \"walk\" supports all Clojure data structures EXCEPT maps
+created with sorted-map-by.  There is no (obvious) way to retrieve
+the sorting function."}
+  clojure.walk)
+
+(defn walk
+  "Traverses form, an arbitrary data structure.  inner and outer are
+  functions.  Applies inner to each element of form, building up a
+  data structure of the same type, then applies outer to the result.
+  Recognizes all Clojure data structures. Consumes seqs as with doall."
+
+  {:added "1.1"}
+  [inner outer form]
+  (cond
+    (list? form)   (outer (apply list (map inner form)))
+    (seq? form)    (outer (doall (map inner form)))
+    (record? form) (outer (reduce (fn [r x] (conj r (inner x))) form form))
+    (coll? form)   (outer (into (empty form) (map inner form)))
+    :else          (outer form)))
+
+(defn postwalk
+  "Performs a depth-first, post-order traversal of form.  Calls f on
+  each sub-form, uses f's return value in place of the original.
+  Recognizes all Clojure data structures. Consumes seqs as with doall."
+  {:added "1.1"}
+  [f form]
+  (walk (partial postwalk f) f form))
+
+(defn prewalk
+  "Like postwalk, but does pre-order traversal."
+  {:added "1.1"}
+  [f form]
+  (walk (partial prewalk f) identity (f form)))
+
+(defn keywordize-keys
+  "Recursively transforms all map keys from strings to keywords."
+  {:added "1.1"}
+  [m]
+  (let [f (fn [[k v]] (if (string? k) [(keyword k) v] [k v]))]
+    ;; only apply to maps
+    (postwalk (fn [x] (if (map? x) (into {} (map f x)) x)) m)))
+
+(defn stringify-keys
+  "Recursively transforms all map keys from keywords to strings."
+  {:added "1.1"}
+  [m]
+  (let [f (fn [[k v]] (if (keyword? k) [(name k) v] [k v]))]
+    ;; only apply to maps
+    (postwalk (fn [x] (if (map? x) (into {} (map f x)) x)) m)))
+
+(defn prewalk-replace
+  "Recursively transforms form by replacing keys in smap with their
+  values.  Like clojure/replace but works on any data structure.  Does
+  replacement at the root of the tree first."
+  {:added "1.1"}
+  [smap form]
+  (prewalk (fn [x] (if (contains? smap x) (smap x) x)) form))
+
+(defn postwalk-replace
+  "Recursively transforms form by replacing keys in smap with their
+  values.  Like clojure/replace but works on any data structure.  Does
+  replacement at the leaves of the tree first."
+  {:added "1.1"}
+  [smap form]
+  (postwalk (fn [x] (if (contains? smap x) (smap x) x)) form))

resources/public/js/compiled/out/clojure/walk.js

@@ -0,0 +1,123 @@
+// Compiled by ClojureScript 1.9.229 {}
+goog.provide('clojure.walk');
+goog.require('cljs.core');
+/**
+ * Traverses form, an arbitrary data structure.  inner and outer are
+ *   functions.  Applies inner to each element of form, building up a
+ *   data structure of the same type, then applies outer to the result.
+ *   Recognizes all Clojure data structures. Consumes seqs as with doall.
+ */
+clojure.walk.walk = (function clojure$walk$walk(inner,outer,form){
+if(cljs.core.list_QMARK_.call(null,form)){
+return outer.call(null,cljs.core.apply.call(null,cljs.core.list,cljs.core.map.call(null,inner,form)));
+} else {
+if(cljs.core.seq_QMARK_.call(null,form)){
+return outer.call(null,cljs.core.doall.call(null,cljs.core.map.call(null,inner,form)));
+} else {
+if(cljs.core.record_QMARK_.call(null,form)){
+return outer.call(null,cljs.core.reduce.call(null,(function (r,x){
+return cljs.core.conj.call(null,r,inner.call(null,x));
+}),form,form));
+} else {
+if(cljs.core.coll_QMARK_.call(null,form)){
+return outer.call(null,cljs.core.into.call(null,cljs.core.empty.call(null,form),cljs.core.map.call(null,inner,form)));
+} else {
+return outer.call(null,form);
+
+}
+}
+}
+}
+});
+/**
+ * Performs a depth-first, post-order traversal of form.  Calls f on
+ *   each sub-form, uses f's return value in place of the original.
+ *   Recognizes all Clojure data structures. Consumes seqs as with doall.
+ */
+clojure.walk.postwalk = (function clojure$walk$postwalk(f,form){
+return clojure.walk.walk.call(null,cljs.core.partial.call(null,clojure$walk$postwalk,f),f,form);
+});
+/**
+ * Like postwalk, but does pre-order traversal.
+ */
+clojure.walk.prewalk = (function clojure$walk$prewalk(f,form){
+return clojure.walk.walk.call(null,cljs.core.partial.call(null,clojure$walk$prewalk,f),cljs.core.identity,f.call(null,form));
+});
+/**
+ * Recursively transforms all map keys from strings to keywords.
+ */
+clojure.walk.keywordize_keys = (function clojure$walk$keywordize_keys(m){
+var f = (function (p__41442){
+var vec__41443 = p__41442;
+var k = cljs.core.nth.call(null,vec__41443,(0),null);
+var v = cljs.core.nth.call(null,vec__41443,(1),null);
+if(typeof k === 'string'){
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.call(null,k),v], null);
+} else {
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [k,v], null);
+}
+});
+return clojure.walk.postwalk.call(null,((function (f){
+return (function (x){
+if(cljs.core.map_QMARK_.call(null,x)){
+return cljs.core.into.call(null,cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.call(null,f,x));
+} else {
+return x;
+}
+});})(f))
+,m);
+});
+/**
+ * Recursively transforms all map keys from keywords to strings.
+ */
+clojure.walk.stringify_keys = (function clojure$walk$stringify_keys(m){
+var f = (function (p__41450){
+var vec__41451 = p__41450;
+var k = cljs.core.nth.call(null,vec__41451,(0),null);
+var v = cljs.core.nth.call(null,vec__41451,(1),null);
+if((k instanceof cljs.core.Keyword)){
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.name.call(null,k),v], null);
+} else {
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [k,v], null);
+}
+});
+return clojure.walk.postwalk.call(null,((function (f){
+return (function (x){
+if(cljs.core.map_QMARK_.call(null,x)){
+return cljs.core.into.call(null,cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.call(null,f,x));
+} else {
+return x;
+}
+});})(f))
+,m);
+});
+/**
+ * Recursively transforms form by replacing keys in smap with their
+ *   values.  Like clojure/replace but works on any data structure.  Does
+ *   replacement at the root of the tree first.
+ */
+clojure.walk.prewalk_replace = (function clojure$walk$prewalk_replace(smap,form){
+return clojure.walk.prewalk.call(null,(function (x){
+if(cljs.core.contains_QMARK_.call(null,smap,x)){
+return smap.call(null,x);
+} else {
+return x;
+}
+}),form);
+});
+/**
+ * Recursively transforms form by replacing keys in smap with their
+ *   values.  Like clojure/replace but works on any data structure.  Does
+ *   replacement at the leaves of the tree first.
+ */
+clojure.walk.postwalk_replace = (function clojure$walk$postwalk_replace(smap,form){
+return clojure.walk.postwalk.call(null,(function (x){
+if(cljs.core.contains_QMARK_.call(null,smap,x)){
+return smap.call(null,x);
+} else {
+return x;
+}
+}),form);
+});
+
+//# sourceMappingURL=walk.js.map?rel=1603199212448

resources/public/js/compiled/out/clojure/walk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"\/Users\/simon\/workspace\/swinging-needle-meter\/docs\/js\/compiled\/out\/clojure\/walk.js","sources":["walk.cljs?rel=1603199212449"],"lineCount":123,"mappings":";AAsBA;;AAcA;;;;;;oBAAA,pBAAMA,gDAOHC,MAAMC,MAAMC;AAPf,AAQE,GACE,AAACC,gCAAMD;AAAQ,OAACD,gBAAM,AAACG,0BAAMC,eAAK,AAACC,wBAAIN,MAAME;;AAD\/C,GAEE,AAACK,+BAAKL;AAAS,OAACD,gBAAM,AAACO,0BAAM,AAACF,wBAAIN,MAAME;;AAF1C,GAGE,AAACO,kCAAQP;AAAM,OAACD,gBAAM,AAACS,2BAAO,WAAKC,EAAEC;AAAP,AAAU,OAACC,yBAAKF,EAAE,AAACX,gBAAMY;GAAKV,KAAKA;;AAHnE,GAIE,AAACY,gCAAMZ;AAAQ,OAACD,gBAAM,AAACc,yBAAK,AAACC,0BAAMd,MAAM,AAACI,wBAAIN,MAAME;;AAJtD,AAKiB,OAACD,gBAAMC;;;;;;;AAE1B;;;;;wBAAA,xBAAMe,wDAKHC,EAAEhB;AALL,AAME,OAACH,4BAAK,AAACoB,4BAAQC,sBAASF,GAAGA,EAAEhB;;AAE\/B;;;uBAAA,vBAAMmB,sDAGHH,EAAEhB;AAHL,AAIE,OAACH,4BAAK,AAACoB,4BAAQG,qBAAQJ,GAAGK,mBAAS,AAACL,YAAEhB;;AAExC;;;+BAAA,\/BAAMsB,sEAGHC;AAHH,AAIE,IAAMP,IAAE,WAAAQ;AAAA,AAAA,IAAAC,aAAAD;QAAA,AAAAE,wBAAAD,WAAA,IAAA,3CAAME;QAAN,AAAAD,wBAAAD,WAAA,IAAA,3CAAQG;AAAR,AAAY,GAAI,OAASD;AAAb,0FAAiB,AAACE,4BAAQF,GAAGC;;AAA7B,0FAAiCD,EAAEC;;;AAAvD,AAEE,OAACb,gCAAS;kBAAKL;AAAL,AAAQ,GAAI,AAACoB,+BAAKpB;AAAG,gCAAA,zBAACG,4DAAQ,AAACT,wBAAIY,EAAEN;;AAAIA;;;CAAIa;;AAE3D;;;8BAAA,9BAAMQ,oEAGHR;AAHH,AAIE,IAAMP,IAAE,WAAAgB;AAAA,AAAA,IAAAC,aAAAD;QAAA,AAAAN,wBAAAO,WAAA,IAAA,3CAAMN;QAAN,AAAAD,wBAAAO,WAAA,IAAA,3CAAQL;AAAR,AAAY,GAAI,cAAAM,bAAUP;AAAd,0FAAkB,AAACQ,yBAAKR,GAAGC;;AAA3B,0FAA+BD,EAAEC;;;AAArD,AAEE,OAACb,gCAAS;kBAAKL;AAAL,AAAQ,GAAI,AAACoB,+BAAKpB;AAAG,gCAAA,zBAACG,4DAAQ,AAACT,wBAAIY,EAAEN;;AAAIA;;;CAAIa;;AAE3D;;;;;+BAAA,\/BAAMa,sEAKHC,KAAKrC;AALR,AAME,OAACmB,+BAAQ,WAAKT;AAAL,AAAQ,GAAI,AAAC4B,oCAAUD,KAAK3B;AAAG,OAAC2B,eAAK3B;;AAAGA;;GAAIV;;AAEvD;;;;;gCAAA,hCAAMuC,wEAKHF,KAAKrC;AALR,AAME,OAACe,gCAAS,WAAKL;AAAL,AAAQ,GAAI,AAAC4B,oCAAUD,KAAK3B;AAAG,OAAC2B,eAAK3B;;AAAGA;;GAAIV","names":["clojure.walk\/walk","inner","outer","form","cljs.core\/list?","cljs.core\/apply","cljs.core\/list","cljs.core\/map","cljs.core\/seq?","cljs.core\/doall","cljs.core\/record?","cljs.core\/reduce","r","x","cljs.core\/conj","cljs.core\/coll?","cljs.core\/into","cljs.core\/empty","clojure.walk\/postwalk","f","cljs.core\/partial","postwalk","clojure.walk\/prewalk","prewalk","cljs.core\/identity","clojure.walk\/keywordize-keys","m","p__41442","vec__41443","cljs.core\/nth","k","v","cljs.core\/keyword","cljs.core\/map?","clojure.walk\/stringify-keys","p__41450","vec__41451","cljs.core\/Keyword","cljs.core\/name","clojure.walk\/prewalk-replace","smap","cljs.core\/contains?","clojure.walk\/postwalk-replace"]}