datahike 0.7.1630

package/medley.core.js

@@ -0,0 +1,1857 @@
+var $CLJS = require("./cljs_env");
+var $jscomp = $CLJS.$jscomp;
+var COMPILED = false;
+require("./cljs.core.js");
+var environ=$CLJS.environ || ($CLJS.environ = {});
+var fress=$CLJS.fress || ($CLJS.fress = {});
+var datahike=$CLJS.datahike || ($CLJS.datahike = {});
+var clojure=$CLJS.clojure || ($CLJS.clojure = {});
+var hasch=$CLJS.hasch || ($CLJS.hasch = {});
+var tailrecursion=$CLJS.tailrecursion || ($CLJS.tailrecursion = {});
+var superv=$CLJS.superv || ($CLJS.superv = {});
+var geheimnis=$CLJS.geheimnis || ($CLJS.geheimnis = {});
+var is=$CLJS.is || ($CLJS.is = {});
+var cljs=$CLJS.cljs || ($CLJS.cljs = {});
+var cljs_node_io=$CLJS.cljs_node_io || ($CLJS.cljs_node_io = {});
+var goog=$CLJS.goog || ($CLJS.goog = {});
+var konserve=$CLJS.konserve || ($CLJS.konserve = {});
+var datalog=$CLJS.datalog || ($CLJS.datalog = {});
+var spec_tools=$CLJS.spec_tools || ($CLJS.spec_tools = {});
+var taoensso=$CLJS.taoensso || ($CLJS.taoensso = {});
+var incognito=$CLJS.incognito || ($CLJS.incognito = {});
+var medley=$CLJS.medley || ($CLJS.medley = {});
+var me=$CLJS.me || ($CLJS.me = {});
+
+$CLJS.SHADOW_ENV.setLoaded("medley.core.js");
+
+goog.provide('medley.core');
+/**
+ * Finds the first item in a collection that matches a predicate. Returns a
+ *   transducer when no collection is provided.
+ */
+medley.core.find_first = (function medley$core$find_first(var_args){
+var G__105598 = arguments.length;
+switch (G__105598) {
+case 1:
+return medley.core.find_first.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
+
+break;
+case 2:
+return medley.core.find_first.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('')));
+
+}
+});
+
+(medley.core.find_first.cljs$core$IFn$_invoke$arity$1 = (function (pred){
+return (function (rf){
+return (function() {
+var G__105866 = null;
+var G__105866__0 = (function (){
+return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));
+});
+var G__105866__1 = (function (result){
+return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));
+});
+var G__105866__2 = (function (result,x){
+if(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(x) : pred.call(null, x)))){
+return cljs.core.ensure_reduced((rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,x) : rf.call(null, result,x)));
+} else {
+return result;
+}
+});
+G__105866 = function(result,x){
+switch(arguments.length){
+case 0:
+return G__105866__0.call(this);
+case 1:
+return G__105866__1.call(this,result);
+case 2:
+return G__105866__2.call(this,result,x);
+}
+throw(new Error('Invalid arity: ' + arguments.length));
+};
+G__105866.cljs$core$IFn$_invoke$arity$0 = G__105866__0;
+G__105866.cljs$core$IFn$_invoke$arity$1 = G__105866__1;
+G__105866.cljs$core$IFn$_invoke$arity$2 = G__105866__2;
+return G__105866;
+})()
+});
+}));
+
+(medley.core.find_first.cljs$core$IFn$_invoke$arity$2 = (function (pred,coll){
+return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (_,x){
+if(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(x) : pred.call(null, x)))){
+return cljs.core.reduced(x);
+} else {
+return null;
+}
+}),null,coll);
+}));
+
+(medley.core.find_first.cljs$lang$maxFixedArity = 2);
+
+/**
+ * Dissociate a value in a nested associative structure, identified by a sequence
+ *   of keys. Any collections left empty by the operation will be dissociated from
+ *   their containing structures.
+ */
+medley.core.dissoc_in = (function medley$core$dissoc_in(var_args){
+var G__105603 = arguments.length;
+switch (G__105603) {
+case 2:
+return medley.core.dissoc_in.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
+
+break;
+default:
+var args_arr__5751__auto__ = [];
+var len__5726__auto___105870 = arguments.length;
+var i__5727__auto___105871 = (0);
+while(true){
+if((i__5727__auto___105871 < len__5726__auto___105870)){
+args_arr__5751__auto__.push((arguments[i__5727__auto___105871]));
+
+var G__105872 = (i__5727__auto___105871 + (1));
+i__5727__auto___105871 = G__105872;
+continue;
+} else {
+}
+break;
+}
+
+var argseq__5752__auto__ = ((((2) < args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);
+return medley.core.dissoc_in.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);
+
+}
+});
+
+(medley.core.dissoc_in.cljs$core$IFn$_invoke$arity$2 = (function (m,ks){
+var temp__5802__auto__ = cljs.core.seq(ks);
+if(temp__5802__auto__){
+var vec__105604 = temp__5802__auto__;
+var seq__105605 = cljs.core.seq(vec__105604);
+var first__105606 = cljs.core.first(seq__105605);
+var seq__105605__$1 = cljs.core.next(seq__105605);
+var k = first__105606;
+var ks__$1 = seq__105605__$1;
+if(cljs.core.seq(ks__$1)){
+var v = medley.core.dissoc_in.cljs$core$IFn$_invoke$arity$2(cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k),ks__$1);
+if(cljs.core.empty_QMARK_(v)){
+return cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(m,k);
+} else {
+return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,v);
+}
+} else {
+return cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(m,k);
+}
+} else {
+return m;
+}
+}));
+
+(medley.core.dissoc_in.cljs$core$IFn$_invoke$arity$variadic = (function (m,ks,kss){
+while(true){
+var temp__5802__auto__ = cljs.core.seq(kss);
+if(temp__5802__auto__){
+var vec__105607 = temp__5802__auto__;
+var seq__105608 = cljs.core.seq(vec__105607);
+var first__105609 = cljs.core.first(seq__105608);
+var seq__105608__$1 = cljs.core.next(seq__105608);
+var ks_SINGLEQUOTE_ = first__105609;
+var kss__$1 = seq__105608__$1;
+var G__105875 = medley.core.dissoc_in.cljs$core$IFn$_invoke$arity$2(m,ks);
+var G__105876 = ks_SINGLEQUOTE_;
+var G__105877 = kss__$1;
+m = G__105875;
+ks = G__105876;
+kss = G__105877;
+continue;
+} else {
+return medley.core.dissoc_in.cljs$core$IFn$_invoke$arity$2(m,ks);
+}
+break;
+}
+}));
+
+/** @this {Function} */
+(medley.core.dissoc_in.cljs$lang$applyTo = (function (seq105600){
+var G__105601 = cljs.core.first(seq105600);
+var seq105600__$1 = cljs.core.next(seq105600);
+var G__105602 = cljs.core.first(seq105600__$1);
+var seq105600__$2 = cljs.core.next(seq105600__$1);
+var self__5711__auto__ = this;
+return self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__105601,G__105602,seq105600__$2);
+}));
+
+(medley.core.dissoc_in.cljs$lang$maxFixedArity = (2));
+
+/**
+ * Associates a key k, with a value v in a map m, if and only if v is not nil.
+ */
+medley.core.assoc_some = (function medley$core$assoc_some(var_args){
+var G__105624 = arguments.length;
+switch (G__105624) {
+case 3:
+return medley.core.assoc_some.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));
+
+break;
+default:
+var args_arr__5751__auto__ = [];
+var len__5726__auto___105880 = arguments.length;
+var i__5727__auto___105881 = (0);
+while(true){
+if((i__5727__auto___105881 < len__5726__auto___105880)){
+args_arr__5751__auto__.push((arguments[i__5727__auto___105881]));
+
+var G__105882 = (i__5727__auto___105881 + (1));
+i__5727__auto___105881 = G__105882;
+continue;
+} else {
+}
+break;
+}
+
+var argseq__5752__auto__ = ((((3) < args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((3)),(0),null)):null);
+return medley.core.assoc_some.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__5752__auto__);
+
+}
+});
+
+(medley.core.assoc_some.cljs$core$IFn$_invoke$arity$3 = (function (m,k,v){
+if((v == null)){
+return m;
+} else {
+return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,v);
+}
+}));
+
+(medley.core.assoc_some.cljs$core$IFn$_invoke$arity$variadic = (function (m,k,v,kvs){
+return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (m__$1,p__105629){
+var vec__105630 = p__105629;
+var k__$1 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__105630,(0),null);
+var v__$1 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__105630,(1),null);
+return medley.core.assoc_some.cljs$core$IFn$_invoke$arity$3(m__$1,k__$1,v__$1);
+}),medley.core.assoc_some.cljs$core$IFn$_invoke$arity$3(m,k,v),cljs.core.partition.cljs$core$IFn$_invoke$arity$2((2),kvs));
+}));
+
+/** @this {Function} */
+(medley.core.assoc_some.cljs$lang$applyTo = (function (seq105620){
+var G__105621 = cljs.core.first(seq105620);
+var seq105620__$1 = cljs.core.next(seq105620);
+var G__105622 = cljs.core.first(seq105620__$1);
+var seq105620__$2 = cljs.core.next(seq105620__$1);
+var G__105623 = cljs.core.first(seq105620__$2);
+var seq105620__$3 = cljs.core.next(seq105620__$2);
+var self__5711__auto__ = this;
+return self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__105621,G__105622,G__105623,seq105620__$3);
+}));
+
+(medley.core.assoc_some.cljs$lang$maxFixedArity = (3));
+
+/**
+ * Updates a value in a map given a key and a function, if and only if the key
+ *   exists in the map. See: `clojure.core/update`.
+ */
+medley.core.update_existing = (function medley$core$update_existing(var_args){
+var G__105645 = arguments.length;
+switch (G__105645) {
+case 3:
+return medley.core.update_existing.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));
+
+break;
+case 4:
+return medley.core.update_existing.cljs$core$IFn$_invoke$arity$4((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]));
+
+break;
+case 5:
+return medley.core.update_existing.cljs$core$IFn$_invoke$arity$5((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]));
+
+break;
+case 6:
+return medley.core.update_existing.cljs$core$IFn$_invoke$arity$6((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]));
+
+break;
+default:
+var args_arr__5751__auto__ = [];
+var len__5726__auto___105886 = arguments.length;
+var i__5727__auto___105887 = (0);
+while(true){
+if((i__5727__auto___105887 < len__5726__auto___105886)){
+args_arr__5751__auto__.push((arguments[i__5727__auto___105887]));
+
+var G__105889 = (i__5727__auto___105887 + (1));
+i__5727__auto___105887 = G__105889;
+continue;
+} else {
+}
+break;
+}
+
+var argseq__5752__auto__ = ((((6) < args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((6)),(0),null)):null);
+return medley.core.update_existing.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),(arguments[(3)]),(arguments[(4)]),(arguments[(5)]),argseq__5752__auto__);
+
+}
+});
+
+(medley.core.update_existing.cljs$core$IFn$_invoke$arity$3 = (function (m,k,f){
+var temp__5802__auto__ = cljs.core.find(m,k);
+if(cljs.core.truth_(temp__5802__auto__)){
+var kv = temp__5802__auto__;
+return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__105646 = cljs.core.val(kv);
+return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__105646) : f.call(null, G__105646));
+})());
+} else {
+return m;
+}
+}));
+
+(medley.core.update_existing.cljs$core$IFn$_invoke$arity$4 = (function (m,k,f,x){
+var temp__5802__auto__ = cljs.core.find(m,k);
+if(cljs.core.truth_(temp__5802__auto__)){
+var kv = temp__5802__auto__;
+return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__105647 = cljs.core.val(kv);
+var G__105648 = x;
+return (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(G__105647,G__105648) : f.call(null, G__105647,G__105648));
+})());
+} else {
+return m;
+}
+}));
+
+(medley.core.update_existing.cljs$core$IFn$_invoke$arity$5 = (function (m,k,f,x,y){
+var temp__5802__auto__ = cljs.core.find(m,k);
+if(cljs.core.truth_(temp__5802__auto__)){
+var kv = temp__5802__auto__;
+return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__105649 = cljs.core.val(kv);
+var G__105650 = x;
+var G__105651 = y;
+return (f.cljs$core$IFn$_invoke$arity$3 ? f.cljs$core$IFn$_invoke$arity$3(G__105649,G__105650,G__105651) : f.call(null, G__105649,G__105650,G__105651));
+})());
+} else {
+return m;
+}
+}));
+
+(medley.core.update_existing.cljs$core$IFn$_invoke$arity$6 = (function (m,k,f,x,y,z){
+var temp__5802__auto__ = cljs.core.find(m,k);
+if(cljs.core.truth_(temp__5802__auto__)){
+var kv = temp__5802__auto__;
+return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var G__105652 = cljs.core.val(kv);
+var G__105653 = x;
+var G__105654 = y;
+var G__105655 = z;
+return (f.cljs$core$IFn$_invoke$arity$4 ? f.cljs$core$IFn$_invoke$arity$4(G__105652,G__105653,G__105654,G__105655) : f.call(null, G__105652,G__105653,G__105654,G__105655));
+})());
+} else {
+return m;
+}
+}));
+
+(medley.core.update_existing.cljs$core$IFn$_invoke$arity$variadic = (function (m,k,f,x,y,z,more){
+var temp__5802__auto__ = cljs.core.find(m,k);
+if(cljs.core.truth_(temp__5802__auto__)){
+var kv = temp__5802__auto__;
+return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,cljs.core.apply.cljs$core$IFn$_invoke$arity$variadic(f,cljs.core.val(kv),x,y,z,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([more], 0)));
+} else {
+return m;
+}
+}));
+
+/** @this {Function} */
+(medley.core.update_existing.cljs$lang$applyTo = (function (seq105638){
+var G__105639 = cljs.core.first(seq105638);
+var seq105638__$1 = cljs.core.next(seq105638);
+var G__105640 = cljs.core.first(seq105638__$1);
+var seq105638__$2 = cljs.core.next(seq105638__$1);
+var G__105641 = cljs.core.first(seq105638__$2);
+var seq105638__$3 = cljs.core.next(seq105638__$2);
+var G__105642 = cljs.core.first(seq105638__$3);
+var seq105638__$4 = cljs.core.next(seq105638__$3);
+var G__105643 = cljs.core.first(seq105638__$4);
+var seq105638__$5 = cljs.core.next(seq105638__$4);
+var G__105644 = cljs.core.first(seq105638__$5);
+var seq105638__$6 = cljs.core.next(seq105638__$5);
+var self__5711__auto__ = this;
+return self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__105639,G__105640,G__105641,G__105642,G__105643,G__105644,seq105638__$6);
+}));
+
+(medley.core.update_existing.cljs$lang$maxFixedArity = (6));
+
+/**
+ * Updates a value in a nested associative structure, if and only if the key
+ *   path exists. See: `clojure.core/update-in`.
+ */
+medley.core.update_existing_in = (function medley$core$update_existing_in(var_args){
+var args__5732__auto__ = [];
+var len__5726__auto___105895 = arguments.length;
+var i__5727__auto___105896 = (0);
+while(true){
+if((i__5727__auto___105896 < len__5726__auto___105895)){
+args__5732__auto__.push((arguments[i__5727__auto___105896]));
+
+var G__105897 = (i__5727__auto___105896 + (1));
+i__5727__auto___105896 = G__105897;
+continue;
+} else {
+}
+break;
+}
+
+var argseq__5733__auto__ = ((((3) < args__5732__auto__.length))?(new cljs.core.IndexedSeq(args__5732__auto__.slice((3)),(0),null)):null);
+return medley.core.update_existing_in.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),(arguments[(2)]),argseq__5733__auto__);
+});
+
+(medley.core.update_existing_in.cljs$core$IFn$_invoke$arity$variadic = (function (m,ks,f,args){
+var up = (function medley$core$up(m__$1,ks__$1,f__$1,args__$1){
+var vec__105663 = ks__$1;
+var seq__105664 = cljs.core.seq(vec__105663);
+var first__105665 = cljs.core.first(seq__105664);
+var seq__105664__$1 = cljs.core.next(seq__105664);
+var k = first__105665;
+var ks__$2 = seq__105664__$1;
+var temp__5802__auto__ = cljs.core.find(m__$1,k);
+if(cljs.core.truth_(temp__5802__auto__)){
+var kv = temp__5802__auto__;
+if(ks__$2){
+return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m__$1,k,medley$core$up(cljs.core.val(kv),ks__$2,f__$1,args__$1));
+} else {
+return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m__$1,k,cljs.core.apply.cljs$core$IFn$_invoke$arity$3(f__$1,cljs.core.val(kv),args__$1));
+}
+} else {
+return m__$1;
+}
+});
+return up(m,ks,f,args);
+}));
+
+(medley.core.update_existing_in.cljs$lang$maxFixedArity = (3));
+
+/** @this {Function} */
+(medley.core.update_existing_in.cljs$lang$applyTo = (function (seq105658){
+var G__105659 = cljs.core.first(seq105658);
+var seq105658__$1 = cljs.core.next(seq105658);
+var G__105660 = cljs.core.first(seq105658__$1);
+var seq105658__$2 = cljs.core.next(seq105658__$1);
+var G__105661 = cljs.core.first(seq105658__$2);
+var seq105658__$3 = cljs.core.next(seq105658__$2);
+var self__5711__auto__ = this;
+return self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__105659,G__105660,G__105661,seq105658__$3);
+}));
+
+medley.core.editable_QMARK_ = (function medley$core$editable_QMARK_(coll){
+if((!((coll == null)))){
+if((((coll.cljs$lang$protocol_mask$partition1$ & (4))) || ((cljs.core.PROTOCOL_SENTINEL === coll.cljs$core$IEditableCollection$)))){
+return true;
+} else {
+if((!coll.cljs$lang$protocol_mask$partition1$)){
+return cljs.core.native_satisfies_QMARK_(cljs.core.IEditableCollection,coll);
+} else {
+return false;
+}
+}
+} else {
+return cljs.core.native_satisfies_QMARK_(cljs.core.IEditableCollection,coll);
+}
+});
+medley.core.reduce_map = (function medley$core$reduce_map(f,coll){
+var coll_SINGLEQUOTE_ = ((cljs.core.record_QMARK_(coll))?cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,coll):coll);
+if(medley.core.editable_QMARK_(coll_SINGLEQUOTE_)){
+return cljs.core.persistent_BANG_(cljs.core.reduce_kv((f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(cljs.core.assoc_BANG_) : f.call(null, cljs.core.assoc_BANG_)),cljs.core.transient$(cljs.core.empty(coll_SINGLEQUOTE_)),coll_SINGLEQUOTE_));
+} else {
+return cljs.core.reduce_kv((f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(cljs.core.assoc) : f.call(null, cljs.core.assoc)),cljs.core.empty(coll_SINGLEQUOTE_),coll_SINGLEQUOTE_);
+}
+});
+/**
+ * Create a map entry for a key and value pair.
+ */
+medley.core.map_entry = (function medley$core$map_entry(k,v){
+return (new cljs.core.MapEntry(k,v,null));
+});
+/**
+ * Maps a function over the key/value pairs of an associative collection. Expects
+ *   a function that takes two arguments, the key and value, and returns the new
+ *   key and value as a collection of two elements.
+ */
+medley.core.map_kv = (function medley$core$map_kv(f,coll){
+return medley.core.reduce_map((function (xf){
+return (function (m,k,v){
+var vec__105673 = (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(k,v) : f.call(null, k,v));
+var k__$1 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__105673,(0),null);
+var v__$1 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__105673,(1),null);
+return (xf.cljs$core$IFn$_invoke$arity$3 ? xf.cljs$core$IFn$_invoke$arity$3(m,k__$1,v__$1) : xf.call(null, m,k__$1,v__$1));
+});
+}),coll);
+});
+/**
+ * Maps a function over the keys of an associative collection.
+ */
+medley.core.map_keys = (function medley$core$map_keys(f,coll){
+return medley.core.reduce_map((function (xf){
+return (function (m,k,v){
+var G__105676 = m;
+var G__105677 = (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(k) : f.call(null, k));
+var G__105678 = v;
+return (xf.cljs$core$IFn$_invoke$arity$3 ? xf.cljs$core$IFn$_invoke$arity$3(G__105676,G__105677,G__105678) : xf.call(null, G__105676,G__105677,G__105678));
+});
+}),coll);
+});
+/**
+ * Maps a function over the values of one or more associative collections.
+ *   The function should accept number-of-colls arguments. Any keys which are not
+ *   shared among all collections are ignored.
+ */
+medley.core.map_vals = (function medley$core$map_vals(var_args){
+var G__105686 = arguments.length;
+switch (G__105686) {
+case 2:
+return medley.core.map_vals.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
+
+break;
+default:
+var args_arr__5751__auto__ = [];
+var len__5726__auto___105907 = arguments.length;
+var i__5727__auto___105909 = (0);
+while(true){
+if((i__5727__auto___105909 < len__5726__auto___105907)){
+args_arr__5751__auto__.push((arguments[i__5727__auto___105909]));
+
+var G__105910 = (i__5727__auto___105909 + (1));
+i__5727__auto___105909 = G__105910;
+continue;
+} else {
+}
+break;
+}
+
+var argseq__5752__auto__ = ((((2) < args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);
+return medley.core.map_vals.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);
+
+}
+});
+
+(medley.core.map_vals.cljs$core$IFn$_invoke$arity$2 = (function (f,coll){
+return medley.core.reduce_map((function (xf){
+return (function (m,k,v){
+var G__105687 = m;
+var G__105688 = k;
+var G__105689 = (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(v) : f.call(null, v));
+return (xf.cljs$core$IFn$_invoke$arity$3 ? xf.cljs$core$IFn$_invoke$arity$3(G__105687,G__105688,G__105689) : xf.call(null, G__105687,G__105688,G__105689));
+});
+}),coll);
+}));
+
+(medley.core.map_vals.cljs$core$IFn$_invoke$arity$variadic = (function (f,c1,colls){
+return medley.core.reduce_map((function (xf){
+return (function (m,k,v){
+if(cljs.core.every_QMARK_((function (p1__105679_SHARP_){
+return cljs.core.contains_QMARK_(p1__105679_SHARP_,k);
+}),colls)){
+var G__105690 = m;
+var G__105691 = k;
+var G__105692 = cljs.core.apply.cljs$core$IFn$_invoke$arity$3(f,v,cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__105680_SHARP_){
+return cljs.core.get.cljs$core$IFn$_invoke$arity$2(p1__105680_SHARP_,k);
+}),colls));
+return (xf.cljs$core$IFn$_invoke$arity$3 ? xf.cljs$core$IFn$_invoke$arity$3(G__105690,G__105691,G__105692) : xf.call(null, G__105690,G__105691,G__105692));
+} else {
+return m;
+}
+});
+}),c1);
+}));
+
+/** @this {Function} */
+(medley.core.map_vals.cljs$lang$applyTo = (function (seq105683){
+var G__105684 = cljs.core.first(seq105683);
+var seq105683__$1 = cljs.core.next(seq105683);
+var G__105685 = cljs.core.first(seq105683__$1);
+var seq105683__$2 = cljs.core.next(seq105683__$1);
+var self__5711__auto__ = this;
+return self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__105684,G__105685,seq105683__$2);
+}));
+
+(medley.core.map_vals.cljs$lang$maxFixedArity = (2));
+
+/**
+ * Maps a function over the key/value pairs of an associative collection, using
+ *   the return of the function as the new key.
+ */
+medley.core.map_kv_keys = (function medley$core$map_kv_keys(f,coll){
+return medley.core.reduce_map((function (xf){
+return (function (m,k,v){
+var G__105696 = m;
+var G__105697 = (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(k,v) : f.call(null, k,v));
+var G__105698 = v;
+return (xf.cljs$core$IFn$_invoke$arity$3 ? xf.cljs$core$IFn$_invoke$arity$3(G__105696,G__105697,G__105698) : xf.call(null, G__105696,G__105697,G__105698));
+});
+}),coll);
+});
+/**
+ * Maps a function over the key/value pairs of an associative collection, using
+ *   the return of the function as the new value.
+ */
+medley.core.map_kv_vals = (function medley$core$map_kv_vals(f,coll){
+return medley.core.reduce_map((function (xf){
+return (function (m,k,v){
+var G__105700 = m;
+var G__105701 = k;
+var G__105702 = (f.cljs$core$IFn$_invoke$arity$2 ? f.cljs$core$IFn$_invoke$arity$2(k,v) : f.call(null, k,v));
+return (xf.cljs$core$IFn$_invoke$arity$3 ? xf.cljs$core$IFn$_invoke$arity$3(G__105700,G__105701,G__105702) : xf.call(null, G__105700,G__105701,G__105702));
+});
+}),coll);
+});
+/**
+ * Returns a new associative collection of the items in coll for which
+ *   `(pred (key item) (val item))` returns true.
+ */
+medley.core.filter_kv = (function medley$core$filter_kv(pred,coll){
+return medley.core.reduce_map((function (xf){
+return (function (m,k,v){
+if(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$2 ? pred.cljs$core$IFn$_invoke$arity$2(k,v) : pred.call(null, k,v)))){
+return (xf.cljs$core$IFn$_invoke$arity$3 ? xf.cljs$core$IFn$_invoke$arity$3(m,k,v) : xf.call(null, m,k,v));
+} else {
+return m;
+}
+});
+}),coll);
+});
+/**
+ * Returns a new associative collection of the items in coll for which
+ *   `(pred (key item))` returns true.
+ */
+medley.core.filter_keys = (function medley$core$filter_keys(pred,coll){
+return medley.core.reduce_map((function (xf){
+return (function (m,k,v){
+if(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(k) : pred.call(null, k)))){
+return (xf.cljs$core$IFn$_invoke$arity$3 ? xf.cljs$core$IFn$_invoke$arity$3(m,k,v) : xf.call(null, m,k,v));
+} else {
+return m;
+}
+});
+}),coll);
+});
+/**
+ * Returns a new associative collection of the items in coll for which
+ *   `(pred (val item))` returns true.
+ */
+medley.core.filter_vals = (function medley$core$filter_vals(pred,coll){
+return medley.core.reduce_map((function (xf){
+return (function (m,k,v){
+if(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(v) : pred.call(null, v)))){
+return (xf.cljs$core$IFn$_invoke$arity$3 ? xf.cljs$core$IFn$_invoke$arity$3(m,k,v) : xf.call(null, m,k,v));
+} else {
+return m;
+}
+});
+}),coll);
+});
+/**
+ * Returns a new associative collection of the items in coll for which
+ *   `(pred (key item) (val item))` returns false.
+ */
+medley.core.remove_kv = (function medley$core$remove_kv(pred,coll){
+return medley.core.filter_kv(cljs.core.complement(pred),coll);
+});
+/**
+ * Returns a new associative collection of the items in coll for which
+ *   `(pred (key item))` returns false.
+ */
+medley.core.remove_keys = (function medley$core$remove_keys(pred,coll){
+return medley.core.filter_keys(cljs.core.complement(pred),coll);
+});
+/**
+ * Returns a new associative collection of the items in coll for which
+ *   `(pred (val item))` returns false.
+ */
+medley.core.remove_vals = (function medley$core$remove_vals(pred,coll){
+return medley.core.filter_vals(cljs.core.complement(pred),coll);
+});
+/**
+ * Creates an empty persistent queue, or one populated with a collection.
+ */
+medley.core.queue = (function medley$core$queue(var_args){
+var G__105705 = arguments.length;
+switch (G__105705) {
+case 0:
+return medley.core.queue.cljs$core$IFn$_invoke$arity$0();
+
+break;
+case 1:
+return medley.core.queue.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
+
+break;
+default:
+throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));
+
+}
+});
+
+(medley.core.queue.cljs$core$IFn$_invoke$arity$0 = (function (){
+return cljs.core.PersistentQueue.EMPTY;
+}));
+
+(medley.core.queue.cljs$core$IFn$_invoke$arity$1 = (function (coll){
+return cljs.core.into.cljs$core$IFn$_invoke$arity$2(medley.core.queue.cljs$core$IFn$_invoke$arity$0(),coll);
+}));
+
+(medley.core.queue.cljs$lang$maxFixedArity = 1);
+
+/**
+ * Returns true if x implements clojure.lang.PersistentQueue.
+ */
+medley.core.queue_QMARK_ = (function medley$core$queue_QMARK_(x){
+return (x instanceof cljs.core.PersistentQueue);
+});
+/**
+ * Returns true if x is a boolean.
+ */
+medley.core.boolean_QMARK_ = (function medley$core$boolean_QMARK_(x){
+return ((x === true) || (x === false));
+});
+/**
+ * Return the least argument (as defined by the compare function) in O(n) time.
+ */
+medley.core.least = (function medley$core$least(var_args){
+var G__105714 = arguments.length;
+switch (G__105714) {
+case 0:
+return medley.core.least.cljs$core$IFn$_invoke$arity$0();
+
+break;
+case 1:
+return medley.core.least.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
+
+break;
+case 2:
+return medley.core.least.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
+
+break;
+default:
+var args_arr__5751__auto__ = [];
+var len__5726__auto___105918 = arguments.length;
+var i__5727__auto___105919 = (0);
+while(true){
+if((i__5727__auto___105919 < len__5726__auto___105918)){
+args_arr__5751__auto__.push((arguments[i__5727__auto___105919]));
+
+var G__105920 = (i__5727__auto___105919 + (1));
+i__5727__auto___105919 = G__105920;
+continue;
+} else {
+}
+break;
+}
+
+var argseq__5752__auto__ = ((((2) < args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);
+return medley.core.least.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);
+
+}
+});
+
+(medley.core.least.cljs$core$IFn$_invoke$arity$0 = (function (){
+return null;
+}));
+
+(medley.core.least.cljs$core$IFn$_invoke$arity$1 = (function (a){
+return a;
+}));
+
+(medley.core.least.cljs$core$IFn$_invoke$arity$2 = (function (a,b){
+if((cljs.core.compare(a,b) < (0))){
+return a;
+} else {
+return b;
+}
+}));
+
+(medley.core.least.cljs$core$IFn$_invoke$arity$variadic = (function (a,b,more){
+return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(medley.core.least,medley.core.least.cljs$core$IFn$_invoke$arity$2(a,b),more);
+}));
+
+/** @this {Function} */
+(medley.core.least.cljs$lang$applyTo = (function (seq105711){
+var G__105712 = cljs.core.first(seq105711);
+var seq105711__$1 = cljs.core.next(seq105711);
+var G__105713 = cljs.core.first(seq105711__$1);
+var seq105711__$2 = cljs.core.next(seq105711__$1);
+var self__5711__auto__ = this;
+return self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__105712,G__105713,seq105711__$2);
+}));
+
+(medley.core.least.cljs$lang$maxFixedArity = (2));
+
+/**
+ * Find the greatest argument (as defined by the compare function) in O(n) time.
+ */
+medley.core.greatest = (function medley$core$greatest(var_args){
+var G__105719 = arguments.length;
+switch (G__105719) {
+case 0:
+return medley.core.greatest.cljs$core$IFn$_invoke$arity$0();
+
+break;
+case 1:
+return medley.core.greatest.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
+
+break;
+case 2:
+return medley.core.greatest.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
+
+break;
+default:
+var args_arr__5751__auto__ = [];
+var len__5726__auto___105922 = arguments.length;
+var i__5727__auto___105923 = (0);
+while(true){
+if((i__5727__auto___105923 < len__5726__auto___105922)){
+args_arr__5751__auto__.push((arguments[i__5727__auto___105923]));
+
+var G__105924 = (i__5727__auto___105923 + (1));
+i__5727__auto___105923 = G__105924;
+continue;
+} else {
+}
+break;
+}
+
+var argseq__5752__auto__ = ((((2) < args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);
+return medley.core.greatest.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);
+
+}
+});
+
+(medley.core.greatest.cljs$core$IFn$_invoke$arity$0 = (function (){
+return null;
+}));
+
+(medley.core.greatest.cljs$core$IFn$_invoke$arity$1 = (function (a){
+return a;
+}));
+
+(medley.core.greatest.cljs$core$IFn$_invoke$arity$2 = (function (a,b){
+if((cljs.core.compare(a,b) > (0))){
+return a;
+} else {
+return b;
+}
+}));
+
+(medley.core.greatest.cljs$core$IFn$_invoke$arity$variadic = (function (a,b,more){
+return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(medley.core.greatest,medley.core.greatest.cljs$core$IFn$_invoke$arity$2(a,b),more);
+}));
+
+/** @this {Function} */
+(medley.core.greatest.cljs$lang$applyTo = (function (seq105716){
+var G__105717 = cljs.core.first(seq105716);
+var seq105716__$1 = cljs.core.next(seq105716);
+var G__105718 = cljs.core.first(seq105716__$1);
+var seq105716__$2 = cljs.core.next(seq105716__$1);
+var self__5711__auto__ = this;
+return self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__105717,G__105718,seq105716__$2);
+}));
+
+(medley.core.greatest.cljs$lang$maxFixedArity = (2));
+
+/**
+ * Lazily concatenates a collection of collections into a flat sequence.
+ */
+medley.core.join = (function medley$core$join(colls){
+return (new cljs.core.LazySeq(null,(function (){
+var temp__5804__auto__ = cljs.core.seq(colls);
+if(temp__5804__auto__){
+var s = temp__5804__auto__;
+return cljs.core.concat.cljs$core$IFn$_invoke$arity$2(cljs.core.first(s),(function (){var G__105720 = cljs.core.rest(s);
+return (medley.core.join.cljs$core$IFn$_invoke$arity$1 ? medley.core.join.cljs$core$IFn$_invoke$arity$1(G__105720) : medley.core.join.call(null, G__105720));
+})());
+} else {
+return null;
+}
+}),null,null));
+});
+/**
+ * Recursively merges maps together. If all the maps supplied have nested maps
+ *   under the same keys, these nested maps are merged. Otherwise the value is
+ *   overwritten, as in `clojure.core/merge`.
+ */
+medley.core.deep_merge = (function medley$core$deep_merge(var_args){
+var G__105725 = arguments.length;
+switch (G__105725) {
+case 0:
+return medley.core.deep_merge.cljs$core$IFn$_invoke$arity$0();
+
+break;
+case 1:
+return medley.core.deep_merge.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
+
+break;
+case 2:
+return medley.core.deep_merge.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
+
+break;
+default:
+var args_arr__5751__auto__ = [];
+var len__5726__auto___105927 = arguments.length;
+var i__5727__auto___105928 = (0);
+while(true){
+if((i__5727__auto___105928 < len__5726__auto___105927)){
+args_arr__5751__auto__.push((arguments[i__5727__auto___105928]));
+
+var G__105929 = (i__5727__auto___105928 + (1));
+i__5727__auto___105928 = G__105929;
+continue;
+} else {
+}
+break;
+}
+
+var argseq__5752__auto__ = ((((2) < args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);
+return medley.core.deep_merge.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);
+
+}
+});
+
+(medley.core.deep_merge.cljs$core$IFn$_invoke$arity$0 = (function (){
+return null;
+}));
+
+(medley.core.deep_merge.cljs$core$IFn$_invoke$arity$1 = (function (a){
+return a;
+}));
+
+(medley.core.deep_merge.cljs$core$IFn$_invoke$arity$2 = (function (a,b){
+if(cljs.core.truth_((function (){var or__5002__auto__ = a;
+if(cljs.core.truth_(or__5002__auto__)){
+return or__5002__auto__;
+} else {
+return b;
+}
+})())){
+var merge_entry = (function medley$core$merge_entry(m,e){
+var k = cljs.core.key(e);
+var v_SINGLEQUOTE_ = cljs.core.val(e);
+if(cljs.core.contains_QMARK_(m,k)){
+return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,(function (){var v = cljs.core.get.cljs$core$IFn$_invoke$arity$2(m,k);
+if(((cljs.core.map_QMARK_(v)) && (cljs.core.map_QMARK_(v_SINGLEQUOTE_)))){
+return medley.core.deep_merge.cljs$core$IFn$_invoke$arity$2(v,v_SINGLEQUOTE_);
+} else {
+return v_SINGLEQUOTE_;
+}
+})());
+} else {
+return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,k,v_SINGLEQUOTE_);
+}
+});
+return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(merge_entry,(function (){var or__5002__auto__ = a;
+if(cljs.core.truth_(or__5002__auto__)){
+return or__5002__auto__;
+} else {
+return cljs.core.PersistentArrayMap.EMPTY;
+}
+})(),cljs.core.seq(b));
+} else {
+return null;
+}
+}));
+
+(medley.core.deep_merge.cljs$core$IFn$_invoke$arity$variadic = (function (a,b,more){
+return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(medley.core.deep_merge,(function (){var or__5002__auto__ = a;
+if(cljs.core.truth_(or__5002__auto__)){
+return or__5002__auto__;
+} else {
+return cljs.core.PersistentArrayMap.EMPTY;
+}
+})(),cljs.core.cons(b,more));
+}));
+
+/** @this {Function} */
+(medley.core.deep_merge.cljs$lang$applyTo = (function (seq105722){
+var G__105723 = cljs.core.first(seq105722);
+var seq105722__$1 = cljs.core.next(seq105722);
+var G__105724 = cljs.core.first(seq105722__$1);
+var seq105722__$2 = cljs.core.next(seq105722__$1);
+var self__5711__auto__ = this;
+return self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__105723,G__105724,seq105722__$2);
+}));
+
+(medley.core.deep_merge.cljs$lang$maxFixedArity = (2));
+
+/**
+ * Applies a function f to the argument list formed by concatenating
+ *   everything but the last element of args with the last element of
+ *   args. This is useful for applying a function that accepts keyword
+ *   arguments to a map.
+ */
+medley.core.mapply = (function medley$core$mapply(var_args){
+var G__105731 = arguments.length;
+switch (G__105731) {
+case 2:
+return medley.core.mapply.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
+
+break;
+default:
+var args_arr__5751__auto__ = [];
+var len__5726__auto___105935 = arguments.length;
+var i__5727__auto___105936 = (0);
+while(true){
+if((i__5727__auto___105936 < len__5726__auto___105935)){
+args_arr__5751__auto__.push((arguments[i__5727__auto___105936]));
+
+var G__105938 = (i__5727__auto___105936 + (1));
+i__5727__auto___105936 = G__105938;
+continue;
+} else {
+}
+break;
+}
+
+var argseq__5752__auto__ = ((((2) < args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);
+return medley.core.mapply.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);
+
+}
+});
+
+(medley.core.mapply.cljs$core$IFn$_invoke$arity$2 = (function (f,m){
+return cljs.core.apply.cljs$core$IFn$_invoke$arity$2(f,cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.concat,m));
+}));
+
+(medley.core.mapply.cljs$core$IFn$_invoke$arity$variadic = (function (f,a,args){
+return cljs.core.apply.cljs$core$IFn$_invoke$arity$3(f,a,cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.concat,cljs.core.butlast(args),cljs.core.last(args)));
+}));
+
+/** @this {Function} */
+(medley.core.mapply.cljs$lang$applyTo = (function (seq105728){
+var G__105729 = cljs.core.first(seq105728);
+var seq105728__$1 = cljs.core.next(seq105728);
+var G__105730 = cljs.core.first(seq105728__$1);
+var seq105728__$2 = cljs.core.next(seq105728__$1);
+var self__5711__auto__ = this;
+return self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__105729,G__105730,seq105728__$2);
+}));
+
+(medley.core.mapply.cljs$lang$maxFixedArity = (2));
+
+/**
+ * Returns a map of the elements of coll keyed by the result of f on each
+ *   element. The value at each key will be the last element in coll associated
+ *   with that key. This function is similar to `clojure.core/group-by`, except
+ *   that elements with the same key are overwritten, rather than added to a
+ *   vector of values.
+ */
+medley.core.index_by = (function medley$core$index_by(f,coll){
+return cljs.core.persistent_BANG_(cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p1__105732_SHARP_,p2__105733_SHARP_){
+return cljs.core.assoc_BANG_.cljs$core$IFn$_invoke$arity$3(p1__105732_SHARP_,(f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(p2__105733_SHARP_) : f.call(null, p2__105733_SHARP_)),p2__105733_SHARP_);
+}),cljs.core.transient$(cljs.core.PersistentArrayMap.EMPTY),coll));
+});
+/**
+ * Returns a lazy seq of the first item in each coll, then the second, etc.
+ *   Unlike `clojure.core/interleave`, the returned seq contains all items in the
+ *   supplied collections, even if the collections are different sizes.
+ */
+medley.core.interleave_all = (function medley$core$interleave_all(var_args){
+var G__105738 = arguments.length;
+switch (G__105738) {
+case 0:
+return medley.core.interleave_all.cljs$core$IFn$_invoke$arity$0();
+
+break;
+case 1:
+return medley.core.interleave_all.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
+
+break;
+case 2:
+return medley.core.interleave_all.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
+
+break;
+default:
+var args_arr__5751__auto__ = [];
+var len__5726__auto___105943 = arguments.length;
+var i__5727__auto___105944 = (0);
+while(true){
+if((i__5727__auto___105944 < len__5726__auto___105943)){
+args_arr__5751__auto__.push((arguments[i__5727__auto___105944]));
+
+var G__105945 = (i__5727__auto___105944 + (1));
+i__5727__auto___105944 = G__105945;
+continue;
+} else {
+}
+break;
+}
+
+var argseq__5752__auto__ = ((((2) < args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);
+return medley.core.interleave_all.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);
+
+}
+});
+
+(medley.core.interleave_all.cljs$core$IFn$_invoke$arity$0 = (function (){
+return cljs.core.List.EMPTY;
+}));
+
+(medley.core.interleave_all.cljs$core$IFn$_invoke$arity$1 = (function (c1){
+return (new cljs.core.LazySeq(null,(function (){
+return c1;
+}),null,null));
+}));
+
+(medley.core.interleave_all.cljs$core$IFn$_invoke$arity$2 = (function (c1,c2){
+return (new cljs.core.LazySeq(null,(function (){
+var s1 = cljs.core.seq(c1);
+var s2 = cljs.core.seq(c2);
+if(((s1) && (s2))){
+return cljs.core.cons(cljs.core.first(s1),cljs.core.cons(cljs.core.first(s2),medley.core.interleave_all.cljs$core$IFn$_invoke$arity$2(cljs.core.rest(s1),cljs.core.rest(s2))));
+} else {
+return ((s1) || (s2));
+}
+}),null,null));
+}));
+
+(medley.core.interleave_all.cljs$core$IFn$_invoke$arity$variadic = (function (c1,c2,colls){
+return (new cljs.core.LazySeq(null,(function (){
+var ss = cljs.core.remove.cljs$core$IFn$_invoke$arity$2(cljs.core.nil_QMARK_,cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.seq,cljs.core.conj.cljs$core$IFn$_invoke$arity$variadic(colls,c2,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([c1], 0))));
+if(cljs.core.seq(ss)){
+return cljs.core.concat.cljs$core$IFn$_invoke$arity$2(cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.first,ss),cljs.core.apply.cljs$core$IFn$_invoke$arity$2(medley.core.interleave_all,cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.rest,ss)));
+} else {
+return null;
+}
+}),null,null));
+}));
+
+/** @this {Function} */
+(medley.core.interleave_all.cljs$lang$applyTo = (function (seq105735){
+var G__105736 = cljs.core.first(seq105735);
+var seq105735__$1 = cljs.core.next(seq105735);
+var G__105737 = cljs.core.first(seq105735__$1);
+var seq105735__$2 = cljs.core.next(seq105735__$1);
+var self__5711__auto__ = this;
+return self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__105736,G__105737,seq105735__$2);
+}));
+
+(medley.core.interleave_all.cljs$lang$maxFixedArity = (2));
+
+/**
+ * Returns a lazy sequence of the elements of coll, removing any elements that
+ *   return duplicate values when passed to a function f. Returns a transducer
+ *   when no collection is provided.
+ */
+medley.core.distinct_by = (function medley$core$distinct_by(var_args){
+var G__105746 = arguments.length;
+switch (G__105746) {
+case 1:
+return medley.core.distinct_by.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
+
+break;
+case 2:
+return medley.core.distinct_by.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('')));
+
+}
+});
+
+(medley.core.distinct_by.cljs$core$IFn$_invoke$arity$1 = (function (f){
+return (function (rf){
+var seen = cljs.core.volatile_BANG_(cljs.core.PersistentHashSet.EMPTY);
+return (function() {
+var G__105951 = null;
+var G__105951__0 = (function (){
+return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));
+});
+var G__105951__1 = (function (result){
+return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));
+});
+var G__105951__2 = (function (result,x){
+var fx = (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(x) : f.call(null, x));
+if(cljs.core.contains_QMARK_(cljs.core.deref(seen),fx)){
+return result;
+} else {
+seen.cljs$core$IVolatile$_vreset_BANG_$arity$2(null, cljs.core.conj.cljs$core$IFn$_invoke$arity$2(seen.cljs$core$IDeref$_deref$arity$1(null, ),fx));
+
+return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,x) : rf.call(null, result,x));
+}
+});
+G__105951 = function(result,x){
+switch(arguments.length){
+case 0:
+return G__105951__0.call(this);
+case 1:
+return G__105951__1.call(this,result);
+case 2:
+return G__105951__2.call(this,result,x);
+}
+throw(new Error('Invalid arity: ' + arguments.length));
+};
+G__105951.cljs$core$IFn$_invoke$arity$0 = G__105951__0;
+G__105951.cljs$core$IFn$_invoke$arity$1 = G__105951__1;
+G__105951.cljs$core$IFn$_invoke$arity$2 = G__105951__2;
+return G__105951;
+})()
+});
+}));
+
+(medley.core.distinct_by.cljs$core$IFn$_invoke$arity$2 = (function (f,coll){
+var step = (function medley$core$step(xs,seen){
+return (new cljs.core.LazySeq(null,(function (){
+return (function (p__105748,seen__$1){
+while(true){
+var vec__105749 = p__105748;
+var x = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__105749,(0),null);
+var xs__$1 = vec__105749;
+var temp__5804__auto__ = cljs.core.seq(xs__$1);
+if(temp__5804__auto__){
+var s = temp__5804__auto__;
+var fx = (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(x) : f.call(null, x));
+if(cljs.core.contains_QMARK_(seen__$1,fx)){
+var G__105952 = cljs.core.rest(s);
+var G__105953 = seen__$1;
+p__105748 = G__105952;
+seen__$1 = G__105953;
+continue;
+} else {
+return cljs.core.cons(x,medley$core$step(cljs.core.rest(s),cljs.core.conj.cljs$core$IFn$_invoke$arity$2(seen__$1,fx)));
+}
+} else {
+return null;
+}
+break;
+}
+})(xs,seen);
+}),null,null));
+});
+return step(coll,cljs.core.PersistentHashSet.EMPTY);
+}));
+
+(medley.core.distinct_by.cljs$lang$maxFixedArity = 2);
+
+/**
+ * Returns a lazy sequence of the elements of coll, removing any **consecutive**
+ *   elements that return duplicate values when passed to a function f. Returns a
+ *   transducer when no collection is provided.
+ */
+medley.core.dedupe_by = (function medley$core$dedupe_by(var_args){
+var G__105753 = arguments.length;
+switch (G__105753) {
+case 1:
+return medley.core.dedupe_by.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
+
+break;
+case 2:
+return medley.core.dedupe_by.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('')));
+
+}
+});
+
+(medley.core.dedupe_by.cljs$core$IFn$_invoke$arity$1 = (function (f){
+return (function (rf){
+var pv = cljs.core.volatile_BANG_(new cljs.core.Keyword("medley.core","none","medley.core/none",60848325));
+return (function() {
+var G__105955 = null;
+var G__105955__0 = (function (){
+return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));
+});
+var G__105955__1 = (function (result){
+return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));
+});
+var G__105955__2 = (function (result,x){
+var prior = cljs.core.deref(pv);
+var fx = (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(x) : f.call(null, x));
+cljs.core.vreset_BANG_(pv,fx);
+
+if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(prior,fx)){
+return result;
+} else {
+return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,x) : rf.call(null, result,x));
+}
+});
+G__105955 = function(result,x){
+switch(arguments.length){
+case 0:
+return G__105955__0.call(this);
+case 1:
+return G__105955__1.call(this,result);
+case 2:
+return G__105955__2.call(this,result,x);
+}
+throw(new Error('Invalid arity: ' + arguments.length));
+};
+G__105955.cljs$core$IFn$_invoke$arity$0 = G__105955__0;
+G__105955.cljs$core$IFn$_invoke$arity$1 = G__105955__1;
+G__105955.cljs$core$IFn$_invoke$arity$2 = G__105955__2;
+return G__105955;
+})()
+});
+}));
+
+(medley.core.dedupe_by.cljs$core$IFn$_invoke$arity$2 = (function (f,coll){
+return cljs.core.sequence.cljs$core$IFn$_invoke$arity$2(medley.core.dedupe_by.cljs$core$IFn$_invoke$arity$1(f),coll);
+}));
+
+(medley.core.dedupe_by.cljs$lang$maxFixedArity = 2);
+
+/**
+ * Returns a lazy sequence of successive items from coll up to and including
+ *   the first item for which `(pred item)` returns true. Returns a transducer
+ *   when no collection is provided.
+ */
+medley.core.take_upto = (function medley$core$take_upto(var_args){
+var G__105755 = arguments.length;
+switch (G__105755) {
+case 1:
+return medley.core.take_upto.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
+
+break;
+case 2:
+return medley.core.take_upto.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('')));
+
+}
+});
+
+(medley.core.take_upto.cljs$core$IFn$_invoke$arity$1 = (function (pred){
+return (function (rf){
+return (function() {
+var G__105959 = null;
+var G__105959__0 = (function (){
+return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));
+});
+var G__105959__1 = (function (result){
+return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));
+});
+var G__105959__2 = (function (result,x){
+var result__$1 = (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,x) : rf.call(null, result,x));
+if(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(x) : pred.call(null, x)))){
+return cljs.core.ensure_reduced(result__$1);
+} else {
+return result__$1;
+}
+});
+G__105959 = function(result,x){
+switch(arguments.length){
+case 0:
+return G__105959__0.call(this);
+case 1:
+return G__105959__1.call(this,result);
+case 2:
+return G__105959__2.call(this,result,x);
+}
+throw(new Error('Invalid arity: ' + arguments.length));
+};
+G__105959.cljs$core$IFn$_invoke$arity$0 = G__105959__0;
+G__105959.cljs$core$IFn$_invoke$arity$1 = G__105959__1;
+G__105959.cljs$core$IFn$_invoke$arity$2 = G__105959__2;
+return G__105959;
+})()
+});
+}));
+
+(medley.core.take_upto.cljs$core$IFn$_invoke$arity$2 = (function (pred,coll){
+return (new cljs.core.LazySeq(null,(function (){
+var temp__5804__auto__ = cljs.core.seq(coll);
+if(temp__5804__auto__){
+var s = temp__5804__auto__;
+var x = cljs.core.first(s);
+return cljs.core.cons(x,(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(x) : pred.call(null, x)))?null:medley.core.take_upto.cljs$core$IFn$_invoke$arity$2(pred,cljs.core.rest(s))));
+} else {
+return null;
+}
+}),null,null));
+}));
+
+(medley.core.take_upto.cljs$lang$maxFixedArity = 2);
+
+/**
+ * Returns a lazy sequence of the items in coll starting *after* the first item
+ *   for which `(pred item)` returns true. Returns a transducer when no collection
+ *   is provided.
+ */
+medley.core.drop_upto = (function medley$core$drop_upto(var_args){
+var G__105759 = arguments.length;
+switch (G__105759) {
+case 1:
+return medley.core.drop_upto.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
+
+break;
+case 2:
+return medley.core.drop_upto.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('')));
+
+}
+});
+
+(medley.core.drop_upto.cljs$core$IFn$_invoke$arity$1 = (function (pred){
+return (function (rf){
+var dv = cljs.core.volatile_BANG_(true);
+return (function() {
+var G__105965 = null;
+var G__105965__0 = (function (){
+return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));
+});
+var G__105965__1 = (function (result){
+return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));
+});
+var G__105965__2 = (function (result,x){
+if(cljs.core.truth_(cljs.core.deref(dv))){
+if(cljs.core.truth_((pred.cljs$core$IFn$_invoke$arity$1 ? pred.cljs$core$IFn$_invoke$arity$1(x) : pred.call(null, x)))){
+cljs.core.vreset_BANG_(dv,false);
+} else {
+}
+
+return result;
+} else {
+return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,x) : rf.call(null, result,x));
+}
+});
+G__105965 = function(result,x){
+switch(arguments.length){
+case 0:
+return G__105965__0.call(this);
+case 1:
+return G__105965__1.call(this,result);
+case 2:
+return G__105965__2.call(this,result,x);
+}
+throw(new Error('Invalid arity: ' + arguments.length));
+};
+G__105965.cljs$core$IFn$_invoke$arity$0 = G__105965__0;
+G__105965.cljs$core$IFn$_invoke$arity$1 = G__105965__1;
+G__105965.cljs$core$IFn$_invoke$arity$2 = G__105965__2;
+return G__105965;
+})()
+});
+}));
+
+(medley.core.drop_upto.cljs$core$IFn$_invoke$arity$2 = (function (pred,coll){
+return cljs.core.rest(cljs.core.drop_while.cljs$core$IFn$_invoke$arity$2(cljs.core.complement(pred),coll));
+}));
+
+(medley.core.drop_upto.cljs$lang$maxFixedArity = 2);
+
+/**
+ * Returns an ordered, lazy sequence of vectors `[index item]`, where item is a
+ *   value in coll, and index its position starting from zero. Returns a transducer
+ *   when no collection is provided.
+ */
+medley.core.indexed = (function medley$core$indexed(var_args){
+var G__105764 = arguments.length;
+switch (G__105764) {
+case 0:
+return medley.core.indexed.cljs$core$IFn$_invoke$arity$0();
+
+break;
+case 1:
+return medley.core.indexed.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
+
+break;
+default:
+throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));
+
+}
+});
+
+(medley.core.indexed.cljs$core$IFn$_invoke$arity$0 = (function (){
+return (function (rf){
+var i = cljs.core.volatile_BANG_((-1));
+return (function() {
+var G__105967 = null;
+var G__105967__0 = (function (){
+return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));
+});
+var G__105967__1 = (function (result){
+return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));
+});
+var G__105967__2 = (function (result,x){
+var G__105765 = result;
+var G__105766 = new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [i.cljs$core$IVolatile$_vreset_BANG_$arity$2(null, (i.cljs$core$IDeref$_deref$arity$1(null, ) + (1))),x], null);
+return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(G__105765,G__105766) : rf.call(null, G__105765,G__105766));
+});
+G__105967 = function(result,x){
+switch(arguments.length){
+case 0:
+return G__105967__0.call(this);
+case 1:
+return G__105967__1.call(this,result);
+case 2:
+return G__105967__2.call(this,result,x);
+}
+throw(new Error('Invalid arity: ' + arguments.length));
+};
+G__105967.cljs$core$IFn$_invoke$arity$0 = G__105967__0;
+G__105967.cljs$core$IFn$_invoke$arity$1 = G__105967__1;
+G__105967.cljs$core$IFn$_invoke$arity$2 = G__105967__2;
+return G__105967;
+})()
+});
+}));
+
+(medley.core.indexed.cljs$core$IFn$_invoke$arity$1 = (function (coll){
+return cljs.core.map_indexed.cljs$core$IFn$_invoke$arity$2(cljs.core.vector,coll);
+}));
+
+(medley.core.indexed.cljs$lang$maxFixedArity = 1);
+
+/**
+ * Returns a lazy sequence of the items in coll, with a new item inserted at
+ *   the supplied index, followed by all subsequent items of the collection. Runs
+ *   in O(n) time. Returns a transducer when no collection is provided.
+ */
+medley.core.insert_nth = (function medley$core$insert_nth(var_args){
+var G__105770 = arguments.length;
+switch (G__105770) {
+case 2:
+return medley.core.insert_nth.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
+
+break;
+case 3:
+return medley.core.insert_nth.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('')));
+
+}
+});
+
+(medley.core.insert_nth.cljs$core$IFn$_invoke$arity$2 = (function (index,item){
+return (function (rf){
+var idx = cljs.core.volatile_BANG_((index + (1)));
+return (function() {
+var G__105971 = null;
+var G__105971__0 = (function (){
+return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));
+});
+var G__105971__1 = (function (result){
+if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.deref(idx),(1))){
+var G__105788 = (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,item) : rf.call(null, result,item));
+return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(G__105788) : rf.call(null, G__105788));
+} else {
+return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));
+}
+});
+var G__105971__2 = (function (result,x){
+if((idx.cljs$core$IVolatile$_vreset_BANG_$arity$2(null, (idx.cljs$core$IDeref$_deref$arity$1(null, ) - (1))) === (0))){
+var G__105789 = (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,item) : rf.call(null, result,item));
+var G__105790 = x;
+return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(G__105789,G__105790) : rf.call(null, G__105789,G__105790));
+} else {
+return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,x) : rf.call(null, result,x));
+}
+});
+G__105971 = function(result,x){
+switch(arguments.length){
+case 0:
+return G__105971__0.call(this);
+case 1:
+return G__105971__1.call(this,result);
+case 2:
+return G__105971__2.call(this,result,x);
+}
+throw(new Error('Invalid arity: ' + arguments.length));
+};
+G__105971.cljs$core$IFn$_invoke$arity$0 = G__105971__0;
+G__105971.cljs$core$IFn$_invoke$arity$1 = G__105971__1;
+G__105971.cljs$core$IFn$_invoke$arity$2 = G__105971__2;
+return G__105971;
+})()
+});
+}));
+
+(medley.core.insert_nth.cljs$core$IFn$_invoke$arity$3 = (function (index,item,coll){
+return (new cljs.core.LazySeq(null,(function (){
+if((index === (0))){
+return cljs.core.cons(item,coll);
+} else {
+if(cljs.core.seq(coll)){
+return cljs.core.cons(cljs.core.first(coll),medley.core.insert_nth.cljs$core$IFn$_invoke$arity$3((index - (1)),item,cljs.core.rest(coll)));
+} else {
+return null;
+}
+}
+}),null,null));
+}));
+
+(medley.core.insert_nth.cljs$lang$maxFixedArity = 3);
+
+/**
+ * Returns a lazy sequence of the items in coll, except for the item at the
+ *   supplied index. Runs in O(n) time. Returns a transducer when no collection is
+ *   provided.
+ */
+medley.core.remove_nth = (function medley$core$remove_nth(var_args){
+var G__105793 = arguments.length;
+switch (G__105793) {
+case 1:
+return medley.core.remove_nth.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));
+
+break;
+case 2:
+return medley.core.remove_nth.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('')));
+
+}
+});
+
+(medley.core.remove_nth.cljs$core$IFn$_invoke$arity$1 = (function (index){
+return (function (rf){
+var idx = cljs.core.volatile_BANG_((index + (1)));
+return (function() {
+var G__105975 = null;
+var G__105975__0 = (function (){
+return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));
+});
+var G__105975__1 = (function (result){
+return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));
+});
+var G__105975__2 = (function (result,x){
+if((idx.cljs$core$IVolatile$_vreset_BANG_$arity$2(null, (idx.cljs$core$IDeref$_deref$arity$1(null, ) - (1))) === (0))){
+return result;
+} else {
+return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,x) : rf.call(null, result,x));
+}
+});
+G__105975 = function(result,x){
+switch(arguments.length){
+case 0:
+return G__105975__0.call(this);
+case 1:
+return G__105975__1.call(this,result);
+case 2:
+return G__105975__2.call(this,result,x);
+}
+throw(new Error('Invalid arity: ' + arguments.length));
+};
+G__105975.cljs$core$IFn$_invoke$arity$0 = G__105975__0;
+G__105975.cljs$core$IFn$_invoke$arity$1 = G__105975__1;
+G__105975.cljs$core$IFn$_invoke$arity$2 = G__105975__2;
+return G__105975;
+})()
+});
+}));
+
+(medley.core.remove_nth.cljs$core$IFn$_invoke$arity$2 = (function (index,coll){
+return (new cljs.core.LazySeq(null,(function (){
+if((index === (0))){
+return cljs.core.rest(coll);
+} else {
+if(cljs.core.seq(coll)){
+return cljs.core.cons(cljs.core.first(coll),medley.core.remove_nth.cljs$core$IFn$_invoke$arity$2((index - (1)),cljs.core.rest(coll)));
+} else {
+return null;
+}
+}
+}),null,null));
+}));
+
+(medley.core.remove_nth.cljs$lang$maxFixedArity = 2);
+
+/**
+ * Returns a lazy sequence of the items in coll, with a new item replacing the
+ *   item at the supplied index. Runs in O(n) time. Returns a transducer when no
+ *   collection is provided.
+ */
+medley.core.replace_nth = (function medley$core$replace_nth(var_args){
+var G__105801 = arguments.length;
+switch (G__105801) {
+case 2:
+return medley.core.replace_nth.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
+
+break;
+case 3:
+return medley.core.replace_nth.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('')));
+
+}
+});
+
+(medley.core.replace_nth.cljs$core$IFn$_invoke$arity$2 = (function (index,item){
+return (function (rf){
+var idx = cljs.core.volatile_BANG_((index + (1)));
+return (function() {
+var G__105978 = null;
+var G__105978__0 = (function (){
+return (rf.cljs$core$IFn$_invoke$arity$0 ? rf.cljs$core$IFn$_invoke$arity$0() : rf.call(null, ));
+});
+var G__105978__1 = (function (result){
+return (rf.cljs$core$IFn$_invoke$arity$1 ? rf.cljs$core$IFn$_invoke$arity$1(result) : rf.call(null, result));
+});
+var G__105978__2 = (function (result,x){
+if((idx.cljs$core$IVolatile$_vreset_BANG_$arity$2(null, (idx.cljs$core$IDeref$_deref$arity$1(null, ) - (1))) === (0))){
+return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,item) : rf.call(null, result,item));
+} else {
+return (rf.cljs$core$IFn$_invoke$arity$2 ? rf.cljs$core$IFn$_invoke$arity$2(result,x) : rf.call(null, result,x));
+}
+});
+G__105978 = function(result,x){
+switch(arguments.length){
+case 0:
+return G__105978__0.call(this);
+case 1:
+return G__105978__1.call(this,result);
+case 2:
+return G__105978__2.call(this,result,x);
+}
+throw(new Error('Invalid arity: ' + arguments.length));
+};
+G__105978.cljs$core$IFn$_invoke$arity$0 = G__105978__0;
+G__105978.cljs$core$IFn$_invoke$arity$1 = G__105978__1;
+G__105978.cljs$core$IFn$_invoke$arity$2 = G__105978__2;
+return G__105978;
+})()
+});
+}));
+
+(medley.core.replace_nth.cljs$core$IFn$_invoke$arity$3 = (function (index,item,coll){
+return (new cljs.core.LazySeq(null,(function (){
+if((index === (0))){
+return cljs.core.cons(item,cljs.core.rest(coll));
+} else {
+if(cljs.core.seq(coll)){
+return cljs.core.cons(cljs.core.first(coll),medley.core.replace_nth.cljs$core$IFn$_invoke$arity$3((index - (1)),item,cljs.core.rest(coll)));
+} else {
+return null;
+}
+}
+}),null,null));
+}));
+
+(medley.core.replace_nth.cljs$lang$maxFixedArity = 3);
+
+/**
+ * Returns the absolute value of a number.
+ */
+medley.core.abs = (function medley$core$abs(x){
+if((x < (0))){
+return (- x);
+} else {
+return x;
+}
+});
+/**
+ * Atomically swaps the value of the atom to be `(apply f x args)`, where x is
+ *   the current value of the atom, then returns the original value of the atom.
+ *   This function therefore acts like an atomic `deref` then `swap!`.
+ */
+medley.core.deref_swap_BANG_ = (function medley$core$deref_swap_BANG_(var_args){
+var G__105815 = arguments.length;
+switch (G__105815) {
+case 2:
+return medley.core.deref_swap_BANG_.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
+
+break;
+default:
+var args_arr__5751__auto__ = [];
+var len__5726__auto___105981 = arguments.length;
+var i__5727__auto___105982 = (0);
+while(true){
+if((i__5727__auto___105982 < len__5726__auto___105981)){
+args_arr__5751__auto__.push((arguments[i__5727__auto___105982]));
+
+var G__105983 = (i__5727__auto___105982 + (1));
+i__5727__auto___105982 = G__105983;
+continue;
+} else {
+}
+break;
+}
+
+var argseq__5752__auto__ = ((((2) < args_arr__5751__auto__.length))?(new cljs.core.IndexedSeq(args_arr__5751__auto__.slice((2)),(0),null)):null);
+return medley.core.deref_swap_BANG_.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5752__auto__);
+
+}
+});
+
+(medley.core.deref_swap_BANG_.cljs$core$IFn$_invoke$arity$2 = (function (atom,f){
+var value = cljs.core.deref(atom);
+cljs.core.reset_BANG_(atom,(f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(value) : f.call(null, value)));
+
+return value;
+}));
+
+(medley.core.deref_swap_BANG_.cljs$core$IFn$_invoke$arity$variadic = (function (atom,f,args){
+return medley.core.deref_swap_BANG_.cljs$core$IFn$_invoke$arity$2(atom,(function (p1__105809_SHARP_){
+return cljs.core.apply.cljs$core$IFn$_invoke$arity$3(f,p1__105809_SHARP_,args);
+}));
+}));
+
+/** @this {Function} */
+(medley.core.deref_swap_BANG_.cljs$lang$applyTo = (function (seq105812){
+var G__105813 = cljs.core.first(seq105812);
+var seq105812__$1 = cljs.core.next(seq105812);
+var G__105814 = cljs.core.first(seq105812__$1);
+var seq105812__$2 = cljs.core.next(seq105812__$1);
+var self__5711__auto__ = this;
+return self__5711__auto__.cljs$core$IFn$_invoke$arity$variadic(G__105813,G__105814,seq105812__$2);
+}));
+
+(medley.core.deref_swap_BANG_.cljs$lang$maxFixedArity = (2));
+
+/**
+ * Sets the value of the atom without regard for the current value, then returns
+ *   the original value of the atom. See also: [[deref-swap!]].
+ */
+medley.core.deref_reset_BANG_ = (function medley$core$deref_reset_BANG_(atom,newval){
+return medley.core.deref_swap_BANG_.cljs$core$IFn$_invoke$arity$2(atom,cljs.core.constantly(newval));
+});
+/**
+ * Returns the message attached to the given Error/Throwable object. For all
+ *   other types returns nil. Same as `cljs.core/ex-message` except it works for
+ *   Clojure as well as ClojureScript.
+ */
+medley.core.ex_message = (function medley$core$ex_message(ex){
+return cljs.core.ex_message(ex);
+});
+/**
+ * Returns the cause attached to the given ExceptionInfo/Throwable object. For
+ *   all other types returns nil. Same as `cljs.core/ex-cause` except it works for
+ *   Clojure as well as ClojureScript.
+ */
+medley.core.ex_cause = (function medley$core$ex_cause(ex){
+return cljs.core.ex_cause(ex);
+});
+/**
+ * Returns true if the value is a UUID.
+ */
+medley.core.uuid_QMARK_ = (function medley$core$uuid_QMARK_(x){
+return (x instanceof cljs.core.UUID);
+});
+/**
+ * Returns a UUID generated from the supplied string. Same as `cljs.core/uuid`
+ *   in ClojureScript, while in Clojure it returns a `java.util.UUID` object.
+ */
+medley.core.uuid = (function medley$core$uuid(s){
+return cljs.core.uuid(s);
+});
+/**
+ * Generates a new random UUID. Same as `cljs.core/random-uuid` except it works
+ *   for Clojure as well as ClojureScript.
+ */
+medley.core.random_uuid = (function medley$core$random_uuid(){
+return cljs.core.random_uuid();
+});
+/**
+ * Returns true if the value is a regular expression.
+ */
+medley.core.regexp_QMARK_ = (function medley$core$regexp_QMARK_(x){
+return (x instanceof RegExp);
+});
+
+//# sourceMappingURL=medley.core.js.map