@atomist/clj-editors/out/cljs_node_io/fs.js

We build a node module `@atomist/clj-editors` here. This allows us to construct clojure editors using `rewrite-cljs`. After adding this dependency, the node application will have access to javascript functions transpiled from clojurescript.

// Compiled by ClojureScript 1.9.946 {: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__14284__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__14284 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__14285__i = 0, G__14285__a = new Array(arguments.length -  0);
while (G__14285__i < G__14285__a.length) {G__14285__a[G__14285__i] = arguments[G__14285__i + 0]; ++G__14285__i;}
  args = new cljs.core.IndexedSeq(G__14285__a,0,null);
} 
return G__14284__delegate.call(this,args);};
G__14284.cljs$lang$maxFixedArity = 0;
G__14284.cljs$lang$applyTo = (function (arglist__14286){
var args = cljs.core.seq(arglist__14286);
return G__14284__delegate(args);
});
G__14284.cljs$core$IFn$_invoke$arity$variadic = G__14284__delegate;
return G__14284;
})()
;})(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__14287__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__14287 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__14288__i = 0, G__14288__a = new Array(arguments.length -  0);
while (G__14288__i < G__14288__a.length) {G__14288__a[G__14288__i] = arguments[G__14288__i + 0]; ++G__14288__i;}
  args = new cljs.core.IndexedSeq(G__14288__a,0,null);
} 
return G__14287__delegate.call(this,args);};
G__14287.cljs$lang$maxFixedArity = 0;
G__14287.cljs$lang$applyTo = (function (arglist__14289){
var args = cljs.core.seq(arglist__14289);
return G__14287__delegate(args);
});
G__14287.cljs$core$IFn$_invoke$arity$variadic = G__14287__delegate;
return G__14287;
})()
;})(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__14290_SHARP_){
return cljs.core._EQ_.call(null,cljs.core.nth.call(null,p1__14290_SHARP_,(0)),"_checkModeProperty");
});})(ks,vs))
),cljs.core.map.call(null,((function (ks,vs){
return (function (p__14291){
var vec__14292 = p__14291;
var k = cljs.core.nth.call(null,vec__14292,(0),null);
var v = cljs.core.nth.call(null,vec__14292,(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__8811__auto__ = a;
var l__8812__auto__ = a__8811__auto__.length;
var res = cljs.core.aclone.call(null,a__8811__auto__);
var i = (0);
while(true){
if((i < l__8812__auto__)){
(res[i] = ((!(((a[i]) === (0))))?(1):(0)));

var G__14297 = (i + (1));
i = G__14297;
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 (e14299){if((e14299 instanceof Error)){
var e = e14299;
return false;
} else {
throw e14299;

}
}})();
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__14302){
var vec__14303 = p__14302;
var err = cljs.core.nth.call(null,vec__14303,(0),null);
var stats = cljs.core.nth.call(null,vec__14303,(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 (e14308){if((e14308 instanceof Error)){
var e = e14308;
return false;
} else {
throw e14308;

}
}})();
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__14309){
var vec__14310 = p__14309;
var err = cljs.core.nth.call(null,vec__14310,(0),null);
var stats = cljs.core.nth.call(null,vec__14310,(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 (e14315){if((e14315 instanceof Error)){
var e = e14315;
return false;
} else {
throw e14315;

}
}});
/**
 * 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 (e14318){if((e14318 instanceof Error)){
var e = e14318;
return false;
} else {
throw e14318;

}
}});
/**
 * 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 (e14320){if((e14320 instanceof Error)){
var e = e14320;
return false;
} else {
throw e14320;

}
}});
/**
 * 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 (e14322){if((e14322 instanceof Error)){
var e = e14322;
return false;
} else {
throw e14322;

}
}} 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 (e14325){if((e14325 instanceof Error)){
var e = e14325;
return false;
} else {
throw e14325;

}
}})();
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__14327){
var vec__14328 = p__14327;
var err = cljs.core.nth.call(null,vec__14328,(0),null);
var stats = cljs.core.nth.call(null,vec__14328,(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__14335 = arguments.length;
switch (G__14335) {
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__9056__auto__ = [];
var len__9049__auto___14339 = arguments.length;
var i__9050__auto___14340 = (0);
while(true){
if((i__9050__auto___14340 < len__9049__auto___14339)){
args__9056__auto__.push((arguments[i__9050__auto___14340]));

var G__14341 = (i__9050__auto___14340 + (1));
i__9050__auto___14340 = G__14341;
continue;
} else {
}
break;
}

var argseq__9057__auto__ = ((((0) < args__9056__auto__.length))?(new cljs.core.IndexedSeq(args__9056__auto__.slice((0)),(0),null)):null);
return cljs_node_io.fs.resolve_path.cljs$core$IFn$_invoke$arity$variadic(argseq__9057__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);

cljs_node_io.fs.resolve_path.cljs$lang$applyTo = (function (seq14337){
return cljs_node_io.fs.resolve_path.cljs$core$IFn$_invoke$arity$variadic(cljs.core.seq.call(null,seq14337));
});

/**
 * @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__14345__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__14345 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__14346__i = 0, G__14346__a = new Array(arguments.length -  0);
while (G__14346__i < G__14346__a.length) {G__14346__a[G__14346__i] = arguments[G__14346__i + 0]; ++G__14346__i;}
  args = new cljs.core.IndexedSeq(G__14346__a,0,null);
} 
return G__14345__delegate.call(this,args);};
G__14345.cljs$lang$maxFixedArity = 0;
G__14345.cljs$lang$applyTo = (function (arglist__14347){
var args = cljs.core.seq(arglist__14347);
return G__14345__delegate(args);
});
G__14345.cljs$core$IFn$_invoke$arity$variadic = G__14345__delegate;
return G__14345;
})()
;})(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__14348__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__14348 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__14349__i = 0, G__14349__a = new Array(arguments.length -  0);
while (G__14349__i < G__14349__a.length) {G__14349__a[G__14349__i] = arguments[G__14349__i + 0]; ++G__14349__i;}
  args = new cljs.core.IndexedSeq(G__14349__a,0,null);
} 
return G__14348__delegate.call(this,args);};
G__14348.cljs$lang$maxFixedArity = 0;
G__14348.cljs$lang$applyTo = (function (arglist__14350){
var args = cljs.core.seq(arglist__14350);
return G__14348__delegate(args);
});
G__14348.cljs$core$IFn$_invoke$arity$variadic = G__14348__delegate;
return G__14348;
})()
;})(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__14351__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__14351 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__14352__i = 0, G__14352__a = new Array(arguments.length -  0);
while (G__14352__i < G__14352__a.length) {G__14352__a[G__14352__i] = arguments[G__14352__i + 0]; ++G__14352__i;}
  args = new cljs.core.IndexedSeq(G__14352__a,0,null);
} 
return G__14351__delegate.call(this,args);};
G__14351.cljs$lang$maxFixedArity = 0;
G__14351.cljs$lang$applyTo = (function (arglist__14353){
var args = cljs.core.seq(arglist__14353);
return G__14351__delegate(args);
});
G__14351.cljs$core$IFn$_invoke$arity$variadic = G__14351__delegate;
return G__14351;
})()
;})(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__14354__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__14354 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__14355__i = 0, G__14355__a = new Array(arguments.length -  0);
while (G__14355__i < G__14355__a.length) {G__14355__a[G__14355__i] = arguments[G__14355__i + 0]; ++G__14355__i;}
  args = new cljs.core.IndexedSeq(G__14355__a,0,null);
} 
return G__14354__delegate.call(this,args);};
G__14354.cljs$lang$maxFixedArity = 0;
G__14354.cljs$lang$applyTo = (function (arglist__14356){
var args = cljs.core.seq(arglist__14356);
return G__14354__delegate(args);
});
G__14354.cljs$core$IFn$_invoke$arity$variadic = G__14354__delegate;
return G__14354;
})()
;})(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__14357__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__14357 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__14358__i = 0, G__14358__a = new Array(arguments.length -  0);
while (G__14358__i < G__14358__a.length) {G__14358__a[G__14358__i] = arguments[G__14358__i + 0]; ++G__14358__i;}
  args = new cljs.core.IndexedSeq(G__14358__a,0,null);
} 
return G__14357__delegate.call(this,args);};
G__14357.cljs$lang$maxFixedArity = 0;
G__14357.cljs$lang$applyTo = (function (arglist__14359){
var args = cljs.core.seq(arglist__14359);
return G__14357__delegate(args);
});
G__14357.cljs$core$IFn$_invoke$arity$variadic = G__14357__delegate;
return G__14357;
})()
;})(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__14360__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__14360 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__14361__i = 0, G__14361__a = new Array(arguments.length -  0);
while (G__14361__i < G__14361__a.length) {G__14361__a[G__14361__i] = arguments[G__14361__i + 0]; ++G__14361__i;}
  args = new cljs.core.IndexedSeq(G__14361__a,0,null);
} 
return G__14360__delegate.call(this,args);};
G__14360.cljs$lang$maxFixedArity = 0;
G__14360.cljs$lang$applyTo = (function (arglist__14362){
var args = cljs.core.seq(arglist__14362);
return G__14360__delegate(args);
});
G__14360.cljs$core$IFn$_invoke$arity$variadic = G__14360__delegate;
return G__14360;
})()
;})(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__14363__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__14363 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__14364__i = 0, G__14364__a = new Array(arguments.length -  0);
while (G__14364__i < G__14364__a.length) {G__14364__a[G__14364__i] = arguments[G__14364__i + 0]; ++G__14364__i;}
  args = new cljs.core.IndexedSeq(G__14364__a,0,null);
} 
return G__14363__delegate.call(this,args);};
G__14363.cljs$lang$maxFixedArity = 0;
G__14363.cljs$lang$applyTo = (function (arglist__14365){
var args = cljs.core.seq(arglist__14365);
return G__14363__delegate(args);
});
G__14363.cljs$core$IFn$_invoke$arity$variadic = G__14363__delegate;
return G__14363;
})()
;})(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__14366__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__14366 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__14367__i = 0, G__14367__a = new Array(arguments.length -  0);
while (G__14367__i < G__14367__a.length) {G__14367__a[G__14367__i] = arguments[G__14367__i + 0]; ++G__14367__i;}
  args = new cljs.core.IndexedSeq(G__14367__a,0,null);
} 
return G__14366__delegate.call(this,args);};
G__14366.cljs$lang$maxFixedArity = 0;
G__14366.cljs$lang$applyTo = (function (arglist__14368){
var args = cljs.core.seq(arglist__14368);
return G__14366__delegate(args);
});
G__14366.cljs$core$IFn$_invoke$arity$variadic = G__14366__delegate;
return G__14366;
})()
;})(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__14369__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__14369 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__14370__i = 0, G__14370__a = new Array(arguments.length -  0);
while (G__14370__i < G__14370__a.length) {G__14370__a[G__14370__i] = arguments[G__14370__i + 0]; ++G__14370__i;}
  args = new cljs.core.IndexedSeq(G__14370__a,0,null);
} 
return G__14369__delegate.call(this,args);};
G__14369.cljs$lang$maxFixedArity = 0;
G__14369.cljs$lang$applyTo = (function (arglist__14371){
var args = cljs.core.seq(arglist__14371);
return G__14369__delegate(args);
});
G__14369.cljs$core$IFn$_invoke$arity$variadic = G__14369__delegate;
return G__14369;
})()
;})(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__14372__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__14372 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__14373__i = 0, G__14373__a = new Array(arguments.length -  0);
while (G__14373__i < G__14373__a.length) {G__14373__a[G__14373__i] = arguments[G__14373__i + 0]; ++G__14373__i;}
  args = new cljs.core.IndexedSeq(G__14373__a,0,null);
} 
return G__14372__delegate.call(this,args);};
G__14372.cljs$lang$maxFixedArity = 0;
G__14372.cljs$lang$applyTo = (function (arglist__14374){
var args = cljs.core.seq(arglist__14374);
return G__14372__delegate(args);
});
G__14372.cljs$core$IFn$_invoke$arity$variadic = G__14372__delegate;
return G__14372;
})()
;})(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__14375__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__14375 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__14376__i = 0, G__14376__a = new Array(arguments.length -  0);
while (G__14376__i < G__14376__a.length) {G__14376__a[G__14376__i] = arguments[G__14376__i + 0]; ++G__14376__i;}
  args = new cljs.core.IndexedSeq(G__14376__a,0,null);
} 
return G__14375__delegate.call(this,args);};
G__14375.cljs$lang$maxFixedArity = 0;
G__14375.cljs$lang$applyTo = (function (arglist__14377){
var args = cljs.core.seq(arglist__14377);
return G__14375__delegate(args);
});
G__14375.cljs$core$IFn$_invoke$arity$variadic = G__14375__delegate;
return G__14375;
})()
;})(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__14378__delegate = function (args){
return cljs.core.async.put_BANG_.call(null,c,cljs.core.vec.call(null,args));
};
var G__14378 = function (var_args){
var args = null;
if (arguments.length > 0) {
var G__14379__i = 0, G__14379__a = new Array(arguments.length -  0);
while (G__14379__i < G__14379__a.length) {G__14379__a[G__14379__i] = arguments[G__14379__i + 0]; ++G__14379__i;}
  args = new cljs.core.IndexedSeq(G__14379__a,0,null);
} 
return G__14378__delegate.call(this,args);};
G__14378.cljs$lang$maxFixedArity = 0;
G__14378.cljs$lang$applyTo = (function (arglist__14380){
var args = cljs.core.seq(arglist__14380);
return G__14378__delegate(args);
});
G__14378.cljs$core$IFn$_invoke$arity$variadic = G__14378__delegate;
return G__14378;
})()
;})(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__14381_14385 = 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__14382_14386 = null;
var count__14383_14387 = (0);
var i__14384_14388 = (0);
while(true){
if((i__14384_14388 < count__14383_14387)){
var p_14389 = cljs.core._nth.call(null,chunk__14382_14386,i__14384_14388);
cljs_node_io.fs.rm_r.call(null,p_14389);

var G__14390 = seq__14381_14385;
var G__14391 = chunk__14382_14386;
var G__14392 = count__14383_14387;
var G__14393 = (i__14384_14388 + (1));
seq__14381_14385 = G__14390;
chunk__14382_14386 = G__14391;
count__14383_14387 = G__14392;
i__14384_14388 = G__14393;
continue;
} else {
var temp__4657__auto___14394 = cljs.core.seq.call(null,seq__14381_14385);
if(temp__4657__auto___14394){
var seq__14381_14395__$1 = temp__4657__auto___14394;
if(cljs.core.chunked_seq_QMARK_.call(null,seq__14381_14395__$1)){
var c__8717__auto___14396 = cljs.core.chunk_first.call(null,seq__14381_14395__$1);
var G__14397 = cljs.core.chunk_rest.call(null,seq__14381_14395__$1);
var G__14398 = c__8717__auto___14396;
var G__14399 = cljs.core.count.call(null,c__8717__auto___14396);
var G__14400 = (0);
seq__14381_14385 = G__14397;
chunk__14382_14386 = G__14398;
count__14383_14387 = G__14399;
i__14384_14388 = G__14400;
continue;
} else {
var p_14401 = cljs.core.first.call(null,seq__14381_14395__$1);
cljs_node_io.fs.rm_r.call(null,p_14401);

var G__14402 = cljs.core.next.call(null,seq__14381_14395__$1);
var G__14403 = null;
var G__14404 = (0);
var G__14405 = (0);
seq__14381_14385 = G__14402;
chunk__14382_14386 = G__14403;
count__14383_14387 = G__14404;
i__14384_14388 = G__14405;
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__12335__auto___14500 = cljs.core.async.chan.call(null,(1));
cljs.core.async.impl.dispatch.run.call(null,((function (c__12335__auto___14500,c){
return (function (){
var f__12336__auto__ = (function (){var switch__12169__auto__ = ((function (c__12335__auto___14500,c){
return (function (state_14471){
var state_val_14472 = (state_14471[(1)]);
if((state_val_14472 === (7))){
var inst_14417 = (state_14471[(7)]);
var inst_14420 = cljs.core.partial.call(null,cljs_node_io.fs.resolve_path,pathstr);
var inst_14421 = cljs.core.mapv.call(null,inst_14420,inst_14417);
var inst_14422 = inst_14421;
var state_14471__$1 = (function (){var statearr_14473 = state_14471;
(statearr_14473[(8)] = inst_14422);

return statearr_14473;
})();
var statearr_14474_14501 = state_14471__$1;
(statearr_14474_14501[(2)] = null);

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


return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_14472 === (20))){
var inst_14453 = (state_14471[(2)]);
var state_14471__$1 = state_14471;
var statearr_14475_14502 = state_14471__$1;
(statearr_14475_14502[(2)] = inst_14453);

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


return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_14472 === (1))){
var inst_14406 = cljs_node_io.fs.adir_QMARK_.call(null,pathstr);
var state_14471__$1 = state_14471;
return cljs.core.async.impl.ioc_helpers.take_BANG_.call(null,state_14471__$1,(2),inst_14406);
} else {
if((state_val_14472 === (24))){
var inst_14465 = (state_14471[(2)]);
var state_14471__$1 = state_14471;
return cljs.core.async.impl.ioc_helpers.put_BANG_.call(null,state_14471__$1,(23),c,inst_14465);
} else {
if((state_val_14472 === (4))){
var inst_14463 = cljs_node_io.fs.aunlink.call(null,pathstr);
var state_14471__$1 = state_14471;
return cljs.core.async.impl.ioc_helpers.take_BANG_.call(null,state_14471__$1,(24),inst_14463);
} else {
if((state_val_14472 === (15))){
var inst_14434 = (state_14471[(9)]);
var inst_14433 = (state_14471[(2)]);
var inst_14434__$1 = cljs.core.nth.call(null,inst_14433,(0),null);
var inst_14435 = (inst_14434__$1 instanceof Error);
var state_14471__$1 = (function (){var statearr_14476 = state_14471;
(statearr_14476[(9)] = inst_14434__$1);

return statearr_14476;
})();
if(cljs.core.truth_(inst_14435)){
var statearr_14477_14503 = state_14471__$1;
(statearr_14477_14503[(1)] = (16));

} else {
var statearr_14478_14504 = state_14471__$1;
(statearr_14478_14504[(1)] = (17));

}

return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_14472 === (21))){
var inst_14451 = (state_14471[(2)]);
var state_14471__$1 = state_14471;
return cljs.core.async.impl.ioc_helpers.put_BANG_.call(null,state_14471__$1,(20),c,inst_14451);
} else {
if((state_val_14472 === (13))){
var state_14471__$1 = state_14471;
var statearr_14479_14505 = state_14471__$1;
(statearr_14479_14505[(2)] = null);

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


return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_14472 === (22))){
var inst_14459 = (state_14471[(2)]);
var state_14471__$1 = state_14471;
var statearr_14480_14506 = state_14471__$1;
(statearr_14480_14506[(2)] = inst_14459);

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


return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_14472 === (6))){
var inst_14416 = (state_14471[(10)]);
var inst_14415 = (state_14471[(2)]);
var inst_14416__$1 = cljs.core.nth.call(null,inst_14415,(0),null);
var inst_14417 = cljs.core.nth.call(null,inst_14415,(1),null);
var inst_14418 = cljs.core.not.call(null,inst_14416__$1);
var state_14471__$1 = (function (){var statearr_14481 = state_14471;
(statearr_14481[(10)] = inst_14416__$1);

(statearr_14481[(7)] = inst_14417);

return statearr_14481;
})();
if(inst_14418){
var statearr_14482_14507 = state_14471__$1;
(statearr_14482_14507[(1)] = (7));

} else {
var statearr_14483_14508 = state_14471__$1;
(statearr_14483_14508[(1)] = (8));

}

return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_14472 === (17))){
var inst_14422 = (state_14471[(8)]);
var inst_14440 = cljs.core.next.call(null,inst_14422);
var inst_14422__$1 = inst_14440;
var state_14471__$1 = (function (){var statearr_14484 = state_14471;
(statearr_14484[(8)] = inst_14422__$1);

return statearr_14484;
})();
var statearr_14485_14509 = state_14471__$1;
(statearr_14485_14509[(2)] = null);

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


return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_14472 === (3))){
var inst_14413 = cljs_node_io.fs.areaddir.call(null,pathstr);
var state_14471__$1 = state_14471;
return cljs.core.async.impl.ioc_helpers.take_BANG_.call(null,state_14471__$1,(6),inst_14413);
} else {
if((state_val_14472 === (12))){
var inst_14422 = (state_14471[(8)]);
var inst_14430 = cljs.core.first.call(null,inst_14422);
var inst_14431 = cljs_node_io.fs.arm_r.call(null,inst_14430);
var state_14471__$1 = state_14471;
return cljs.core.async.impl.ioc_helpers.take_BANG_.call(null,state_14471__$1,(15),inst_14431);
} else {
if((state_val_14472 === (2))){
var inst_14408 = (state_14471[(2)]);
var state_14471__$1 = state_14471;
if(cljs.core.truth_(inst_14408)){
var statearr_14486_14510 = state_14471__$1;
(statearr_14486_14510[(1)] = (3));

} else {
var statearr_14487_14511 = state_14471__$1;
(statearr_14487_14511[(1)] = (4));

}

return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_14472 === (23))){
var inst_14467 = (state_14471[(2)]);
var state_14471__$1 = state_14471;
var statearr_14488_14512 = state_14471__$1;
(statearr_14488_14512[(2)] = inst_14467);

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


return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_14472 === (19))){
var inst_14438 = (state_14471[(2)]);
var state_14471__$1 = state_14471;
var statearr_14489_14513 = state_14471__$1;
(statearr_14489_14513[(2)] = inst_14438);

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


return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_14472 === (11))){
var inst_14448 = (state_14471[(2)]);
var inst_14449 = cljs_node_io.fs.armdir.call(null,pathstr);
var state_14471__$1 = (function (){var statearr_14490 = state_14471;
(statearr_14490[(11)] = inst_14448);

return statearr_14490;
})();
return cljs.core.async.impl.ioc_helpers.take_BANG_.call(null,state_14471__$1,(21),inst_14449);
} else {
if((state_val_14472 === (9))){
var inst_14461 = (state_14471[(2)]);
var state_14471__$1 = state_14471;
var statearr_14491_14514 = state_14471__$1;
(statearr_14491_14514[(2)] = inst_14461);

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


return new cljs.core.Keyword(null,"recur","recur",-437573268);
} else {
if((state_val_14472 === (5))){
var inst_14469 = (state_14471[(2)]);
var state_14471__$1 = state_14471;
return cljs.core.async.impl.ioc_helpers.return_chan.call(null,state_14471__$1,inst_14469);
} else {
if((state_val_14472 === (14))){
var inst_14446 = (state_14471[(2)]);