first commit

node_modules/sander/CHANGELOG.md

@@ -0,0 +1,68 @@
+# changelog
+
+## 0.5.1
+
+* Update dependencies
+
+## 0.5.0
+
+* Update dependencies
+* Simplify build process
+
+## 0.4.0
+
+* Add ES6 build
+
+## 0.3.8
+
+* `sander.writeFile` and `sander.appendFile` return promises that resolve with the data written or appended
+
+## 0.3.7
+
+* Previous version introduced a bug that affected older versions of Node.js – now fixed
+
+## 0.3.6
+
+* In Node.js 4, buffers are created in JavaScript – replace `!== '[object Buffer]'` check with `=== '[object Object]'`
+
+## 0.3.5
+
+* `sander.writeFile` and `sander.appendFile`, and their sync equivalents, can take a final `options` argument specifying e.g. encoding ([#6](https://github.com/Rich-Harris/sander/pull/6))
+
+## 0.3.4
+
+* Fix `symlinkOrCopy` on Windows ([#4](https://github.com/Rich-Harris/sander/pull/4)) - thanks [@clintwood](https://github.com/clintwood)
+
+## 0.3.3
+
+* Reinstate graceful-fs to avoid EMFILE errors
+
+## 0.3.2
+
+* Create intermediate directories when symlinking
+
+## 0.3.1
+
+* Include dist files in npm package. (Whoops!)
+
+## 0.3.0
+
+* Rewrote as ES6 modules
+* Added `symlinkOrCopy` and `symlinkOrCopySync` methods, inspired by [symlink-or-copy](https://github.com/broccolijs/node-symlink-or-copy)
+
+## 0.2.4
+
+* Add `appendFile` and `appendFileSync` methods ([#2](https://github.com/Rich-Harris/sander/issues/2))
+
+## 0.2.2-0.2.3
+
+* Appeasing the npm gods
+
+## 0.2.1
+
+* `sander.copydir()` no longer fails with empty directories
+
+## 0.2.0
+
+* Now using [graceful-fs](https://github.com/isaacs/node-graceful-fs), to prevent EMFILE errors from ruining your day
+* Intermediate directories are created by `sander.link()`, `sander.rename()` and their synchronous equivalents

node_modules/sander/dist/sander.cjs.js

@@ -0,0 +1,779 @@
+'use strict';
+
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+var fs = require('graceful-fs');
+var es6Promise = require('es6-promise');
+var path = require('path');
+var mkdirp = _interopDefault(require('mkdirp'));
+var fs$1 = require('fs');
+var _rimraf = _interopDefault(require('rimraf'));
+
+function resolvePath ( args ) {
+	return path.resolve.apply( null, args );
+}
+
+function normaliseArguments ( args ) {
+	var len = args.length;
+
+	var buildingPath = true;
+	var pathargs = [];
+	var normalised = [ null ]; // null is a placeholder for the resolved path
+	var i;
+
+	for ( i = 0; i < len; i += 1 ) {
+		if ( buildingPath && typeof args[i] === 'string' ) {
+			pathargs[i] = args[i];
+		} else {
+			buildingPath = false;
+			normalised.push( args[i] );
+		}
+	}
+
+	normalised[0] = resolvePath( pathargs );
+
+	return normalised;
+}
+
+function asyncMethod ( methodName ) {
+	return function () {
+		var args = normaliseArguments( arguments );
+
+		return new Promise( function ( fulfil, reject ) {
+			args.push( function ( err, result ) {
+				if ( err ) {
+					reject( err );
+				} else {
+					fulfil( result );
+				}
+			});
+
+			fs[ methodName ].apply( fs, args );
+		});
+	};
+}
+
+function syncMethod ( methodName ) {
+	return function () {
+		var args = normaliseArguments( arguments );
+		return fs[ methodName ].apply( fs, args );
+	};
+}
+
+function asyncFileDescriptorMethod ( methodName ) {
+	return function () {
+		var arguments$1 = arguments;
+
+		var args = [];
+		var i = arguments.length;
+
+		while ( i-- ) {
+			args[i] = arguments$1[i];
+		}
+
+		return new Promise( function ( fulfil, reject ) {
+			args.push( function ( err, result ) {
+				if ( err ) {
+					reject( err );
+				} else {
+					fulfil( result );
+				}
+			});
+
+			fs[ methodName ].apply( fs, args );
+		});
+	};
+}
+
+function resolvePathAndOptions ( args ) {
+	var options;
+	var pathargs;
+
+	if ( typeof args[ args.length - 1 ] === 'object' ) {
+		options = args[ args.length - 1 ];
+
+		var i = args.length - 1;
+		pathargs = new Array( i );
+
+		while ( i-- ) {
+			pathargs[i] = args[i];
+		}
+	} else {
+		options = {};
+		pathargs = args;
+	}
+
+	var resolvedPath = path.resolve.apply( null, pathargs );
+
+	return { options: options, resolvedPath: resolvedPath };
+}
+
+function createReadStream$1 () {
+	var ref = resolvePathAndOptions( arguments ), resolvedPath = ref.resolvedPath, options = ref.options;
+	return fs.createReadStream( resolvedPath, options );
+}
+
+function createWriteStream$1 () {
+	var ref = resolvePathAndOptions( arguments ), resolvedPath = ref.resolvedPath, options = ref.options;
+
+	mkdirp.sync( path.dirname( resolvedPath ) );
+	return fs.createWriteStream( resolvedPath, options );
+}
+
+function exists () {
+	var target = resolvePath( arguments );
+
+	return new Promise( function ( fulfil ) {
+		fs.exists( target, function ( exists ) { return fulfil( exists ); } );
+	});
+}
+
+function existsSync () {
+	return fs.existsSync( resolvePath( arguments ) );
+}
+
+var rename = asyncMethod$1( 'rename' );
+var link = asyncMethod$1( 'link' );
+
+var renameSync = syncMethod$1( 'renameSync' );
+var linkSync = syncMethod$1( 'linkSync' );
+
+function asyncMethod$1 ( methodName ) {
+	return function () {
+		var src = resolvePath( arguments );
+
+		return {
+			to: function to () {
+				var dest = resolvePath( arguments );
+
+				return new Promise( function ( fulfil, reject ) {
+					mkdirp( path.dirname( dest ), function ( err ) {
+						if ( err ) {
+							reject( err );
+						} else {
+							fs[ methodName ]( src, dest, function ( err ) {
+								if ( err ) {
+									reject( err );
+								} else {
+									fulfil();
+								}
+							});
+						}
+					});
+				});
+			}
+		};
+	};
+}
+
+function syncMethod$1 ( methodName ) {
+	return function () {
+		var src = resolvePath( arguments );
+
+		return {
+			to: function to () {
+				var dest = resolvePath( arguments );
+
+				mkdirp.sync( path.dirname( dest ) );
+				return fs[ methodName ]( src, dest );
+			}
+		};
+	};
+}
+
+function mkdir () {
+	var dir = resolvePath( arguments );
+
+	return new Promise( function ( fulfil, reject ) {
+		mkdirp( dir, function ( err ) {
+			if ( err ) {
+				reject( err );
+			} else {
+				fulfil();
+			}
+		});
+	});
+}
+
+function mkdirSync () {
+	var dir = resolvePath( arguments );
+	mkdirp.sync( dir );
+}
+
+function normaliseArguments$1 ( args ) {
+	var options;
+	var flags;
+	var i;
+
+	if ( typeof args[ args.length - 1 ] === 'object' ) {
+		options = args[ args.length - 1 ];
+		flags = args[ args.length - 2 ];
+		i = args.length - 2;
+	} else {
+		options = {};
+		flags = args[ args.length - 1 ];
+		i = args.length - 1;
+	}
+
+	var pathargs = new Array( i );
+	while ( i-- ) {
+		pathargs[i] = args[i];
+	}
+
+	var resolvedPath = resolvePath( pathargs );
+
+	return { resolvedPath: resolvedPath, options: options, flags: flags };
+}
+
+function bailIfExists ( src, flags, mode ) {
+	var alreadyExists;
+
+	try {
+		fs.statSync( src );
+		alreadyExists = true;
+	} catch ( err ) {
+		if ( err.code !== 'ENOENT' ) {
+			throw err;
+		}
+	}
+
+	if ( alreadyExists ) {
+		// attempt the operation = that way, we get the intended error message
+		// TODO can't we just do this in the first place?
+		fs.openSync( src, flags, mode );
+	}
+}
+
+function open () {
+	var ref = normaliseArguments$1( arguments ), src = ref.resolvedPath, options = ref.options, flags = ref.flags;
+
+	if ( /^.x/.test( flags ) ) {
+		bailIfExists( src, flags, options.mode );
+	}
+
+	return new Promise( function ( fulfil, reject ) {
+		function open () {
+			fs.open( src, flags, options.mode, function ( err, fd ) {
+				if ( err ) {
+					reject( err );
+				} else {
+					fulfil( fd );
+				}
+			});
+		}
+
+		// create dirs if necessary
+		if ( /^[wa]/.test( flags ) ) {
+			mkdirp( path.dirname( src ), function ( err ) {
+				if ( err ) {
+					reject( err );
+				} else {
+					open();
+				}
+			});
+		} else {
+			open();
+		}
+	});
+}
+
+
+function openSync () {
+	var ref = normaliseArguments$1( arguments ), src = ref.resolvedPath, options = ref.options, flags = ref.flags;
+
+	if ( /^.x/.test( flags ) ) {
+		bailIfExists( src, flags, options.mode );
+	}
+
+	// create dirs if necessary
+	if ( /^[wa]/.test( flags ) ) {
+		mkdirp.sync( path.dirname( src ) );
+	}
+
+	return fs.openSync( src, flags, options.mode );
+}
+
+function symlink () {
+	var src = resolvePath( arguments );
+
+	return {
+		to: function to () {
+			var ref = resolvePathAndOptions( arguments ), options = ref.options, dest = ref.resolvedPath;
+
+			return new Promise( function ( fulfil, reject ) {
+				mkdirp( path.dirname( dest ), function ( err ) {
+					if ( err ) {
+						reject( err );
+					} else {
+						fs.symlink( src, dest, options.type, function ( err ) {
+							if ( err ) {
+								reject( err );
+							} else {
+								fulfil();
+							}
+						});
+					}
+				});
+			});
+		}
+	};
+}
+
+function symlinkSync () {
+	var src = resolvePath( arguments );
+
+	return {
+		to: function to () {
+			var ref = resolvePathAndOptions( arguments ), options = ref.options, dest = ref.resolvedPath;
+			mkdirp.sync( path.dirname( dest ) );
+			return fs.symlinkSync( src, dest, options.type );
+		}
+	};
+}
+
+var writeFile = asyncMethod$2( 'writeFile' );
+var appendFile = asyncMethod$2( 'appendFile' );
+
+var writeFileSync = syncMethod$2( 'writeFileSync' );
+var appendFileSync = syncMethod$2( 'appendFileSync' );
+
+function normaliseArguments$2 ( args ) {
+	args = Array.prototype.slice.call( args, 0 );
+	var opts = {};
+
+	if ( typeof args[ args.length - 1 ] === 'object' && !( args[ args.length - 1 ] instanceof Buffer ) ) {
+		opts = args.pop();
+	}
+
+	return { opts: opts, data: args.pop(), dest: resolvePath( args ) };
+}
+
+function asyncMethod$2 ( methodName ) {
+	return function () {
+		var ref = normaliseArguments$2( arguments ), dest = ref.dest, data = ref.data, opts = ref.opts;
+
+		return new Promise( function ( fulfil, reject ) {
+			mkdirp( path.dirname( dest ), function ( err ) {
+				if ( err ) {
+					reject( err );
+				} else {
+					fs[ methodName ]( dest, data, opts, function ( err ) {
+						if ( err ) {
+							reject( err );
+						} else {
+							fulfil( data );
+						}
+					});
+				}
+			});
+		});
+	};
+}
+
+function syncMethod$2 ( methodName ) {
+	return function () {
+		var ref = normaliseArguments$2( arguments ), dest = ref.dest, data = ref.data;
+
+		mkdirp.sync( path.dirname( dest ) );
+		return fs[ methodName ]( dest, data );
+	};
+}
+
+function copydir () {
+	var ref = resolvePathAndOptions( arguments ), src = ref.resolvedPath, readOptions = ref.options;
+
+	return {
+		to: function to () {
+			var ref = resolvePathAndOptions( arguments ), dest = ref.resolvedPath, writeOptions = ref.options;
+
+			function copydir ( src, dest, cb ) {
+				mkdirp( dest, function ( err ) {
+					if ( err ) return cb( err );
+
+					fs.readdir( src, function ( err, files ) {
+						if ( err ) return cb( err );
+
+						var remaining = files.length;
+
+						if ( !remaining ) return cb();
+
+						function check ( err ) {
+							if ( err ) {
+								return cb( err );
+							}
+
+							if ( !--remaining ) {
+								cb();
+							}
+						}
+
+						files.forEach( function ( filename ) {
+							var srcpath = src + path.sep + filename;
+							var destpath = dest + path.sep + filename;
+
+							fs.stat( srcpath, function ( err, stats ) {
+								var readStream, writeStream;
+
+								if ( stats.isDirectory() ) {
+									return copydir( srcpath, destpath, check );
+								}
+
+								readStream = fs.createReadStream( srcpath, readOptions );
+								writeStream = fs.createWriteStream( destpath, writeOptions );
+
+								readStream.on( 'error', cb );
+								writeStream.on( 'error', cb );
+
+								writeStream.on( 'close', check );
+
+								readStream.pipe( writeStream );
+							});
+						});
+					});
+				});
+			}
+
+			return new Promise( function ( fulfil, reject ) {
+				copydir( src, dest, function ( err ) {
+					if ( err ) {
+						reject( err );
+					} else {
+						fulfil();
+					}
+				});
+			});
+		}
+	};
+}
+
+function copydirSync () {
+	var ref = resolvePathAndOptions( arguments ), src = ref.resolvedPath, readOptions = ref.options;
+
+	return {
+		to: function to () {
+			var ref = resolvePathAndOptions( arguments ), dest = ref.resolvedPath, writeOptions = ref.options;
+
+			function copydir ( src, dest ) {
+				mkdirp.sync( dest );
+
+				fs.readdirSync( src ).forEach( function ( filename ) {
+					var srcpath = src + path.sep + filename;
+					var destpath = dest + path.sep + filename;
+
+					if ( fs.statSync( srcpath ).isDirectory() ) {
+						return copydir( srcpath, destpath );
+					}
+
+					var data = fs.readFileSync( srcpath, readOptions );
+					fs.writeFileSync( destpath, data, writeOptions );
+				});
+			}
+
+			copydir( src, dest );
+		}
+	};
+}
+
+function copyFile () {
+	var ref = resolvePathAndOptions( arguments ), src = ref.resolvedPath, readOptions = ref.options;
+
+	return {
+		to: function to () {
+			var ref = resolvePathAndOptions( arguments ), dest = ref.resolvedPath, writeOptions = ref.options;
+
+			return new Promise( function ( fulfil, reject ) {
+				mkdirp( path.dirname( dest ), function ( err ) {
+					if ( err ) {
+						reject( err );
+					} else {
+						var readStream = fs.createReadStream( src, readOptions );
+						var writeStream = fs.createWriteStream( dest, writeOptions );
+
+						readStream.on( 'error', reject );
+						writeStream.on( 'error', reject );
+
+						writeStream.on( 'close', fulfil );
+
+						readStream.pipe( writeStream );
+					}
+				});
+			});
+		}
+	};
+}
+
+function copyFileSync () {
+	var ref = resolvePathAndOptions( arguments ), src = ref.resolvedPath, readOptions = ref.options;
+
+	return {
+		to: function to () {
+			var ref = resolvePathAndOptions( arguments ), dest = ref.resolvedPath, writeOptions = ref.options;
+
+			var data = fs.readFileSync( src, readOptions );
+
+			mkdirp.sync( path.dirname( dest ) );
+			fs.writeFileSync( dest, data, writeOptions );
+		}
+	};
+}
+
+function walk ( dir, callback ) {
+	var results = [];
+
+	fs$1.readdir( dir, function ( err, files ) {
+		if ( err ) return callback( err );
+
+		var pending = files.length;
+		if ( !pending ) return callback( null, results );
+
+		files.forEach( function ( file ) {
+			file = path.resolve( dir, file );
+
+			fs$1.stat( file, function ( err, stats ) {
+				if ( stats && stats.isDirectory() ) {
+					walk( file, function ( err, res ) {
+						results = results.concat( res );
+						if ( !--pending ) callback( null, results );
+					});
+				} else {
+					results.push( file );
+					if ( !--pending ) callback( null, results );
+				}
+			});
+		});
+	});
+};
+
+function lsr () {
+	var basedir = resolvePath( arguments );
+
+	return new Promise( function ( fulfil, reject ) {
+		walk( basedir, function ( err, result ) {
+			if ( err ) return reject( err );
+
+			// files should be relative to basedir
+			var index = basedir.length + 1;
+			var i = result.length;
+			while ( i-- ) {
+				result[i] = result[i].substring( index );
+			}
+
+			fulfil( result );
+		});
+	});
+}
+
+function lsrSync () {
+	var basedir = resolvePath( arguments );
+
+	var result = [];
+
+	function processdir ( dir ) {
+		fs$1.readdirSync( dir ).forEach( function ( file ) {
+			var filepath = dir + path.sep + file;
+
+			if ( fs$1.statSync( filepath ).isDirectory() ) {
+				processdir( filepath );
+			} else {
+				result.push( filepath.replace( basedir + path.sep, '' ) );
+			}
+		});
+	}
+
+	processdir( basedir );
+	return result;
+}
+
+function rimraf () {
+	var target = resolvePath( arguments );
+
+	return new Promise( function ( fulfil, reject ) {
+		_rimraf( target, function ( err ) {
+			if ( err ) {
+				reject( err );
+			} else {
+				fulfil();
+			}
+		});
+	});
+}
+
+function rimrafSync () {
+	_rimraf.sync( resolvePath( arguments ) );
+}
+
+var isWindows = process.platform === 'win32';
+
+function symlinkOrCopy () {
+	var arguments$1 = arguments;
+
+	if ( isWindows ) {
+		var ref = resolvePathAndOptions( arguments ), src = ref.resolvedPath, readOptions = ref.options;
+
+		var copyDirOrFileTo = stat( src )
+			.then( function ( stats ) {
+				return ( stats.isDirectory() ? copydir : copyFile )
+					.apply( null, arguments$1 )
+					.to;
+			});
+
+		return {
+			to: function to () {
+				var arguments$1 = arguments;
+
+				return copyDirOrFileTo
+					.then(function ( fn ) {
+						return fn.apply(null, arguments$1);
+					});
+			}
+		};
+	}
+
+	return symlink.apply( null, arguments );
+}
+
+function symlinkOrCopySync () {
+	if ( isWindows ) {
+		var ref = resolvePathAndOptions( arguments ), src = ref.resolvedPath, readOptions = ref.options;
+		return ( statSync( src ).isDirectory() ? copydirSync : copyFileSync ).apply( null, arguments );
+	}
+
+	return symlinkSync.apply( null, arguments );
+}
+
+// standard async methods
+var chmod = asyncMethod( 'chmod' );
+var chown = asyncMethod( 'chown' );
+var lchmod = asyncMethod( 'lchmod' );
+var lchown = asyncMethod( 'lchown' );
+var lstat = asyncMethod( 'lstat' );
+var readdir = asyncMethod( 'readdir' );
+var readFile = asyncMethod( 'readFile' );
+var readlink = asyncMethod( 'readlink' );
+var realpath = asyncMethod( 'realpath' );
+var rmdir = asyncMethod( 'rmdir' );
+var stat = asyncMethod( 'stat' );
+var truncate = asyncMethod( 'truncate' );
+var unlink = asyncMethod( 'unlink' );
+var utimes = asyncMethod( 'utimes' );
+var unwatchFile = asyncMethod( 'unwatchFile' );
+var watch = asyncMethod( 'watch' );
+var watchFile = asyncMethod( 'watchFile' );
+
+// standard sync methods
+var chmodSync = syncMethod( 'chmodSync' );
+var chownSync = syncMethod( 'chownSync' );
+var lchmodSync = syncMethod( 'lchmodSync' );
+var lchownSync = syncMethod( 'lchownSync' );
+var lstatSync = syncMethod( 'lstatSync' );
+var readdirSync = syncMethod( 'readdirSync' );
+var readFileSync = syncMethod( 'readFileSync' );
+var readlinkSync = syncMethod( 'readlinkSync' );
+var realpathSync = syncMethod( 'realpathSync' );
+var rmdirSync = syncMethod( 'rmdirSync' );
+var statSync = syncMethod( 'statSync' );
+var truncateSync = syncMethod( 'truncateSync' );
+var unlinkSync = syncMethod( 'unlinkSync' );
+var utimesSync = syncMethod( 'utimesSync' );
+
+// file descriptor async methods
+var close = asyncFileDescriptorMethod( 'close' );
+var fchmod = asyncFileDescriptorMethod( 'fchmod' );
+var fchown = asyncFileDescriptorMethod( 'fchown' );
+var fstat = asyncFileDescriptorMethod( 'fstat' );
+var fsync = asyncFileDescriptorMethod( 'fsync' );
+var ftruncate = asyncFileDescriptorMethod( 'ftruncate' );
+var futimes = asyncFileDescriptorMethod( 'futimes' );
+var read = asyncFileDescriptorMethod( 'read' );
+
+// file descriptor sync methods
+var closeSync = fs.closeSync;
+var fchmodSync = fs.fchmodSync;
+var fchownSync = fs.fchownSync;
+var fstatSync = fs.fstatSync;
+var fsyncSync = fs.fsyncSync;
+var ftruncateSync = fs.ftruncateSync;
+var futimesSync = fs.futimesSync;
+var readSync = fs.readSync;
+
+// expose Promise for convenience
+// https://github.com/esperantojs/esperanto/issues/161
+var Promise$1 = es6Promise.Promise;
+
+exports.chmod = chmod;
+exports.chown = chown;
+exports.createReadStream = createReadStream$1;
+exports.createWriteStream = createWriteStream$1;
+exports.lchmod = lchmod;
+exports.lchown = lchown;
+exports.lstat = lstat;
+exports.readdir = readdir;
+exports.readFile = readFile;
+exports.readlink = readlink;
+exports.realpath = realpath;
+exports.rmdir = rmdir;
+exports.stat = stat;
+exports.truncate = truncate;
+exports.unlink = unlink;
+exports.utimes = utimes;
+exports.unwatchFile = unwatchFile;
+exports.watch = watch;
+exports.watchFile = watchFile;
+exports.chmodSync = chmodSync;
+exports.chownSync = chownSync;
+exports.lchmodSync = lchmodSync;
+exports.lchownSync = lchownSync;
+exports.lstatSync = lstatSync;
+exports.readdirSync = readdirSync;
+exports.readFileSync = readFileSync;
+exports.readlinkSync = readlinkSync;
+exports.realpathSync = realpathSync;
+exports.rmdirSync = rmdirSync;
+exports.statSync = statSync;
+exports.truncateSync = truncateSync;
+exports.unlinkSync = unlinkSync;
+exports.utimesSync = utimesSync;
+exports.close = close;
+exports.fchmod = fchmod;
+exports.fchown = fchown;
+exports.fstat = fstat;
+exports.fsync = fsync;
+exports.ftruncate = ftruncate;
+exports.futimes = futimes;
+exports.read = read;
+exports.closeSync = closeSync;
+exports.fchmodSync = fchmodSync;
+exports.fchownSync = fchownSync;
+exports.fstatSync = fstatSync;
+exports.fsyncSync = fsyncSync;
+exports.ftruncateSync = ftruncateSync;
+exports.futimesSync = futimesSync;
+exports.readSync = readSync;
+exports.Promise = Promise$1;
+exports.exists = exists;
+exports.existsSync = existsSync;
+exports.link = link;
+exports.linkSync = linkSync;
+exports.rename = rename;
+exports.renameSync = renameSync;
+exports.mkdir = mkdir;
+exports.mkdirSync = mkdirSync;
+exports.open = open;
+exports.openSync = openSync;
+exports.symlink = symlink;
+exports.symlinkSync = symlinkSync;
+exports.writeFile = writeFile;
+exports.writeFileSync = writeFileSync;
+exports.appendFile = appendFile;
+exports.appendFileSync = appendFileSync;
+exports.copydir = copydir;
+exports.copydirSync = copydirSync;
+exports.copyFile = copyFile;
+exports.copyFileSync = copyFileSync;
+exports.lsr = lsr;
+exports.lsrSync = lsrSync;
+exports.rimraf = rimraf;
+exports.rimrafSync = rimrafSync;
+exports.symlinkOrCopy = symlinkOrCopy;
+exports.symlinkOrCopySync = symlinkOrCopySync;
+//# sourceMappingURL=sander.cjs.js.map

node_modules/sander/dist/sander.es.js

@@ -0,0 +1,700 @@
+import * as fs from 'graceful-fs';
+import * as es6Promise from 'es6-promise';
+import { resolve, dirname, sep } from 'path';
+import mkdirp from 'mkdirp';
+import * as fs$1 from 'fs';
+import _rimraf from 'rimraf';
+
+function resolvePath ( args ) {
+	return resolve.apply( null, args );
+}
+
+function normaliseArguments ( args ) {
+	var len = args.length;
+
+	var buildingPath = true;
+	var pathargs = [];
+	var normalised = [ null ]; // null is a placeholder for the resolved path
+	var i;
+
+	for ( i = 0; i < len; i += 1 ) {
+		if ( buildingPath && typeof args[i] === 'string' ) {
+			pathargs[i] = args[i];
+		} else {
+			buildingPath = false;
+			normalised.push( args[i] );
+		}
+	}
+
+	normalised[0] = resolvePath( pathargs );
+
+	return normalised;
+}
+
+function asyncMethod ( methodName ) {
+	return function () {
+		var args = normaliseArguments( arguments );
+
+		return new Promise( function ( fulfil, reject ) {
+			args.push( function ( err, result ) {
+				if ( err ) {
+					reject( err );
+				} else {
+					fulfil( result );
+				}
+			});
+
+			fs[ methodName ].apply( fs, args );
+		});
+	};
+}
+
+function syncMethod ( methodName ) {
+	return function () {
+		var args = normaliseArguments( arguments );
+		return fs[ methodName ].apply( fs, args );
+	};
+}
+
+function asyncFileDescriptorMethod ( methodName ) {
+	return function () {
+		var arguments$1 = arguments;
+
+		var args = [];
+		var i = arguments.length;
+
+		while ( i-- ) {
+			args[i] = arguments$1[i];
+		}
+
+		return new Promise( function ( fulfil, reject ) {
+			args.push( function ( err, result ) {
+				if ( err ) {
+					reject( err );
+				} else {
+					fulfil( result );
+				}
+			});
+
+			fs[ methodName ].apply( fs, args );
+		});
+	};
+}
+
+function resolvePathAndOptions ( args ) {
+	var options;
+	var pathargs;
+
+	if ( typeof args[ args.length - 1 ] === 'object' ) {
+		options = args[ args.length - 1 ];
+
+		var i = args.length - 1;
+		pathargs = new Array( i );
+
+		while ( i-- ) {
+			pathargs[i] = args[i];
+		}
+	} else {
+		options = {};
+		pathargs = args;
+	}
+
+	var resolvedPath = resolve.apply( null, pathargs );
+
+	return { options: options, resolvedPath: resolvedPath };
+}
+
+function createReadStream$1 () {
+	var ref = resolvePathAndOptions( arguments ), resolvedPath = ref.resolvedPath, options = ref.options;
+	return fs.createReadStream( resolvedPath, options );
+}
+
+function createWriteStream$1 () {
+	var ref = resolvePathAndOptions( arguments ), resolvedPath = ref.resolvedPath, options = ref.options;
+
+	mkdirp.sync( dirname( resolvedPath ) );
+	return fs.createWriteStream( resolvedPath, options );
+}
+
+function exists () {
+	var target = resolvePath( arguments );
+
+	return new Promise( function ( fulfil ) {
+		fs.exists( target, function ( exists ) { return fulfil( exists ); } );
+	});
+}
+
+function existsSync () {
+	return fs.existsSync( resolvePath( arguments ) );
+}
+
+var rename = asyncMethod$1( 'rename' );
+var link = asyncMethod$1( 'link' );
+
+var renameSync = syncMethod$1( 'renameSync' );
+var linkSync = syncMethod$1( 'linkSync' );
+
+function asyncMethod$1 ( methodName ) {
+	return function () {
+		var src = resolvePath( arguments );
+
+		return {
+			to: function to () {
+				var dest = resolvePath( arguments );
+
+				return new Promise( function ( fulfil, reject ) {
+					mkdirp( dirname( dest ), function ( err ) {
+						if ( err ) {
+							reject( err );
+						} else {
+							fs[ methodName ]( src, dest, function ( err ) {
+								if ( err ) {
+									reject( err );
+								} else {
+									fulfil();
+								}
+							});
+						}
+					});
+				});
+			}
+		};
+	};
+}
+
+function syncMethod$1 ( methodName ) {
+	return function () {
+		var src = resolvePath( arguments );
+
+		return {
+			to: function to () {
+				var dest = resolvePath( arguments );
+
+				mkdirp.sync( dirname( dest ) );
+				return fs[ methodName ]( src, dest );
+			}
+		};
+	};
+}
+
+function mkdir () {
+	var dir = resolvePath( arguments );
+
+	return new Promise( function ( fulfil, reject ) {
+		mkdirp( dir, function ( err ) {
+			if ( err ) {
+				reject( err );
+			} else {
+				fulfil();
+			}
+		});
+	});
+}
+
+function mkdirSync () {
+	var dir = resolvePath( arguments );
+	mkdirp.sync( dir );
+}
+
+function normaliseArguments$1 ( args ) {
+	var options;
+	var flags;
+	var i;
+
+	if ( typeof args[ args.length - 1 ] === 'object' ) {
+		options = args[ args.length - 1 ];
+		flags = args[ args.length - 2 ];
+		i = args.length - 2;
+	} else {
+		options = {};
+		flags = args[ args.length - 1 ];
+		i = args.length - 1;
+	}
+
+	var pathargs = new Array( i );
+	while ( i-- ) {
+		pathargs[i] = args[i];
+	}
+
+	var resolvedPath = resolvePath( pathargs );
+
+	return { resolvedPath: resolvedPath, options: options, flags: flags };
+}
+
+function bailIfExists ( src, flags, mode ) {
+	var alreadyExists;
+
+	try {
+		fs.statSync( src );
+		alreadyExists = true;
+	} catch ( err ) {
+		if ( err.code !== 'ENOENT' ) {
+			throw err;
+		}
+	}
+
+	if ( alreadyExists ) {
+		// attempt the operation = that way, we get the intended error message
+		// TODO can't we just do this in the first place?
+		fs.openSync( src, flags, mode );
+	}
+}
+
+function open () {
+	var ref = normaliseArguments$1( arguments ), src = ref.resolvedPath, options = ref.options, flags = ref.flags;
+
+	if ( /^.x/.test( flags ) ) {
+		bailIfExists( src, flags, options.mode );
+	}
+
+	return new Promise( function ( fulfil, reject ) {
+		function open () {
+			fs.open( src, flags, options.mode, function ( err, fd ) {
+				if ( err ) {
+					reject( err );
+				} else {
+					fulfil( fd );
+				}
+			});
+		}
+
+		// create dirs if necessary
+		if ( /^[wa]/.test( flags ) ) {
+			mkdirp( dirname( src ), function ( err ) {
+				if ( err ) {
+					reject( err );
+				} else {
+					open();
+				}
+			});
+		} else {
+			open();
+		}
+	});
+}
+
+
+function openSync () {
+	var ref = normaliseArguments$1( arguments ), src = ref.resolvedPath, options = ref.options, flags = ref.flags;
+
+	if ( /^.x/.test( flags ) ) {
+		bailIfExists( src, flags, options.mode );
+	}
+
+	// create dirs if necessary
+	if ( /^[wa]/.test( flags ) ) {
+		mkdirp.sync( dirname( src ) );
+	}
+
+	return fs.openSync( src, flags, options.mode );
+}
+
+function symlink () {
+	var src = resolvePath( arguments );
+
+	return {
+		to: function to () {
+			var ref = resolvePathAndOptions( arguments ), options = ref.options, dest = ref.resolvedPath;
+
+			return new Promise( function ( fulfil, reject ) {
+				mkdirp( dirname( dest ), function ( err ) {
+					if ( err ) {
+						reject( err );
+					} else {
+						fs.symlink( src, dest, options.type, function ( err ) {
+							if ( err ) {
+								reject( err );
+							} else {
+								fulfil();
+							}
+						});
+					}
+				});
+			});
+		}
+	};
+}
+
+function symlinkSync () {
+	var src = resolvePath( arguments );
+
+	return {
+		to: function to () {
+			var ref = resolvePathAndOptions( arguments ), options = ref.options, dest = ref.resolvedPath;
+			mkdirp.sync( dirname( dest ) );
+			return fs.symlinkSync( src, dest, options.type );
+		}
+	};
+}
+
+var writeFile = asyncMethod$2( 'writeFile' );
+var appendFile = asyncMethod$2( 'appendFile' );
+
+var writeFileSync = syncMethod$2( 'writeFileSync' );
+var appendFileSync = syncMethod$2( 'appendFileSync' );
+
+function normaliseArguments$2 ( args ) {
+	args = Array.prototype.slice.call( args, 0 );
+	var opts = {};
+
+	if ( typeof args[ args.length - 1 ] === 'object' && !( args[ args.length - 1 ] instanceof Buffer ) ) {
+		opts = args.pop();
+	}
+
+	return { opts: opts, data: args.pop(), dest: resolvePath( args ) };
+}
+
+function asyncMethod$2 ( methodName ) {
+	return function () {
+		var ref = normaliseArguments$2( arguments ), dest = ref.dest, data = ref.data, opts = ref.opts;
+
+		return new Promise( function ( fulfil, reject ) {
+			mkdirp( dirname( dest ), function ( err ) {
+				if ( err ) {
+					reject( err );
+				} else {
+					fs[ methodName ]( dest, data, opts, function ( err ) {
+						if ( err ) {
+							reject( err );
+						} else {
+							fulfil( data );
+						}
+					});
+				}
+			});
+		});
+	};
+}
+
+function syncMethod$2 ( methodName ) {
+	return function () {
+		var ref = normaliseArguments$2( arguments ), dest = ref.dest, data = ref.data;
+
+		mkdirp.sync( dirname( dest ) );
+		return fs[ methodName ]( dest, data );
+	};
+}
+
+function copydir () {
+	var ref = resolvePathAndOptions( arguments ), src = ref.resolvedPath, readOptions = ref.options;
+
+	return {
+		to: function to () {
+			var ref = resolvePathAndOptions( arguments ), dest = ref.resolvedPath, writeOptions = ref.options;
+
+			function copydir ( src, dest, cb ) {
+				mkdirp( dest, function ( err ) {
+					if ( err ) return cb( err );
+
+					fs.readdir( src, function ( err, files ) {
+						if ( err ) return cb( err );
+
+						var remaining = files.length;
+
+						if ( !remaining ) return cb();
+
+						function check ( err ) {
+							if ( err ) {
+								return cb( err );
+							}
+
+							if ( !--remaining ) {
+								cb();
+							}
+						}
+
+						files.forEach( function ( filename ) {
+							var srcpath = src + sep + filename;
+							var destpath = dest + sep + filename;
+
+							fs.stat( srcpath, function ( err, stats ) {
+								var readStream, writeStream;
+
+								if ( stats.isDirectory() ) {
+									return copydir( srcpath, destpath, check );
+								}
+
+								readStream = fs.createReadStream( srcpath, readOptions );
+								writeStream = fs.createWriteStream( destpath, writeOptions );
+
+								readStream.on( 'error', cb );
+								writeStream.on( 'error', cb );
+
+								writeStream.on( 'close', check );
+
+								readStream.pipe( writeStream );
+							});
+						});
+					});
+				});
+			}
+
+			return new Promise( function ( fulfil, reject ) {
+				copydir( src, dest, function ( err ) {
+					if ( err ) {
+						reject( err );
+					} else {
+						fulfil();
+					}
+				});
+			});
+		}
+	};
+}
+
+function copydirSync () {
+	var ref = resolvePathAndOptions( arguments ), src = ref.resolvedPath, readOptions = ref.options;
+
+	return {
+		to: function to () {
+			var ref = resolvePathAndOptions( arguments ), dest = ref.resolvedPath, writeOptions = ref.options;
+
+			function copydir ( src, dest ) {
+				mkdirp.sync( dest );
+
+				fs.readdirSync( src ).forEach( function ( filename ) {
+					var srcpath = src + sep + filename;
+					var destpath = dest + sep + filename;
+
+					if ( fs.statSync( srcpath ).isDirectory() ) {
+						return copydir( srcpath, destpath );
+					}
+
+					var data = fs.readFileSync( srcpath, readOptions );
+					fs.writeFileSync( destpath, data, writeOptions );
+				});
+			}
+
+			copydir( src, dest );
+		}
+	};
+}
+
+function copyFile () {
+	var ref = resolvePathAndOptions( arguments ), src = ref.resolvedPath, readOptions = ref.options;
+
+	return {
+		to: function to () {
+			var ref = resolvePathAndOptions( arguments ), dest = ref.resolvedPath, writeOptions = ref.options;
+
+			return new Promise( function ( fulfil, reject ) {
+				mkdirp( dirname( dest ), function ( err ) {
+					if ( err ) {
+						reject( err );
+					} else {
+						var readStream = fs.createReadStream( src, readOptions );
+						var writeStream = fs.createWriteStream( dest, writeOptions );
+
+						readStream.on( 'error', reject );
+						writeStream.on( 'error', reject );
+
+						writeStream.on( 'close', fulfil );
+
+						readStream.pipe( writeStream );
+					}
+				});
+			});
+		}
+	};
+}
+
+function copyFileSync () {
+	var ref = resolvePathAndOptions( arguments ), src = ref.resolvedPath, readOptions = ref.options;
+
+	return {
+		to: function to () {
+			var ref = resolvePathAndOptions( arguments ), dest = ref.resolvedPath, writeOptions = ref.options;
+
+			var data = fs.readFileSync( src, readOptions );
+
+			mkdirp.sync( dirname( dest ) );
+			fs.writeFileSync( dest, data, writeOptions );
+		}
+	};
+}
+
+function walk ( dir, callback ) {
+	var results = [];
+
+	fs$1.readdir( dir, function ( err, files ) {
+		if ( err ) return callback( err );
+
+		var pending = files.length;
+		if ( !pending ) return callback( null, results );
+
+		files.forEach( function ( file ) {
+			file = resolve( dir, file );
+
+			fs$1.stat( file, function ( err, stats ) {
+				if ( stats && stats.isDirectory() ) {
+					walk( file, function ( err, res ) {
+						results = results.concat( res );
+						if ( !--pending ) callback( null, results );
+					});
+				} else {
+					results.push( file );
+					if ( !--pending ) callback( null, results );
+				}
+			});
+		});
+	});
+};
+
+function lsr () {
+	var basedir = resolvePath( arguments );
+
+	return new Promise( function ( fulfil, reject ) {
+		walk( basedir, function ( err, result ) {
+			if ( err ) return reject( err );
+
+			// files should be relative to basedir
+			var index = basedir.length + 1;
+			var i = result.length;
+			while ( i-- ) {
+				result[i] = result[i].substring( index );
+			}
+
+			fulfil( result );
+		});
+	});
+}
+
+function lsrSync () {
+	var basedir = resolvePath( arguments );
+
+	var result = [];
+
+	function processdir ( dir ) {
+		fs$1.readdirSync( dir ).forEach( function ( file ) {
+			var filepath = dir + sep + file;
+
+			if ( fs$1.statSync( filepath ).isDirectory() ) {
+				processdir( filepath );
+			} else {
+				result.push( filepath.replace( basedir + sep, '' ) );
+			}
+		});
+	}
+
+	processdir( basedir );
+	return result;
+}
+
+function rimraf () {
+	var target = resolvePath( arguments );
+
+	return new Promise( function ( fulfil, reject ) {
+		_rimraf( target, function ( err ) {
+			if ( err ) {
+				reject( err );
+			} else {
+				fulfil();
+			}
+		});
+	});
+}
+
+function rimrafSync () {
+	_rimraf.sync( resolvePath( arguments ) );
+}
+
+var isWindows = process.platform === 'win32';
+
+function symlinkOrCopy () {
+	var arguments$1 = arguments;
+
+	if ( isWindows ) {
+		var ref = resolvePathAndOptions( arguments ), src = ref.resolvedPath, readOptions = ref.options;
+
+		var copyDirOrFileTo = stat( src )
+			.then( function ( stats ) {
+				return ( stats.isDirectory() ? copydir : copyFile )
+					.apply( null, arguments$1 )
+					.to;
+			});
+
+		return {
+			to: function to () {
+				var arguments$1 = arguments;
+
+				return copyDirOrFileTo
+					.then(function ( fn ) {
+						return fn.apply(null, arguments$1);
+					});
+			}
+		};
+	}
+
+	return symlink.apply( null, arguments );
+}
+
+function symlinkOrCopySync () {
+	if ( isWindows ) {
+		var ref = resolvePathAndOptions( arguments ), src = ref.resolvedPath, readOptions = ref.options;
+		return ( statSync( src ).isDirectory() ? copydirSync : copyFileSync ).apply( null, arguments );
+	}
+
+	return symlinkSync.apply( null, arguments );
+}
+
+// standard async methods
+var chmod = asyncMethod( 'chmod' );
+var chown = asyncMethod( 'chown' );
+var lchmod = asyncMethod( 'lchmod' );
+var lchown = asyncMethod( 'lchown' );
+var lstat = asyncMethod( 'lstat' );
+var readdir = asyncMethod( 'readdir' );
+var readFile = asyncMethod( 'readFile' );
+var readlink = asyncMethod( 'readlink' );
+var realpath = asyncMethod( 'realpath' );
+var rmdir = asyncMethod( 'rmdir' );
+var stat = asyncMethod( 'stat' );
+var truncate = asyncMethod( 'truncate' );
+var unlink = asyncMethod( 'unlink' );
+var utimes = asyncMethod( 'utimes' );
+var unwatchFile = asyncMethod( 'unwatchFile' );
+var watch = asyncMethod( 'watch' );
+var watchFile = asyncMethod( 'watchFile' );
+
+// standard sync methods
+var chmodSync = syncMethod( 'chmodSync' );
+var chownSync = syncMethod( 'chownSync' );
+var lchmodSync = syncMethod( 'lchmodSync' );
+var lchownSync = syncMethod( 'lchownSync' );
+var lstatSync = syncMethod( 'lstatSync' );
+var readdirSync = syncMethod( 'readdirSync' );
+var readFileSync = syncMethod( 'readFileSync' );
+var readlinkSync = syncMethod( 'readlinkSync' );
+var realpathSync = syncMethod( 'realpathSync' );
+var rmdirSync = syncMethod( 'rmdirSync' );
+var statSync = syncMethod( 'statSync' );
+var truncateSync = syncMethod( 'truncateSync' );
+var unlinkSync = syncMethod( 'unlinkSync' );
+var utimesSync = syncMethod( 'utimesSync' );
+
+// file descriptor async methods
+var close = asyncFileDescriptorMethod( 'close' );
+var fchmod = asyncFileDescriptorMethod( 'fchmod' );
+var fchown = asyncFileDescriptorMethod( 'fchown' );
+var fstat = asyncFileDescriptorMethod( 'fstat' );
+var fsync = asyncFileDescriptorMethod( 'fsync' );
+var ftruncate = asyncFileDescriptorMethod( 'ftruncate' );
+var futimes = asyncFileDescriptorMethod( 'futimes' );
+var read = asyncFileDescriptorMethod( 'read' );
+
+// file descriptor sync methods
+var closeSync = fs.closeSync;
+var fchmodSync = fs.fchmodSync;
+var fchownSync = fs.fchownSync;
+var fstatSync = fs.fstatSync;
+var fsyncSync = fs.fsyncSync;
+var ftruncateSync = fs.ftruncateSync;
+var futimesSync = fs.futimesSync;
+var readSync = fs.readSync;
+
+// expose Promise for convenience
+// https://github.com/esperantojs/esperanto/issues/161
+var Promise$1 = es6Promise.Promise;
+
+export { chmod, chown, createReadStream$1 as createReadStream, createWriteStream$1 as createWriteStream, lchmod, lchown, lstat, readdir, readFile, readlink, realpath, rmdir, stat, truncate, unlink, utimes, unwatchFile, watch, watchFile, chmodSync, chownSync, lchmodSync, lchownSync, lstatSync, readdirSync, readFileSync, readlinkSync, realpathSync, rmdirSync, statSync, truncateSync, unlinkSync, utimesSync, close, fchmod, fchown, fstat, fsync, ftruncate, futimes, read, closeSync, fchmodSync, fchownSync, fstatSync, fsyncSync, ftruncateSync, futimesSync, readSync, Promise$1 as Promise, exists, existsSync, link, linkSync, rename, renameSync, mkdir, mkdirSync, open, openSync, symlink, symlinkSync, writeFile, writeFileSync, appendFile, appendFileSync, copydir, copydirSync, copyFile, copyFileSync, lsr, lsrSync, rimraf, rimrafSync, symlinkOrCopy, symlinkOrCopySync };
+//# sourceMappingURL=sander.es.js.map

node_modules/sander/dist/sander.es6.js

@@ -0,0 +1,763 @@
+import * as fs from 'graceful-fs';
+import * as es6Promise from 'es6-promise';
+import { dirname, sep, resolve } from 'path';
+import mkdirp from 'mkdirp';
+import * as fs$1 from 'fs';
+import _rimraf from 'rimraf';
+
+function resolvePath(args) {
+	return resolve.apply(null, args);
+}
+
+function normaliseArguments(args) {
+	var len = args.length;
+
+	var buildingPath = true;
+	var pathargs = [];
+	var normalised = [null]; // null is a placeholder for the resolved path
+	var i = undefined;
+
+	for (i = 0; i < len; i += 1) {
+		if (buildingPath && typeof args[i] === 'string') {
+			pathargs[i] = args[i];
+		} else {
+			buildingPath = false;
+			normalised.push(args[i]);
+		}
+	}
+
+	normalised[0] = resolvePath(pathargs);
+
+	return normalised;
+}
+
+function asyncMethod(methodName) {
+	return function () {
+		var args = normaliseArguments(arguments);
+
+		return new Promise(function (fulfil, reject) {
+			args.push(function (err, result) {
+				if (err) {
+					reject(err);
+				} else {
+					fulfil(result);
+				}
+			});
+
+			fs[methodName].apply(fs, args);
+		});
+	};
+}
+
+function syncMethod(methodName) {
+	return function () {
+		var args = normaliseArguments(arguments);
+		return fs[methodName].apply(fs, args);
+	};
+}
+
+function asyncFileDescriptorMethod(methodName) {
+	return function () {
+		var args = [];
+		var i = arguments.length;
+
+		while (i--) {
+			args[i] = arguments[i];
+		}
+
+		return new Promise(function (fulfil, reject) {
+			args.push(function (err, result) {
+				if (err) {
+					reject(err);
+				} else {
+					fulfil(result);
+				}
+			});
+
+			fs[methodName].apply(fs, args);
+		});
+	};
+}
+
+function resolvePathAndOptions(args) {
+	var options = undefined;
+	var pathargs = undefined;
+
+	if (typeof args[args.length - 1] === 'object') {
+		options = args[args.length - 1];
+
+		var i = args.length - 1;
+		pathargs = new Array(i);
+
+		while (i--) {
+			pathargs[i] = args[i];
+		}
+	} else {
+		options = {};
+		pathargs = args;
+	}
+
+	var resolvedPath = resolve.apply(null, pathargs);
+
+	return { options: options, resolvedPath: resolvedPath };
+}
+
+function createReadStream$1() {
+	var _resolvePathAndOptions = resolvePathAndOptions(arguments);
+
+	var resolvedPath = _resolvePathAndOptions.resolvedPath;
+	var options = _resolvePathAndOptions.options;
+
+	return fs.createReadStream(resolvedPath, options);
+}
+
+function createWriteStream$1() {
+	var _resolvePathAndOptions2 = resolvePathAndOptions(arguments);
+
+	var resolvedPath = _resolvePathAndOptions2.resolvedPath;
+	var options = _resolvePathAndOptions2.options;
+
+	mkdirp.sync(dirname(resolvedPath));
+	return fs.createWriteStream(resolvedPath, options);
+}
+
+function exists$1() {
+	var target = resolvePath(arguments);
+
+	return new Promise(function (fulfil) {
+		fs.exists(target, function (exists) {
+			return fulfil(exists);
+		});
+	});
+}
+
+function existsSync$1() {
+	return fs.existsSync(resolvePath(arguments));
+}
+
+var rename$1 = asyncMethod$1('rename');
+var link$1 = asyncMethod$1('link');
+
+var renameSync$1 = syncMethod$1('renameSync');
+var linkSync$1 = syncMethod$1('linkSync');
+
+function asyncMethod$1(methodName) {
+	return function () {
+		var src = resolvePath(arguments);
+
+		return {
+			to: function () {
+				var dest = resolvePath(arguments);
+
+				return new Promise(function (fulfil, reject) {
+					mkdirp(dirname(dest), function (err) {
+						if (err) {
+							reject(err);
+						} else {
+							fs[methodName](src, dest, function (err) {
+								if (err) {
+									reject(err);
+								} else {
+									fulfil();
+								}
+							});
+						}
+					});
+				});
+			}
+		};
+	};
+}
+
+function syncMethod$1(methodName) {
+	return function () {
+		var src = resolvePath(arguments);
+
+		return {
+			to: function () {
+				var dest = resolvePath(arguments);
+
+				mkdirp.sync(dirname(dest));
+				return fs[methodName](src, dest);
+			}
+		};
+	};
+}
+
+function mkdir$1() {
+	var dir = resolvePath(arguments);
+
+	return new Promise(function (fulfil, reject) {
+		mkdirp(dir, function (err) {
+			if (err) {
+				reject(err);
+			} else {
+				fulfil();
+			}
+		});
+	});
+}
+
+function mkdirSync$1() {
+	var dir = resolvePath(arguments);
+	mkdirp.sync(dir);
+}
+
+function normaliseArguments$1(args) {
+	var options = undefined;
+	var flags = undefined;
+	var i = undefined;
+
+	if (typeof args[args.length - 1] === 'object') {
+		options = args[args.length - 1];
+		flags = args[args.length - 2];
+		i = args.length - 2;
+	} else {
+		options = {};
+		flags = args[args.length - 1];
+		i = args.length - 1;
+	}
+
+	var pathargs = new Array(i);
+	while (i--) {
+		pathargs[i] = args[i];
+	}
+
+	var resolvedPath = resolvePath(pathargs);
+
+	return { resolvedPath: resolvedPath, options: options, flags: flags };
+}
+
+function bailIfExists(src, flags, mode) {
+	var alreadyExists = undefined;
+
+	try {
+		fs.statSync(src);
+		alreadyExists = true;
+	} catch (err) {
+		if (err.code !== 'ENOENT') {
+			throw err;
+		}
+	}
+
+	if (alreadyExists) {
+		// attempt the operation = that way, we get the intended error message
+		// TODO can't we just do this in the first place?
+		fs.openSync(src, flags, mode);
+	}
+}
+
+function open$1() {
+	var _normaliseArguments = normaliseArguments$1(arguments);
+
+	var src = _normaliseArguments.resolvedPath;
+	var options = _normaliseArguments.options;
+	var flags = _normaliseArguments.flags;
+
+	if (/^.x/.test(flags)) {
+		bailIfExists(src, flags, options.mode);
+	}
+
+	return new Promise(function (fulfil, reject) {
+		function open() {
+			fs.open(src, flags, options.mode, function (err, fd) {
+				if (err) {
+					reject(err);
+				} else {
+					fulfil(fd);
+				}
+			});
+		}
+
+		// create dirs if necessary
+		if (/^[wa]/.test(flags)) {
+			mkdirp(dirname(src), function (err) {
+				if (err) {
+					reject(err);
+				} else {
+					open();
+				}
+			});
+		} else {
+			open();
+		}
+	});
+}
+
+function openSync$1() {
+	var _normaliseArguments2 = normaliseArguments$1(arguments);
+
+	var src = _normaliseArguments2.resolvedPath;
+	var options = _normaliseArguments2.options;
+	var flags = _normaliseArguments2.flags;
+
+	if (/^.x/.test(flags)) {
+		bailIfExists(src, flags, options.mode);
+	}
+
+	// create dirs if necessary
+	if (/^[wa]/.test(flags)) {
+		mkdirp.sync(dirname(src));
+	}
+
+	return fs.openSync(src, flags, options.mode);
+}
+
+function symlink$1() {
+	var src = resolvePath(arguments);
+
+	return {
+		to: function () {
+			var _resolvePathAndOptions = resolvePathAndOptions(arguments);
+
+			var options = _resolvePathAndOptions.options;
+			var dest = _resolvePathAndOptions.resolvedPath;
+
+			return new Promise(function (fulfil, reject) {
+				mkdirp(dirname(dest), function (err) {
+					if (err) {
+						reject(err);
+					} else {
+						fs.symlink(src, dest, options.type, function (err) {
+							if (err) {
+								reject(err);
+							} else {
+								fulfil();
+							}
+						});
+					}
+				});
+			});
+		}
+	};
+}
+
+function symlinkSync$1() {
+	var src = resolvePath(arguments);
+
+	return {
+		to: function () {
+			var _resolvePathAndOptions2 = resolvePathAndOptions(arguments);
+
+			var options = _resolvePathAndOptions2.options;
+			var dest = _resolvePathAndOptions2.resolvedPath;
+
+			mkdirp.sync(dirname(dest));
+			return fs.symlinkSync(src, dest, options.type);
+		}
+	};
+}
+
+var writeFile$1 = asyncMethod$2('writeFile');
+var appendFile$1 = asyncMethod$2('appendFile');
+
+var writeFileSync$1 = syncMethod$2('writeFileSync');
+var appendFileSync$1 = syncMethod$2('appendFileSync');
+
+function normaliseArguments$2(args) {
+	args = Array.prototype.slice.call(args, 0);
+	var opts = {};
+
+	if (typeof args[args.length - 1] === 'object' && !(args[args.length - 1] instanceof Buffer)) {
+		opts = args.pop();
+	}
+
+	return { opts: opts, data: args.pop(), dest: resolvePath(args) };
+}
+
+function asyncMethod$2(methodName) {
+	return function () {
+		var _normaliseArguments = normaliseArguments$2(arguments);
+
+		var dest = _normaliseArguments.dest;
+		var data = _normaliseArguments.data;
+		var opts = _normaliseArguments.opts;
+
+		return new Promise(function (fulfil, reject) {
+			mkdirp(dirname(dest), function (err) {
+				if (err) {
+					reject(err);
+				} else {
+					fs[methodName](dest, data, opts, function (err) {
+						if (err) {
+							reject(err);
+						} else {
+							fulfil(data);
+						}
+					});
+				}
+			});
+		});
+	};
+}
+
+function syncMethod$2(methodName) {
+	return function () {
+		var _normaliseArguments2 = normaliseArguments$2(arguments);
+
+		var dest = _normaliseArguments2.dest;
+		var data = _normaliseArguments2.data;
+
+		mkdirp.sync(dirname(dest));
+		return fs[methodName](dest, data);
+	};
+}
+
+function copydir$1() {
+	var _resolvePathAndOptions = resolvePathAndOptions(arguments);
+
+	var src = _resolvePathAndOptions.resolvedPath;
+	var readOptions = _resolvePathAndOptions.options;
+
+	return {
+		to: function () {
+			var _resolvePathAndOptions2 = resolvePathAndOptions(arguments);
+
+			var dest = _resolvePathAndOptions2.resolvedPath;
+			var writeOptions = _resolvePathAndOptions2.options;
+
+			function copydir(src, dest, cb) {
+				mkdirp(dest, function (err) {
+					if (err) return cb(err);
+
+					fs.readdir(src, function (err, files) {
+						if (err) return cb(err);
+
+						var remaining = files.length;
+
+						if (!remaining) return cb();
+
+						function check(err) {
+							if (err) {
+								return cb(err);
+							}
+
+							if (! --remaining) {
+								cb();
+							}
+						}
+
+						files.forEach(function (filename) {
+							var srcpath = src + sep + filename;
+							var destpath = dest + sep + filename;
+
+							fs.stat(srcpath, function (err, stats) {
+								var readStream, writeStream;
+
+								if (stats.isDirectory()) {
+									return copydir(srcpath, destpath, check);
+								}
+
+								readStream = fs.createReadStream(srcpath, readOptions);
+								writeStream = fs.createWriteStream(destpath, writeOptions);
+
+								readStream.on('error', cb);
+								writeStream.on('error', cb);
+
+								writeStream.on('close', check);
+
+								readStream.pipe(writeStream);
+							});
+						});
+					});
+				});
+			}
+
+			return new Promise(function (fulfil, reject) {
+				copydir(src, dest, function (err) {
+					if (err) {
+						reject(err);
+					} else {
+						fulfil();
+					}
+				});
+			});
+		}
+	};
+}
+
+function copydirSync$1() {
+	var _resolvePathAndOptions3 = resolvePathAndOptions(arguments);
+
+	var src = _resolvePathAndOptions3.resolvedPath;
+	var readOptions = _resolvePathAndOptions3.options;
+
+	return {
+		to: function () {
+			var _resolvePathAndOptions4 = resolvePathAndOptions(arguments);
+
+			var dest = _resolvePathAndOptions4.resolvedPath;
+			var writeOptions = _resolvePathAndOptions4.options;
+
+			function copydir(src, dest) {
+				mkdirp.sync(dest);
+
+				fs.readdirSync(src).forEach(function (filename) {
+					var srcpath = src + sep + filename;
+					var destpath = dest + sep + filename;
+
+					if (fs.statSync(srcpath).isDirectory()) {
+						return copydir(srcpath, destpath);
+					}
+
+					var data = fs.readFileSync(srcpath, readOptions);
+					fs.writeFileSync(destpath, data, writeOptions);
+				});
+			}
+
+			copydir(src, dest);
+		}
+	};
+}
+
+function copyFile$1() {
+	var _resolvePathAndOptions = resolvePathAndOptions(arguments);
+
+	var src = _resolvePathAndOptions.resolvedPath;
+	var readOptions = _resolvePathAndOptions.options;
+
+	return {
+		to: function () {
+			var _resolvePathAndOptions2 = resolvePathAndOptions(arguments);
+
+			var dest = _resolvePathAndOptions2.resolvedPath;
+			var writeOptions = _resolvePathAndOptions2.options;
+
+			return new Promise(function (fulfil, reject) {
+				mkdirp(dirname(dest), function (err) {
+					if (err) {
+						reject(err);
+					} else {
+						var readStream = fs.createReadStream(src, readOptions);
+						var writeStream = fs.createWriteStream(dest, writeOptions);
+
+						readStream.on('error', reject);
+						writeStream.on('error', reject);
+
+						writeStream.on('close', fulfil);
+
+						readStream.pipe(writeStream);
+					}
+				});
+			});
+		}
+	};
+}
+
+function copyFileSync$1() {
+	var _resolvePathAndOptions3 = resolvePathAndOptions(arguments);
+
+	var src = _resolvePathAndOptions3.resolvedPath;
+	var readOptions = _resolvePathAndOptions3.options;
+
+	return {
+		to: function () {
+			var _resolvePathAndOptions4 = resolvePathAndOptions(arguments);
+
+			var dest = _resolvePathAndOptions4.resolvedPath;
+			var writeOptions = _resolvePathAndOptions4.options;
+
+			var data = fs.readFileSync(src, readOptions);
+
+			mkdirp.sync(dirname(dest));
+			fs.writeFileSync(dest, data, writeOptions);
+		}
+	};
+}
+
+function walk(dir, callback) {
+	var results = [];
+
+	fs$1.readdir(dir, function (err, files) {
+		if (err) return callback(err);
+
+		var pending = files.length;
+		if (!pending) return callback(null, results);
+
+		files.forEach(function (file) {
+			file = resolve(dir, file);
+
+			fs$1.stat(file, function (err, stats) {
+				if (stats && stats.isDirectory()) {
+					walk(file, function (err, res) {
+						results = results.concat(res);
+						if (! --pending) callback(null, results);
+					});
+				} else {
+					results.push(file);
+					if (! --pending) callback(null, results);
+				}
+			});
+		});
+	});
+};
+
+function lsr$1() {
+	var basedir = resolvePath(arguments);
+
+	return new Promise(function (fulfil, reject) {
+		walk(basedir, function (err, result) {
+			if (err) return reject(err);
+
+			// files should be relative to basedir
+			var index = basedir.length + 1;
+			var i = result.length;
+			while (i--) {
+				result[i] = result[i].substring(index);
+			}
+
+			fulfil(result);
+		});
+	});
+}
+
+function lsrSync$1() {
+	var basedir = resolvePath(arguments);
+
+	var result = [];
+
+	function processdir(dir) {
+		fs$1.readdirSync(dir).forEach(function (file) {
+			var filepath = dir + sep + file;
+
+			if (fs$1.statSync(filepath).isDirectory()) {
+				processdir(filepath);
+			} else {
+				result.push(filepath.replace(basedir + sep, ''));
+			}
+		});
+	}
+
+	processdir(basedir);
+	return result;
+}
+
+function rimraf$1() {
+	var target = resolvePath(arguments);
+
+	return new Promise(function (fulfil, reject) {
+		_rimraf(target, function (err) {
+			if (err) {
+				reject(err);
+			} else {
+				fulfil();
+			}
+		});
+	});
+}
+
+function rimrafSync$1() {
+	_rimraf.sync(resolvePath(arguments));
+}
+
+var isWindows = process.platform === 'win32';
+
+function symlinkOrCopy$1() {
+	var _arguments = arguments;
+
+	if (isWindows) {
+		var _ret = (function () {
+			var _resolvePathAndOptions = resolvePathAndOptions(_arguments);
+
+			var src = _resolvePathAndOptions.resolvedPath;
+			var readOptions = _resolvePathAndOptions.options;
+
+			var copyDirOrFileTo = stat(src).then(function (stats) {
+				return (stats.isDirectory() ? copydir$1 : copyFile$1).apply(null, _arguments).to;
+			});
+
+			return {
+				v: {
+					to: function () {
+						var _arguments2 = arguments;
+
+						return copyDirOrFileTo.then(function (fn) {
+							return fn.apply(null, _arguments2);
+						});
+					}
+				}
+			};
+		})();
+
+		if (typeof _ret === 'object') return _ret.v;
+	}
+
+	return symlink$1.apply(null, arguments);
+}
+
+function symlinkOrCopySync$1() {
+	if (isWindows) {
+		var _resolvePathAndOptions2 = resolvePathAndOptions(arguments);
+
+		var src = _resolvePathAndOptions2.resolvedPath;
+		var readOptions = _resolvePathAndOptions2.options;
+
+		return (statSync(src).isDirectory() ? copydirSync$1 : copyFileSync$1).apply(null, arguments);
+	}
+
+	return symlinkSync$1.apply(null, arguments);
+}
+
+// standard async methods
+var chmod = asyncMethod('chmod');
+var chown = asyncMethod('chown');
+var createReadStream = asyncMethod('createReadStream');
+var createWriteStream = asyncMethod('createWriteStream');
+var lchmod = asyncMethod('lchmod');
+var lchown = asyncMethod('lchown');
+var lstat = asyncMethod('lstat');
+var readdir = asyncMethod('readdir');
+var readFile = asyncMethod('readFile');
+var readlink = asyncMethod('readlink');
+var realpath = asyncMethod('realpath');
+var rmdir = asyncMethod('rmdir');
+var stat = asyncMethod('stat');
+var truncate = asyncMethod('truncate');
+var unlink = asyncMethod('unlink');
+var utimes = asyncMethod('utimes');
+var unwatchFile = asyncMethod('unwatchFile');
+var watch = asyncMethod('watch');
+var watchFile = asyncMethod('watchFile');
+
+// standard sync methods
+var chmodSync = syncMethod('chmodSync');
+var chownSync = syncMethod('chownSync');
+var lchmodSync = syncMethod('lchmodSync');
+var lchownSync = syncMethod('lchownSync');
+var lstatSync = syncMethod('lstatSync');
+var readdirSync = syncMethod('readdirSync');
+var readFileSync = syncMethod('readFileSync');
+var readlinkSync = syncMethod('readlinkSync');
+var realpathSync = syncMethod('realpathSync');
+var rmdirSync = syncMethod('rmdirSync');
+var statSync = syncMethod('statSync');
+var truncateSync = syncMethod('truncateSync');
+var unlinkSync = syncMethod('unlinkSync');
+var utimesSync = syncMethod('utimesSync');
+
+// file descriptor async methods
+var close = asyncFileDescriptorMethod('close');
+var fchmod = asyncFileDescriptorMethod('fchmod');
+var fchown = asyncFileDescriptorMethod('fchown');
+var fstat = asyncFileDescriptorMethod('fstat');
+var fsync = asyncFileDescriptorMethod('fsync');
+var ftruncate = asyncFileDescriptorMethod('ftruncate');
+var futimes = asyncFileDescriptorMethod('futimes');
+var read = asyncFileDescriptorMethod('read');
+
+// file descriptor sync methods
+var closeSync = fs.closeSync;
+var fchmodSync = fs.fchmodSync;
+var fchownSync = fs.fchownSync;
+var fstatSync = fs.fstatSync;
+var fsyncSync = fs.fsyncSync;
+var ftruncateSync = fs.ftruncateSync;
+var futimesSync = fs.futimesSync;
+var readSync = fs.readSync;
+
+// expose Promise for convenience
+// https://github.com/esperantojs/esperanto/issues/161
+var Promise$1 = es6Promise.Promise;
+
+export { chmod, chown, createReadStream$1 as createReadStream, createWriteStream$1 as createWriteStream, lchmod, lchown, lstat, readdir, readFile, readlink, realpath, rmdir, stat, truncate, unlink, utimes, unwatchFile, watch, watchFile, chmodSync, chownSync, lchmodSync, lchownSync, lstatSync, readdirSync, readFileSync, readlinkSync, realpathSync, rmdirSync, statSync, truncateSync, unlinkSync, utimesSync, close, fchmod, fchown, fstat, fsync, ftruncate, futimes, read, closeSync, fchmodSync, fchownSync, fstatSync, fsyncSync, ftruncateSync, futimesSync, readSync, Promise$1 as Promise, exists$1 as exists, existsSync$1 as existsSync, link$1 as link, linkSync$1 as linkSync, rename$1 as rename, renameSync$1 as renameSync, mkdir$1 as mkdir, mkdirSync$1 as mkdirSync, open$1 as open, openSync$1 as openSync, symlink$1 as symlink, symlinkSync$1 as symlinkSync, writeFile$1 as writeFile, writeFileSync$1 as writeFileSync, appendFile$1 as appendFile, appendFileSync$1 as appendFileSync, copydir$1 as copydir, copydirSync$1 as copydirSync, copyFile$1 as copyFile, copyFileSync$1 as copyFileSync, lsr$1 as lsr, lsrSync$1 as lsrSync, rimraf$1 as rimraf, rimrafSync$1 as rimrafSync, symlinkOrCopy$1 as symlinkOrCopy, symlinkOrCopySync$1 as symlinkOrCopySync };
+//# sourceMappingURL=sander.es6.js.map

node_modules/sander/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "sander",
+  "description": "Promise-based power tool for common filesystem tasks",
+  "author": "Rich Harris",
+  "version": "0.5.1",
+  "license": "MIT",
+  "repository": "https://github.com/rich-harris/sander",
+  "dependencies": {
+    "es6-promise": "^3.1.2",
+    "mkdirp": "^0.5.1",
+    "rimraf": "^2.5.2",
+    "graceful-fs": "^4.1.3"
+  },
+  "main": "dist/sander.cjs.js",
+  "jsnext:main": "dist/sander.es.js",
+  "devDependencies": {
+    "buffer-crc32": "^0.2.5",
+    "mocha": "^2.4.5",
+    "rollup": "^0.26.2",
+    "rollup-plugin-buble": "^0.7.0"
+  },
+  "scripts": {
+    "test": "mocha",
+    "pretest": "npm run build:cjs",
+    "build": "npm run build:cjs && npm run build:es",
+    "build:cjs": "rollup -c -f cjs -o dist/sander.cjs.js",
+    "build:es": "rollup -c -f es6 -o dist/sander.es.js",
+    "prepublish": "npm test && npm run build:es"
+  },
+  "files": [
+    "src",
+    "dist",
+    "README.md"
+  ]
+}

node_modules/sander/src/extraMethods/copyFile.js

@@ -0,0 +1,47 @@
+import * as fs from 'graceful-fs';
+import { dirname } from 'path';
+import mkdirp from 'mkdirp';
+import resolvePathAndOptions from '../utils/resolvePathAndOptions';
+
+export function copyFile () {
+	const { resolvedPath: src, options: readOptions } = resolvePathAndOptions( arguments );
+
+	return {
+		to () {
+			const { resolvedPath: dest, options: writeOptions } = resolvePathAndOptions( arguments );
+
+			return new Promise( ( fulfil, reject ) => {
+				mkdirp( dirname( dest ), err => {
+					if ( err ) {
+						reject( err );
+					} else {
+						const readStream = fs.createReadStream( src, readOptions );
+						const writeStream = fs.createWriteStream( dest, writeOptions );
+
+						readStream.on( 'error', reject );
+						writeStream.on( 'error', reject );
+
+						writeStream.on( 'close', fulfil );
+
+						readStream.pipe( writeStream );
+					}
+				});
+			});
+		}
+	};
+}
+
+export function copyFileSync () {
+	const { resolvedPath: src, options: readOptions } = resolvePathAndOptions( arguments );
+
+	return {
+		to () {
+			const { resolvedPath: dest, options: writeOptions } = resolvePathAndOptions( arguments );
+
+			const data = fs.readFileSync( src, readOptions );
+
+			mkdirp.sync( dirname( dest ) );
+			fs.writeFileSync( dest, data, writeOptions );
+		}
+	};
+}

node_modules/sander/src/extraMethods/copydir.js

@@ -0,0 +1,99 @@
+import { sep } from 'path';
+import * as fs from 'graceful-fs';
+import mkdirp from 'mkdirp';
+import resolvePathAndOptions from '../utils/resolvePathAndOptions';
+
+export function copydir () {
+	const { resolvedPath: src, options: readOptions } = resolvePathAndOptions( arguments );
+
+	return {
+		to () {
+			const { resolvedPath: dest, options: writeOptions } = resolvePathAndOptions( arguments );
+
+			function copydir ( src, dest, cb ) {
+				mkdirp( dest, err => {
+					if ( err ) return cb( err );
+
+					fs.readdir( src, ( err, files ) => {
+						if ( err ) return cb( err );
+
+						let remaining = files.length;
+
+						if ( !remaining ) return cb();
+
+						function check ( err ) {
+							if ( err ) {
+								return cb( err );
+							}
+
+							if ( !--remaining ) {
+								cb();
+							}
+						}
+
+						files.forEach( function ( filename ) {
+							const srcpath = src + sep + filename;
+							const destpath = dest + sep + filename;
+
+							fs.stat( srcpath, ( err, stats ) => {
+								var readStream, writeStream;
+
+								if ( stats.isDirectory() ) {
+									return copydir( srcpath, destpath, check );
+								}
+
+								readStream = fs.createReadStream( srcpath, readOptions );
+								writeStream = fs.createWriteStream( destpath, writeOptions );
+
+								readStream.on( 'error', cb );
+								writeStream.on( 'error', cb );
+
+								writeStream.on( 'close', check );
+
+								readStream.pipe( writeStream );
+							});
+						});
+					});
+				});
+			}
+
+			return new Promise( ( fulfil, reject ) => {
+				copydir( src, dest, err => {
+					if ( err ) {
+						reject( err );
+					} else {
+						fulfil();
+					}
+				});
+			});
+		}
+	};
+}
+
+export function copydirSync () {
+	const { resolvedPath: src, options: readOptions } = resolvePathAndOptions( arguments );
+
+	return {
+		to () {
+			const { resolvedPath: dest, options: writeOptions } = resolvePathAndOptions( arguments );
+
+			function copydir ( src, dest ) {
+				mkdirp.sync( dest );
+
+				fs.readdirSync( src ).forEach( filename => {
+					const srcpath = src + sep + filename;
+					const destpath = dest + sep + filename;
+
+					if ( fs.statSync( srcpath ).isDirectory() ) {
+						return copydir( srcpath, destpath );
+					}
+
+					const data = fs.readFileSync( srcpath, readOptions );
+					fs.writeFileSync( destpath, data, writeOptions );
+				});
+			}
+
+			copydir( src, dest );
+		}
+	};
+}

node_modules/sander/src/extraMethods/lsr.js

@@ -0,0 +1,70 @@
+import * as fs from 'fs';
+import { resolve, sep } from 'path';
+import resolvePath from '../utils/resolvePath';
+
+function walk ( dir, callback ) {
+	let results = [];
+
+	fs.readdir( dir, ( err, files ) => {
+		if ( err ) return callback( err );
+
+		let pending = files.length;
+		if ( !pending ) return callback( null, results );
+
+		files.forEach( file => {
+			file = resolve( dir, file );
+
+			fs.stat( file, ( err, stats ) => {
+				if ( stats && stats.isDirectory() ) {
+					walk( file, ( err, res ) => {
+						results = results.concat( res );
+						if ( !--pending ) callback( null, results );
+					});
+				} else {
+					results.push( file );
+					if ( !--pending ) callback( null, results );
+				}
+			});
+		});
+	});
+};
+
+export function lsr () {
+	const basedir = resolvePath( arguments );
+
+	return new Promise( ( fulfil, reject ) => {
+		walk( basedir, function ( err, result ) {
+			if ( err ) return reject( err );
+
+			// files should be relative to basedir
+			const index = basedir.length + 1;
+			let i = result.length;
+			while ( i-- ) {
+				result[i] = result[i].substring( index );
+			}
+
+			fulfil( result );
+		});
+	});
+}
+
+export function lsrSync () {
+	const basedir = resolvePath( arguments );
+
+	let result = [];
+
+	function processdir ( dir ) {
+		fs.readdirSync( dir ).forEach( file => {
+			const filepath = dir + sep + file;
+
+			if ( fs.statSync( filepath ).isDirectory() ) {
+				processdir( filepath );
+			} else {
+				result.push( filepath.replace( basedir + sep, '' ) );
+			}
+		});
+	}
+
+	processdir( basedir );
+	return result;
+}

node_modules/sander/src/extraMethods/rimraf.js

@@ -0,0 +1,20 @@
+import _rimraf from 'rimraf';
+import resolvePath from '../utils/resolvePath';
+
+export function rimraf () {
+	const target = resolvePath( arguments );
+
+	return new Promise( ( fulfil, reject ) => {
+		_rimraf( target, err => {
+			if ( err ) {
+				reject( err );
+			} else {
+				fulfil();
+			}
+		});
+	});
+}
+
+export function rimrafSync () {
+	_rimraf.sync( resolvePath( arguments ) );
+}

node_modules/sander/src/extraMethods/symlinkOrCopy.js

@@ -0,0 +1,40 @@
+import { stat, statSync } from '../sander';
+import { copydir, copydirSync } from './copydir';
+import { copyFile, copyFileSync } from './copyFile';
+import { symlink, symlinkSync } from '../specialMethods/symlink';
+import resolvePathAndOptions from '../utils/resolvePathAndOptions';
+
+const isWindows = process.platform === 'win32';
+
+export function symlinkOrCopy () {
+	if ( isWindows ) {
+		const { resolvedPath: src, options: readOptions } = resolvePathAndOptions( arguments );
+
+		let copyDirOrFileTo = stat( src )
+			.then( stats => {
+				return ( stats.isDirectory() ? copydir : copyFile )
+					.apply( null, arguments )
+					.to;
+			});
+
+		return {
+			to () {
+				return copyDirOrFileTo
+					.then(fn => {
+						return fn.apply(null, arguments);
+					});
+			}
+		};
+	}
+
+	return symlink.apply( null, arguments );
+}
+
+export function symlinkOrCopySync () {
+	if ( isWindows ) {
+		const { resolvedPath: src, options: readOptions } = resolvePathAndOptions( arguments );
+		return ( statSync( src ).isDirectory() ? copydirSync : copyFileSync ).apply( null, arguments );
+	}
+
+	return symlinkSync.apply( null, arguments );
+}

node_modules/sander/src/methodMakers/fileDescriptorMethod.js

@@ -0,0 +1,24 @@
+import * as fs from 'graceful-fs';
+
+export function asyncFileDescriptorMethod ( methodName ) {
+	return function () {
+		let args = [];
+		let i = arguments.length;
+
+		while ( i-- ) {
+			args[i] = arguments[i];
+		}
+
+		return new Promise( ( fulfil, reject ) => {
+			args.push( ( err, result ) => {
+				if ( err ) {
+					reject( err );
+				} else {
+					fulfil( result );
+				}
+			});
+
+			fs[ methodName ].apply( fs, args );
+		});
+	};
+}

node_modules/sander/src/methodMakers/standardMethod.js

@@ -0,0 +1,49 @@
+import * as fs from 'graceful-fs';
+import resolvePath from '../utils/resolvePath';
+
+function normaliseArguments ( args ) {
+	const len = args.length;
+
+	let buildingPath = true;
+	let pathargs = [];
+	let normalised = [ null ]; // null is a placeholder for the resolved path
+	let i;
+
+	for ( i = 0; i < len; i += 1 ) {
+		if ( buildingPath && typeof args[i] === 'string' ) {
+			pathargs[i] = args[i];
+		} else {
+			buildingPath = false;
+			normalised.push( args[i] );
+		}
+	}
+
+	normalised[0] = resolvePath( pathargs );
+
+	return normalised;
+}
+
+export function asyncMethod ( methodName ) {
+	return function () {
+		const args = normaliseArguments( arguments );
+
+		return new Promise( ( fulfil, reject ) => {
+			args.push( ( err, result ) => {
+				if ( err ) {
+					reject( err );
+				} else {
+					fulfil( result );
+				}
+			});
+
+			fs[ methodName ].apply( fs, args );
+		});
+	};
+}
+
+export function syncMethod ( methodName ) {
+	return function () {
+		const args = normaliseArguments( arguments );
+		return fs[ methodName ].apply( fs, args );
+	};
+}

node_modules/sander/src/sander.js

@@ -0,0 +1,81 @@
+import * as fs from 'graceful-fs';
+import * as es6Promise from 'es6-promise';
+import { syncMethod, asyncMethod } from './methodMakers/standardMethod';
+import { asyncFileDescriptorMethod } from './methodMakers/fileDescriptorMethod';
+
+// standard async methods
+export const chmod = asyncMethod( 'chmod' );
+export const chown = asyncMethod( 'chown' );
+export const createReadStream = asyncMethod( 'createReadStream' );
+export const createWriteStream = asyncMethod( 'createWriteStream' );
+export const lchmod = asyncMethod( 'lchmod' );
+export const lchown = asyncMethod( 'lchown' );
+export const lstat = asyncMethod( 'lstat' );
+export const readdir = asyncMethod( 'readdir' );
+export const readFile = asyncMethod( 'readFile' );
+export const readlink = asyncMethod( 'readlink' );
+export const realpath = asyncMethod( 'realpath' );
+export const rmdir = asyncMethod( 'rmdir' );
+export const stat = asyncMethod( 'stat' );
+export const truncate = asyncMethod( 'truncate' );
+export const unlink = asyncMethod( 'unlink' );
+export const utimes = asyncMethod( 'utimes' );
+export const unwatchFile = asyncMethod( 'unwatchFile' );
+export const watch = asyncMethod( 'watch' );
+export const watchFile = asyncMethod( 'watchFile' );
+
+// standard sync methods
+export const chmodSync = syncMethod( 'chmodSync' );
+export const chownSync = syncMethod( 'chownSync' );
+export const lchmodSync = syncMethod( 'lchmodSync' );
+export const lchownSync = syncMethod( 'lchownSync' );
+export const lstatSync = syncMethod( 'lstatSync' );
+export const readdirSync = syncMethod( 'readdirSync' );
+export const readFileSync = syncMethod( 'readFileSync' );
+export const readlinkSync = syncMethod( 'readlinkSync' );
+export const realpathSync = syncMethod( 'realpathSync' );
+export const rmdirSync = syncMethod( 'rmdirSync' );
+export const statSync = syncMethod( 'statSync' );
+export const truncateSync = syncMethod( 'truncateSync' );
+export const unlinkSync = syncMethod( 'unlinkSync' );
+export const utimesSync = syncMethod( 'utimesSync' );
+
+// file descriptor async methods
+export const close = asyncFileDescriptorMethod( 'close' );
+export const fchmod = asyncFileDescriptorMethod( 'fchmod' );
+export const fchown = asyncFileDescriptorMethod( 'fchown' );
+export const fstat = asyncFileDescriptorMethod( 'fstat' );
+export const fsync = asyncFileDescriptorMethod( 'fsync' );
+export const ftruncate = asyncFileDescriptorMethod( 'ftruncate' );
+export const futimes = asyncFileDescriptorMethod( 'futimes' );
+export const read = asyncFileDescriptorMethod( 'read' );
+
+// file descriptor sync methods
+export const closeSync = fs.closeSync;
+export const fchmodSync = fs.fchmodSync;
+export const fchownSync = fs.fchownSync;
+export const fstatSync = fs.fstatSync;
+export const fsyncSync = fs.fsyncSync;
+export const ftruncateSync = fs.ftruncateSync;
+export const futimesSync = fs.futimesSync;
+export const readSync = fs.readSync;
+
+// special methods
+export { createReadStream, createWriteStream } from './specialMethods/createReadStream-createWriteStream'; // TODO aren't these covered by the standard methods?
+export { exists, existsSync } from './specialMethods/exists';
+export { link, linkSync, rename, renameSync } from './specialMethods/link-rename';
+export { mkdir, mkdirSync } from './specialMethods/mkdir';
+export { open, openSync } from './specialMethods/open';
+export { symlink, symlinkSync } from './specialMethods/symlink';
+export { writeFile, writeFileSync, appendFile, appendFileSync } from './specialMethods/writeFile-appendFile';
+
+// extra methods
+export { copydir, copydirSync } from './extraMethods/copydir';
+export { copyFile, copyFileSync } from './extraMethods/copyFile';
+export { lsr, lsrSync } from './extraMethods/lsr';
+export { rimraf, rimrafSync } from './extraMethods/rimraf';
+export { symlinkOrCopy, symlinkOrCopySync } from './extraMethods/symlinkOrCopy';
+
+// expose Promise for convenience
+// https://github.com/esperantojs/esperanto/issues/161
+export const Promise = es6Promise.Promise;

node_modules/sander/src/specialMethods/createReadStream-createWriteStream.js

@@ -0,0 +1,16 @@
+import * as fs from 'graceful-fs';
+import { dirname } from 'path';
+import mkdirp from 'mkdirp';
+import resolvePathAndOptions from '../utils/resolvePathAndOptions';
+
+export function createReadStream () {
+	const { resolvedPath, options } = resolvePathAndOptions( arguments );
+	return fs.createReadStream( resolvedPath, options );
+}
+
+export function createWriteStream () {
+	const { resolvedPath, options } = resolvePathAndOptions( arguments );
+
+	mkdirp.sync( dirname( resolvedPath ) );
+	return fs.createWriteStream( resolvedPath, options );
+}

node_modules/sander/src/specialMethods/exists.js

@@ -0,0 +1,14 @@
+import * as fs from 'graceful-fs';
+import resolvePath from '../utils/resolvePath';
+
+export function exists () {
+	const target = resolvePath( arguments );
+
+	return new Promise( fulfil => {
+		fs.exists( target, exists => fulfil( exists ) );
+	});
+}
+
+export function existsSync () {
+	return fs.existsSync( resolvePath( arguments ) );
+}

node_modules/sander/src/specialMethods/link-rename.js

@@ -0,0 +1,53 @@
+import * as fs from 'graceful-fs';
+import { dirname } from 'path';
+import mkdirp from 'mkdirp';
+import resolvePath from '../utils/resolvePath';
+
+export const rename = asyncMethod( 'rename' );
+export const link = asyncMethod( 'link' );
+
+export const renameSync = syncMethod( 'renameSync' );
+export const linkSync = syncMethod( 'linkSync' );
+
+function asyncMethod ( methodName ) {
+	return function () {
+		const src = resolvePath( arguments );
+
+		return {
+			to () {
+				const dest = resolvePath( arguments );
+
+				return new Promise( ( fulfil, reject ) => {
+					mkdirp( dirname( dest ), err => {
+						if ( err ) {
+							reject( err );
+						} else {
+							fs[ methodName ]( src, dest, err => {
+								if ( err ) {
+									reject( err );
+								} else {
+									fulfil();
+								}
+							});
+						}
+					});
+				});
+			}
+		};
+	};
+}
+
+function syncMethod ( methodName ) {
+	return function () {
+		const src = resolvePath( arguments );
+
+		return {
+			to () {
+				const dest = resolvePath( arguments );
+
+				mkdirp.sync( dirname( dest ) );
+				return fs[ methodName ]( src, dest );
+			}
+		};
+	};
+}

node_modules/sander/src/specialMethods/mkdir.js

@@ -0,0 +1,21 @@
+import mkdirp from 'mkdirp';
+import resolvePath from '../utils/resolvePath';
+
+export function mkdir () {
+	const dir = resolvePath( arguments );
+
+	return new Promise( ( fulfil, reject ) => {
+		mkdirp( dir, err => {
+			if ( err ) {
+				reject( err );
+			} else {
+				fulfil();
+			}
+		});
+	});
+}
+
+export function mkdirSync () {
+	const dir = resolvePath( arguments );
+	mkdirp.sync( dir );
+}

node_modules/sander/src/specialMethods/open.js

@@ -0,0 +1,97 @@
+import { dirname } from 'path';
+import * as fs from 'graceful-fs';
+import mkdirp from 'mkdirp';
+import resolvePath from '../utils/resolvePath';
+
+function normaliseArguments ( args ) {
+	let options;
+	let flags;
+	let i;
+
+	if ( typeof args[ args.length - 1 ] === 'object' ) {
+		options = args[ args.length - 1 ];
+		flags = args[ args.length - 2 ];
+		i = args.length - 2;
+	} else {
+		options = {};
+		flags = args[ args.length - 1 ];
+		i = args.length - 1;
+	}
+
+	let pathargs = new Array( i );
+	while ( i-- ) {
+		pathargs[i] = args[i];
+	}
+
+	const resolvedPath = resolvePath( pathargs );
+
+	return { resolvedPath, options, flags };
+}
+
+function bailIfExists ( src, flags, mode ) {
+	let alreadyExists;
+
+	try {
+		fs.statSync( src );
+		alreadyExists = true;
+	} catch ( err ) {
+		if ( err.code !== 'ENOENT' ) {
+			throw err;
+		}
+	}
+
+	if ( alreadyExists ) {
+		// attempt the operation = that way, we get the intended error message
+		// TODO can't we just do this in the first place?
+		fs.openSync( src, flags, mode );
+	}
+}
+
+export function open () {
+	const { resolvedPath: src, options, flags } = normaliseArguments( arguments );
+
+	if ( /^.x/.test( flags ) ) {
+		bailIfExists( src, flags, options.mode );
+	}
+
+	return new Promise( ( fulfil, reject ) => {
+		function open () {
+			fs.open( src, flags, options.mode, ( err, fd ) => {
+				if ( err ) {
+					reject( err );
+				} else {
+					fulfil( fd );
+				}
+			});
+		}
+
+		// create dirs if necessary
+		if ( /^[wa]/.test( flags ) ) {
+			mkdirp( dirname( src ), err => {
+				if ( err ) {
+					reject( err );
+				} else {
+					open();
+				}
+			});
+		} else {
+			open();
+		}
+	});
+}
+
+
+export function openSync () {
+	const { resolvedPath: src, options, flags } = normaliseArguments( arguments );
+
+	if ( /^.x/.test( flags ) ) {
+		bailIfExists( src, flags, options.mode );
+	}
+
+	// create dirs if necessary
+	if ( /^[wa]/.test( flags ) ) {
+		mkdirp.sync( dirname( src ) );
+	}
+
+	return fs.openSync( src, flags, options.mode );
+}

node_modules/sander/src/specialMethods/symlink.js

@@ -0,0 +1,43 @@
+import { dirname } from 'path';
+import * as fs from 'graceful-fs';
+import mkdirp from 'mkdirp';
+import resolvePath from '../utils/resolvePath';
+import resolvePathAndOptions from '../utils/resolvePathAndOptions';
+
+export function symlink () {
+	const src = resolvePath( arguments );
+
+	return {
+		to () {
+			const { options, resolvedPath: dest } = resolvePathAndOptions( arguments );
+
+			return new Promise( ( fulfil, reject ) => {
+				mkdirp( dirname( dest ), err => {
+					if ( err ) {
+						reject( err );
+					} else {
+						fs.symlink( src, dest, options.type, err => {
+							if ( err ) {
+								reject( err );
+							} else {
+								fulfil();
+							}
+						});
+					}
+				});
+			});
+		}
+	};
+}
+
+export function symlinkSync () {
+	const src = resolvePath( arguments );
+
+	return {
+		to () {
+			const { options, resolvedPath: dest } = resolvePathAndOptions( arguments );
+			mkdirp.sync( dirname( dest ) );
+			return fs.symlinkSync( src, dest, options.type );
+		}
+	};
+}

node_modules/sander/src/specialMethods/writeFile-appendFile.js

@@ -0,0 +1,52 @@
+import * as fs from 'graceful-fs';
+import { dirname } from 'path';
+import mkdirp from 'mkdirp';
+import resolvePath from '../utils/resolvePath';
+
+export const writeFile = asyncMethod( 'writeFile' );
+export const appendFile = asyncMethod( 'appendFile' );
+
+export const writeFileSync = syncMethod( 'writeFileSync' );
+export const appendFileSync = syncMethod( 'appendFileSync' );
+
+function normaliseArguments ( args ) {
+	args = Array.prototype.slice.call( args, 0 );
+	let opts = {};
+
+	if ( typeof args[ args.length - 1 ] === 'object' && !( args[ args.length - 1 ] instanceof Buffer ) ) {
+		opts = args.pop();
+	}
+
+	return { opts, data: args.pop(), dest: resolvePath( args ) };
+}
+
+function asyncMethod ( methodName ) {
+	return function () {
+		const { dest, data, opts } = normaliseArguments( arguments );
+
+		return new Promise( ( fulfil, reject ) => {
+			mkdirp( dirname( dest ), err => {
+				if ( err ) {
+					reject( err );
+				} else {
+					fs[ methodName ]( dest, data, opts, err => {
+						if ( err ) {
+							reject( err );
+						} else {
+							fulfil( data );
+						}
+					});
+				}
+			});
+		});
+	};
+}
+
+function syncMethod ( methodName ) {
+	return function () {
+		const { dest, data } = normaliseArguments( arguments );
+
+		mkdirp.sync( dirname( dest ) );
+		return fs[ methodName ]( dest, data );
+	};
+}

node_modules/sander/src/utils/resolvePath.js

@@ -0,0 +1,5 @@
+import { resolve } from 'path';
+
+export default function resolvePath ( args ) {
+	return resolve.apply( null, args );
+}

node_modules/sander/src/utils/resolvePathAndOptions.js

@@ -0,0 +1,24 @@
+import { resolve } from 'path';
+
+export default function resolvePathAndOptions ( args ) {
+	let options;
+	let pathargs;
+
+	if ( typeof args[ args.length - 1 ] === 'object' ) {
+		options = args[ args.length - 1 ];
+
+		let i = args.length - 1;
+		pathargs = new Array( i );
+
+		while ( i-- ) {
+			pathargs[i] = args[i];
+		}
+	} else {
+		options = {};
+		pathargs = args;
+	}
+
+	const resolvedPath = resolve.apply( null, pathargs );
+
+	return { options, resolvedPath };
+}