text: 'use strict';
  
  var graceful_fs = require('graceful-fs');
  var es6_promise = require('es6-promise');
  var path = require('path');
  var mkdirp = require('mkdirp');
  mkdirp = ('default' in mkdirp ? mkdirp['default'] : mkdirp);
  var _rimraf = require('rimraf');
  _rimraf = ('default' in _rimraf ? _rimraf['default'] : _rimraf);
  
  var utils_resolvePath = resolvePath;
  function resolvePath(args) {
  	return path.resolve.apply(null, args);
  }
  
  function standardMethod__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] = utils_resolvePath(pathargs);
  
  	return normalised;
  }
  
  function standardMethod__asyncMethod(methodName) {
  	return function () {
  		var args = standardMethod__normaliseArguments(arguments);
  
  		return new Promise(function (fulfil, reject) {
  			args.push(function (err, result) {
  				if (err) {
  					reject(err);
  				} else {
  					fulfil(result);
  				}
  			});
  
  			graceful_fs[methodName].apply(graceful_fs, args);
  		});
  	};
  }
  
  function standardMethod__syncMethod(methodName) {
  	return function () {
  		var args = standardMethod__normaliseArguments(arguments);
  		return graceful_fs[methodName].apply(graceful_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);
  				}
  			});
  
  			graceful_fs[methodName].apply(graceful_fs, args);
  		});
  	};
  }
  
  var utils_resolvePathAndOptions = resolvePathAndOptions;
  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 = path.resolve.apply(null, pathargs);
  
  	return { options: options, resolvedPath: resolvedPath };
  }
  
  function createReadStream_createWriteStream__createReadStream() {
  	var _resolvePathAndOptions = utils_resolvePathAndOptions(arguments);
  
  	var resolvedPath = _resolvePathAndOptions.resolvedPath;
  	var options = _resolvePathAndOptions.options;
  
  	return graceful_fs.createReadStream(resolvedPath, options);
  }
  
  function createReadStream_createWriteStream__createWriteStream() {
  	var _resolvePathAndOptions2 = utils_resolvePathAndOptions(arguments);
  
  	var resolvedPath = _resolvePathAndOptions2.resolvedPath;
  	var options = _resolvePathAndOptions2.options;
  
  	mkdirp.sync(path.dirname(resolvedPath));
  	return graceful_fs.createWriteStream(resolvedPath, options);
  }
  
  exports.createReadStream = createReadStream_createWriteStream__createReadStream;
  exports.createWriteStream = createReadStream_createWriteStream__createWriteStream;
  
  function exists() {
  	var target = utils_resolvePath(arguments);
  
  	return new Promise(function (fulfil) {
  		graceful_fs.exists(target, function (exists) {
  			return fulfil(exists);
  		});
  	});
  }
  
  function existsSync() {
  	return graceful_fs.existsSync(utils_resolvePath(arguments));
  }
  
  exports.exists = exists;
  exports.existsSync = existsSync;
  
  var rename = link_rename__asyncMethod('rename');
  var link = link_rename__asyncMethod('link');
  
  var renameSync = link_rename__syncMethod('renameSync');
  var linkSync = link_rename__syncMethod('linkSync');
  
  function link_rename__asyncMethod(methodName) {
  	return function () {
  		var src = utils_resolvePath(arguments);
  
  		return {
  			to: function () {
  				var dest = utils_resolvePath(arguments);
  
  				return new Promise(function (fulfil, reject) {
  					mkdirp(path.dirname(dest), function (err) {
  						if (err) {
  							reject(err);
  						} else {
  							graceful_fs[methodName](src, dest, function (err) {
  								if (err) {
  									reject(err);
  								} else {
  									fulfil();
  								}
  							});
  						}
  					});
  				});
  			}
  		};
  	};
  }
  
  function link_rename__syncMethod(methodName) {
  	return function () {
  		var src = utils_resolvePath(arguments);
  
  		return {
  			to: function () {
  				var dest = utils_resolvePath(arguments);
  
  				mkdirp.sync(path.dirname(dest));
  				return graceful_fs[methodName](src, dest);
  			}
  		};
  	};
  }
  
  exports.link = link;
  exports.linkSync = linkSync;
  exports.rename = rename;
  exports.renameSync = renameSync;
  
  function mkdir() {
  	var dir = utils_resolvePath(arguments);
  
  	return new Promise(function (fulfil, reject) {
  		mkdirp(dir, function (err) {
  			if (err) {
  				reject(err);
  			} else {
  				fulfil();
  			}
  		});
  	});
  }
  
  function mkdirSync() {
  	var dir = utils_resolvePath(arguments);
  	mkdirp.sync(dir);
  }
  
  exports.mkdir = mkdir;
  exports.mkdirSync = mkdirSync;
  
  function specialMethods_open__normaliseArguments(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 = utils_resolvePath(pathargs);
  
  	return { resolvedPath: resolvedPath, options: options, flags: flags };
  }
  
  function bailIfExists(src, flags, mode) {
  	var alreadyExists = undefined;
  
  	try {
  		graceful_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?
  		graceful_fs.openSync(src, flags, mode);
  	}
  }
  
  function open() {
  	var _normaliseArguments = specialMethods_open__normaliseArguments(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() {
  			graceful_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 _normaliseArguments2 = specialMethods_open__normaliseArguments(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(path.dirname(src));
  	}
  
  	return graceful_fs.openSync(src, flags, options.mode);
  }
  
  exports.open = open;
  exports.openSync = openSync;
  
  function symlink() {
  	var src = utils_resolvePath(arguments);
  
  	return {
  		to: function () {
  			var _resolvePathAndOptions = utils_resolvePathAndOptions(arguments);
  
  			var options = _resolvePathAndOptions.options;
  			var dest = _resolvePathAndOptions.resolvedPath;
  
  			return new Promise(function (fulfil, reject) {
  				mkdirp(path.dirname(dest), function (err) {
  					if (err) {
  						reject(err);
  					} else {
  						graceful_fs.symlink(src, dest, options.type, function (err) {
  							if (err) {
  								reject(err);
  							} else {
  								fulfil();
  							}
  						});
  					}
  				});
  			});
  		}
  	};
  }
  
  function symlinkSync() {
  	var src = utils_resolvePath(arguments);
  
  	return {
  		to: function () {
  			var _resolvePathAndOptions2 = utils_resolvePathAndOptions(arguments);
  
  			var options = _resolvePathAndOptions2.options;
  			var dest = _resolvePathAndOptions2.resolvedPath;
  
  			mkdirp.sync(path.dirname(dest));
  			return graceful_fs.symlinkSync(src, dest, options.type);
  		}
  	};
  }
  
  exports.symlink = symlink;
  exports.symlinkSync = symlinkSync;
  
  var writeFile = writeFile_appendFile__asyncMethod('writeFile');
  var appendFile = writeFile_appendFile__asyncMethod('appendFile');
  
  var writeFileSync = writeFile_appendFile__syncMethod('writeFileSync');
  var appendFileSync = writeFile_appendFile__syncMethod('appendFileSync');
  
  function writeFile_appendFile__normaliseArguments(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: utils_resolvePath(args) };
  }
  
  function writeFile_appendFile__asyncMethod(methodName) {
  	return function () {
  		var _normaliseArguments = writeFile_appendFile__normaliseArguments(arguments);
  
  		var dest = _normaliseArguments.dest;
  		var data = _normaliseArguments.data;
  		var opts = _normaliseArguments.opts;
  
  		return new Promise(function (fulfil, reject) {
  			mkdirp(path.dirname(dest), function (err) {
  				if (err) {
  					reject(err);
  				} else {
  					graceful_fs[methodName](dest, data, opts, function (err) {
  						if (err) {
  							reject(err);
  						} else {
  							fulfil(data);
  						}
  					});
  				}
  			});
  		});
  	};
  }
  
  function writeFile_appendFile__syncMethod(methodName) {
  	return function () {
  		var _normaliseArguments2 = writeFile_appendFile__normaliseArguments(arguments);
  
  		var dest = _normaliseArguments2.dest;
  		var data = _normaliseArguments2.data;
  
  		mkdirp.sync(path.dirname(dest));
  		return graceful_fs[methodName](dest, data);
  	};
  }
  
  exports.writeFile = writeFile;
  exports.writeFileSync = writeFileSync;
  exports.appendFile = appendFile;
  exports.appendFileSync = appendFileSync;
  
  function copydir() {
  	var _resolvePathAndOptions = utils_resolvePathAndOptions(arguments);
  
  	var src = _resolvePathAndOptions.resolvedPath;
  	var readOptions = _resolvePathAndOptions.options;
  
  	return {
  		to: function () {
  			var _resolvePathAndOptions2 = utils_resolvePathAndOptions(arguments);
  
  			var dest = _resolvePathAndOptions2.resolvedPath;
  			var writeOptions = _resolvePathAndOptions2.options;
  
  			function copydir(src, dest, cb) {
  				mkdirp(dest, function (err) {
  					if (err) return cb(err);
  
  					graceful_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;
  
  							graceful_fs.stat(srcpath, function (err, stats) {
  								var readStream, writeStream;
  
  								if (stats.isDirectory()) {
  									return copydir(srcpath, destpath, check);
  								}
  
  								readStream = graceful_fs.createReadStream(srcpath, readOptions);
  								writeStream = graceful_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 _resolvePathAndOptions3 = utils_resolvePathAndOptions(arguments);
  
  	var src = _resolvePathAndOptions3.resolvedPath;
  	var readOptions = _resolvePathAndOptions3.options;
  
  	return {
  		to: function () {
  			var _resolvePathAndOptions4 = utils_resolvePathAndOptions(arguments);
  
  			var dest = _resolvePathAndOptions4.resolvedPath;
  			var writeOptions = _resolvePathAndOptions4.options;
  
  			function copydir(src, dest) {
  				mkdirp.sync(dest);
  
  				graceful_fs.readdirSync(src).forEach(function (filename) {
  					var srcpath = src + path.sep + filename;
  					var destpath = dest + path.sep + filename;
  
  					if (graceful_fs.statSync(srcpath).isDirectory()) {
  						return copydir(srcpath, destpath);
  					}
  
  					var data = graceful_fs.readFileSync(srcpath, readOptions);
  					graceful_fs.writeFileSync(destpath, data, writeOptions);
  				});
  			}
  
  			copydir(src, dest);
  		}
  	};
  }
  
  exports.copydir = copydir;
  exports.copydirSync = copydirSync;
  
  function copyFile() {
  	var _resolvePathAndOptions = utils_resolvePathAndOptions(arguments);
  
  	var src = _resolvePathAndOptions.resolvedPath;
  	var readOptions = _resolvePathAndOptions.options;
  
  	return {
  		to: function () {
  			var _resolvePathAndOptions2 = utils_resolvePathAndOptions(arguments);
  
  			var dest = _resolvePathAndOptions2.resolvedPath;
  			var writeOptions = _resolvePathAndOptions2.options;
  
  			return new Promise(function (fulfil, reject) {
  				mkdirp(path.dirname(dest), function (err) {
  					if (err) {
  						reject(err);
  					} else {
  						var readStream = graceful_fs.createReadStream(src, readOptions);
  						var writeStream = graceful_fs.createWriteStream(dest, writeOptions);
  
  						readStream.on('error', reject);
  						writeStream.on('error', reject);
  
  						writeStream.on('close', fulfil);
  
  						readStream.pipe(writeStream);
  					}
  				});
  			});
  		}
  	};
  }
  
  function copyFileSync() {
  	var _resolvePathAndOptions3 = utils_resolvePathAndOptions(arguments);
  
  	var src = _resolvePathAndOptions3.resolvedPath;
  	var readOptions = _resolvePathAndOptions3.options;
  
  	return {
  		to: function () {
  			var _resolvePathAndOptions4 = utils_resolvePathAndOptions(arguments);
  
  			var dest = _resolvePathAndOptions4.resolvedPath;
  			var writeOptions = _resolvePathAndOptions4.options;
  
  			var data = graceful_fs.readFileSync(src, readOptions);
  
  			mkdirp.sync(path.dirname(dest));
  			graceful_fs.writeFileSync(dest, data, writeOptions);
  		}
  	};
  }
  
  exports.copyFile = copyFile;
  exports.copyFileSync = copyFileSync;
  
  function lsr() {
  	var basedir = utils_resolvePath(arguments);
  
  	var result = [];
  
  	function processdir(dir, cb) {
  		graceful_fs.readdir(dir, function (err, files) {
  			if (err) {
  				return cb(err);
  			}
  
  			var remaining = files.length;
  
  			if (!remaining) {
  				return cb();
  			}
  
  			files = files.map(function (file) {
  				return dir + path.sep + file;
  			});
  
  			function check(err) {
  				if (err) {
  					cb(err);
  				} else if (! --remaining) {
  					cb();
  				}
  			}
  
  			files.forEach(function (file) {
  				graceful_fs.stat(file, function (err, stats) {
  					if (err) {
  						cb(err);
  					} else {
  						if (stats.isDirectory()) {
  							processdir(file, check);
  						} else {
  							result.push(file.replace(basedir + path.sep, ''));
  							check();
  						}
  					}
  				});
  			});
  		});
  	}
  
  	return new Promise(function (fulfil, reject) {
  		processdir(basedir, function (err) {
  			if (err) {
  				reject(err);
  			} else {
  				fulfil(result);
  			}
  		});
  	});
  }
  
  function lsrSync() {
  	var basedir = utils_resolvePath(arguments);
  
  	var result = [];
  
  	function processdir(dir) {
  		graceful_fs.readdirSync(dir).forEach(function (file) {
  			var filepath = dir + path.sep + file;
  
  			if (graceful_fs.statSync(filepath).isDirectory()) {
  				processdir(filepath);
  			} else {
  				result.push(filepath.replace(basedir + path.sep, ''));
  			}
  		});
  	}
  
  	processdir(basedir);
  	return result;
  }
  
  exports.lsr = lsr;
  exports.lsrSync = lsrSync;
  
  function rimraf() {
  	var target = utils_resolvePath(arguments);
  
  	return new Promise(function (fulfil, reject) {
  		_rimraf(target, function (err) {
  			if (err) {
  				reject(err);
  			} else {
  				fulfil();
  			}
  		});
  	});
  }
  
  function rimrafSync() {
  	_rimraf.sync(utils_resolvePath(arguments));
  }
  
  exports.rimraf = rimraf;
  exports.rimrafSync = rimrafSync;
  
  var isWindows = process.platform === 'win32';
  
  function symlinkOrCopy() {
  	var _arguments = arguments;
  
  	if (isWindows) {
  		var _ret = (function () {
  			var _resolvePathAndOptions = utils_resolvePathAndOptions(_arguments);
  
  			var src = _resolvePathAndOptions.resolvedPath;
  			var readOptions = _resolvePathAndOptions.options;
  
  			var copyDirOrFileTo = stat(src).then(function (stats) {
  				return (stats.isDirectory() ? copydir : copyFile).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.apply(null, arguments);
  }
  
  function symlinkOrCopySync() {
  	if (isWindows) {
  		var _resolvePathAndOptions2 = utils_resolvePathAndOptions(arguments);
  
  		var src = _resolvePathAndOptions2.resolvedPath;
  		var readOptions = _resolvePathAndOptions2.options;
  
  		return (statSync(src).isDirectory() ? copydirSync : copyFileSync).apply(null, arguments);
  	}
  
  	return symlinkSync.apply(null, arguments);
  }
  
  exports.symlinkOrCopy = symlinkOrCopy;
  exports.symlinkOrCopySync = symlinkOrCopySync;
  
  var chmod = standardMethod__asyncMethod('chmod');
  var chown = standardMethod__asyncMethod('chown');
  var sander__createReadStream = standardMethod__asyncMethod('createReadStream');
  var sander__createWriteStream = standardMethod__asyncMethod('createWriteStream');
  var lchmod = standardMethod__asyncMethod('lchmod');
  var lchown = standardMethod__asyncMethod('lchown');
  var lstat = standardMethod__asyncMethod('lstat');
  var readdir = standardMethod__asyncMethod('readdir');
  var readFile = standardMethod__asyncMethod('readFile');
  var readlink = standardMethod__asyncMethod('readlink');
  var realpath = standardMethod__asyncMethod('realpath');
  var rmdir = standardMethod__asyncMethod('rmdir');
  var stat = standardMethod__asyncMethod('stat');
  var truncate = standardMethod__asyncMethod('truncate');
  var unlink = standardMethod__asyncMethod('unlink');
  var utimes = standardMethod__asyncMethod('utimes');
  var unwatchFile = standardMethod__asyncMethod('unwatchFile');
  var watch = standardMethod__asyncMethod('watch');
  var watchFile = standardMethod__asyncMethod('watchFile');
  
  var chmodSync = standardMethod__syncMethod('chmodSync');
  var chownSync = standardMethod__syncMethod('chownSync');
  var lchmodSync = standardMethod__syncMethod('lchmodSync');
  var lchownSync = standardMethod__syncMethod('lchownSync');
  var lstatSync = standardMethod__syncMethod('lstatSync');
  var readdirSync = standardMethod__syncMethod('readdirSync');
  var readFileSync = standardMethod__syncMethod('readFileSync');
  var readlinkSync = standardMethod__syncMethod('readlinkSync');
  var realpathSync = standardMethod__syncMethod('realpathSync');
  var rmdirSync = standardMethod__syncMethod('rmdirSync');
  var statSync = standardMethod__syncMethod('statSync');
  var truncateSync = standardMethod__syncMethod('truncateSync');
  var unlinkSync = standardMethod__syncMethod('unlinkSync');
  var utimesSync = standardMethod__syncMethod('utimesSync');
  
  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');
  
  var closeSync = graceful_fs.closeSync;
  var fchmodSync = graceful_fs.fchmodSync;
  var fchownSync = graceful_fs.fchownSync;
  var fstatSync = graceful_fs.fstatSync;
  var fsyncSync = graceful_fs.fsyncSync;
  var ftruncateSync = graceful_fs.ftruncateSync;
  var futimesSync = graceful_fs.futimesSync;
  var readSync = graceful_fs.readSync;
  
  var sander__Promise = es6_promise.Promise;
  
  exports.chmod = chmod;
  exports.chown = chown;
  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 = sander__Promise;
  //# sourceMappingURL=sander.js.map
  