longdown 2023.4.18

package/lib/cljs-runtime/clojure.tools.cli.js

@@ -0,0 +1,1684 @@
+import "./cljs_env.js";
+goog.provide('clojure.tools.cli');
+/**
+ * Reduce arguments sequence into [opt-type opt ?optarg?] vectors and a vector
+ *   of remaining arguments. Returns as [option-tokens remaining-args].
+ * 
+ *   Expands clumped short options like "-abc" into:
+ *   [[:short-opt "-a"] [:short-opt "-b"] [:short-opt "-c"]]
+ * 
+ *   If "-b" were in the set of options that require arguments, "-abc" would
+ *   then be interpreted as: [[:short-opt "-a"] [:short-opt "-b" "c"]]
+ * 
+ *   Long options with `=` are always parsed as option + optarg, even if nothing
+ *   follows the `=` sign.
+ * 
+ *   If the :in-order flag is true, the first non-option, non-optarg argument
+ *   stops options processing. This is useful for handling subcommand options.
+ */
+clojure.tools.cli.tokenize_args = (function clojure$tools$cli$tokenize_args(var_args){
+var args__5775__auto__ = [];
+var len__5769__auto___21810 = arguments.length;
+var i__5770__auto___21811 = (0);
+while(true){
+if((i__5770__auto___21811 < len__5769__auto___21810)){
+args__5775__auto__.push((arguments[i__5770__auto___21811]));
+
+var G__21812 = (i__5770__auto___21811 + (1));
+i__5770__auto___21811 = G__21812;
+continue;
+} else {
+}
+break;
+}
+
+var argseq__5776__auto__ = ((((2) < args__5775__auto__.length))?(new cljs.core.IndexedSeq(args__5775__auto__.slice((2)),(0),null)):null);
+return clojure.tools.cli.tokenize_args.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5776__auto__);
+});
+
+(clojure.tools.cli.tokenize_args.cljs$core$IFn$_invoke$arity$variadic = (function (required_set,args,options){
+var map__21508 = cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.hash_map,options);
+var map__21508__$1 = cljs.core.__destructure_map(map__21508);
+var in_order = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21508__$1,new cljs.core.Keyword(null,"in-order","in-order",-1605651796));
+var opts = cljs.core.PersistentVector.EMPTY;
+var argv = cljs.core.PersistentVector.EMPTY;
+var G__21512 = args;
+var vec__21513 = G__21512;
+var seq__21514 = cljs.core.seq(vec__21513);
+var first__21515 = cljs.core.first(seq__21514);
+var seq__21514__$1 = cljs.core.next(seq__21514);
+var car = first__21515;
+var cdr = seq__21514__$1;
+var opts__$1 = opts;
+var argv__$1 = argv;
+var G__21512__$1 = G__21512;
+while(true){
+var opts__$2 = opts__$1;
+var argv__$2 = argv__$1;
+var vec__21562 = G__21512__$1;
+var seq__21563 = cljs.core.seq(vec__21562);
+var first__21564 = cljs.core.first(seq__21563);
+var seq__21563__$1 = cljs.core.next(seq__21563);
+var car__$1 = first__21564;
+var cdr__$1 = seq__21563__$1;
+if(cljs.core.truth_(car__$1)){
+var pred__21565 = cljs.core.re_seq;
+var expr__21566 = car__$1;
+if(cljs.core.truth_((function (){var G__21568 = /^--$/;
+var G__21569 = expr__21566;
+return (pred__21565.cljs$core$IFn$_invoke$arity$2 ? pred__21565.cljs$core$IFn$_invoke$arity$2(G__21568,G__21569) : pred__21565.call(null,G__21568,G__21569));
+})())){
+var G__21813 = opts__$2;
+var G__21814 = cljs.core.into.cljs$core$IFn$_invoke$arity$2(argv__$2,cdr__$1);
+var G__21815 = cljs.core.PersistentVector.EMPTY;
+opts__$1 = G__21813;
+argv__$1 = G__21814;
+G__21512__$1 = G__21815;
+continue;
+} else {
+if(cljs.core.truth_((function (){var G__21571 = /^--\S+=/;
+var G__21572 = expr__21566;
+return (pred__21565.cljs$core$IFn$_invoke$arity$2 ? pred__21565.cljs$core$IFn$_invoke$arity$2(G__21571,G__21572) : pred__21565.call(null,G__21571,G__21572));
+})())){
+var G__21817 = cljs.core.conj.cljs$core$IFn$_invoke$arity$2(opts__$2,cljs.core.into.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"long-opt","long-opt",-386094553)], null),clojure.string.split.cljs$core$IFn$_invoke$arity$3(car__$1,/=/,(2))));
+var G__21818 = argv__$2;
+var G__21819 = cdr__$1;
+opts__$1 = G__21817;
+argv__$1 = G__21818;
+G__21512__$1 = G__21819;
+continue;
+} else {
+if(cljs.core.truth_((function (){var G__21574 = /^--/;
+var G__21575 = expr__21566;
+return (pred__21565.cljs$core$IFn$_invoke$arity$2 ? pred__21565.cljs$core$IFn$_invoke$arity$2(G__21574,G__21575) : pred__21565.call(null,G__21574,G__21575));
+})())){
+var vec__21576 = ((cljs.core.contains_QMARK_(required_set,car__$1))?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.first(cdr__$1),cljs.core.rest(cdr__$1)], null):new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,cdr__$1], null));
+var optarg = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21576,(0),null);
+var cdr__$2 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21576,(1),null);
+var G__21820 = cljs.core.conj.cljs$core$IFn$_invoke$arity$2(opts__$2,cljs.core.into.cljs$core$IFn$_invoke$arity$2(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"long-opt","long-opt",-386094553),car__$1], null),(cljs.core.truth_(optarg)?new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [optarg], null):cljs.core.PersistentVector.EMPTY)));
+var G__21821 = argv__$2;
+var G__21822 = cdr__$2;
+opts__$1 = G__21820;
+argv__$1 = G__21821;
+G__21512__$1 = G__21822;
+continue;
+} else {
+if(cljs.core.truth_((function (){var G__21579 = /^-./;
+var G__21580 = expr__21566;
+return (pred__21565.cljs$core$IFn$_invoke$arity$2 ? pred__21565.cljs$core$IFn$_invoke$arity$2(G__21579,G__21580) : pred__21565.call(null,G__21579,G__21580));
+})())){
+var vec__21581 = (function (){var os = cljs.core.PersistentVector.EMPTY;
+var G__21587 = cljs.core.rest(car__$1);
+var vec__21588 = G__21587;
+var seq__21589 = cljs.core.seq(vec__21588);
+var first__21590 = cljs.core.first(seq__21589);
+var seq__21589__$1 = cljs.core.next(seq__21589);
+var c = first__21590;
+var cs = seq__21589__$1;
+var os__$1 = os;
+var G__21587__$1 = G__21587;
+while(true){
+var os__$2 = os__$1;
+var vec__21599 = G__21587__$1;
+var seq__21600 = cljs.core.seq(vec__21599);
+var first__21601 = cljs.core.first(seq__21600);
+var seq__21600__$1 = cljs.core.next(seq__21600);
+var c__$1 = first__21601;
+var cs__$1 = seq__21600__$1;
+var o = ["-",cljs.core.str.cljs$core$IFn$_invoke$arity$1(c__$1)].join('');
+if(cljs.core.contains_QMARK_(required_set,o)){
+if(cljs.core.seq(cs__$1)){
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.conj.cljs$core$IFn$_invoke$arity$2(os__$2,new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"short-opt","short-opt",-384995699),o,clojure.string.join.cljs$core$IFn$_invoke$arity$1(cs__$1)], null)),cdr__$1], null);
+} else {
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.conj.cljs$core$IFn$_invoke$arity$2(os__$2,new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"short-opt","short-opt",-384995699),o,cljs.core.first(cdr__$1)], null)),cljs.core.rest(cdr__$1)], null);
+}
+} else {
+if(cljs.core.seq(cs__$1)){
+var G__21824 = cljs.core.conj.cljs$core$IFn$_invoke$arity$2(os__$2,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"short-opt","short-opt",-384995699),o], null));
+var G__21825 = cs__$1;
+os__$1 = G__21824;
+G__21587__$1 = G__21825;
+continue;
+} else {
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.conj.cljs$core$IFn$_invoke$arity$2(os__$2,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"short-opt","short-opt",-384995699),o], null)),cdr__$1], null);
+}
+}
+break;
+}
+})();
+var os = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21581,(0),null);
+var cdr__$2 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21581,(1),null);
+var G__21826 = cljs.core.into.cljs$core$IFn$_invoke$arity$2(opts__$2,os);
+var G__21827 = argv__$2;
+var G__21828 = cdr__$2;
+opts__$1 = G__21826;
+argv__$1 = G__21827;
+G__21512__$1 = G__21828;
+continue;
+} else {
+if(cljs.core.truth_(in_order)){
+var G__21829 = opts__$2;
+var G__21830 = cljs.core.into.cljs$core$IFn$_invoke$arity$2(argv__$2,cljs.core.cons(car__$1,cdr__$1));
+var G__21831 = cljs.core.PersistentVector.EMPTY;
+opts__$1 = G__21829;
+argv__$1 = G__21830;
+G__21512__$1 = G__21831;
+continue;
+} else {
+var G__21832 = opts__$2;
+var G__21833 = cljs.core.conj.cljs$core$IFn$_invoke$arity$2(argv__$2,car__$1);
+var G__21834 = cdr__$1;
+opts__$1 = G__21832;
+argv__$1 = G__21833;
+G__21512__$1 = G__21834;
+continue;
+}
+}
+}
+}
+}
+} else {
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [opts__$2,argv__$2], null);
+}
+break;
+}
+}));
+
+(clojure.tools.cli.tokenize_args.cljs$lang$maxFixedArity = (2));
+
+/** @this {Function} */
+(clojure.tools.cli.tokenize_args.cljs$lang$applyTo = (function (seq21500){
+var G__21501 = cljs.core.first(seq21500);
+var seq21500__$1 = cljs.core.next(seq21500);
+var G__21502 = cljs.core.first(seq21500__$1);
+var seq21500__$2 = cljs.core.next(seq21500__$1);
+var self__5754__auto__ = this;
+return self__5754__auto__.cljs$core$IFn$_invoke$arity$variadic(G__21501,G__21502,seq21500__$2);
+}));
+
+/**
+ * Given a sequence of column widths, return a string suitable for use in
+ *   format to print a sequences of strings in those columns.
+ */
+clojure.tools.cli.make_format = (function clojure$tools$cli$make_format(lens){
+return clojure.string.join.cljs$core$IFn$_invoke$arity$1(cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__21606_SHARP_){
+return ["  %",(((p1__21606_SHARP_ === (0)))?null:["-",cljs.core.str.cljs$core$IFn$_invoke$arity$1(p1__21606_SHARP_)].join('')),"s"].join('');
+}),lens));
+});
+clojure.tools.cli.build_doc = (function clojure$tools$cli$build_doc(p__21607){
+var map__21608 = p__21607;
+var map__21608__$1 = cljs.core.__destructure_map(map__21608);
+var switches = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21608__$1,new cljs.core.Keyword(null,"switches","switches",2013040888));
+var docs = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21608__$1,new cljs.core.Keyword(null,"docs","docs",-1974280502));
+var default$ = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21608__$1,new cljs.core.Keyword(null,"default","default",-1987822328));
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.interpose.cljs$core$IFn$_invoke$arity$2(", ",switches)),(function (){var or__5045__auto__ = cljs.core.str.cljs$core$IFn$_invoke$arity$1(default$);
+if(cljs.core.truth_(or__5045__auto__)){
+return or__5045__auto__;
+} else {
+return "";
+}
+})(),(function (){var or__5045__auto__ = docs;
+if(cljs.core.truth_(or__5045__auto__)){
+return or__5045__auto__;
+} else {
+return "";
+}
+})()], null);
+});
+clojure.tools.cli.format = (function clojure$tools$cli$format(var_args){
+var args__5775__auto__ = [];
+var len__5769__auto___21837 = arguments.length;
+var i__5770__auto___21838 = (0);
+while(true){
+if((i__5770__auto___21838 < len__5769__auto___21837)){
+args__5775__auto__.push((arguments[i__5770__auto___21838]));
+
+var G__21839 = (i__5770__auto___21838 + (1));
+i__5770__auto___21838 = G__21839;
+continue;
+} else {
+}
+break;
+}
+
+var argseq__5776__auto__ = ((((1) < args__5775__auto__.length))?(new cljs.core.IndexedSeq(args__5775__auto__.slice((1)),(0),null)):null);
+return clojure.tools.cli.format.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__5776__auto__);
+});
+
+(clojure.tools.cli.format.cljs$core$IFn$_invoke$arity$variadic = (function (fmt,args){
+return cljs.core.apply.cljs$core$IFn$_invoke$arity$3(goog.string.format,fmt,args);
+}));
+
+(clojure.tools.cli.format.cljs$lang$maxFixedArity = (1));
+
+/** @this {Function} */
+(clojure.tools.cli.format.cljs$lang$applyTo = (function (seq21610){
+var G__21611 = cljs.core.first(seq21610);
+var seq21610__$1 = cljs.core.next(seq21610);
+var self__5754__auto__ = this;
+return self__5754__auto__.cljs$core$IFn$_invoke$arity$variadic(G__21611,seq21610__$1);
+}));
+
+clojure.tools.cli.banner_for = (function clojure$tools$cli$banner_for(desc,specs){
+if(cljs.core.truth_(desc)){
+cljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([desc], 0));
+
+cljs.core.println();
+} else {
+}
+
+var docs = cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.map.cljs$core$IFn$_invoke$arity$2(clojure.tools.cli.build_doc,specs),new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, ["--------","-------","----"], null),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, ["Switches","Default","Desc"], null)], null));
+var max_cols = cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__21615_SHARP_){
+return cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.max,p1__21615_SHARP_);
+}),cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.map,(function() { 
+var G__21845__delegate = function (c){
+return cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.vector,c);
+};
+var G__21845 = function (var_args){
+var c = null;
+if (arguments.length > 0) {
+var G__21846__i = 0, G__21846__a = new Array(arguments.length -  0);
+while (G__21846__i < G__21846__a.length) {G__21846__a[G__21846__i] = arguments[G__21846__i + 0]; ++G__21846__i;}
+  c = new cljs.core.IndexedSeq(G__21846__a,0,null);
+} 
+return G__21845__delegate.call(this,c);};
+G__21845.cljs$lang$maxFixedArity = 0;
+G__21845.cljs$lang$applyTo = (function (arglist__21847){
+var c = cljs.core.seq(arglist__21847);
+return G__21845__delegate(c);
+});
+G__21845.cljs$core$IFn$_invoke$arity$variadic = G__21845__delegate;
+return G__21845;
+})()
+,(function (){var iter__5523__auto__ = (function clojure$tools$cli$banner_for_$_iter__21618(s__21619){
+return (new cljs.core.LazySeq(null,(function (){
+var s__21619__$1 = s__21619;
+while(true){
+var temp__5804__auto__ = cljs.core.seq(s__21619__$1);
+if(temp__5804__auto__){
+var s__21619__$2 = temp__5804__auto__;
+if(cljs.core.chunked_seq_QMARK_(s__21619__$2)){
+var c__5521__auto__ = cljs.core.chunk_first(s__21619__$2);
+var size__5522__auto__ = cljs.core.count(c__5521__auto__);
+var b__21621 = cljs.core.chunk_buffer(size__5522__auto__);
+if((function (){var i__21620 = (0);
+while(true){
+if((i__21620 < size__5522__auto__)){
+var d = cljs.core._nth(c__5521__auto__,i__21620);
+cljs.core.chunk_append(b__21621,cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.count,d));
+
+var G__21849 = (i__21620 + (1));
+i__21620 = G__21849;
+continue;
+} else {
+return true;
+}
+break;
+}
+})()){
+return cljs.core.chunk_cons(cljs.core.chunk(b__21621),clojure$tools$cli$banner_for_$_iter__21618(cljs.core.chunk_rest(s__21619__$2)));
+} else {
+return cljs.core.chunk_cons(cljs.core.chunk(b__21621),null);
+}
+} else {
+var d = cljs.core.first(s__21619__$2);
+return cljs.core.cons(cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.count,d),clojure$tools$cli$banner_for_$_iter__21618(cljs.core.rest(s__21619__$2)));
+}
+} else {
+return null;
+}
+break;
+}
+}),null,null));
+});
+return iter__5523__auto__(docs);
+})()));
+var vs = (function (){var iter__5523__auto__ = (function clojure$tools$cli$banner_for_$_iter__21622(s__21623){
+return (new cljs.core.LazySeq(null,(function (){
+var s__21623__$1 = s__21623;
+while(true){
+var temp__5804__auto__ = cljs.core.seq(s__21623__$1);
+if(temp__5804__auto__){
+var s__21623__$2 = temp__5804__auto__;
+if(cljs.core.chunked_seq_QMARK_(s__21623__$2)){
+var c__5521__auto__ = cljs.core.chunk_first(s__21623__$2);
+var size__5522__auto__ = cljs.core.count(c__5521__auto__);
+var b__21625 = cljs.core.chunk_buffer(size__5522__auto__);
+if((function (){var i__21624 = (0);
+while(true){
+if((i__21624 < size__5522__auto__)){
+var d = cljs.core._nth(c__5521__auto__,i__21624);
+cljs.core.chunk_append(b__21625,cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic(((function (i__21624,d,c__5521__auto__,size__5522__auto__,b__21625,s__21623__$2,temp__5804__auto__,docs,max_cols){
+return (function() { 
+var G__21851__delegate = function (x){
+return cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.vector,x);
+};
+var G__21851 = function (var_args){
+var x = null;
+if (arguments.length > 0) {
+var G__21852__i = 0, G__21852__a = new Array(arguments.length -  0);
+while (G__21852__i < G__21852__a.length) {G__21852__a[G__21852__i] = arguments[G__21852__i + 0]; ++G__21852__i;}
+  x = new cljs.core.IndexedSeq(G__21852__a,0,null);
+} 
+return G__21851__delegate.call(this,x);};
+G__21851.cljs$lang$maxFixedArity = 0;
+G__21851.cljs$lang$applyTo = (function (arglist__21853){
+var x = cljs.core.seq(arglist__21853);
+return G__21851__delegate(x);
+});
+G__21851.cljs$core$IFn$_invoke$arity$variadic = G__21851__delegate;
+return G__21851;
+})()
+;})(i__21624,d,c__5521__auto__,size__5522__auto__,b__21625,s__21623__$2,temp__5804__auto__,docs,max_cols))
+,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([max_cols,d], 0)));
+
+var G__21854 = (i__21624 + (1));
+i__21624 = G__21854;
+continue;
+} else {
+return true;
+}
+break;
+}
+})()){
+return cljs.core.chunk_cons(cljs.core.chunk(b__21625),clojure$tools$cli$banner_for_$_iter__21622(cljs.core.chunk_rest(s__21623__$2)));
+} else {
+return cljs.core.chunk_cons(cljs.core.chunk(b__21625),null);
+}
+} else {
+var d = cljs.core.first(s__21623__$2);
+return cljs.core.cons(cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic(((function (d,s__21623__$2,temp__5804__auto__,docs,max_cols){
+return (function() { 
+var G__21855__delegate = function (x){
+return cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.vector,x);
+};
+var G__21855 = function (var_args){
+var x = null;
+if (arguments.length > 0) {
+var G__21856__i = 0, G__21856__a = new Array(arguments.length -  0);
+while (G__21856__i < G__21856__a.length) {G__21856__a[G__21856__i] = arguments[G__21856__i + 0]; ++G__21856__i;}
+  x = new cljs.core.IndexedSeq(G__21856__a,0,null);
+} 
+return G__21855__delegate.call(this,x);};
+G__21855.cljs$lang$maxFixedArity = 0;
+G__21855.cljs$lang$applyTo = (function (arglist__21857){
+var x = cljs.core.seq(arglist__21857);
+return G__21855__delegate(x);
+});
+G__21855.cljs$core$IFn$_invoke$arity$variadic = G__21855__delegate;
+return G__21855;
+})()
+;})(d,s__21623__$2,temp__5804__auto__,docs,max_cols))
+,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([max_cols,d], 0)),clojure$tools$cli$banner_for_$_iter__21622(cljs.core.rest(s__21623__$2)));
+}
+} else {
+return null;
+}
+break;
+}
+}),null,null));
+});
+return iter__5523__auto__(docs);
+})();
+var seq__21626 = cljs.core.seq(vs);
+var chunk__21627 = null;
+var count__21628 = (0);
+var i__21629 = (0);
+while(true){
+if((i__21629 < count__21628)){
+var v = chunk__21627.cljs$core$IIndexed$_nth$arity$2(null,i__21629);
+var fmt_21859 = clojure.tools.cli.make_format(cljs.core.take_nth.cljs$core$IFn$_invoke$arity$2((2),v));
+cljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.apply.cljs$core$IFn$_invoke$arity$3(clojure.tools.cli.format,fmt_21859,cljs.core.take_nth.cljs$core$IFn$_invoke$arity$2((2),cljs.core.rest(v)))], 0));
+
+cljs.core.prn();
+
+
+var G__21860 = seq__21626;
+var G__21861 = chunk__21627;
+var G__21862 = count__21628;
+var G__21863 = (i__21629 + (1));
+seq__21626 = G__21860;
+chunk__21627 = G__21861;
+count__21628 = G__21862;
+i__21629 = G__21863;
+continue;
+} else {
+var temp__5804__auto__ = cljs.core.seq(seq__21626);
+if(temp__5804__auto__){
+var seq__21626__$1 = temp__5804__auto__;
+if(cljs.core.chunked_seq_QMARK_(seq__21626__$1)){
+var c__5568__auto__ = cljs.core.chunk_first(seq__21626__$1);
+var G__21864 = cljs.core.chunk_rest(seq__21626__$1);
+var G__21865 = c__5568__auto__;
+var G__21866 = cljs.core.count(c__5568__auto__);
+var G__21867 = (0);
+seq__21626 = G__21864;
+chunk__21627 = G__21865;
+count__21628 = G__21866;
+i__21629 = G__21867;
+continue;
+} else {
+var v = cljs.core.first(seq__21626__$1);
+var fmt_21868 = clojure.tools.cli.make_format(cljs.core.take_nth.cljs$core$IFn$_invoke$arity$2((2),v));
+cljs.core.print.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.apply.cljs$core$IFn$_invoke$arity$3(clojure.tools.cli.format,fmt_21868,cljs.core.take_nth.cljs$core$IFn$_invoke$arity$2((2),cljs.core.rest(v)))], 0));
+
+cljs.core.prn();
+
+
+var G__21870 = cljs.core.next(seq__21626__$1);
+var G__21871 = null;
+var G__21872 = (0);
+var G__21873 = (0);
+seq__21626 = G__21870;
+chunk__21627 = G__21871;
+count__21628 = G__21872;
+i__21629 = G__21873;
+continue;
+}
+} else {
+return null;
+}
+}
+break;
+}
+});
+clojure.tools.cli.name_for = (function clojure$tools$cli$name_for(k){
+return clojure.string.replace(k,/^--no-|^--\[no-\]|^--|^-/,"");
+});
+clojure.tools.cli.flag_for = (function clojure$tools$cli$flag_for(v){
+return (!(clojure.string.starts_with_QMARK_(v,"--no-")));
+});
+clojure.tools.cli.opt_QMARK_ = (function clojure$tools$cli$opt_QMARK_(x){
+return clojure.string.starts_with_QMARK_(x,"-");
+});
+clojure.tools.cli.flag_QMARK_ = (function clojure$tools$cli$flag_QMARK_(x){
+return clojure.string.starts_with_QMARK_(x,"--[no-]");
+});
+clojure.tools.cli.end_of_args_QMARK_ = (function clojure$tools$cli$end_of_args_QMARK_(x){
+return cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2("--",x);
+});
+clojure.tools.cli.spec_for = (function clojure$tools$cli$spec_for(arg,specs){
+return cljs.core.first(cljs.core.filter.cljs$core$IFn$_invoke$arity$2((function (s){
+var switches = cljs.core.set((s.cljs$core$IFn$_invoke$arity$1 ? s.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,"switches","switches",2013040888)) : s.call(null,new cljs.core.Keyword(null,"switches","switches",2013040888))));
+return cljs.core.contains_QMARK_(switches,arg);
+}),specs));
+});
+clojure.tools.cli.default_values_for = (function clojure$tools$cli$default_values_for(specs){
+return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (m,s){
+if(cljs.core.contains_QMARK_(s,new cljs.core.Keyword(null,"default","default",-1987822328))){
+var G__21631 = m;
+var G__21632 = new cljs.core.Keyword(null,"name","name",1843675177).cljs$core$IFn$_invoke$arity$1(s);
+var G__21633 = new cljs.core.Keyword(null,"default","default",-1987822328).cljs$core$IFn$_invoke$arity$1(s);
+var fexpr__21630 = new cljs.core.Keyword(null,"assoc-fn","assoc-fn",418597603).cljs$core$IFn$_invoke$arity$1(s);
+return (fexpr__21630.cljs$core$IFn$_invoke$arity$3 ? fexpr__21630.cljs$core$IFn$_invoke$arity$3(G__21631,G__21632,G__21633) : fexpr__21630.call(null,G__21631,G__21632,G__21633));
+} else {
+return m;
+}
+}),cljs.core.PersistentArrayMap.EMPTY,specs);
+});
+clojure.tools.cli.apply_specs = (function clojure$tools$cli$apply_specs(specs,args){
+var options = clojure.tools.cli.default_values_for(specs);
+var extra_args = cljs.core.PersistentVector.EMPTY;
+var args__$1 = args;
+while(true){
+if(cljs.core.not(cljs.core.seq(args__$1))){
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [options,extra_args], null);
+} else {
+var opt = cljs.core.first(args__$1);
+var spec = clojure.tools.cli.spec_for(opt,specs);
+if(clojure.tools.cli.end_of_args_QMARK_(opt)){
+var G__21878 = options;
+var G__21879 = cljs.core.into.cljs$core$IFn$_invoke$arity$2(extra_args,cljs.core.vec(cljs.core.rest(args__$1)));
+var G__21880 = null;
+options = G__21878;
+extra_args = G__21879;
+args__$1 = G__21880;
+continue;
+} else {
+if(((clojure.tools.cli.opt_QMARK_(opt)) && ((spec == null)))){
+throw (new Error(["'",cljs.core.str.cljs$core$IFn$_invoke$arity$1(opt),"' is not a valid argument"].join('')));
+} else {
+if(cljs.core.truth_((function (){var and__5043__auto__ = clojure.tools.cli.opt_QMARK_(opt);
+if(and__5043__auto__){
+return (spec.cljs$core$IFn$_invoke$arity$1 ? spec.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,"flag","flag",1088647881)) : spec.call(null,new cljs.core.Keyword(null,"flag","flag",1088647881)));
+} else {
+return and__5043__auto__;
+}
+})())){
+var G__21881 = (function (){var G__21645 = options;
+var G__21646 = (spec.cljs$core$IFn$_invoke$arity$1 ? spec.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,"name","name",1843675177)) : spec.call(null,new cljs.core.Keyword(null,"name","name",1843675177)));
+var G__21647 = clojure.tools.cli.flag_for(opt);
+var fexpr__21644 = (spec.cljs$core$IFn$_invoke$arity$1 ? spec.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,"assoc-fn","assoc-fn",418597603)) : spec.call(null,new cljs.core.Keyword(null,"assoc-fn","assoc-fn",418597603)));
+return (fexpr__21644.cljs$core$IFn$_invoke$arity$3 ? fexpr__21644.cljs$core$IFn$_invoke$arity$3(G__21645,G__21646,G__21647) : fexpr__21644.call(null,G__21645,G__21646,G__21647));
+})();
+var G__21882 = extra_args;
+var G__21883 = cljs.core.rest(args__$1);
+options = G__21881;
+extra_args = G__21882;
+args__$1 = G__21883;
+continue;
+} else {
+if(clojure.tools.cli.opt_QMARK_(opt)){
+var G__21885 = (function (){var G__21649 = options;
+var G__21650 = (spec.cljs$core$IFn$_invoke$arity$1 ? spec.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,"name","name",1843675177)) : spec.call(null,new cljs.core.Keyword(null,"name","name",1843675177)));
+var G__21651 = (function (){var G__21653 = cljs.core.second(args__$1);
+var fexpr__21652 = (spec.cljs$core$IFn$_invoke$arity$1 ? spec.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,"parse-fn","parse-fn",1818406345)) : spec.call(null,new cljs.core.Keyword(null,"parse-fn","parse-fn",1818406345)));
+return (fexpr__21652.cljs$core$IFn$_invoke$arity$1 ? fexpr__21652.cljs$core$IFn$_invoke$arity$1(G__21653) : fexpr__21652.call(null,G__21653));
+})();
+var fexpr__21648 = (spec.cljs$core$IFn$_invoke$arity$1 ? spec.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,"assoc-fn","assoc-fn",418597603)) : spec.call(null,new cljs.core.Keyword(null,"assoc-fn","assoc-fn",418597603)));
+return (fexpr__21648.cljs$core$IFn$_invoke$arity$3 ? fexpr__21648.cljs$core$IFn$_invoke$arity$3(G__21649,G__21650,G__21651) : fexpr__21648.call(null,G__21649,G__21650,G__21651));
+})();
+var G__21886 = extra_args;
+var G__21887 = cljs.core.drop.cljs$core$IFn$_invoke$arity$2((2),args__$1);
+options = G__21885;
+extra_args = G__21886;
+args__$1 = G__21887;
+continue;
+} else {
+var G__21888 = options;
+var G__21889 = cljs.core.conj.cljs$core$IFn$_invoke$arity$2(extra_args,cljs.core.first(args__$1));
+var G__21890 = cljs.core.rest(args__$1);
+options = G__21888;
+extra_args = G__21889;
+args__$1 = G__21890;
+continue;
+
+}
+}
+}
+}
+}
+break;
+}
+});
+clojure.tools.cli.switches_for = (function clojure$tools$cli$switches_for(switches,flag){
+return cljs.core.flatten((function (){var iter__5523__auto__ = (function clojure$tools$cli$switches_for_$_iter__21654(s__21655){
+return (new cljs.core.LazySeq(null,(function (){
+var s__21655__$1 = s__21655;
+while(true){
+var temp__5804__auto__ = cljs.core.seq(s__21655__$1);
+if(temp__5804__auto__){
+var s__21655__$2 = temp__5804__auto__;
+if(cljs.core.chunked_seq_QMARK_(s__21655__$2)){
+var c__5521__auto__ = cljs.core.chunk_first(s__21655__$2);
+var size__5522__auto__ = cljs.core.count(c__5521__auto__);
+var b__21657 = cljs.core.chunk_buffer(size__5522__auto__);
+if((function (){var i__21656 = (0);
+while(true){
+if((i__21656 < size__5522__auto__)){
+var s = cljs.core._nth(c__5521__auto__,i__21656);
+cljs.core.chunk_append(b__21657,(cljs.core.truth_((function (){var and__5043__auto__ = flag;
+if(cljs.core.truth_(and__5043__auto__)){
+return clojure.tools.cli.flag_QMARK_(s);
+} else {
+return and__5043__auto__;
+}
+})())?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [clojure.string.replace(s,/\[no-\]/,"no-"),clojure.string.replace(s,/\[no-\]/,"")], null):(cljs.core.truth_((function (){var and__5043__auto__ = flag;
+if(cljs.core.truth_(and__5043__auto__)){
+return clojure.string.starts_with_QMARK_(s,"--");
+} else {
+return and__5043__auto__;
+}
+})())?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [clojure.string.replace(s,/--/,"--no-"),s], null):new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [s], null)
+)));
+
+var G__21897 = (i__21656 + (1));
+i__21656 = G__21897;
+continue;
+} else {
+return true;
+}
+break;
+}
+})()){
+return cljs.core.chunk_cons(cljs.core.chunk(b__21657),clojure$tools$cli$switches_for_$_iter__21654(cljs.core.chunk_rest(s__21655__$2)));
+} else {
+return cljs.core.chunk_cons(cljs.core.chunk(b__21657),null);
+}
+} else {
+var s = cljs.core.first(s__21655__$2);
+return cljs.core.cons((cljs.core.truth_((function (){var and__5043__auto__ = flag;
+if(cljs.core.truth_(and__5043__auto__)){
+return clojure.tools.cli.flag_QMARK_(s);
+} else {
+return and__5043__auto__;
+}
+})())?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [clojure.string.replace(s,/\[no-\]/,"no-"),clojure.string.replace(s,/\[no-\]/,"")], null):(cljs.core.truth_((function (){var and__5043__auto__ = flag;
+if(cljs.core.truth_(and__5043__auto__)){
+return clojure.string.starts_with_QMARK_(s,"--");
+} else {
+return and__5043__auto__;
+}
+})())?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [clojure.string.replace(s,/--/,"--no-"),s], null):new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [s], null)
+)),clojure$tools$cli$switches_for_$_iter__21654(cljs.core.rest(s__21655__$2)));
+}
+} else {
+return null;
+}
+break;
+}
+}),null,null));
+});
+return iter__5523__auto__(switches);
+})());
+});
+clojure.tools.cli.generate_spec = (function clojure$tools$cli$generate_spec(raw_spec){
+var vec__21659 = cljs.core.split_with((function (p1__21658_SHARP_){
+return ((typeof p1__21658_SHARP_ === 'string') && (clojure.tools.cli.opt_QMARK_(p1__21658_SHARP_)));
+}),raw_spec);
+var switches = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21659,(0),null);
+var raw_spec__$1 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21659,(1),null);
+var vec__21662 = cljs.core.split_with(cljs.core.string_QMARK_,raw_spec__$1);
+var docs = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21662,(0),null);
+var raw_spec__$2 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21662,(1),null);
+var options = cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.hash_map,raw_spec__$2);
+var aliases = cljs.core.map.cljs$core$IFn$_invoke$arity$2(clojure.tools.cli.name_for,switches);
+var flag = (function (){var or__5045__auto__ = clojure.tools.cli.flag_QMARK_(cljs.core.last(switches));
+if(or__5045__auto__){
+return or__5045__auto__;
+} else {
+return (options.cljs$core$IFn$_invoke$arity$1 ? options.cljs$core$IFn$_invoke$arity$1(new cljs.core.Keyword(null,"flag","flag",1088647881)) : options.call(null,new cljs.core.Keyword(null,"flag","flag",1088647881)));
+}
+})();
+return cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentArrayMap(null, 7, [new cljs.core.Keyword(null,"switches","switches",2013040888),clojure.tools.cli.switches_for(switches,flag),new cljs.core.Keyword(null,"docs","docs",-1974280502),cljs.core.first(docs),new cljs.core.Keyword(null,"aliases","aliases",1346874714),cljs.core.set(aliases),new cljs.core.Keyword(null,"name","name",1843675177),cljs.core.keyword.cljs$core$IFn$_invoke$arity$1(cljs.core.last(aliases)),new cljs.core.Keyword(null,"parse-fn","parse-fn",1818406345),cljs.core.identity,new cljs.core.Keyword(null,"assoc-fn","assoc-fn",418597603),cljs.core.assoc,new cljs.core.Keyword(null,"flag","flag",1088647881),flag], null),(cljs.core.truth_(flag)?new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,"default","default",-1987822328),false], null):null),options], 0));
+});
+/**
+ * Rewrite arguments sequence into a normalized form that is parsable by cli.
+ */
+clojure.tools.cli.normalize_args = (function clojure$tools$cli$normalize_args(specs,args){
+var required_opts = cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentHashSet.EMPTY,cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic(new cljs.core.Keyword(null,"switches","switches",2013040888),cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([cljs.core.filter.cljs$core$IFn$_invoke$arity$2(cljs.core.complement(new cljs.core.Keyword(null,"flag","flag",1088647881)),specs)], 0)));
+var largs = cljs.core.take_while.cljs$core$IFn$_invoke$arity$2(cljs.core.partial.cljs$core$IFn$_invoke$arity$2(cljs.core.not_EQ_,"--"),args);
+var rargs = cljs.core.drop.cljs$core$IFn$_invoke$arity$2(cljs.core.count(largs),args);
+var vec__21665 = clojure.tools.cli.tokenize_args(required_opts,largs);
+var opts = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21665,(0),null);
+var largs__$1 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21665,(1),null);
+return cljs.core.concat.cljs$core$IFn$_invoke$arity$variadic(cljs.core.mapcat.cljs$core$IFn$_invoke$arity$variadic(cljs.core.rest,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([opts], 0)),largs__$1,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([rargs], 0));
+});
+/**
+ * THIS IS A LEGACY FUNCTION and may be deprecated in the future. Please use
+ *   clojure.tools.cli/parse-opts in new applications.
+ * 
+ *   Parse the provided args using the given specs. Specs are vectors
+ *   describing a command line argument. For example:
+ * 
+ *   ["-p" "--port" "Port to listen on" :default 3000 :parse-fn #(Integer/parseInt %)]
+ * 
+ *   First provide the switches (from least to most specific), then a doc
+ *   string, and pairs of options.
+ * 
+ *   Valid options are :default, :parse-fn, and :flag. See
+ *   https://github.com/clojure/tools.cli/wiki/Documentation-for-0.2.4 for more
+ *   detailed examples.
+ * 
+ *   Returns a vector containing a map of the parsed arguments, a vector
+ *   of extra arguments that did not match known switches, and a
+ *   documentation banner to provide usage instructions.
+ */
+clojure.tools.cli.cli = (function clojure$tools$cli$cli(var_args){
+var args__5775__auto__ = [];
+var len__5769__auto___21913 = arguments.length;
+var i__5770__auto___21914 = (0);
+while(true){
+if((i__5770__auto___21914 < len__5769__auto___21913)){
+args__5775__auto__.push((arguments[i__5770__auto___21914]));
+
+var G__21915 = (i__5770__auto___21914 + (1));
+i__5770__auto___21914 = G__21915;
+continue;
+} else {
+}
+break;
+}
+
+var argseq__5776__auto__ = ((((1) < args__5775__auto__.length))?(new cljs.core.IndexedSeq(args__5775__auto__.slice((1)),(0),null)):null);
+return clojure.tools.cli.cli.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),argseq__5776__auto__);
+});
+
+(clojure.tools.cli.cli.cljs$core$IFn$_invoke$arity$variadic = (function (args,specs){
+var vec__21670 = ((typeof cljs.core.first(specs) === 'string')?new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.first(specs),cljs.core.rest(specs)], null):new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,specs], null));
+var desc = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21670,(0),null);
+var specs__$1 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21670,(1),null);
+var specs__$2 = cljs.core.map.cljs$core$IFn$_invoke$arity$2(clojure.tools.cli.generate_spec,specs__$1);
+var args__$1 = clojure.tools.cli.normalize_args(specs__$2,args);
+var vec__21673 = clojure.tools.cli.apply_specs(specs__$2,args__$1);
+var options = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21673,(0),null);
+var extra_args = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21673,(1),null);
+var banner = (function (){var sb__5690__auto__ = (new goog.string.StringBuffer());
+var _STAR_print_newline_STAR__orig_val__21676_21917 = cljs.core._STAR_print_newline_STAR_;
+var _STAR_print_fn_STAR__orig_val__21677_21918 = cljs.core._STAR_print_fn_STAR_;
+var _STAR_print_newline_STAR__temp_val__21678_21919 = true;
+var _STAR_print_fn_STAR__temp_val__21679_21920 = (function (x__5691__auto__){
+return sb__5690__auto__.append(x__5691__auto__);
+});
+(cljs.core._STAR_print_newline_STAR_ = _STAR_print_newline_STAR__temp_val__21678_21919);
+
+(cljs.core._STAR_print_fn_STAR_ = _STAR_print_fn_STAR__temp_val__21679_21920);
+
+try{clojure.tools.cli.banner_for(desc,specs__$2);
+}finally {(cljs.core._STAR_print_fn_STAR_ = _STAR_print_fn_STAR__orig_val__21677_21918);
+
+(cljs.core._STAR_print_newline_STAR_ = _STAR_print_newline_STAR__orig_val__21676_21917);
+}
+return cljs.core.str.cljs$core$IFn$_invoke$arity$1(sb__5690__auto__);
+})();
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [options,extra_args,banner], null);
+}));
+
+(clojure.tools.cli.cli.cljs$lang$maxFixedArity = (1));
+
+/** @this {Function} */
+(clojure.tools.cli.cli.cljs$lang$applyTo = (function (seq21668){
+var G__21669 = cljs.core.first(seq21668);
+var seq21668__$1 = cljs.core.next(seq21668);
+var self__5754__auto__ = this;
+return self__5754__auto__.cljs$core$IFn$_invoke$arity$variadic(G__21669,seq21668__$1);
+}));
+
+clojure.tools.cli.spec_keys = new cljs.core.PersistentVector(null, 16, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null,"id","id",-1388402092),new cljs.core.Keyword(null,"short-opt","short-opt",-384995699),new cljs.core.Keyword(null,"long-opt","long-opt",-386094553),new cljs.core.Keyword(null,"required","required",1807647006),new cljs.core.Keyword(null,"desc","desc",2093485764),new cljs.core.Keyword(null,"default","default",-1987822328),new cljs.core.Keyword(null,"default-desc","default-desc",324577013),new cljs.core.Keyword(null,"default-fn","default-fn",-473729550),new cljs.core.Keyword(null,"parse-fn","parse-fn",1818406345),new cljs.core.Keyword(null,"assoc-fn","assoc-fn",418597603),new cljs.core.Keyword(null,"update-fn","update-fn",711087313),new cljs.core.Keyword(null,"multi","multi",-190293005),new cljs.core.Keyword(null,"post-validation","post-validation",-1787936392),new cljs.core.Keyword(null,"validate-fn","validate-fn",1430169944),new cljs.core.Keyword(null,"validate-msg","validate-msg",-1415932287),new cljs.core.Keyword(null,"missing","missing",362507769)], null);
+/**
+ * Select only known spec entries from map and warn the user about unknown
+ * entries at development time.
+ */
+clojure.tools.cli.select_spec_keys = (function clojure$tools$cli$select_spec_keys(map){
+if(cljs.core.truth_(cljs.core._STAR_assert_STAR_)){
+var unknown_keys_21922 = cljs.core.keys(cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.dissoc,map,clojure.tools.cli.spec_keys));
+if(cljs.core.seq(unknown_keys_21922)){
+var msg_21923 = ["Warning: The following options to parse-opts are unrecognized: ",clojure.string.join.cljs$core$IFn$_invoke$arity$2(", ",unknown_keys_21922)].join('');
+var _STAR_print_fn_STAR__orig_val__21680_21924 = cljs.core._STAR_print_fn_STAR_;
+var _STAR_print_fn_STAR__temp_val__21681_21925 = cljs.core._STAR_print_err_fn_STAR_;
+(cljs.core._STAR_print_fn_STAR_ = _STAR_print_fn_STAR__temp_val__21681_21925);
+
+try{cljs.core.println.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([msg_21923], 0));
+}finally {(cljs.core._STAR_print_fn_STAR_ = _STAR_print_fn_STAR__orig_val__21680_21924);
+}} else {
+}
+} else {
+}
+
+return cljs.core.select_keys(map,clojure.tools.cli.spec_keys);
+});
+clojure.tools.cli.compile_spec = (function clojure$tools$cli$compile_spec(spec){
+var sopt_lopt_desc = cljs.core.take_while.cljs$core$IFn$_invoke$arity$2((function (p1__21682_SHARP_){
+return ((typeof p1__21682_SHARP_ === 'string') || ((p1__21682_SHARP_ == null)));
+}),spec);
+var spec_map = cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.hash_map,cljs.core.drop.cljs$core$IFn$_invoke$arity$2(cljs.core.count(sopt_lopt_desc),spec));
+var vec__21683 = sopt_lopt_desc;
+var short_opt = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21683,(0),null);
+var long_opt = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21683,(1),null);
+var desc = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21683,(2),null);
+var long_opt__$1 = (function (){var or__5045__auto__ = long_opt;
+if(cljs.core.truth_(or__5045__auto__)){
+return or__5045__auto__;
+} else {
+return new cljs.core.Keyword(null,"long-opt","long-opt",-386094553).cljs$core$IFn$_invoke$arity$1(spec_map);
+}
+})();
+var vec__21686 = (cljs.core.truth_(long_opt__$1)?cljs.core.rest(cljs.core.re_find(/^(--[^ =]+)(?:[ =](.*))?/,long_opt__$1)):null);
+var long_opt__$2 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21686,(0),null);
+var req = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21686,(1),null);
+var id = (cljs.core.truth_(long_opt__$2)?cljs.core.keyword.cljs$core$IFn$_invoke$arity$1(cljs.core.nth.cljs$core$IFn$_invoke$arity$2(cljs.core.re_find(/^--(\[no-\])?(.*)/,long_opt__$2),(2))):null);
+var validate = new cljs.core.Keyword(null,"validate","validate",-201300827).cljs$core$IFn$_invoke$arity$1(spec_map);
+var vec__21689 = ((cljs.core.seq(validate))?cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.map,cljs.core.vector,cljs.core.partition.cljs$core$IFn$_invoke$arity$4((2),(2),cljs.core.repeat.cljs$core$IFn$_invoke$arity$1(null),validate)):null);
+var validate_fn = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21689,(0),null);
+var validate_msg = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21689,(1),null);
+return cljs.core.merge.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.PersistentArrayMap(null, 7, [new cljs.core.Keyword(null,"id","id",-1388402092),id,new cljs.core.Keyword(null,"short-opt","short-opt",-384995699),short_opt,new cljs.core.Keyword(null,"long-opt","long-opt",-386094553),long_opt__$2,new cljs.core.Keyword(null,"required","required",1807647006),req,new cljs.core.Keyword(null,"desc","desc",2093485764),desc,new cljs.core.Keyword(null,"validate-fn","validate-fn",1430169944),validate_fn,new cljs.core.Keyword(null,"validate-msg","validate-msg",-1415932287),validate_msg], null),clojure.tools.cli.select_spec_keys(cljs.core.dissoc.cljs$core$IFn$_invoke$arity$2(spec_map,new cljs.core.Keyword(null,"validate","validate",-201300827)))], 0));
+});
+clojure.tools.cli.distinct_QMARK__STAR_ = (function clojure$tools$cli$distinct_QMARK__STAR_(coll){
+if(cljs.core.seq(coll)){
+return cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.distinct_QMARK_,coll);
+} else {
+return true;
+}
+});
+clojure.tools.cli.wrap_val = (function clojure$tools$cli$wrap_val(map,key){
+if(cljs.core.contains_QMARK_(map,key)){
+return cljs.core.update_in.cljs$core$IFn$_invoke$arity$3(map,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [key], null),(function (p1__21693_SHARP_){
+if((p1__21693_SHARP_ == null)){
+return null;
+} else {
+if(cljs.core.coll_QMARK_(p1__21693_SHARP_)){
+return p1__21693_SHARP_;
+} else {
+return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [p1__21693_SHARP_], null);
+
+}
+}
+}));
+} else {
+return map;
+}
+});
+/**
+ * Map a sequence of option specification vectors to a sequence of:
+ * 
+ *   {:id           Keyword  ; :server
+ * :short-opt    String   ; "-s"
+ * :long-opt     String   ; "--server"
+ * :required     String   ; "HOSTNAME"
+ * :desc         String   ; "Remote server"
+ * :default      Object   ; #<Inet4Address example.com/93.184.216.119>
+ * :default-desc String   ; "example.com"
+ * :default-fn   IFn      ; (constantly 0)
+ * :parse-fn     IFn      ; #(InetAddress/getByName %)
+ * :assoc-fn     IFn      ; assoc
+ * :update-fn    IFn      ; identity
+ * :validate-fn  [IFn]    ; [#(instance? Inet4Address %)
+ *                        ;  #(not (.isMulticastAddress %)]
+ * :validate-msg [String] ; ["Must be an IPv4 host"
+ *                        ;  "Must not be a multicast address"]
+ *                        ; can also be a function (of the invalid argument)
+ * :post-validation Boolean ; default false
+ * :missing      String   ; "server must be specified"
+ * }
+ * 
+ *   :id defaults to the keywordized name of long-opt without leading dashes, but
+ *   may be overridden in the option spec.
+ * 
+ *   The option spec entry `:validate [fn msg ...]` desugars into the two vector
+ *   entries :validate-fn and :validate-msg. Multiple pairs of validation
+ *   functions and error messages may be provided.
+ * 
+ *   A :default(-fn) entry will not be included in the compiled spec unless
+ *   specified. The :default is applied before options are parsed, the :default-fn
+ *   is applied after options are parsed (only where an option was not specified,
+ *   and is passed the whole options map as its single argument, so defaults can
+ *   be computed from other options if needed).
+ * 
+ *   An option spec may also be passed as a map containing the entries above,
+ *   in which case that subset of the map is transferred directly to the result
+ *   vector.
+ * 
+ *   An assertion error is thrown if any :id values are unset, or if there exist
+ *   any duplicate :id, :short-opt, or :long-opt values, or if both :assoc-fn and
+ *   :update-fn are provided for any single option.
+ */
+clojure.tools.cli.compile_option_specs = (function clojure$tools$cli$compile_option_specs(option_specs){
+var _PERCENT_ = cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (spec){
+return clojure.tools.cli.wrap_val(clojure.tools.cli.wrap_val(((cljs.core.map_QMARK_(spec))?clojure.tools.cli.select_spec_keys(spec):clojure.tools.cli.compile_spec(spec)),new cljs.core.Keyword(null,"validate-fn","validate-fn",1430169944)),new cljs.core.Keyword(null,"validate-msg","validate-msg",-1415932287));
+}),option_specs);
+if(cljs.core.every_QMARK_(new cljs.core.Keyword(null,"id","id",-1388402092),_PERCENT_)){
+} else {
+throw (new Error("Assert failed: (every? :id %)"));
+}
+
+if(cljs.core.truth_(clojure.tools.cli.distinct_QMARK__STAR_(cljs.core.map.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,"id","id",-1388402092),cljs.core.filter.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,"default","default",-1987822328),_PERCENT_))))){
+} else {
+throw (new Error("Assert failed: (distinct?* (map :id (filter :default %)))"));
+}
+
+if(cljs.core.truth_(clojure.tools.cli.distinct_QMARK__STAR_(cljs.core.map.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,"id","id",-1388402092),cljs.core.filter.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,"default-fn","default-fn",-473729550),_PERCENT_))))){
+} else {
+throw (new Error("Assert failed: (distinct?* (map :id (filter :default-fn %)))"));
+}
+
+if(cljs.core.truth_(clojure.tools.cli.distinct_QMARK__STAR_(cljs.core.remove.cljs$core$IFn$_invoke$arity$2(cljs.core.nil_QMARK_,cljs.core.map.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,"short-opt","short-opt",-384995699),_PERCENT_))))){
+} else {
+throw (new Error("Assert failed: (distinct?* (remove nil? (map :short-opt %)))"));
+}
+
+if(cljs.core.truth_(clojure.tools.cli.distinct_QMARK__STAR_(cljs.core.remove.cljs$core$IFn$_invoke$arity$2(cljs.core.nil_QMARK_,cljs.core.map.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,"long-opt","long-opt",-386094553),_PERCENT_))))){
+} else {
+throw (new Error("Assert failed: (distinct?* (remove nil? (map :long-opt %)))"));
+}
+
+if(cljs.core.every_QMARK_(cljs.core.comp.cljs$core$IFn$_invoke$arity$2(cljs.core.not,cljs.core.partial.cljs$core$IFn$_invoke$arity$2(cljs.core.every_QMARK_,cljs.core.identity)),cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.juxt.cljs$core$IFn$_invoke$arity$2(new cljs.core.Keyword(null,"assoc-fn","assoc-fn",418597603),new cljs.core.Keyword(null,"update-fn","update-fn",711087313)),_PERCENT_))){
+} else {
+throw (new Error("Assert failed: (every? (comp not (partial every? identity)) (map (juxt :assoc-fn :update-fn) %))"));
+}
+
+return _PERCENT_;
+});
+clojure.tools.cli.default_option_map = (function clojure$tools$cli$default_option_map(specs,default_key){
+return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (m,s){
+if(cljs.core.contains_QMARK_(s,default_key)){
+return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,new cljs.core.Keyword(null,"id","id",-1388402092).cljs$core$IFn$_invoke$arity$1(s),(default_key.cljs$core$IFn$_invoke$arity$1 ? default_key.cljs$core$IFn$_invoke$arity$1(s) : default_key.call(null,s)));
+} else {
+return m;
+}
+}),cljs.core.PersistentArrayMap.EMPTY,specs);
+});
+/**
+ * Given specs, returns a map of spec id to error message if missing.
+ */
+clojure.tools.cli.missing_errors = (function clojure$tools$cli$missing_errors(specs){
+return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (m,s){
+if(cljs.core.truth_(new cljs.core.Keyword(null,"missing","missing",362507769).cljs$core$IFn$_invoke$arity$1(s))){
+return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,new cljs.core.Keyword(null,"id","id",-1388402092).cljs$core$IFn$_invoke$arity$1(s),new cljs.core.Keyword(null,"missing","missing",362507769).cljs$core$IFn$_invoke$arity$1(s));
+} else {
+return m;
+}
+}),cljs.core.PersistentArrayMap.EMPTY,specs);
+});
+clojure.tools.cli.find_spec = (function clojure$tools$cli$find_spec(specs,opt_type,opt){
+return cljs.core.first(cljs.core.filter.cljs$core$IFn$_invoke$arity$2((function (spec){
+var temp__5804__auto__ = cljs.core.get.cljs$core$IFn$_invoke$arity$2(spec,opt_type);
+if(cljs.core.truth_(temp__5804__auto__)){
+var spec_opt = temp__5804__auto__;
+var flag_tail = cljs.core.second(cljs.core.re_find(/^--\[no-\](.*)/,spec_opt));
+var candidates = (cljs.core.truth_(flag_tail)?cljs.core.PersistentHashSet.createAsIfByAssoc([["--",cljs.core.str.cljs$core$IFn$_invoke$arity$1(flag_tail)].join(''),["--no-",cljs.core.str.cljs$core$IFn$_invoke$arity$1(flag_tail)].join('')]):cljs.core.PersistentHashSet.createAsIfByAssoc([spec_opt]));
+return cljs.core.contains_QMARK_(candidates,opt);
+} else {
+return null;
+}
+}),specs));
+});
+clojure.tools.cli.pr_join = (function clojure$tools$cli$pr_join(var_args){
+var args__5775__auto__ = [];
+var len__5769__auto___21931 = arguments.length;
+var i__5770__auto___21933 = (0);
+while(true){
+if((i__5770__auto___21933 < len__5769__auto___21931)){
+args__5775__auto__.push((arguments[i__5770__auto___21933]));
+
+var G__21934 = (i__5770__auto___21933 + (1));
+i__5770__auto___21933 = G__21934;
+continue;
+} else {
+}
+break;
+}
+
+var argseq__5776__auto__ = ((((0) < args__5775__auto__.length))?(new cljs.core.IndexedSeq(args__5775__auto__.slice((0)),(0),null)):null);
+return clojure.tools.cli.pr_join.cljs$core$IFn$_invoke$arity$variadic(argseq__5776__auto__);
+});
+
+(clojure.tools.cli.pr_join.cljs$core$IFn$_invoke$arity$variadic = (function (xs){
+return cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([clojure.string.join.cljs$core$IFn$_invoke$arity$2(" ",xs)], 0));
+}));
+
+(clojure.tools.cli.pr_join.cljs$lang$maxFixedArity = (0));
+
+/** @this {Function} */
+(clojure.tools.cli.pr_join.cljs$lang$applyTo = (function (seq21694){
+var self__5755__auto__ = this;
+return self__5755__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq(seq21694));
+}));
+
+clojure.tools.cli.missing_required_error = (function clojure$tools$cli$missing_required_error(opt,example_required){
+return ["Missing required argument for ",clojure.tools.cli.pr_join.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([opt,example_required], 0))].join('');
+});
+clojure.tools.cli.parse_error = (function clojure$tools$cli$parse_error(opt,optarg,msg){
+return ["Error while parsing option ",clojure.tools.cli.pr_join.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([opt,optarg], 0)),": ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(msg)].join('');
+});
+clojure.tools.cli.validation_error = (function clojure$tools$cli$validation_error(value,opt,optarg,msg){
+return ["Failed to validate ",clojure.tools.cli.pr_join.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([opt,optarg], 0)),(cljs.core.truth_(msg)?[": ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(((typeof msg === 'string')?msg:(msg.cljs$core$IFn$_invoke$arity$1 ? msg.cljs$core$IFn$_invoke$arity$1(value) : msg.call(null,value))))].join(''):"")].join('');
+});
+clojure.tools.cli.validate = (function clojure$tools$cli$validate(value,spec,opt,optarg){
+var map__21695 = spec;
+var map__21695__$1 = cljs.core.__destructure_map(map__21695);
+var validate_fn = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21695__$1,new cljs.core.Keyword(null,"validate-fn","validate-fn",1430169944));
+var validate_msg = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21695__$1,new cljs.core.Keyword(null,"validate-msg","validate-msg",-1415932287));
+var or__5045__auto__ = (function (){var G__21702 = validate_fn;
+var vec__21704 = G__21702;
+var seq__21705 = cljs.core.seq(vec__21704);
+var first__21706 = cljs.core.first(seq__21705);
+var seq__21705__$1 = cljs.core.next(seq__21705);
+var vfn = first__21706;
+var vfns = seq__21705__$1;
+var G__21703 = validate_msg;
+var vec__21707 = G__21703;
+var seq__21708 = cljs.core.seq(vec__21707);
+var first__21709 = cljs.core.first(seq__21708);
+var seq__21708__$1 = cljs.core.next(seq__21708);
+var msg = first__21709;
+var msgs = seq__21708__$1;
+var G__21702__$1 = G__21702;
+var G__21703__$1 = G__21703;
+while(true){
+var vec__21717 = G__21702__$1;
+var seq__21718 = cljs.core.seq(vec__21717);
+var first__21719 = cljs.core.first(seq__21718);
+var seq__21718__$1 = cljs.core.next(seq__21718);
+var vfn__$1 = first__21719;
+var vfns__$1 = seq__21718__$1;
+var vec__21720 = G__21703__$1;
+var seq__21721 = cljs.core.seq(vec__21720);
+var first__21722 = cljs.core.first(seq__21721);
+var seq__21721__$1 = cljs.core.next(seq__21721);
+var msg__$1 = first__21722;
+var msgs__$1 = seq__21721__$1;
+if(cljs.core.truth_(vfn__$1)){
+if(cljs.core.truth_((function (){try{return (vfn__$1.cljs$core$IFn$_invoke$arity$1 ? vfn__$1.cljs$core$IFn$_invoke$arity$1(value) : vfn__$1.call(null,value));
+}catch (e21723){var _ = e21723;
+return null;
+}})())){
+var G__21940 = vfns__$1;
+var G__21941 = msgs__$1;
+G__21702__$1 = G__21940;
+G__21703__$1 = G__21941;
+continue;
+} else {
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword("clojure.tools.cli","error","clojure.tools.cli/error",1727067675),clojure.tools.cli.validation_error(value,opt,optarg,msg__$1)], null);
+}
+} else {
+return null;
+}
+break;
+}
+})();
+if(cljs.core.truth_(or__5045__auto__)){
+return or__5045__auto__;
+} else {
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [value,null], null);
+}
+});
+clojure.tools.cli.parse_value = (function clojure$tools$cli$parse_value(value,spec,opt,optarg){
+var map__21724 = spec;
+var map__21724__$1 = cljs.core.__destructure_map(map__21724);
+var parse_fn = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21724__$1,new cljs.core.Keyword(null,"parse-fn","parse-fn",1818406345));
+var vec__21725 = (cljs.core.truth_(parse_fn)?(function (){try{return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(parse_fn.cljs$core$IFn$_invoke$arity$1 ? parse_fn.cljs$core$IFn$_invoke$arity$1(value) : parse_fn.call(null,value)),null], null);
+}catch (e21728){var e = e21728;
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,clojure.tools.cli.parse_error(opt,optarg,cljs.core.str.cljs$core$IFn$_invoke$arity$1(e))], null);
+}})():new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [value,null], null));
+var value__$1 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21725,(0),null);
+var error = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21725,(1),null);
+if(cljs.core.truth_(error)){
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword("clojure.tools.cli","error","clojure.tools.cli/error",1727067675),error], null);
+} else {
+if(cljs.core.truth_(new cljs.core.Keyword(null,"post-validation","post-validation",-1787936392).cljs$core$IFn$_invoke$arity$1(spec))){
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [value__$1,null], null);
+} else {
+return clojure.tools.cli.validate(value__$1,spec,opt,optarg);
+
+}
+}
+});
+clojure.tools.cli.allow_no_QMARK_ = (function clojure$tools$cli$allow_no_QMARK_(spec){
+var and__5043__auto__ = new cljs.core.Keyword(null,"long-opt","long-opt",-386094553).cljs$core$IFn$_invoke$arity$1(spec);
+if(cljs.core.truth_(and__5043__auto__)){
+return cljs.core.re_find(/^--\[no-\]/,new cljs.core.Keyword(null,"long-opt","long-opt",-386094553).cljs$core$IFn$_invoke$arity$1(spec));
+} else {
+return and__5043__auto__;
+}
+});
+clojure.tools.cli.neg_flag_QMARK_ = (function clojure$tools$cli$neg_flag_QMARK_(spec,opt){
+var and__5043__auto__ = clojure.tools.cli.allow_no_QMARK_(spec);
+if(cljs.core.truth_(and__5043__auto__)){
+return cljs.core.re_find(/^--no-/,opt);
+} else {
+return and__5043__auto__;
+}
+});
+clojure.tools.cli.parse_optarg = (function clojure$tools$cli$parse_optarg(spec,opt,optarg){
+var map__21729 = spec;
+var map__21729__$1 = cljs.core.__destructure_map(map__21729);
+var required = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21729__$1,new cljs.core.Keyword(null,"required","required",1807647006));
+if(cljs.core.truth_((function (){var and__5043__auto__ = required;
+if(cljs.core.truth_(and__5043__auto__)){
+return (optarg == null);
+} else {
+return and__5043__auto__;
+}
+})())){
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword("clojure.tools.cli","error","clojure.tools.cli/error",1727067675),clojure.tools.cli.missing_required_error(opt,required)], null);
+} else {
+var value = (cljs.core.truth_(required)?optarg:cljs.core.not(clojure.tools.cli.neg_flag_QMARK_(spec,opt)));
+return clojure.tools.cli.parse_value(value,spec,opt,optarg);
+}
+});
+/**
+ * Reduce sequence of [opt-type opt ?optarg?] tokens into a map of
+ *   {option-id value} merged over the default values in the option
+ *   specifications.
+ * 
+ *   If the :no-defaults flag is true, only options specified in the tokens are
+ *   included in the option-map.
+ * 
+ *   Unknown options, missing options, missing required arguments, option
+ *   argument parsing exceptions, and validation failures are collected into
+ *   a vector of error message strings.
+ * 
+ *   If the :strict flag is true, required arguments that match other options
+ *   are treated as missing, instead of a literal value beginning with - or --.
+ * 
+ *   Returns [option-map error-messages-vector].
+ */
+clojure.tools.cli.parse_option_tokens = (function clojure$tools$cli$parse_option_tokens(var_args){
+var args__5775__auto__ = [];
+var len__5769__auto___21945 = arguments.length;
+var i__5770__auto___21946 = (0);
+while(true){
+if((i__5770__auto___21946 < len__5769__auto___21945)){
+args__5775__auto__.push((arguments[i__5770__auto___21946]));
+
+var G__21947 = (i__5770__auto___21946 + (1));
+i__5770__auto___21946 = G__21947;
+continue;
+} else {
+}
+break;
+}
+
+var argseq__5776__auto__ = ((((2) < args__5775__auto__.length))?(new cljs.core.IndexedSeq(args__5775__auto__.slice((2)),(0),null)):null);
+return clojure.tools.cli.parse_option_tokens.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5776__auto__);
+});
+
+(clojure.tools.cli.parse_option_tokens.cljs$core$IFn$_invoke$arity$variadic = (function (specs,tokens,options){
+var map__21736 = cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.hash_map,options);
+var map__21736__$1 = cljs.core.__destructure_map(map__21736);
+var no_defaults = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21736__$1,new cljs.core.Keyword(null,"no-defaults","no-defaults",-1025033878));
+var strict = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21736__$1,new cljs.core.Keyword(null,"strict","strict",-665564191));
+var defaults = clojure.tools.cli.default_option_map(specs,new cljs.core.Keyword(null,"default","default",-1987822328));
+var default_fns = clojure.tools.cli.default_option_map(specs,new cljs.core.Keyword(null,"default-fn","default-fn",-473729550));
+var requireds = clojure.tools.cli.missing_errors(specs);
+return (function (p1__21732_SHARP_){
+var vec__21737 = p1__21732_SHARP_;
+var m = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21737,(0),null);
+var ids = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21737,(1),null);
+var errors = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21737,(2),null);
+if(cljs.core.truth_(no_defaults)){
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.select_keys(m,ids),errors], null);
+} else {
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [m,errors], null);
+}
+})((function (p1__21731_SHARP_){
+return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p__21740,p__21741){
+var vec__21742 = p__21740;
+var m = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21742,(0),null);
+var ids = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21742,(1),null);
+var errors = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21742,(2),null);
+var vec__21745 = p__21741;
+var id = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21745,(0),null);
+var f = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21745,(1),null);
+if(cljs.core.contains_QMARK_(cljs.core.set(ids),id)){
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [m,ids,errors], null);
+} else {
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(m,id,(function (){var G__21748 = cljs.core.first(p1__21731_SHARP_);
+return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__21748) : f.call(null,G__21748));
+})()),ids,errors], null);
+}
+}),p1__21731_SHARP_,default_fns);
+})((function (p1__21730_SHARP_){
+return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p__21749,p__21750){
+var vec__21751 = p__21749;
+var m = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21751,(0),null);
+var ids = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21751,(1),null);
+var errors = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21751,(2),null);
+var vec__21754 = p__21750;
+var id = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21754,(0),null);
+var error = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21754,(1),null);
+if(cljs.core.contains_QMARK_(m,id)){
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [m,ids,errors], null);
+} else {
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [m,ids,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(errors,error)], null);
+}
+}),p1__21730_SHARP_,requireds);
+})(cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (p__21758,p__21759){
+var vec__21760 = p__21758;
+var m = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21760,(0),null);
+var ids = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21760,(1),null);
+var errors = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21760,(2),null);
+var vec__21763 = p__21759;
+var opt_type = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21763,(0),null);
+var opt = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21763,(1),null);
+var optarg = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21763,(2),null);
+var temp__5802__auto__ = clojure.tools.cli.find_spec(specs,opt_type,opt);
+if(cljs.core.truth_(temp__5802__auto__)){
+var spec = temp__5802__auto__;
+var vec__21766 = clojure.tools.cli.parse_optarg(spec,opt,optarg);
+var value = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21766,(0),null);
+var error = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21766,(1),null);
+var id = new cljs.core.Keyword(null,"id","id",-1388402092).cljs$core$IFn$_invoke$arity$1(spec);
+if((!(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(value,new cljs.core.Keyword("clojure.tools.cli","error","clojure.tools.cli/error",1727067675))))){
+if(cljs.core.truth_((function (){var and__5043__auto__ = strict;
+if(cljs.core.truth_(and__5043__auto__)){
+var or__5045__auto__ = clojure.tools.cli.find_spec(specs,new cljs.core.Keyword(null,"short-opt","short-opt",-384995699),optarg);
+if(cljs.core.truth_(or__5045__auto__)){
+return or__5045__auto__;
+} else {
+return clojure.tools.cli.find_spec(specs,new cljs.core.Keyword(null,"long-opt","long-opt",-386094553),optarg);
+}
+} else {
+return and__5043__auto__;
+}
+})())){
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [m,ids,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(errors,clojure.tools.cli.missing_required_error(opt,new cljs.core.Keyword(null,"required","required",1807647006).cljs$core$IFn$_invoke$arity$1(spec)))], null);
+} else {
+var m_SINGLEQUOTE_ = (function (){var temp__5802__auto____$1 = new cljs.core.Keyword(null,"update-fn","update-fn",711087313).cljs$core$IFn$_invoke$arity$1(spec);
+if(cljs.core.truth_(temp__5802__auto____$1)){
+var update_fn = temp__5802__auto____$1;
+if(cljs.core.truth_(new cljs.core.Keyword(null,"multi","multi",-190293005).cljs$core$IFn$_invoke$arity$1(spec))){
+return cljs.core.update.cljs$core$IFn$_invoke$arity$4(m,id,update_fn,value);
+} else {
+return cljs.core.update.cljs$core$IFn$_invoke$arity$3(m,id,update_fn);
+}
+} else {
+var fexpr__21770 = new cljs.core.Keyword(null,"assoc-fn","assoc-fn",418597603).cljs$core$IFn$_invoke$arity$2(spec,cljs.core.assoc);
+return (fexpr__21770.cljs$core$IFn$_invoke$arity$3 ? fexpr__21770.cljs$core$IFn$_invoke$arity$3(m,id,value) : fexpr__21770.call(null,m,id,value));
+}
+})();
+if(cljs.core.truth_(new cljs.core.Keyword(null,"post-validation","post-validation",-1787936392).cljs$core$IFn$_invoke$arity$1(spec))){
+var vec__21771 = clojure.tools.cli.validate(cljs.core.get.cljs$core$IFn$_invoke$arity$2(m_SINGLEQUOTE_,id),spec,opt,optarg);
+var value__$1 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21771,(0),null);
+var error__$1 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21771,(1),null);
+if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(value__$1,new cljs.core.Keyword("clojure.tools.cli","error","clojure.tools.cli/error",1727067675))){
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [m,ids,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(errors,error__$1)], null);
+} else {
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [m_SINGLEQUOTE_,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(ids,id),errors], null);
+}
+} else {
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [m_SINGLEQUOTE_,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(ids,id),errors], null);
+}
+}
+} else {
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [m,ids,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(errors,error)], null);
+}
+} else {
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [m,ids,cljs.core.conj.cljs$core$IFn$_invoke$arity$2(errors,["Unknown option: ",cljs.core.pr_str.cljs$core$IFn$_invoke$arity$variadic(cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([opt], 0))].join(''))], null);
+}
+}),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [defaults,cljs.core.PersistentVector.EMPTY,cljs.core.PersistentVector.EMPTY], null),tokens))));
+}));
+
+(clojure.tools.cli.parse_option_tokens.cljs$lang$maxFixedArity = (2));
+
+/** @this {Function} */
+(clojure.tools.cli.parse_option_tokens.cljs$lang$applyTo = (function (seq21733){
+var G__21734 = cljs.core.first(seq21733);
+var seq21733__$1 = cljs.core.next(seq21733);
+var G__21735 = cljs.core.first(seq21733__$1);
+var seq21733__$2 = cljs.core.next(seq21733__$1);
+var self__5754__auto__ = this;
+return self__5754__auto__.cljs$core$IFn$_invoke$arity$variadic(G__21734,G__21735,seq21733__$2);
+}));
+
+/**
+ * Given a single compiled option spec, turn it into a formatted string,
+ *   optionally with its default values if requested.
+ */
+clojure.tools.cli.make_summary_part = (function clojure$tools$cli$make_summary_part(show_defaults_QMARK_,spec){
+var map__21776 = spec;
+var map__21776__$1 = cljs.core.__destructure_map(map__21776);
+var short_opt = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21776__$1,new cljs.core.Keyword(null,"short-opt","short-opt",-384995699));
+var long_opt = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21776__$1,new cljs.core.Keyword(null,"long-opt","long-opt",-386094553));
+var required = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21776__$1,new cljs.core.Keyword(null,"required","required",1807647006));
+var desc = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21776__$1,new cljs.core.Keyword(null,"desc","desc",2093485764));
+var default$ = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21776__$1,new cljs.core.Keyword(null,"default","default",-1987822328));
+var default_desc = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21776__$1,new cljs.core.Keyword(null,"default-desc","default-desc",324577013));
+var default_fn = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21776__$1,new cljs.core.Keyword(null,"default-fn","default-fn",-473729550));
+var opt = (cljs.core.truth_((function (){var and__5043__auto__ = short_opt;
+if(cljs.core.truth_(and__5043__auto__)){
+return long_opt;
+} else {
+return and__5043__auto__;
+}
+})())?[cljs.core.str.cljs$core$IFn$_invoke$arity$1(short_opt),", ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(long_opt)].join(''):(cljs.core.truth_(long_opt)?["    ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(long_opt)].join(''):(cljs.core.truth_(short_opt)?short_opt:null)));
+var vec__21777 = new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [(cljs.core.truth_(required)?[cljs.core.str.cljs$core$IFn$_invoke$arity$1(opt)," ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(required)].join(''):opt),(function (){var or__5045__auto__ = default_desc;
+if(cljs.core.truth_(or__5045__auto__)){
+return or__5045__auto__;
+} else {
+var or__5045__auto____$1 = ((cljs.core.contains_QMARK_(spec,new cljs.core.Keyword(null,"default","default",-1987822328)))?(((!((default$ == null))))?cljs.core.str.cljs$core$IFn$_invoke$arity$1(default$):"nil"):null);
+if(cljs.core.truth_(or__5045__auto____$1)){
+return or__5045__auto____$1;
+} else {
+var or__5045__auto____$2 = (cljs.core.truth_(default_fn)?"<computed>":null);
+if(cljs.core.truth_(or__5045__auto____$2)){
+return or__5045__auto____$2;
+} else {
+return "";
+}
+}
+}
+})()], null);
+var opt__$1 = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21777,(0),null);
+var dd = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21777,(1),null);
+if(cljs.core.truth_(show_defaults_QMARK_)){
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [opt__$1,dd,(function (){var or__5045__auto__ = desc;
+if(cljs.core.truth_(or__5045__auto__)){
+return or__5045__auto__;
+} else {
+return "";
+}
+})()], null);
+} else {
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [opt__$1,(function (){var or__5045__auto__ = desc;
+if(cljs.core.truth_(or__5045__auto__)){
+return or__5045__auto__;
+} else {
+return "";
+}
+})()], null);
+}
+});
+/**
+ * Format a sequence of summary parts into columns. lens is a sequence of
+ *   lengths to use for parts. There are two sequences of lengths if we are
+ *   not displaying defaults. There are three sequences of lengths if we
+ *   are showing defaults.
+ */
+clojure.tools.cli.format_lines = (function clojure$tools$cli$format_lines(lens,parts){
+var fmt = clojure.tools.cli.make_format(lens);
+return cljs.core.map.cljs$core$IFn$_invoke$arity$2((function (p1__21782_SHARP_){
+return clojure.string.trimr(cljs.core.apply.cljs$core$IFn$_invoke$arity$3(clojure.tools.cli.format,fmt,p1__21782_SHARP_));
+}),parts);
+});
+clojure.tools.cli.required_arguments = (function clojure$tools$cli$required_arguments(specs){
+return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (s,p__21784){
+var map__21785 = p__21784;
+var map__21785__$1 = cljs.core.__destructure_map(map__21785);
+var required = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21785__$1,new cljs.core.Keyword(null,"required","required",1807647006));
+var short_opt = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21785__$1,new cljs.core.Keyword(null,"short-opt","short-opt",-384995699));
+var long_opt = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21785__$1,new cljs.core.Keyword(null,"long-opt","long-opt",-386094553));
+if(cljs.core.truth_(required)){
+return cljs.core.into.cljs$core$IFn$_invoke$arity$2(s,cljs.core.remove.cljs$core$IFn$_invoke$arity$2(cljs.core.nil_QMARK_,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [short_opt,long_opt], null)));
+} else {
+return s;
+}
+}),cljs.core.PersistentHashSet.EMPTY,specs);
+});
+/**
+ * Reduce options specs into a options summary for printing at a terminal.
+ *   Note that the specs argument should be the compiled version. That effectively
+ *   means that you shouldn't call summarize directly. When you call parse-opts
+ *   you get back a :summary key which is the result of calling summarize (or
+ *   your user-supplied :summary-fn option) on the compiled option specs.
+ */
+clojure.tools.cli.summarize = (function clojure$tools$cli$summarize(specs){
+if(cljs.core.seq(specs)){
+var show_defaults_QMARK_ = cljs.core.some((function (p1__21786_SHARP_){
+return ((cljs.core.contains_QMARK_(p1__21786_SHARP_,new cljs.core.Keyword(null,"default","default",-1987822328))) || (cljs.core.contains_QMARK_(p1__21786_SHARP_,new cljs.core.Keyword(null,"default-fn","default-fn",-473729550))));
+}),specs);
+var parts = cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.partial.cljs$core$IFn$_invoke$arity$2(clojure.tools.cli.make_summary_part,show_defaults_QMARK_),specs);
+var lens = cljs.core.apply.cljs$core$IFn$_invoke$arity$3(cljs.core.map,(function() { 
+var G__21958__delegate = function (cols){
+return cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.max,cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.count,cols));
+};
+var G__21958 = function (var_args){
+var cols = null;
+if (arguments.length > 0) {
+var G__21959__i = 0, G__21959__a = new Array(arguments.length -  0);
+while (G__21959__i < G__21959__a.length) {G__21959__a[G__21959__i] = arguments[G__21959__i + 0]; ++G__21959__i;}
+  cols = new cljs.core.IndexedSeq(G__21959__a,0,null);
+} 
+return G__21958__delegate.call(this,cols);};
+G__21958.cljs$lang$maxFixedArity = 0;
+G__21958.cljs$lang$applyTo = (function (arglist__21960){
+var cols = cljs.core.seq(arglist__21960);
+return G__21958__delegate(cols);
+});
+G__21958.cljs$core$IFn$_invoke$arity$variadic = G__21958__delegate;
+return G__21958;
+})()
+,parts);
+var lines = clojure.tools.cli.format_lines(lens,parts);
+return clojure.string.join.cljs$core$IFn$_invoke$arity$2("\n",lines);
+} else {
+return "";
+}
+});
+/**
+ * Extract the map of default options from a sequence of option vectors.
+ * 
+ *   As of 0.4.1, this also applies any :default-fn present.
+ */
+clojure.tools.cli.get_default_options = (function clojure$tools$cli$get_default_options(option_specs){
+var specs = clojure.tools.cli.compile_option_specs(option_specs);
+var vals = clojure.tools.cli.default_option_map(specs,new cljs.core.Keyword(null,"default","default",-1987822328));
+return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (m,p__21789){
+var vec__21790 = p__21789;
+var id = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21790,(0),null);
+var f = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21790,(1),null);
+if(cljs.core.contains_QMARK_(m,id)){
+return m;
+} else {
+return cljs.core.update_in.cljs$core$IFn$_invoke$arity$3(m,new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [id], null),(f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(vals) : f.call(null,vals)));
+}
+}),vals,clojure.tools.cli.default_option_map(specs,new cljs.core.Keyword(null,"default-fn","default-fn",-473729550)));
+});
+/**
+ * Parse arguments sequence according to given option specifications and the
+ *   GNU Program Argument Syntax Conventions:
+ * 
+ *  https://www.gnu.org/software/libc/manual/html_node/Argument-Syntax.html
+ * 
+ *   Option specifications are a sequence of vectors with the following format:
+ * 
+ *  [short-opt long-opt-with-required-description description
+ *   :property value]
+ * 
+ *   The first three string parameters in an option spec are positional and
+ *   optional, and may be nil in order to specify a later parameter.
+ * 
+ *   By default, options are toggles that default to nil, but the second string
+ *   parameter may be used to specify that an option requires an argument.
+ * 
+ *  e.g. ["-p" "--port PORT"] specifies that --port requires an argument,
+ *       of which PORT is a short description.
+ * 
+ *   The :property value pairs are optional and take precedence over the
+ *   positional string arguments. The valid properties are:
+ * 
+ *  :id           The key for this option in the resulting option map. This
+ *                is normally set to the keywordized name of the long option
+ *                without the leading dashes.
+ * 
+ *                Multiple option entries can share the same :id in order to
+ *                transform a value in different ways, but only one of these
+ *                option entries may contain a :default(-fn) entry.
+ * 
+ *                This option is mandatory.
+ * 
+ *  :short-opt    The short format for this option, normally set by the first
+ *                positional string parameter: e.g. "-p". Must be unique.
+ * 
+ *  :long-opt     The long format for this option, normally set by the second
+ *                positional string parameter; e.g. "--port". Must be unique.
+ * 
+ *  :required     A description of the required argument for this option if
+ *                one is required; normally set in the second positional
+ *                string parameter after the long option: "--port PORT".
+ * 
+ *                The absence of this entry indicates that the option is a
+ *                boolean toggle that is set to true when specified on the
+ *                command line.
+ * 
+ *  :missing      Indicates that this option is required (not just an argument),
+ *                and provides the string to use as an error message if omitted.
+ * 
+ *  :desc         A optional short description of this option.
+ * 
+ *  :default      The default value of this option. If none is specified, the
+ *                resulting option map will not contain an entry for this
+ *                option unless set on the command line. Also see :default-fn
+ *                (below).
+ * 
+ *                This default is applied before any arguments are parsed so
+ *                this is a good way to seed values for :assoc-fn or :update-fn
+ *                as well as the simplest way to provide defaults.
+ * 
+ *                If you need to compute a default based on other command line
+ *                arguments, or you need to provide a default separate from the
+ *                seed for :assoc-fn or :update-fn, see :default-fn below.
+ * 
+ *  :default-desc An optional description of the default value. This should be
+ *                used when the string representation of the default value is
+ *                too ugly to be printed on the command line, or :default-fn
+ *                is used to compute the default.
+ * 
+ *  :default-fn   A function to compute the default value of this option, given
+ *                the whole, parsed option map as its one argument. If no
+ *                function is specified, the resulting option map will not
+ *                contain an entry for this option unless set on the command
+ *                line. Also see :default (above).
+ * 
+ *                If both :default and :default-fn are provided, if the
+ *                argument is not provided on the command-line, :default-fn will
+ *                still be called (and can override :default).
+ * 
+ *  :parse-fn     A function that receives the required option argument and
+ *                returns the option value.
+ * 
+ *                If this is a boolean option, parse-fn will receive the value
+ *                true. This may be used to invert the logic of this option:
+ * 
+ *                ["-q" "--quiet"
+ *                 :id :verbose
+ *                 :default true
+ *                 :parse-fn not]
+ * 
+ *  :assoc-fn     A function that receives the current option map, the current
+ *                option :id, and the current parsed option value, and returns
+ *                a new option map. The default is 'assoc'.
+ * 
+ *                For non-idempotent options, where you need to compute a option
+ *                value based on the current value and a new value from the
+ *                command line. If you only need the the current value, consider
+ *                :update-fn (below).
+ * 
+ *                You cannot specify both :assoc-fn and :update-fn for an
+ *                option.
+ * 
+ *  :update-fn    Without :multi true:
+ * 
+ *                A function that receives just the existing parsed option value,
+ *                and returns a new option value, for each option :id present.
+ *                The default is 'identity'.
+ * 
+ *                This may be used to create non-idempotent options where you
+ *                only need the current value, like setting a verbosity level by
+ *                specifying an option multiple times. ("-vvv" -> 3)
+ * 
+ *                ["-v" "--verbose"
+ *                 :default 0
+ *                 :update-fn inc]
+ * 
+ *                :default is applied first. If you wish to omit the :default
+ *                option value, use fnil in your :update-fn as follows:
+ * 
+ *                ["-v" "--verbose"
+ *                 :update-fn (fnil inc 0)]
+ * 
+ *                With :multi true:
+ * 
+ *                A function that receives both the existing parsed option value,
+ *                and the parsed option value from each instance of the option,
+ *                and returns a new option value, for each option :id present.
+ *                The :multi option is ignored if you do not specify :update-fn.
+ * 
+ *                For non-idempotent options, where you need to compute a option
+ *                value based on the current value and a new value from the
+ *                command line. This can sometimes be easier than use :assoc-fn.
+ * 
+ *                ["-f" "--file NAME"
+ *                 :default []
+ *                 :update-fn conj
+ *                 :multi true]
+ * 
+ *                :default is applied first. If you wish to omit the :default
+ *                option value, use fnil in your :update-fn as follows:
+ * 
+ *                ["-f" "--file NAME"
+ *                 :update-fn (fnil conj [])
+ *                 :multi true]
+ * 
+ *                Regardless of :multi, you cannot specify both :assoc-fn
+ *                and :update-fn for an option.
+ * 
+ *  :multi        true/false, applies only to options that use :update-fn.
+ * 
+ *  :validate     A vector of [validate-fn validate-msg ...]. Multiple pairs
+ *                of validation functions and error messages may be provided.
+ * 
+ *  :validate-fn  A vector of functions that receives the parsed option value
+ *                and returns a falsy value or throws an exception when the
+ *                value is invalid. The validations are tried in the given
+ *                order.
+ * 
+ *  :validate-msg A vector of error messages corresponding to :validate-fn
+ *                that will be added to the :errors vector on validation
+ *                failure. Can be plain strings, or functions to be applied
+ *                to the (invalid) option argument to produce a string.
+ * 
+ *  :post-validation true/false. By default, validation is performed after
+ *                parsing an option, prior to assoc/default/update processing.
+ *                Specifying true here will cause the validation to be
+ *                performed after assoc/default/update processing, instead.
+ * 
+ *   parse-opts returns a map with four entries:
+ * 
+ *  {:options     The options map, keyed by :id, mapped to the parsed value
+ *   :arguments   A vector of unprocessed arguments
+ *   :summary     A string containing a minimal options summary
+ *   :errors      A possible vector of error message strings generated during
+ *                parsing; nil when no errors exist}
+ * 
+ *   A few function options may be specified to influence the behavior of
+ *   parse-opts:
+ * 
+ *  :in-order     Stop option processing at the first unknown argument. Useful
+ *                for building programs with subcommands that have their own
+ *                option specs.
+ * 
+ *  :no-defaults  Only include option values specified in arguments and do not
+ *                include any default values in the resulting options map.
+ *                Useful for parsing options from multiple sources; i.e. from a
+ *                config file and from the command line.
+ * 
+ *  :strict       Parse required arguments strictly: if a required argument value
+ *                matches any other option, it is considered to be missing (and
+ *                you have a parse error).
+ * 
+ *  :summary-fn   A function that receives the sequence of compiled option specs
+ *                (documented at #'clojure.tools.cli/compile-option-specs), and
+ *                returns a custom option summary string.
+ *   
+ */
+clojure.tools.cli.parse_opts = (function clojure$tools$cli$parse_opts(var_args){
+var args__5775__auto__ = [];
+var len__5769__auto___21963 = arguments.length;
+var i__5770__auto___21964 = (0);
+while(true){
+if((i__5770__auto___21964 < len__5769__auto___21963)){
+args__5775__auto__.push((arguments[i__5770__auto___21964]));
+
+var G__21965 = (i__5770__auto___21964 + (1));
+i__5770__auto___21964 = G__21965;
+continue;
+} else {
+}
+break;
+}
+
+var argseq__5776__auto__ = ((((2) < args__5775__auto__.length))?(new cljs.core.IndexedSeq(args__5775__auto__.slice((2)),(0),null)):null);
+return clojure.tools.cli.parse_opts.cljs$core$IFn$_invoke$arity$variadic((arguments[(0)]),(arguments[(1)]),argseq__5776__auto__);
+});
+
+(clojure.tools.cli.parse_opts.cljs$core$IFn$_invoke$arity$variadic = (function (args,option_specs,options){
+var map__21799 = cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.hash_map,options);
+var map__21799__$1 = cljs.core.__destructure_map(map__21799);
+var in_order = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21799__$1,new cljs.core.Keyword(null,"in-order","in-order",-1605651796));
+var no_defaults = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21799__$1,new cljs.core.Keyword(null,"no-defaults","no-defaults",-1025033878));
+var strict = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21799__$1,new cljs.core.Keyword(null,"strict","strict",-665564191));
+var summary_fn = cljs.core.get.cljs$core$IFn$_invoke$arity$2(map__21799__$1,new cljs.core.Keyword(null,"summary-fn","summary-fn",-2130107959));
+var specs = clojure.tools.cli.compile_option_specs(option_specs);
+var req = clojure.tools.cli.required_arguments(specs);
+var vec__21800 = clojure.tools.cli.tokenize_args.cljs$core$IFn$_invoke$arity$variadic(req,args,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,"in-order","in-order",-1605651796),in_order], 0));
+var tokens = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21800,(0),null);
+var rest_args = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21800,(1),null);
+var vec__21803 = clojure.tools.cli.parse_option_tokens.cljs$core$IFn$_invoke$arity$variadic(specs,tokens,cljs.core.prim_seq.cljs$core$IFn$_invoke$arity$2([new cljs.core.Keyword(null,"no-defaults","no-defaults",-1025033878),no_defaults,new cljs.core.Keyword(null,"strict","strict",-665564191),strict], 0));
+var opts = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21803,(0),null);
+var errors = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__21803,(1),null);
+return new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null,"options","options",99638489),opts,new cljs.core.Keyword(null,"arguments","arguments",-1182834456),rest_args,new cljs.core.Keyword(null,"summary","summary",380847952),(function (){var fexpr__21806 = (function (){var or__5045__auto__ = summary_fn;
+if(cljs.core.truth_(or__5045__auto__)){
+return or__5045__auto__;
+} else {
+return clojure.tools.cli.summarize;
+}
+})();
+return (fexpr__21806.cljs$core$IFn$_invoke$arity$1 ? fexpr__21806.cljs$core$IFn$_invoke$arity$1(specs) : fexpr__21806.call(null,specs));
+})(),new cljs.core.Keyword(null,"errors","errors",-908790718),((cljs.core.seq(errors))?errors:null)], null);
+}));
+
+(clojure.tools.cli.parse_opts.cljs$lang$maxFixedArity = (2));
+
+/** @this {Function} */
+(clojure.tools.cli.parse_opts.cljs$lang$applyTo = (function (seq21794){
+var G__21795 = cljs.core.first(seq21794);
+var seq21794__$1 = cljs.core.next(seq21794);
+var G__21796 = cljs.core.first(seq21794__$1);
+var seq21794__$2 = cljs.core.next(seq21794__$1);
+var self__5754__auto__ = this;
+return self__5754__auto__.cljs$core$IFn$_invoke$arity$variadic(G__21795,G__21796,seq21794__$2);
+}));
+
+
+//# sourceMappingURL=clojure.tools.cli.js.map