@atomist/clj-editors/target/cljsbuild-compiler-1/cljs_node_io/fs.js

editor functions that use rewrite-clj and other important things from the clojurescript ecosystem

// Compiled by ClojureScript 1.10.238 {:target :nodejs}
goog.provide('cljs_node_io.fs');
goog.require('cljs.core');
goog.require('cljs.core.async');
goog.require('cljs.core.async.impl.protocols');
cljs_node_io.fs.fs = require("fs");
cljs_node_io.fs.path = require("path");
/**
 * @type {!string}
 */
cljs_node_io.fs.sep = cljs_node_io.fs.path.sep;
/**
 * Synchronous stat
 * @param {!string} pathstring
 * @return {!fs.Stats} file stats object
 */
cljs_node_io.fs.stat = (function cljs_node_io$fs$stat(pathstring){
return cljs_node_io.fs.fs.statSync(pathstring);
});
/**
 * Asynchronous stat
 * @param {!string} pathstr
 * @return {!Channel} promise-chan receiving [?err ?fs.Stats]
 */
cljs_node_io.fs.astat = (function cljs_node_io$fs$astat(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
cljs_node_io.fs.fs.stat(pathstr,((function (c){
return (function() { 
var G__20152__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__20152 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__20153__i = 0, G__20153__a = new Array(arguments.length -  0);
while (G__20153__i < G__20153__a.length) {G__20153__a[G__20153__i] = arguments[G__20153__i + 0]; ++G__20153__i;}
  args = new cljs.core.IndexedSeq(G__20153__a,0,null);
} 
return G__20152__delegate.call(this,args);};
G__20152.cljs$lang$maxFixedArity = 0;
G__20152.cljs$lang$applyTo = (function (arglist__20154){
var args = cljs.core.seq(arglist__20154);
return G__20152__delegate(args);
});
G__20152.cljs$core$IFn$_invoke$arity$variadic = G__20152__delegate;
return G__20152;
})()
;})(c))
);

return c;
});
/**
 * Synchronous lstat identical to stat(), except that if path is a symbolic link,
 * then the link itself is stat-ed, not the file that it refers to
 * @param {!string} pathstr
 * @return {!fs.Stats} file stats object
 */
cljs_node_io.fs.lstat = (function cljs_node_io$fs$lstat(pathstr){
return cljs_node_io.fs.fs.lstatSync(pathstr);
});
/**
 * Asynchronous lstat
 * @param {!string} pathstr
 * @return {!Channel} promise-chan receiving [?err ?fs.Stats]
 */
cljs_node_io.fs.alstat = (function cljs_node_io$fs$alstat(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
cljs_node_io.fs.fs.lstat(pathstr,((function (c){
return (function() { 
var G__20155__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__20155 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__20156__i = 0, G__20156__a = new Array(arguments.length -  0);
while (G__20156__i < G__20156__a.length) {G__20156__a[G__20156__i] = arguments[G__20156__i + 0]; ++G__20156__i;}
  args = new cljs.core.IndexedSeq(G__20156__a,0,null);
} 
return G__20155__delegate.call(this,args);};
G__20155.cljs$lang$maxFixedArity = 0;
G__20155.cljs$lang$applyTo = (function (arglist__20157){
var args = cljs.core.seq(arglist__20157);
return G__20155__delegate(args);
});
G__20155.cljs$core$IFn$_invoke$arity$variadic = G__20155__delegate;
return G__20155;
})()
;})(c))
);

return c;
});
/**
 * Convert a fs.Stats object to edn. Function are swapped out for their return values.
 * This is useful at repl but not particularly efficient.
 * @param {!fs.Stats} st
 * @return {!IMap}
 */
cljs_node_io.fs.stat__GT_clj = (function cljs_node_io$fs$stat__GT_clj(st){
var ks = goog.object.getKeys(st);
var vs = goog.object.getValues(st);
return cljs.core.into.call(null,cljs.core.PersistentArrayMap.EMPTY,cljs.core.comp.call(null,cljs.core.remove.call(null,((function (ks,vs){
return (function (p1__20158_SHARP_){
return cljs.core._EQ_.call(null,cljs.core.nth.call(null,p1__20158_SHARP_,(0)),"_checkModeProperty");
});})(ks,vs))
),cljs.core.map.call(null,((function (ks,vs){
return (function (p__20159){
var vec__20160 = p__20159;
var k = cljs.core.nth.call(null,vec__20160,(0),null);
var v = cljs.core.nth.call(null,vec__20160,(1),null);
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.call(null,k),((cljs.core.fn_QMARK_.call(null,v))?v.apply(st):v)], null);
});})(ks,vs))
)),cljs.core.map.call(null,cljs.core.vector,ks,vs));
});
/**
 * @param {!Array<!Number>} bita :: an array of 1s an 0s
 * @return {!Number} integer
 */
cljs_node_io.fs.bita__GT_int = (function cljs_node_io$fs$bita__GT_int(bita){
return parseInt(bita.join(""),(2));
});
/**
 * @param {!fs.Stats} s :: a fs.Stats object
 * @return {!Array<Number>}
 */
cljs_node_io.fs.stat__GT_perm_bita = (function cljs_node_io$fs$stat__GT_perm_bita(s){
var mode = (s["mode"]);
var ownr = (mode & (256));
var ownw = (mode & (128));
var ownx = (mode & (64));
var grpr = (mode & (32));
var grpw = (mode & (16));
var grpx = (mode & (8));
var othr = (mode & (4));
var othw = (mode & (2));
var othx = (mode & (1));
var a = [ownr,ownw,ownx,grpr,grpw,grpx,othr,othw,othx];
var a__4370__auto__ = a;
var l__4371__auto__ = a__4370__auto__.length;
var res = cljs.core.aclone.call(null,a__4370__auto__);
var i = (0);
while(true){
if((i < l__4371__auto__)){
(res[i] = ((!(((a[i]) === (0))))?(1):(0)));

var G__20163 = (i + (1));
i = G__20163;
continue;
} else {
return res;
}
break;
}
});
/**
 * @param {!fs.Stats} st
 * @return {!Number}
 */
cljs_node_io.fs.permissions = (function cljs_node_io$fs$permissions(st){
return cljs_node_io.fs.bita__GT_int.call(null,cljs_node_io.fs.stat__GT_perm_bita.call(null,st));
});
/**
 * @return {!IMap}
 */
cljs_node_io.fs.gid_uid = (function cljs_node_io$fs$gid_uid(){
return new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,"gid","gid",-714078321),process.getgid(),new cljs.core.Keyword(null,"uid","uid",-1447769400),process.getuid()], null);
});
/**
 * @param {!string} pathstr
 * @return {!boolean} is the file hidden (unix only)
 */
cljs_node_io.fs.hidden_QMARK_ = (function cljs_node_io$fs$hidden_QMARK_(pathstr){
return (new RegExp("(^|\\/)\\.[^\\/\\.]")).test(pathstr);
});
/**
 * @param {!string} pathstring
 * @return {!boolean} iff abstract pathname exists and is a directory
 */
cljs_node_io.fs.dir_QMARK_ = (function cljs_node_io$fs$dir_QMARK_(pathstring){
if(typeof pathstring === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstring)"));
}

var stats = (function (){try{return cljs_node_io.fs.fs.statSync(pathstring);
}catch (e20164){if((e20164 instanceof Error)){
var e = e20164;
return false;
} else {
throw e20164;

}
}})();
if(cljs.core.not.call(null,stats)){
return false;
} else {
return stats.isDirectory();
}
});
/**
 * Asynchronous directory predicate.
 * @param {!string} pathstr
 * @return {!Channel} promise-chan receiving boolean
 */
cljs_node_io.fs.adir_QMARK_ = (function cljs_node_io$fs$adir_QMARK_(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
var stat_ch = cljs_node_io.fs.astat.call(null,pathstr);
cljs.core.async.take_BANG_.call(null,stat_ch,((function (c,stat_ch){
return (function (p__20165){
var vec__20166 = p__20165;
var err = cljs.core.nth.call(null,vec__20166,(0),null);
var stats = cljs.core.nth.call(null,vec__20166,(1),null);
return cljs.core.async.put_BANG_.call(null,c,((cljs.core.not.call(null,err))?stats.isDirectory():false));
});})(c,stat_ch))
);

return c;
});
/**
 * Synchronous file predicate
 * @param {!string} pathstring
 * @return {!boolean} iff abstract pathname exists and is a file
 */
cljs_node_io.fs.file_QMARK_ = (function cljs_node_io$fs$file_QMARK_(pathstring){
if(typeof pathstring === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstring)"));
}

var stats = (function (){try{return cljs_node_io.fs.lstat.call(null,pathstring);
}catch (e20169){if((e20169 instanceof Error)){
var e = e20169;
return false;
} else {
throw e20169;

}
}})();
if(cljs.core.not.call(null,stats)){
return false;
} else {
return stats.isFile();
}
});
/**
 * Asynchronous file predicate.
 * @param {!string} pathstr
 * @return {!Channel} promise-chan receiving boolean
 */
cljs_node_io.fs.afile_QMARK_ = (function cljs_node_io$fs$afile_QMARK_(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
var stat_ch = cljs_node_io.fs.alstat.call(null,pathstr);
cljs.core.async.take_BANG_.call(null,stat_ch,((function (c,stat_ch){
return (function (p__20170){
var vec__20171 = p__20170;
var err = cljs.core.nth.call(null,vec__20171,(0),null);
var stats = cljs.core.nth.call(null,vec__20171,(1),null);
return cljs.core.async.put_BANG_.call(null,c,((cljs.core.not.call(null,err))?stats.isFile():false));
});})(c,stat_ch))
);

return c;
});
/**
 * @param {!string} pathstr :: path to test
 * @return {!boolean} is pathstr an absolute path
 */
cljs_node_io.fs.absolute_QMARK_ = (function cljs_node_io$fs$absolute_QMARK_(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

return cljs_node_io.fs.path.isAbsolute.call(null,pathstr);
});
/**
 * Synchronously test if a file or directory exists
 * @param {!string} pathstr :: file path to test
 * @return {!boolean}
 */
cljs_node_io.fs.fexists_QMARK_ = (function cljs_node_io$fs$fexists_QMARK_(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

try{cljs_node_io.fs.fs.accessSync(pathstr,cljs_node_io.fs.fs.F_OK);

return true;
}catch (e20174){if((e20174 instanceof Error)){
var e = e20174;
return false;
} else {
throw e20174;

}
}});
/**
 * Asynchronously test if a file or directory exists
 * @param {!string} pathstr
 * @return {!Channel} promise-chan receiving boolean
 */
cljs_node_io.fs.afexists_QMARK_ = (function cljs_node_io$fs$afexists_QMARK_(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
cljs_node_io.fs.fs.access(pathstr,cljs_node_io.fs.fs.F_OK,((function (c){
return (function (e){
return cljs.core.async.put_BANG_.call(null,c,((cljs.core.not.call(null,e))?true:false));
});})(c))
);

return c;
});
/**
 * Synchronously test if a file is readable to the process
 * @param {!string} pathstr :: path to test for process read permission
 * @return {!boolean}
 */
cljs_node_io.fs.readable_QMARK_ = (function cljs_node_io$fs$readable_QMARK_(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

try{cljs_node_io.fs.fs.accessSync(pathstr,cljs_node_io.fs.fs.R_OK);

return true;
}catch (e20175){if((e20175 instanceof Error)){
var e = e20175;
return false;
} else {
throw e20175;

}
}});
/**
 * Asynchronously test if a file is readable to the process
 * @param {!string} pathstr
 * @return {!Channel} promise-chan receiving boolean
 */
cljs_node_io.fs.areadable_QMARK_ = (function cljs_node_io$fs$areadable_QMARK_(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
cljs_node_io.fs.fs.access(pathstr,cljs_node_io.fs.fs.R_OK,((function (c){
return (function (e){
return cljs.core.async.put_BANG_.call(null,c,((cljs.core.not.call(null,e))?true:false));
});})(c))
);

return c;
});
/**
 * Synchronously test if a file is writable to the process
 * @param {!string} pathstr :: path to test for process write permission
 * @return {!boolean}
 */
cljs_node_io.fs.writable_QMARK_ = (function cljs_node_io$fs$writable_QMARK_(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

try{cljs_node_io.fs.fs.accessSync(pathstr,cljs_node_io.fs.fs.W_OK);

return true;
}catch (e20176){if((e20176 instanceof Error)){
var e = e20176;
return false;
} else {
throw e20176;

}
}});
/**
 * Asynchronously test if a file is writable to the process
 * @param {!string} pathstr :: path to test for process write permission
 * @return {!Channel} promise-chan receiving boolean
 */
cljs_node_io.fs.awritable_QMARK_ = (function cljs_node_io$fs$awritable_QMARK_(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
cljs_node_io.fs.fs.access(pathstr,cljs_node_io.fs.fs.W_OK,((function (c){
return (function (e){
return cljs.core.async.put_BANG_.call(null,c,((cljs.core.not.call(null,e))?true:false));
});})(c))
);

return c;
});
/**
 * @param {!string} pathstr :: path to test for process executable permission
 * @return {!boolean}
 */
cljs_node_io.fs.executable_QMARK_ = (function cljs_node_io$fs$executable_QMARK_(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

if(!(cljs.core._EQ_.call(null,"win32",process.platform))){
try{cljs_node_io.fs.fs.accessSync(pathstr,cljs_node_io.fs.fs.X_OK);

return true;
}catch (e20177){if((e20177 instanceof Error)){
var e = e20177;
return false;
} else {
throw e20177;

}
}} else {
throw Error("Testing if a file is executable has no effect on Windows");
}
});
/**
 * Asynchronously test if a file is executable to the process
 * @param {!string} pathstr :: path to test for process execute permission
 * @return {!Channel} promise-chan receiving boolean
 */
cljs_node_io.fs.aexecutable_QMARK_ = (function cljs_node_io$fs$aexecutable_QMARK_(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

if(!(cljs.core._EQ_.call(null,"win32",process.platform))){
var c = cljs.core.async.promise_chan.call(null);
cljs_node_io.fs.fs.access(pathstr,cljs_node_io.fs.fs.X_OK,((function (c){
return (function (e){
return cljs.core.async.put_BANG_.call(null,c,((cljs.core.not.call(null,e))?true:false));
});})(c))
);

return c;
} else {
throw Error("Testing if a file is executable has no effect on Windows");
}
});
/**
 * Synchronous test for symbolic link
 * @param {!string} pathstr :: path to test
 * @return {!boolean}
 */
cljs_node_io.fs.symlink_QMARK_ = (function cljs_node_io$fs$symlink_QMARK_(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var stats = (function (){try{return cljs_node_io.fs.lstat.call(null,pathstr);
}catch (e20178){if((e20178 instanceof Error)){
var e = e20178;
return false;
} else {
throw e20178;

}
}})();
if(cljs.core.not.call(null,stats)){
return false;
} else {
return stats.isSymbolicLink();
}
});
/**
 * Asynchronously test if path is a symbolic link
 * @param {!string} pathstr :: path to test
 * @return {!Channel} promise-chan receiving boolean
 */
cljs_node_io.fs.asymlink_QMARK_ = (function cljs_node_io$fs$asymlink_QMARK_(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
var stat_ch = cljs_node_io.fs.alstat.call(null,pathstr);
cljs.core.async.take_BANG_.call(null,stat_ch,((function (c,stat_ch){
return (function (p__20179){
var vec__20180 = p__20179;
var err = cljs.core.nth.call(null,vec__20180,(0),null);
var stats = cljs.core.nth.call(null,vec__20180,(1),null);
return cljs.core.async.put_BANG_.call(null,c,((cljs.core.not.call(null,err))?stats.isSymbolicLink():false));
});})(c,stat_ch))
);

return c;
});
/**
 * @param {!string} pathstring :: path to get parent of
 * @return {!string} the parent directory
 */
cljs_node_io.fs.dirname = (function cljs_node_io$fs$dirname(pathstring){
return cljs_node_io.fs.path.dirname(pathstring);
});
/**
 * @return {!string}
 */
cljs_node_io.fs.basename = (function cljs_node_io$fs$basename(var_args){
var G__20184 = arguments.length;
switch (G__20184) {
case 1:
return cljs_node_io.fs.basename.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));

break;
case 2:
return cljs_node_io.fs.basename.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('')));

}
});

cljs_node_io.fs.basename.cljs$core$IFn$_invoke$arity$1 = (function (p){
return cljs_node_io.fs.path.basename(p);
});

cljs_node_io.fs.basename.cljs$core$IFn$_invoke$arity$2 = (function (p,ext){
return cljs_node_io.fs.path.basename(p,ext);
});

cljs_node_io.fs.basename.cljs$lang$maxFixedArity = 2;

/**
 * @return {!string}
 */
cljs_node_io.fs.resolve_path = (function cljs_node_io$fs$resolve_path(var_args){
var args__4502__auto__ = [];
var len__4499__auto___20187 = arguments.length;
var i__4500__auto___20188 = (0);
while(true){
if((i__4500__auto___20188 < len__4499__auto___20187)){
args__4502__auto__.push((arguments[i__4500__auto___20188]));

var G__20189 = (i__4500__auto___20188 + (1));
i__4500__auto___20188 = G__20189;
continue;
} else {
}
break;
}

var argseq__4503__auto__ = ((((0) < args__4502__auto__.length))?(new cljs.core.IndexedSeq(args__4502__auto__.slice((0)),(0),null)):null);
return cljs_node_io.fs.resolve_path.cljs$core$IFn$_invoke$arity$variadic(argseq__4503__auto__);
});

cljs_node_io.fs.resolve_path.cljs$core$IFn$_invoke$arity$variadic = (function (paths){
return cljs_node_io.fs.path.resolve.apply(null,cljs.core.apply.call(null,cljs.core.array,paths));
});

cljs_node_io.fs.resolve_path.cljs$lang$maxFixedArity = (0);

/** @this {Function} */
cljs_node_io.fs.resolve_path.cljs$lang$applyTo = (function (seq20186){
var self__4487__auto__ = this;
return self__4487__auto__.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq.call(null,seq20186));
});

/**
 * @param {!string} pathstring :: pathstring to normalize
 * @return {!string}
 */
cljs_node_io.fs.normalize_path = (function cljs_node_io$fs$normalize_path(pathstring){
return cljs_node_io.fs.path.normalize(pathstring);
});
/**
 * @param {!string} pathstring :: file to get extension from
 * @return {!string}
 */
cljs_node_io.fs.ext = (function cljs_node_io$fs$ext(pathstring){
return cljs_node_io.fs.path.extname(pathstring);
});
/**
 * Synchronous realpath
 * @param {!string} pathstr
 * @return {!string} resolved path
 */
cljs_node_io.fs.realpath = (function cljs_node_io$fs$realpath(pathstr){
return cljs_node_io.fs.fs.realpathSync(pathstr);
});
/**
 * Asynchronous realpath
 * @param {!string} pathstr
 * @return {!Channel} promise-chan recieving [?err ?resolvedPathstr]
 */
cljs_node_io.fs.arealpath = (function cljs_node_io$fs$arealpath(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
cljs_node_io.fs.fs.realpath(pathstr,((function (c){
return (function() { 
var G__20190__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__20190 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__20191__i = 0, G__20191__a = new Array(arguments.length -  0);
while (G__20191__i < G__20191__a.length) {G__20191__a[G__20191__i] = arguments[G__20191__i + 0]; ++G__20191__i;}
  args = new cljs.core.IndexedSeq(G__20191__a,0,null);
} 
return G__20190__delegate.call(this,args);};
G__20190.cljs$lang$maxFixedArity = 0;
G__20190.cljs$lang$applyTo = (function (arglist__20192){
var args = cljs.core.seq(arglist__20192);
return G__20190__delegate(args);
});
G__20190.cljs$core$IFn$_invoke$arity$variadic = G__20190__delegate;
return G__20190;
})()
;})(c))
);

return c;
});
/**
 * Synchronous readlink
 * @param {!string} pathstr :: the symbolic link to read
 * @return {!string} the symbolic link's string value
 */
cljs_node_io.fs.readlink = (function cljs_node_io$fs$readlink(pathstr){
return cljs_node_io.fs.fs.readlinkSync(pathstr);
});
/**
 * Asynchronous readlink
 * @param {!string} pathstr :: the symbolic link to read
 * @return {!Channel} promise-chan receiving [?err ?linkstring]
 */
cljs_node_io.fs.areadlink = (function cljs_node_io$fs$areadlink(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
cljs_node_io.fs.fs.readlink(pathstr,((function (c){
return (function() { 
var G__20193__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__20193 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__20194__i = 0, G__20194__a = new Array(arguments.length -  0);
while (G__20194__i < G__20194__a.length) {G__20194__a[G__20194__i] = arguments[G__20194__i + 0]; ++G__20194__i;}
  args = new cljs.core.IndexedSeq(G__20194__a,0,null);
} 
return G__20193__delegate.call(this,args);};
G__20193.cljs$lang$maxFixedArity = 0;
G__20193.cljs$lang$applyTo = (function (arglist__20195){
var args = cljs.core.seq(arglist__20195);
return G__20193__delegate(args);
});
G__20193.cljs$core$IFn$_invoke$arity$variadic = G__20193__delegate;
return G__20193;
})()
;})(c))
);

return c;
});
/**
 * Synchronously reads directory content
 * @param {!string} dirpath :: directory path to read
 * @return {!IVector} Vector<strings> representing directory content
 */
cljs_node_io.fs.readdir = (function cljs_node_io$fs$readdir(dirpath){
if(typeof dirpath === 'string'){
} else {
throw (new Error("Assert failed: (string? dirpath)"));
}

return cljs.core.vec.call(null,cljs_node_io.fs.fs.readdirSync(dirpath));
});
/**
 * Asynchronously reads directory content
 * @param {!string} dirpath :: directory path to read
 * @return {!Channel} promise-chan receiving [?err, ?Vector<string>]
 *  where strings are representing directory content
 */
cljs_node_io.fs.areaddir = (function cljs_node_io$fs$areaddir(dirpath){
if(typeof dirpath === 'string'){
} else {
throw (new Error("Assert failed: (string? dirpath)"));
}

var c = cljs.core.async.promise_chan.call(null);
cljs_node_io.fs.fs.readdir(dirpath,((function (c){
return (function (e,data){
return cljs.core.async.put_BANG_.call(null,c,new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [e,cljs.core.vec.call(null,data)], null));
});})(c))
);

return c;
});
/**
 * Synchronous chmod
 * @param {!string} pathstr
 * @param {!Number} mode :: must be an integer
 * @return {nil} or throws
 */
cljs_node_io.fs.chmod = (function cljs_node_io$fs$chmod(pathstr,mode){
return cljs_node_io.fs.fs.chmodSync(pathstr,mode);
});
/**
 * Asynchronous chmod
 * @param {!string} pathstr
 * @param {!Number} mode :: must be an integer
 * @return {!Channel} promise-chan receiving [?err]
 */
cljs_node_io.fs.achmod = (function cljs_node_io$fs$achmod(pathstr,mode){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
cljs_node_io.fs.fs.chmod(pathstr,mode,((function (c){
return (function() { 
var G__20196__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__20196 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__20197__i = 0, G__20197__a = new Array(arguments.length -  0);
while (G__20197__i < G__20197__a.length) {G__20197__a[G__20197__i] = arguments[G__20197__i + 0]; ++G__20197__i;}
  args = new cljs.core.IndexedSeq(G__20197__a,0,null);
} 
return G__20196__delegate.call(this,args);};
G__20196.cljs$lang$maxFixedArity = 0;
G__20196.cljs$lang$applyTo = (function (arglist__20198){
var args = cljs.core.seq(arglist__20198);
return G__20196__delegate(args);
});
G__20196.cljs$core$IFn$_invoke$arity$variadic = G__20196__delegate;
return G__20196;
})()
;})(c))
);

return c;
});
/**
 * Synchronous lchmod
 * @param {!string} pathstr
 * @param {!Number} mode :: must be an integer
 * @return {nil}
 */
cljs_node_io.fs.lchmod = (function cljs_node_io$fs$lchmod(pathstr,mode){
return cljs_node_io.fs.fs.lchmodSync(pathstr,mode);
});
/**
 * Asynchronous lchmod
 * @param {!string} pathstr
 * @param {!Number} mode :: must be an integer
 * @return {!Channel} promise-chan receiving [?err]
 */
cljs_node_io.fs.alchmod = (function cljs_node_io$fs$alchmod(pathstr,mode){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
cljs_node_io.fs.fs.lchmod(pathstr,mode,((function (c){
return (function() { 
var G__20199__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__20199 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__20200__i = 0, G__20200__a = new Array(arguments.length -  0);
while (G__20200__i < G__20200__a.length) {G__20200__a[G__20200__i] = arguments[G__20200__i + 0]; ++G__20200__i;}
  args = new cljs.core.IndexedSeq(G__20200__a,0,null);
} 
return G__20199__delegate.call(this,args);};
G__20199.cljs$lang$maxFixedArity = 0;
G__20199.cljs$lang$applyTo = (function (arglist__20201){
var args = cljs.core.seq(arglist__20201);
return G__20199__delegate(args);
});
G__20199.cljs$core$IFn$_invoke$arity$variadic = G__20199__delegate;
return G__20199;
})()
;})(c))
);

return c;
});
/**
 * Synchronous chown
 * @param {!string} pathstr
 * @param {!Number} uid
 * @param {!Number} gid
 * @return {nil}
 */
cljs_node_io.fs.chown = (function cljs_node_io$fs$chown(pathstr,uid,gid){
return cljs_node_io.fs.fs.chownSync(pathstr,uid,gid);
});
/**
 * Asynchronous chown
 * @param {!string} pathstr
 * @param {!Number} uid
 * @param {!Number} gid
 * @return {!Channel} promise-chan receiving [?err]
 */
cljs_node_io.fs.achown = (function cljs_node_io$fs$achown(pathstr,uid,gid){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
cljs_node_io.fs.fs.chown(pathstr,uid,gid,((function (c){
return (function() { 
var G__20202__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__20202 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__20203__i = 0, G__20203__a = new Array(arguments.length -  0);
while (G__20203__i < G__20203__a.length) {G__20203__a[G__20203__i] = arguments[G__20203__i + 0]; ++G__20203__i;}
  args = new cljs.core.IndexedSeq(G__20203__a,0,null);
} 
return G__20202__delegate.call(this,args);};
G__20202.cljs$lang$maxFixedArity = 0;
G__20202.cljs$lang$applyTo = (function (arglist__20204){
var args = cljs.core.seq(arglist__20204);
return G__20202__delegate(args);
});
G__20202.cljs$core$IFn$_invoke$arity$variadic = G__20202__delegate;
return G__20202;
})()
;})(c))
);

return c;
});
/**
 * Synchronous lchown
 * @param {!string} pathstr
 * @param {!Number} uid
 * @param {!Number} gid
 * @return {nil} or throws
 */
cljs_node_io.fs.lchown = (function cljs_node_io$fs$lchown(pathstr,uid,gid){
return cljs_node_io.fs.fs.lchownSync(pathstr,uid,gid);
});
/**
 * Asynchronous lchown
 * @param {!string} pathstr
 * @param {!Number} uid
 * @param {!Number} gid
 * @return {!Channel} promise-chan receiving [?err]
 */
cljs_node_io.fs.alchown = (function cljs_node_io$fs$alchown(pathstr,uid,gid){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
cljs_node_io.fs.fs.lchown(pathstr,uid,gid,((function (c){
return (function() { 
var G__20205__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__20205 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__20206__i = 0, G__20206__a = new Array(arguments.length -  0);
while (G__20206__i < G__20206__a.length) {G__20206__a[G__20206__i] = arguments[G__20206__i + 0]; ++G__20206__i;}
  args = new cljs.core.IndexedSeq(G__20206__a,0,null);
} 
return G__20205__delegate.call(this,args);};
G__20205.cljs$lang$maxFixedArity = 0;
G__20205.cljs$lang$applyTo = (function (arglist__20207){
var args = cljs.core.seq(arglist__20207);
return G__20205__delegate(args);
});
G__20205.cljs$core$IFn$_invoke$arity$variadic = G__20205__delegate;
return G__20205;
})()
;})(c))
);

return c;
});
/**
 * synchronous utimes
 * - If the value is NaN or Infinity, the value would get converted to Date.now()
 * - numerable strings ie '12235' are converted to numbers
 * @param {!string} pathstr
 * @param {(string|Number)} atime
 * @param {(string|Number)} mtime
 * @return {nil}
 */
cljs_node_io.fs.utimes = (function cljs_node_io$fs$utimes(pathstr,atime,mtime){
return cljs_node_io.fs.fs.utimesSync(pathstr,atime,mtime);
});
/**
 * asynchronous utimes
 * - If the value is NaN or Infinity, the value would get converted to Date.now()
 * - numerable strings ie '12235' are converted to numbers
 * @param {!string} pathstr
 * @param {(string|Number)} atime
 * @param {(string|Number)} mtime
 * @return {!Channel} promise-chan receiving [?err]
 */
cljs_node_io.fs.autimes = (function cljs_node_io$fs$autimes(pathstr,atime,mtime){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
cljs_node_io.fs.fs.utimes(pathstr,atime,mtime,((function (c){
return (function() { 
var G__20208__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__20208 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__20209__i = 0, G__20209__a = new Array(arguments.length -  0);
while (G__20209__i < G__20209__a.length) {G__20209__a[G__20209__i] = arguments[G__20209__i + 0]; ++G__20209__i;}
  args = new cljs.core.IndexedSeq(G__20209__a,0,null);
} 
return G__20208__delegate.call(this,args);};
G__20208.cljs$lang$maxFixedArity = 0;
G__20208.cljs$lang$applyTo = (function (arglist__20210){
var args = cljs.core.seq(arglist__20210);
return G__20208__delegate(args);
});
G__20208.cljs$core$IFn$_invoke$arity$variadic = G__20208__delegate;
return G__20208;
})()
;})(c))
);

return c;
});
/**
 * Synchronously create a directory
 * @param {!string} pathstr :: path of directory to create
 * @return {nil} or throws
 */
cljs_node_io.fs.mkdir = (function cljs_node_io$fs$mkdir(pathstr){
return cljs_node_io.fs.fs.mkdirSync(pathstr);
});
/**
 * Asynchronously create a directory
 * @param {!string} pathstr :: path of directory to create
 * @return {!Channel} promise-chan receiving [?err]
 */
cljs_node_io.fs.amkdir = (function cljs_node_io$fs$amkdir(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
cljs_node_io.fs.fs.mkdir(pathstr,((function (c){
return (function() { 
var G__20211__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__20211 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__20212__i = 0, G__20212__a = new Array(arguments.length -  0);
while (G__20212__i < G__20212__a.length) {G__20212__a[G__20212__i] = arguments[G__20212__i + 0]; ++G__20212__i;}
  args = new cljs.core.IndexedSeq(G__20212__a,0,null);
} 
return G__20211__delegate.call(this,args);};
G__20211.cljs$lang$maxFixedArity = 0;
G__20211.cljs$lang$applyTo = (function (arglist__20213){
var args = cljs.core.seq(arglist__20213);
return G__20211__delegate(args);
});
G__20211.cljs$core$IFn$_invoke$arity$variadic = G__20211__delegate;
return G__20211;
})()
;})(c))
);

return c;
});
/**
 * Synchronously remove a directory
 * @param {!string} pathstr :: path of directory to remove
 * @return {nil} or throws
 */
cljs_node_io.fs.rmdir = (function cljs_node_io$fs$rmdir(pathstr){
return cljs_node_io.fs.fs.rmdirSync(pathstr);
});
/**
 * Asynchronously remove a directory
 * @param {!string} pathstr :: path of directory to remove
 * @return {!Channel} promise-chan receiving [?err]
 */
cljs_node_io.fs.armdir = (function cljs_node_io$fs$armdir(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
cljs_node_io.fs.fs.rmdir(pathstr,((function (c){
return (function() { 
var G__20214__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__20214 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__20215__i = 0, G__20215__a = new Array(arguments.length -  0);
while (G__20215__i < G__20215__a.length) {G__20215__a[G__20215__i] = arguments[G__20215__i + 0]; ++G__20215__i;}
  args = new cljs.core.IndexedSeq(G__20215__a,0,null);
} 
return G__20214__delegate.call(this,args);};
G__20214.cljs$lang$maxFixedArity = 0;
G__20214.cljs$lang$applyTo = (function (arglist__20216){
var args = cljs.core.seq(arglist__20216);
return G__20214__delegate(args);
});
G__20214.cljs$core$IFn$_invoke$arity$variadic = G__20214__delegate;
return G__20214;
})()
;})(c))
);

return c;
});
/**
 * Synchronous link. Will not overwrite newpath if it exists.
 * @param {!string} srcpathstr
 * @param {!string} dstpathstr
 * @return {nil} or throws
 */
cljs_node_io.fs.link = (function cljs_node_io$fs$link(srcpathstr,dstpathstr){
if(typeof srcpathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? srcpathstr)"));
}

if(typeof dstpathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? dstpathstr)"));
}

return cljs_node_io.fs.fs.linkSync(srcpathstr,dstpathstr);
});
/**
 * Synchronous link. Will not overwrite newpath if it exists.
 * @param {!string} srcpathstr
 * @param {!string} dstpathstr
 * @return {!Channel} promise-chan receiving [?err]
 */
cljs_node_io.fs.alink = (function cljs_node_io$fs$alink(srcpathstr,dstpathstr){
if(typeof srcpathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? srcpathstr)"));
}

if(typeof dstpathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? dstpathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
cljs_node_io.fs.fs.link(srcpathstr,dstpathstr,((function (c){
return (function() { 
var G__20217__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__20217 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__20218__i = 0, G__20218__a = new Array(arguments.length -  0);
while (G__20218__i < G__20218__a.length) {G__20218__a[G__20218__i] = arguments[G__20218__i + 0]; ++G__20218__i;}
  args = new cljs.core.IndexedSeq(G__20218__a,0,null);
} 
return G__20217__delegate.call(this,args);};
G__20217.cljs$lang$maxFixedArity = 0;
G__20217.cljs$lang$applyTo = (function (arglist__20219){
var args = cljs.core.seq(arglist__20219);
return G__20217__delegate(args);
});
G__20217.cljs$core$IFn$_invoke$arity$variadic = G__20217__delegate;
return G__20217;
})()
;})(c))
);

return c;
});
/**
 * Synchronous symlink.
 * @param {!string} target :: what gets pointed to
 * @param {!string} pathstr :: the new symbolic link that points to target
 * @return {nil} or throws
 */
cljs_node_io.fs.symlink = (function cljs_node_io$fs$symlink(target,pathstr){
return cljs_node_io.fs.fs.symlinkSync(target,pathstr);
});
/**
 * Synchronous symlink.
 * @param {!string} targetstr :: what gets pointed to
 * @param {!string} pathstr :: the new symbolic link that points to target
 * @return {!Channel} promise-chan receiving [?err]
 */
cljs_node_io.fs.asymlink = (function cljs_node_io$fs$asymlink(targetstr,pathstr){
if(typeof targetstr === 'string'){
} else {
throw (new Error("Assert failed: (string? targetstr)"));
}

if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
cljs_node_io.fs.fs.symlink(targetstr,pathstr,((function (c){
return (function() { 
var G__20220__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__20220 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__20221__i = 0, G__20221__a = new Array(arguments.length -  0);
while (G__20221__i < G__20221__a.length) {G__20221__a[G__20221__i] = arguments[G__20221__i + 0]; ++G__20221__i;}
  args = new cljs.core.IndexedSeq(G__20221__a,0,null);
} 
return G__20220__delegate.call(this,args);};
G__20220.cljs$lang$maxFixedArity = 0;
G__20220.cljs$lang$applyTo = (function (arglist__20222){
var args = cljs.core.seq(arglist__20222);
return G__20220__delegate(args);
});
G__20220.cljs$core$IFn$_invoke$arity$variadic = G__20220__delegate;
return G__20220;
})()
;})(c))
);

return c;
});
/**
 * Synchronously unlink a file.
 * @param {!string} pathstr :: path of file to unlink
 * @return {nil} or throws
 */
cljs_node_io.fs.unlink = (function cljs_node_io$fs$unlink(pathstr){
return cljs_node_io.fs.fs.unlinkSync(pathstr);
});
/**
 * Asynchronously unlink a file
 * @param {!string} pathstr :: path of file to unlink
 * @return {!Channel} promise-chan receiving [?err]
 */
cljs_node_io.fs.aunlink = (function cljs_node_io$fs$aunlink(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
cljs_node_io.fs.fs.unlink(pathstr,((function (c){
return (function() { 
var G__20223__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__20223 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__20224__i = 0, G__20224__a = new Array(arguments.length -  0);
while (G__20224__i < G__20224__a.length) {G__20224__a[G__20224__i] = arguments[G__20224__i + 0]; ++G__20224__i;}
  args = new cljs.core.IndexedSeq(G__20224__a,0,null);
} 
return G__20223__delegate.call(this,args);};
G__20223.cljs$lang$maxFixedArity = 0;
G__20223.cljs$lang$applyTo = (function (arglist__20225){
var args = cljs.core.seq(arglist__20225);
return G__20223__delegate(args);
});
G__20223.cljs$core$IFn$_invoke$arity$variadic = G__20223__delegate;
return G__20223;
})()
;})(c))
);

return c;
});
/**
 * Synchronously delete the file or directory path
 * @param {!string} pathstr :: can be file or directory
 * @return {nil} or throws
 */
cljs_node_io.fs.rm = (function cljs_node_io$fs$rm(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

if(cljs_node_io.fs.dir_QMARK_.call(null,pathstr)){
return cljs_node_io.fs.rmdir.call(null,pathstr);
} else {
return cljs_node_io.fs.unlink.call(null,pathstr);
}
});
/**
 * Asynchronously delete the file or directory path
 * @param {!string} pathstr
 * @return {!Channel} promise-chan receiving [?err]
 */
cljs_node_io.fs.arm = (function cljs_node_io$fs$arm(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

var c = cljs.core.async.promise_chan.call(null);
var dc = cljs_node_io.fs.adir_QMARK_.call(null,pathstr);
cljs.core.async.take_BANG_.call(null,dc,((function (c,dc){
return (function (d_QMARK_){
return cljs.core.async.take_BANG_.call(null,(cljs.core.truth_(d_QMARK_)?cljs_node_io.fs.armdir.call(null,pathstr):cljs_node_io.fs.aunlink.call(null,pathstr)),((function (c,dc){
return (function (ev){
return cljs.core.async.put_BANG_.call(null,c,ev);
});})(c,dc))
);
});})(c,dc))
);

return c;
});
/**
 * @param {!string} pathstr :: path to a directory to recursively delete. Deletes a passed file as well.
 * @return {nil} or throws
 */
cljs_node_io.fs.rm_r = (function cljs_node_io$fs$rm_r(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

if(cljs.core.boolean$.call(null,new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 4, ["/",null,"\\\\",null,"\\",null,"//",null], null), null).call(null,pathstr)) === false){
} else {
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["you just tried to delete root, ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_str.call(null,pathstr)),", be more careful."].join('')),"\n","(false? (boolean (#{\"/\" \"\\\\\\\\\" \"\\\\\" \"//\"} pathstr)))"].join('')));
}

if(cljs_node_io.fs.dir_QMARK_.call(null,pathstr)){
var seq__20226_20230 = cljs.core.seq.call(null,cljs.core.mapv.call(null,cljs.core.partial.call(null,cljs_node_io.fs.resolve_path,pathstr),cljs_node_io.fs.readdir.call(null,pathstr)));
var chunk__20227_20231 = null;
var count__20228_20232 = (0);
var i__20229_20233 = (0);
while(true){
if((i__20229_20233 < count__20228_20232)){
var p_20234 = cljs.core._nth.call(null,chunk__20227_20231,i__20229_20233);
cljs_node_io.fs.rm_r.call(null,p_20234);


var G__20235 = seq__20226_20230;
var G__20236 = chunk__20227_20231;
var G__20237 = count__20228_20232;
var G__20238 = (i__20229_20233 + (1));
seq__20226_20230 = G__20235;
chunk__20227_20231 = G__20236;
count__20228_20232 = G__20237;
i__20229_20233 = G__20238;
continue;
} else {
var temp__5457__auto___20239 = cljs.core.seq.call(null,seq__20226_20230);
if(temp__5457__auto___20239){
var seq__20226_20240__$1 = temp__5457__auto___20239;
if(cljs.core.chunked_seq_QMARK_.call(null,seq__20226_20240__$1)){
var c__4319__auto___20241 = cljs.core.chunk_first.call(null,seq__20226_20240__$1);
var G__20242 = cljs.core.chunk_rest.call(null,seq__20226_20240__$1);
var G__20243 = c__4319__auto___20241;
var G__20244 = cljs.core.count.call(null,c__4319__auto___20241);
var G__20245 = (0);
seq__20226_20230 = G__20242;
chunk__20227_20231 = G__20243;
count__20228_20232 = G__20244;
i__20229_20233 = G__20245;
continue;
} else {
var p_20246 = cljs.core.first.call(null,seq__20226_20240__$1);
cljs_node_io.fs.rm_r.call(null,p_20246);


var G__20247 = cljs.core.next.call(null,seq__20226_20240__$1);
var G__20248 = null;
var G__20249 = (0);
var G__20250 = (0);
seq__20226_20230 = G__20247;
chunk__20227_20231 = G__20248;
count__20228_20232 = G__20249;
i__20229_20233 = G__20250;
continue;
}
} else {
}
}
break;
}

return cljs_node_io.fs.rmdir.call(null,pathstr);
} else {
return cljs_node_io.fs.unlink.call(null,pathstr);
}
});
/**
 * asynchronous recursive delete. Crawls in order provided by readdir and makes unlink/rmdir calls sequentially
 * after the previous has completed. Breaks on any err which is returned as [err].
 * @param {!string} pathstr
 * @return {!Channel} promise-chan receiving [?err]
 */
cljs_node_io.fs.arm_r = (function cljs_node_io$fs$arm_r(pathstr){
if(typeof pathstr === 'string'){
} else {
throw (new Error("Assert failed: (string? pathstr)"));
}

if(cljs.core.boolean$.call(null,new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 4, ["/",null,"\\\\",null,"\\",null,"//",null], null), null).call(null,pathstr)) === false){
} else {
throw (new Error(["Assert failed: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(["you just tried to delete root, ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.pr_str.call(null,pathstr)),", be more careful."].join('')),"\n","(false? (boolean (#{\"/\" \"\\\\\\\\\" \"\\\\\" \"//\"} pathstr)))"].join('')));
}

var c = cljs.core.async.promise_chan.call(null);
var c__4714__auto___20345 = cljs.core.async.chan.call(null,(1));
cljs.core.async.impl.dispatch.run.call(null,((function (c__4714__auto___20345,c){
return (function (){
var f__4715__auto__ = (function (){var switch__4668__auto__ = ((function (c__4714__auto___20345,c){
return (function (state_20316){
var state_val_20317 = (state_20316[(1)]);
if((state_val_20317 === (7))){
var inst_20262 = (state_20316[(7)]);
var inst_20265 = cljs.core.partial.call(null,cljs_node_io.fs.resolve_path,pathstr);
var inst_20266 = cljs.core.mapv.call(null,inst_20265,inst_20262);
var inst_20267 = inst_20266;
var state_20316__$1 = (function (){var statearr_20318 = state_20316;
(statearr_20318[(8)] = inst_20267);

return statearr_20318;
})();
var statearr_20319_20346 = state_20316__$1;
(statearr_20319_20346[(2)] = null);

(statearr_20319_20346[(1)] = (10));


return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_20317 === (20))){
var inst_20298 = (state_20316[(2)]);
var state_20316__$1 = state_20316;
var statearr_20320_20347 = state_20316__$1;
(statearr_20320_20347[(2)] = inst_20298);

(statearr_20320_20347[(1)] = (9));


return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_20317 === (1))){
var inst_20251 = cljs_node_io.fs.adir_QMARK_.call(null,pathstr);
var state_20316__$1 = state_20316;
return cljs.core.async.impl.ioc_helpers.take_BANG_.call(null,state_20316__$1,(2),inst_20251);
} else {
if((state_val_20317 === (24))){
var inst_20310 = (state_20316[(2)]);
var state_20316__$1 = state_20316;
return cljs.core.async.impl.ioc_helpers.put_BANG_.call(null,state_20316__$1,(23),c,inst_20310);
} else {
if((state_val_20317 === (4))){
var inst_20308 = cljs_node_io.fs.aunlink.call(null,pathstr);
var state_20316__$1 = state_20316;
return cljs.core.async.impl.ioc_helpers.take_BANG_.call(null,state_20316__$1,(24),inst_20308);
} else {
if((state_val_20317 === (15))){
var inst_20279 = (state_20316[(9)]);
var inst_20278 = (state_20316[(2)]);
var inst_20279__$1 = cljs.core.nth.call(null,inst_20278,(0),null);
var inst_20280 = (inst_20279__$1 instanceof Error);
var state_20316__$1 = (function (){var statearr_20321 = state_20316;
(statearr_20321[(9)] = inst_20279__$1);

return statearr_20321;
})();
if(cljs.core.truth_(inst_20280)){
var statearr_20322_20348 = state_20316__$1;
(statearr_20322_20348[(1)] = (16));

} else {
var statearr_20323_20349 = state_20316__$1;
(statearr_20323_20349[(1)] = (17));

}

return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_20317 === (21))){
var inst_20296 = (state_20316[(2)]);
var state_20316__$1 = state_20316;
return cljs.core.async.impl.ioc_helpers.put_BANG_.call(null,state_20316__$1,(20),c,inst_20296);
} else {
if((state_val_20317 === (13))){
var state_20316__$1 = state_20316;
var statearr_20324_20350 = state_20316__$1;
(statearr_20324_20350[(2)] = null);

(statearr_20324_20350[(1)] = (14));


return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_20317 === (22))){
var inst_20304 = (state_20316[(2)]);
var state_20316__$1 = state_20316;
var statearr_20325_20351 = state_20316__$1;
(statearr_20325_20351[(2)] = inst_20304);

(statearr_20325_20351[(1)] = (9));


return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_20317 === (6))){
var inst_20261 = (state_20316[(10)]);
var inst_20260 = (state_20316[(2)]);
var inst_20261__$1 = cljs.core.nth.call(null,inst_20260,(0),null);
var inst_20262 = cljs.core.nth.call(null,inst_20260,(1),null);
var inst_20263 = cljs.core.not.call(null,inst_20261__$1);
var state_20316__$1 = (function (){var statearr_20326 = state_20316;
(statearr_20326[(7)] = inst_20262);

(statearr_20326[(10)] = inst_20261__$1);

return statearr_20326;
})();
if(inst_20263){
var statearr_20327_20352 = state_20316__$1;
(statearr_20327_20352[(1)] = (7));

} else {
var statearr_20328_20353 = state_20316__$1;
(statearr_20328_20353[(1)] = (8));

}

return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_20317 === (17))){
var inst_20267 = (state_20316[(8)]);
var inst_20285 = cljs.core.next.call(null,inst_20267);
var inst_20267__$1 = inst_20285;
var state_20316__$1 = (function (){var statearr_20329 = state_20316;
(statearr_20329[(8)] = inst_20267__$1);

return statearr_20329;
})();
var statearr_20330_20354 = state_20316__$1;
(statearr_20330_20354[(2)] = null);

(statearr_20330_20354[(1)] = (10));


return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_20317 === (3))){
var inst_20258 = cljs_node_io.fs.areaddir.call(null,pathstr);
var state_20316__$1 = state_20316;
return cljs.core.async.impl.ioc_helpers.take_BANG_.call(null,state_20316__$1,(6),inst_20258);
} else {
if((state_val_20317 === (12))){
var inst_20267 = (state_20316[(8)]);
var inst_20275 = cljs.core.first.call(null,inst_20267);
var inst_20276 = cljs_node_io.fs.arm_r.call(null,inst_20275);
var state_20316__$1 = state_20316;
return cljs.core.async.impl.ioc_helpers.take_BANG_.call(null,state_20316__$1,(15),inst_20276);
} else {
if((state_val_20317 === (2))){
var inst_20253 = (state_20316[(2)]);
var state_20316__$1 = state_20316;
if(cljs.core.truth_(inst_20253)){
var statearr_20331_20355 = state_20316__$1;
(statearr_20331_20355[(1)] = (3));

} else {
var statearr_20332_20356 = state_20316__$1;
(statearr_20332_20356[(1)] = (4));

}

return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_20317 === (23))){
var inst_20312 = (state_20316[(2)]);
var state_20316__$1 = state_20316;
var statearr_20333_20357 = state_20316__$1;
(statearr_20333_20357[(2)] = inst_20312);

(statearr_20333_20357[(1)] = (5));


return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_20317 === (19))){
var inst_20283 = (state_20316[(2)]);
var state_20316__$1 = state_20316;
var statearr_20334_20358 = state_20316__$1;
(statearr_20334_20358[(2)] = inst_20283);

(statearr_20334_20358[(1)] = (18));


return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_20317 === (11))){
var inst_20293 = (state_20316[(2)]);
var inst_20294 = cljs_node_io.fs.armdir.call(null,pathstr);
var state_20316__$1 = (function (){var statearr_20335 = state_20316;
(statearr_20335[(11)] = inst_20293);

return statearr_20335;
})();
return cljs.core.async.impl.ioc_helpers.take_BANG_.call(null,state_20316__$1,(21),inst_20294);
} else {
if((state_val_20317 === (9))){
var inst_20306 = (state_20316[(2)]);
var state_20316__$1 = state_20316;
var statearr_20336_20359 = state_20316__$1;
(statearr_20336_20359[(2)] = inst_20306);

(statearr_20336_20359[(1)] = (5));


return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_20317 === (5))){
var inst_20314 = (state_20316[(2)]);
var state_20316__$1 = state_20316;
return cljs.core.async.impl.ioc_helpers.return_chan.call(null,state_20316__$1,inst_20314);
} else {
if((state_val_20317 === (