feat: docker compose maybe

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/node_modules/.bin/rimraf

@@ -0,0 +1 @@
+../rimraf/bin.js

node_modules/sander/node_modules/rimraf/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

node_modules/sander/node_modules/rimraf/README.md

@@ -0,0 +1,101 @@
+[![Build Status](https://travis-ci.org/isaacs/rimraf.svg?branch=master)](https://travis-ci.org/isaacs/rimraf) [![Dependency Status](https://david-dm.org/isaacs/rimraf.svg)](https://david-dm.org/isaacs/rimraf) [![devDependency Status](https://david-dm.org/isaacs/rimraf/dev-status.svg)](https://david-dm.org/isaacs/rimraf#info=devDependencies)
+
+The [UNIX command](http://en.wikipedia.org/wiki/Rm_(Unix)) `rm -rf` for node.
+
+Install with `npm install rimraf`, or just drop rimraf.js somewhere.
+
+## API
+
+`rimraf(f, [opts], callback)`
+
+The first parameter will be interpreted as a globbing pattern for files. If you
+want to disable globbing you can do so with `opts.disableGlob` (defaults to
+`false`). This might be handy, for instance, if you have filenames that contain
+globbing wildcard characters.
+
+The callback will be called with an error if there is one.  Certain
+errors are handled for you:
+
+* Windows: `EBUSY` and `ENOTEMPTY` - rimraf will back off a maximum of
+  `opts.maxBusyTries` times before giving up, adding 100ms of wait
+  between each attempt.  The default `maxBusyTries` is 3.
+* `ENOENT` - If the file doesn't exist, rimraf will return
+  successfully, since your desired outcome is already the case.
+* `EMFILE` - Since `readdir` requires opening a file descriptor, it's
+  possible to hit `EMFILE` if too many file descriptors are in use.
+  In the sync case, there's nothing to be done for this.  But in the
+  async case, rimraf will gradually back off with timeouts up to
+  `opts.emfileWait` ms, which defaults to 1000.
+
+## options
+
+* unlink, chmod, stat, lstat, rmdir, readdir,
+  unlinkSync, chmodSync, statSync, lstatSync, rmdirSync, readdirSync
+
+    In order to use a custom file system library, you can override
+    specific fs functions on the options object.
+
+    If any of these functions are present on the options object, then
+    the supplied function will be used instead of the default fs
+    method.
+
+    Sync methods are only relevant for `rimraf.sync()`, of course.
+
+    For example:
+
+    ```javascript
+    var myCustomFS = require('some-custom-fs')
+
+    rimraf('some-thing', myCustomFS, callback)
+    ```
+
+* maxBusyTries
+
+    If an `EBUSY`, `ENOTEMPTY`, or `EPERM` error code is encountered
+    on Windows systems, then rimraf will retry with a linear backoff
+    wait of 100ms longer on each try.  The default maxBusyTries is 3.
+
+    Only relevant for async usage.
+
+* emfileWait
+
+    If an `EMFILE` error is encountered, then rimraf will retry
+    repeatedly with a linear backoff of 1ms longer on each try, until
+    the timeout counter hits this max.  The default limit is 1000.
+
+    If you repeatedly encounter `EMFILE` errors, then consider using
+    [graceful-fs](http://npm.im/graceful-fs) in your program.
+
+    Only relevant for async usage.
+
+* glob
+
+    Set to `false` to disable [glob](http://npm.im/glob) pattern
+    matching.
+
+    Set to an object to pass options to the glob module.  The default
+    glob options are `{ nosort: true, silent: true }`.
+
+    Glob version 6 is used in this module.
+
+    Relevant for both sync and async usage.
+
+* disableGlob
+
+    Set to any non-falsey value to disable globbing entirely.
+    (Equivalent to setting `glob: false`.)
+
+## rimraf.sync
+
+It can remove stuff synchronously, too.  But that's not so good.  Use
+the async API.  It's better.
+
+## CLI
+
+If installed with `npm install rimraf -g` it can be used as a global
+command `rimraf <path> [<path> ...]` which is useful for cross platform support.
+
+## mkdirp
+
+If you need to create a directory recursively, check out
+[mkdirp](https://github.com/substack/node-mkdirp).

node_modules/sander/node_modules/rimraf/bin.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+var rimraf = require('./')
+
+var help = false
+var dashdash = false
+var noglob = false
+var args = process.argv.slice(2).filter(function(arg) {
+  if (dashdash)
+    return !!arg
+  else if (arg === '--')
+    dashdash = true
+  else if (arg === '--no-glob' || arg === '-G')
+    noglob = true
+  else if (arg === '--glob' || arg === '-g')
+    noglob = false
+  else if (arg.match(/^(-+|\/)(h(elp)?|\?)$/))
+    help = true
+  else
+    return !!arg
+})
+
+if (help || args.length === 0) {
+  // If they didn't ask for help, then this is not a "success"
+  var log = help ? console.log : console.error
+  log('Usage: rimraf <path> [<path> ...]')
+  log('')
+  log('  Deletes all files and folders at "path" recursively.')
+  log('')
+  log('Options:')
+  log('')
+  log('  -h, --help     Display this usage info')
+  log('  -G, --no-glob  Do not expand glob patterns in arguments')
+  log('  -g, --glob     Expand glob patterns in arguments (default)')
+  process.exit(help ? 0 : 1)
+} else
+  go(0)
+
+function go (n) {
+  if (n >= args.length)
+    return
+  var options = {}
+  if (noglob)
+    options = { glob: false }
+  rimraf(args[n], options, function (er) {
+    if (er)
+      throw er
+    go(n+1)
+  })
+}

node_modules/sander/node_modules/rimraf/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "rimraf",
+  "version": "2.7.1",
+  "main": "rimraf.js",
+  "description": "A deep deletion module for node (like `rm -rf`)",
+  "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)",
+  "license": "ISC",
+  "repository": "git://github.com/isaacs/rimraf.git",
+  "scripts": {
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "postpublish": "git push origin --all; git push origin --tags",
+    "test": "tap test/*.js"
+  },
+  "bin": "./bin.js",
+  "dependencies": {
+    "glob": "^7.1.3"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "bin.js",
+    "rimraf.js"
+  ],
+  "devDependencies": {
+    "mkdirp": "^0.5.1",
+    "tap": "^12.1.1"
+  }
+}

node_modules/sander/node_modules/rimraf/rimraf.js

@@ -0,0 +1,372 @@
+module.exports = rimraf
+rimraf.sync = rimrafSync
+
+var assert = require("assert")
+var path = require("path")
+var fs = require("fs")
+var glob = undefined
+try {
+  glob = require("glob")
+} catch (_err) {
+  // treat glob as optional.
+}
+var _0666 = parseInt('666', 8)
+
+var defaultGlobOpts = {
+  nosort: true,
+  silent: true
+}
+
+// for EMFILE handling
+var timeout = 0
+
+var isWindows = (process.platform === "win32")
+
+function defaults (options) {
+  var methods = [
+    'unlink',
+    'chmod',
+    'stat',
+    'lstat',
+    'rmdir',
+    'readdir'
+  ]
+  methods.forEach(function(m) {
+    options[m] = options[m] || fs[m]
+    m = m + 'Sync'
+    options[m] = options[m] || fs[m]
+  })
+
+  options.maxBusyTries = options.maxBusyTries || 3
+  options.emfileWait = options.emfileWait || 1000
+  if (options.glob === false) {
+    options.disableGlob = true
+  }
+  if (options.disableGlob !== true && glob === undefined) {
+    throw Error('glob dependency not found, set `options.disableGlob = true` if intentional')
+  }
+  options.disableGlob = options.disableGlob || false
+  options.glob = options.glob || defaultGlobOpts
+}
+
+function rimraf (p, options, cb) {
+  if (typeof options === 'function') {
+    cb = options
+    options = {}
+  }
+
+  assert(p, 'rimraf: missing path')
+  assert.equal(typeof p, 'string', 'rimraf: path should be a string')
+  assert.equal(typeof cb, 'function', 'rimraf: callback function required')
+  assert(options, 'rimraf: invalid options argument provided')
+  assert.equal(typeof options, 'object', 'rimraf: options should be object')
+
+  defaults(options)
+
+  var busyTries = 0
+  var errState = null
+  var n = 0
+
+  if (options.disableGlob || !glob.hasMagic(p))
+    return afterGlob(null, [p])
+
+  options.lstat(p, function (er, stat) {
+    if (!er)
+      return afterGlob(null, [p])
+
+    glob(p, options.glob, afterGlob)
+  })
+
+  function next (er) {
+    errState = errState || er
+    if (--n === 0)
+      cb(errState)
+  }
+
+  function afterGlob (er, results) {
+    if (er)
+      return cb(er)
+
+    n = results.length
+    if (n === 0)
+      return cb()
+
+    results.forEach(function (p) {
+      rimraf_(p, options, function CB (er) {
+        if (er) {
+          if ((er.code === "EBUSY" || er.code === "ENOTEMPTY" || er.code === "EPERM") &&
+              busyTries < options.maxBusyTries) {
+            busyTries ++
+            var time = busyTries * 100
+            // try again, with the same exact callback as this one.
+            return setTimeout(function () {
+              rimraf_(p, options, CB)
+            }, time)
+          }
+
+          // this one won't happen if graceful-fs is used.
+          if (er.code === "EMFILE" && timeout < options.emfileWait) {
+            return setTimeout(function () {
+              rimraf_(p, options, CB)
+            }, timeout ++)
+          }
+
+          // already gone
+          if (er.code === "ENOENT") er = null
+        }
+
+        timeout = 0
+        next(er)
+      })
+    })
+  }
+}
+
+// Two possible strategies.
+// 1. Assume it's a file.  unlink it, then do the dir stuff on EPERM or EISDIR
+// 2. Assume it's a directory.  readdir, then do the file stuff on ENOTDIR
+//
+// Both result in an extra syscall when you guess wrong.  However, there
+// are likely far more normal files in the world than directories.  This
+// is based on the assumption that a the average number of files per
+// directory is >= 1.
+//
+// If anyone ever complains about this, then I guess the strategy could
+// be made configurable somehow.  But until then, YAGNI.
+function rimraf_ (p, options, cb) {
+  assert(p)
+  assert(options)
+  assert(typeof cb === 'function')
+
+  // sunos lets the root user unlink directories, which is... weird.
+  // so we have to lstat here and make sure it's not a dir.
+  options.lstat(p, function (er, st) {
+    if (er && er.code === "ENOENT")
+      return cb(null)
+
+    // Windows can EPERM on stat.  Life is suffering.
+    if (er && er.code === "EPERM" && isWindows)
+      fixWinEPERM(p, options, er, cb)
+
+    if (st && st.isDirectory())
+      return rmdir(p, options, er, cb)
+
+    options.unlink(p, function (er) {
+      if (er) {
+        if (er.code === "ENOENT")
+          return cb(null)
+        if (er.code === "EPERM")
+          return (isWindows)
+            ? fixWinEPERM(p, options, er, cb)
+            : rmdir(p, options, er, cb)
+        if (er.code === "EISDIR")
+          return rmdir(p, options, er, cb)
+      }
+      return cb(er)
+    })
+  })
+}
+
+function fixWinEPERM (p, options, er, cb) {
+  assert(p)
+  assert(options)
+  assert(typeof cb === 'function')
+  if (er)
+    assert(er instanceof Error)
+
+  options.chmod(p, _0666, function (er2) {
+    if (er2)
+      cb(er2.code === "ENOENT" ? null : er)
+    else
+      options.stat(p, function(er3, stats) {
+        if (er3)
+          cb(er3.code === "ENOENT" ? null : er)
+        else if (stats.isDirectory())
+          rmdir(p, options, er, cb)
+        else
+          options.unlink(p, cb)
+      })
+  })
+}
+
+function fixWinEPERMSync (p, options, er) {
+  assert(p)
+  assert(options)
+  if (er)
+    assert(er instanceof Error)
+
+  try {
+    options.chmodSync(p, _0666)
+  } catch (er2) {
+    if (er2.code === "ENOENT")
+      return
+    else
+      throw er
+  }
+
+  try {
+    var stats = options.statSync(p)
+  } catch (er3) {
+    if (er3.code === "ENOENT")
+      return
+    else
+      throw er
+  }
+
+  if (stats.isDirectory())
+    rmdirSync(p, options, er)
+  else
+    options.unlinkSync(p)
+}
+
+function rmdir (p, options, originalEr, cb) {
+  assert(p)
+  assert(options)
+  if (originalEr)
+    assert(originalEr instanceof Error)
+  assert(typeof cb === 'function')
+
+  // try to rmdir first, and only readdir on ENOTEMPTY or EEXIST (SunOS)
+  // if we guessed wrong, and it's not a directory, then
+  // raise the original error.
+  options.rmdir(p, function (er) {
+    if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM"))
+      rmkids(p, options, cb)
+    else if (er && er.code === "ENOTDIR")
+      cb(originalEr)
+    else
+      cb(er)
+  })
+}
+
+function rmkids(p, options, cb) {
+  assert(p)
+  assert(options)
+  assert(typeof cb === 'function')
+
+  options.readdir(p, function (er, files) {
+    if (er)
+      return cb(er)
+    var n = files.length
+    if (n === 0)
+      return options.rmdir(p, cb)
+    var errState
+    files.forEach(function (f) {
+      rimraf(path.join(p, f), options, function (er) {
+        if (errState)
+          return
+        if (er)
+          return cb(errState = er)
+        if (--n === 0)
+          options.rmdir(p, cb)
+      })
+    })
+  })
+}
+
+// this looks simpler, and is strictly *faster*, but will
+// tie up the JavaScript thread and fail on excessively
+// deep directory trees.
+function rimrafSync (p, options) {
+  options = options || {}
+  defaults(options)
+
+  assert(p, 'rimraf: missing path')
+  assert.equal(typeof p, 'string', 'rimraf: path should be a string')
+  assert(options, 'rimraf: missing options')
+  assert.equal(typeof options, 'object', 'rimraf: options should be object')
+
+  var results
+
+  if (options.disableGlob || !glob.hasMagic(p)) {
+    results = [p]
+  } else {
+    try {
+      options.lstatSync(p)
+      results = [p]
+    } catch (er) {
+      results = glob.sync(p, options.glob)
+    }
+  }
+
+  if (!results.length)
+    return
+
+  for (var i = 0; i < results.length; i++) {
+    var p = results[i]
+
+    try {
+      var st = options.lstatSync(p)
+    } catch (er) {
+      if (er.code === "ENOENT")
+        return
+
+      // Windows can EPERM on stat.  Life is suffering.
+      if (er.code === "EPERM" && isWindows)
+        fixWinEPERMSync(p, options, er)
+    }
+
+    try {
+      // sunos lets the root user unlink directories, which is... weird.
+      if (st && st.isDirectory())
+        rmdirSync(p, options, null)
+      else
+        options.unlinkSync(p)
+    } catch (er) {
+      if (er.code === "ENOENT")
+        return
+      if (er.code === "EPERM")
+        return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er)
+      if (er.code !== "EISDIR")
+        throw er
+
+      rmdirSync(p, options, er)
+    }
+  }
+}
+
+function rmdirSync (p, options, originalEr) {
+  assert(p)
+  assert(options)
+  if (originalEr)
+    assert(originalEr instanceof Error)
+
+  try {
+    options.rmdirSync(p)
+  } catch (er) {
+    if (er.code === "ENOENT")
+      return
+    if (er.code === "ENOTDIR")
+      throw originalEr
+    if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")
+      rmkidsSync(p, options)
+  }
+}
+
+function rmkidsSync (p, options) {
+  assert(p)
+  assert(options)
+  options.readdirSync(p).forEach(function (f) {
+    rimrafSync(path.join(p, f), options)
+  })
+
+  // We only end up here once we got ENOTEMPTY at least once, and
+  // at this point, we are guaranteed to have removed all the kids.
+  // So, we know that it won't be ENOENT or ENOTDIR or anything else.
+  // try really hard to delete stuff on windows, because it has a
+  // PROFOUNDLY annoying habit of not closing handles promptly when
+  // files are deleted, resulting in spurious ENOTEMPTY errors.
+  var retries = isWindows ? 100 : 1
+  var i = 0
+  do {
+    var threw = true
+    try {
+      var ret = options.rmdirSync(p, options)
+      threw = false
+      return ret
+    } finally {
+      if (++i < retries && threw)
+        continue
+    }
+  } while (true)
+}

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 };
+}