Socket
Socket
Sign inDemoInstall

sander

Package Overview
Dependencies
16
Maintainers
1
Versions
24
Alerts
File Explorer

Advanced tools

npm Scripts

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 0.4.0 to 0.5.0

CHANGELOG.md
dist/sander.es.js
dist/sander.es.js.map

767

dist/sander.cjs.js
'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 = require('mkdirp');
mkdirp = 'default' in mkdirp ? mkdirp['default'] : mkdirp;
var mkdirp = _interopDefault(require('mkdirp'));
var fs$1 = require('fs');
var _rimraf = require('rimraf');
_rimraf = 'default' in _rimraf ? _rimraf['default'] : _rimraf;
var _rimraf = _interopDefault(require('rimraf'));
function resolvePath(args) {
return path.resolve.apply(null, args);
function resolvePath ( args ) {
return path.resolve.apply( null, args );
}
function normaliseArguments(args) {
function normaliseArguments ( args ) {
var len = args.length;

@@ -21,15 +21,15 @@

var pathargs = [];
var normalised = [null]; // null is a placeholder for the resolved path
var i = undefined;
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') {
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.push( args[i] );
}
}
normalised[0] = resolvePath(pathargs);
normalised[0] = resolvePath( pathargs );

@@ -39,16 +39,16 @@ return normalised;

function asyncMethod(methodName) {
function asyncMethod ( methodName ) {
return function () {
var args = normaliseArguments(arguments);
var args = normaliseArguments( arguments );
return new Promise(function (fulfil, reject) {
args.push(function (err, result) {
if (err) {
reject(err);
return new Promise( function ( fulfil, reject ) {
args.push( function ( err, result ) {
if ( err ) {
reject( err );
} else {
fulfil(result);
fulfil( result );
}
});
fs[methodName].apply(fs, args);
fs[ methodName ].apply( fs, args );
});

@@ -58,28 +58,30 @@ };

function syncMethod(methodName) {
function syncMethod ( methodName ) {
return function () {
var args = normaliseArguments(arguments);
return fs[methodName].apply(fs, args);
var args = normaliseArguments( arguments );
return fs[ methodName ].apply( fs, args );
};
}
function asyncFileDescriptorMethod(methodName) {
function asyncFileDescriptorMethod ( methodName ) {
return function () {
var arguments$1 = arguments;
var args = [];
var i = arguments.length;
while (i--) {
args[i] = arguments[i];
while ( i-- ) {
args[i] = arguments$1[i];
}
return new Promise(function (fulfil, reject) {
args.push(function (err, result) {
if (err) {
reject(err);
return new Promise( function ( fulfil, reject ) {
args.push( function ( err, result ) {
if ( err ) {
reject( err );
} else {
fulfil(result);
fulfil( result );
}
});
fs[methodName].apply(fs, args);
fs[ methodName ].apply( fs, args );
});

@@ -89,13 +91,13 @@ };

function resolvePathAndOptions(args) {
var options = undefined;
var pathargs = undefined;
function resolvePathAndOptions ( args ) {
var options;
var pathargs;
if (typeof args[args.length - 1] === 'object') {
options = args[args.length - 1];
if ( typeof args[ args.length - 1 ] === 'object' ) {
options = args[ args.length - 1 ];
var i = args.length - 1;
pathargs = new Array(i);
pathargs = new Array( i );
while (i--) {
while ( i-- ) {
pathargs[i] = args[i];

@@ -108,3 +110,3 @@ }

var resolvedPath = path.resolve.apply(null, pathargs);
var resolvedPath = path.resolve.apply( null, pathargs );

@@ -114,57 +116,48 @@ 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 createReadStream$1 () {
var ref = resolvePathAndOptions( arguments ), resolvedPath = ref.resolvedPath, options = ref.options;
return fs.createReadStream( resolvedPath, options );
}
function createWriteStream$1() {
var _resolvePathAndOptions2 = resolvePathAndOptions(arguments);
function createWriteStream$1 () {
var ref = resolvePathAndOptions( arguments ), resolvedPath = ref.resolvedPath, options = ref.options;
var resolvedPath = _resolvePathAndOptions2.resolvedPath;
var options = _resolvePathAndOptions2.options;
mkdirp.sync(path.dirname(resolvedPath));
return fs.createWriteStream(resolvedPath, options);
mkdirp.sync( path.dirname( resolvedPath ) );
return fs.createWriteStream( resolvedPath, options );
}
function exists$1() {
var target = resolvePath(arguments);
function exists () {
var target = resolvePath( arguments );
return new Promise(function (fulfil) {
fs.exists(target, function (exists) {
return fulfil(exists);
});
return new Promise( function ( fulfil ) {
fs.exists( target, function ( exists ) { return fulfil( exists ); } );
});
}
function existsSync$1() {
return fs.existsSync(resolvePath(arguments));
function existsSync () {
return fs.existsSync( resolvePath( arguments ) );
}
var rename$1 = asyncMethod$1('rename');
var link$1 = asyncMethod$1('link');
var rename = asyncMethod$1( 'rename' );
var link = asyncMethod$1( 'link' );
var renameSync$1 = syncMethod$1('renameSync');
var linkSync$1 = syncMethod$1('linkSync');
var renameSync = syncMethod$1( 'renameSync' );
var linkSync = syncMethod$1( 'linkSync' );
function asyncMethod$1(methodName) {
function asyncMethod$1 ( methodName ) {
return function () {
var src = resolvePath(arguments);
var src = resolvePath( arguments );
return {
to: function () {
var dest = resolvePath(arguments);
to: function to () {
var dest = resolvePath( arguments );
return new Promise(function (fulfil, reject) {
mkdirp(path.dirname(dest), function (err) {
if (err) {
reject(err);
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);
fs[ methodName ]( src, dest, function ( err ) {
if ( err ) {
reject( err );
} else {

@@ -182,12 +175,12 @@ fulfil();

function syncMethod$1(methodName) {
function syncMethod$1 ( methodName ) {
return function () {
var src = resolvePath(arguments);
var src = resolvePath( arguments );
return {
to: function () {
var dest = resolvePath(arguments);
to: function to () {
var dest = resolvePath( arguments );
mkdirp.sync(path.dirname(dest));
return fs[methodName](src, dest);
mkdirp.sync( path.dirname( dest ) );
return fs[ methodName ]( src, dest );
}

@@ -198,9 +191,9 @@ };

function mkdir$1() {
var dir = resolvePath(arguments);
function mkdir () {
var dir = resolvePath( arguments );
return new Promise(function (fulfil, reject) {
mkdirp(dir, function (err) {
if (err) {
reject(err);
return new Promise( function ( fulfil, reject ) {
mkdirp( dir, function ( err ) {
if ( err ) {
reject( err );
} else {

@@ -213,28 +206,28 @@ fulfil();

function mkdirSync$1() {
var dir = resolvePath(arguments);
mkdirp.sync(dir);
function mkdirSync () {
var dir = resolvePath( arguments );
mkdirp.sync( dir );
}
function normaliseArguments$1(args) {
var options = undefined;
var flags = undefined;
var i = undefined;
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];
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];
flags = args[ args.length - 1 ];
i = args.length - 1;
}
var pathargs = new Array(i);
while (i--) {
var pathargs = new Array( i );
while ( i-- ) {
pathargs[i] = args[i];
}
var resolvedPath = resolvePath(pathargs);
var resolvedPath = resolvePath( pathargs );

@@ -244,10 +237,10 @@ return { resolvedPath: resolvedPath, options: options, flags: flags };

function bailIfExists(src, flags, mode) {
var alreadyExists = undefined;
function bailIfExists ( src, flags, mode ) {
var alreadyExists;
try {
fs.statSync(src);
fs.statSync( src );
alreadyExists = true;
} catch (err) {
if (err.code !== 'ENOENT') {
} catch ( err ) {
if ( err.code !== 'ENOENT' ) {
throw err;

@@ -257,27 +250,23 @@ }

if (alreadyExists) {
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);
fs.openSync( src, flags, mode );
}
}
function open$1() {
var _normaliseArguments = normaliseArguments$1(arguments);
function open () {
var ref = normaliseArguments$1( arguments ), src = ref.resolvedPath, options = ref.options, flags = ref.flags;
var src = _normaliseArguments.resolvedPath;
var options = _normaliseArguments.options;
var flags = _normaliseArguments.flags;
if (/^.x/.test(flags)) {
bailIfExists(src, flags, options.mode);
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);
return new Promise( function ( fulfil, reject ) {
function open () {
fs.open( src, flags, options.mode, function ( err, fd ) {
if ( err ) {
reject( err );
} else {
fulfil(fd);
fulfil( fd );
}

@@ -288,6 +277,6 @@ });

// create dirs if necessary
if (/^[wa]/.test(flags)) {
mkdirp(path.dirname(src), function (err) {
if (err) {
reject(err);
if ( /^[wa]/.test( flags ) ) {
mkdirp( path.dirname( src ), function ( err ) {
if ( err ) {
reject( err );
} else {

@@ -303,39 +292,33 @@ open();

function openSync$1() {
var _normaliseArguments2 = normaliseArguments$1(arguments);
var src = _normaliseArguments2.resolvedPath;
var options = _normaliseArguments2.options;
var flags = _normaliseArguments2.flags;
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);
if ( /^.x/.test( flags ) ) {
bailIfExists( src, flags, options.mode );
}
// create dirs if necessary
if (/^[wa]/.test(flags)) {
mkdirp.sync(path.dirname(src));
if ( /^[wa]/.test( flags ) ) {
mkdirp.sync( path.dirname( src ) );
}
return fs.openSync(src, flags, options.mode);
return fs.openSync( src, flags, options.mode );
}
function symlink$1() {
var src = resolvePath(arguments);
function symlink () {
var src = resolvePath( arguments );
return {
to: function () {
var _resolvePathAndOptions = resolvePathAndOptions(arguments);
to: function to () {
var ref = resolvePathAndOptions( arguments ), options = ref.options, dest = ref.resolvedPath;
var options = _resolvePathAndOptions.options;
var dest = _resolvePathAndOptions.resolvedPath;
return new Promise(function (fulfil, reject) {
mkdirp(path.dirname(dest), function (err) {
if (err) {
reject(err);
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);
fs.symlink( src, dest, options.type, function ( err ) {
if ( err ) {
reject( err );
} else {

@@ -352,14 +335,10 @@ fulfil();

function symlinkSync$1() {
var src = resolvePath(arguments);
function symlinkSync () {
var src = resolvePath( arguments );
return {
to: function () {
var _resolvePathAndOptions2 = resolvePathAndOptions(arguments);
var options = _resolvePathAndOptions2.options;
var dest = _resolvePathAndOptions2.resolvedPath;
mkdirp.sync(path.dirname(dest));
return fs.symlinkSync(src, dest, options.type);
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 );
}

@@ -369,37 +348,33 @@ };

var writeFile$1 = asyncMethod$2('writeFile');
var appendFile$1 = asyncMethod$2('appendFile');
var writeFile = asyncMethod$2( 'writeFile' );
var appendFile = asyncMethod$2( 'appendFile' );
var writeFileSync$1 = syncMethod$2('writeFileSync');
var appendFileSync$1 = syncMethod$2('appendFileSync');
var writeFileSync = syncMethod$2( 'writeFileSync' );
var appendFileSync = syncMethod$2( 'appendFileSync' );
function normaliseArguments$2(args) {
args = Array.prototype.slice.call(args, 0);
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)) {
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) };
return { opts: opts, data: args.pop(), dest: resolvePath( args ) };
}
function asyncMethod$2(methodName) {
function asyncMethod$2 ( methodName ) {
return function () {
var _normaliseArguments = normaliseArguments$2(arguments);
var ref = normaliseArguments$2( arguments ), dest = ref.dest, data = ref.data, opts = ref.opts;
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);
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);
fs[ methodName ]( dest, data, opts, function ( err ) {
if ( err ) {
reject( err );
} else {
fulfil(data);
fulfil( data );
}

@@ -413,44 +388,35 @@ });

function syncMethod$2(methodName) {
function syncMethod$2 ( methodName ) {
return function () {
var _normaliseArguments2 = normaliseArguments$2(arguments);
var ref = normaliseArguments$2( arguments ), dest = ref.dest, data = ref.data;
var dest = _normaliseArguments2.dest;
var data = _normaliseArguments2.data;
mkdirp.sync(path.dirname(dest));
return fs[methodName](dest, data);
mkdirp.sync( path.dirname( dest ) );
return fs[ methodName ]( dest, data );
};
}
function copydir$1() {
var _resolvePathAndOptions = resolvePathAndOptions(arguments);
function copydir () {
var ref = resolvePathAndOptions( arguments ), src = ref.resolvedPath, readOptions = ref.options;
var src = _resolvePathAndOptions.resolvedPath;
var readOptions = _resolvePathAndOptions.options;
return {
to: function () {
var _resolvePathAndOptions2 = resolvePathAndOptions(arguments);
to: function to () {
var ref = resolvePathAndOptions( arguments ), dest = ref.resolvedPath, writeOptions = ref.options;
var dest = _resolvePathAndOptions2.resolvedPath;
var writeOptions = _resolvePathAndOptions2.options;
function copydir ( src, dest, cb ) {
mkdirp( dest, function ( err ) {
if ( err ) return cb( err );
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 );
fs.readdir(src, function (err, files) {
if (err) return cb(err);
var remaining = files.length;
if (!remaining) return cb();
if ( !remaining ) return cb();
function check(err) {
if (err) {
return cb(err);
function check ( err ) {
if ( err ) {
return cb( err );
}
if (! --remaining) {
if ( !--remaining ) {
cb();

@@ -460,22 +426,22 @@ }

files.forEach(function (filename) {
files.forEach( function ( filename ) {
var srcpath = src + path.sep + filename;
var destpath = dest + path.sep + filename;
fs.stat(srcpath, function (err, stats) {
fs.stat( srcpath, function ( err, stats ) {
var readStream, writeStream;
if (stats.isDirectory()) {
return copydir(srcpath, destpath, check);
if ( stats.isDirectory() ) {
return copydir( srcpath, destpath, check );
}
readStream = fs.createReadStream(srcpath, readOptions);
writeStream = fs.createWriteStream(destpath, writeOptions);
readStream = fs.createReadStream( srcpath, readOptions );
writeStream = fs.createWriteStream( destpath, writeOptions );
readStream.on('error', cb);
writeStream.on('error', cb);
readStream.on( 'error', cb );
writeStream.on( 'error', cb );
writeStream.on('close', check);
writeStream.on( 'close', check );
readStream.pipe(writeStream);
readStream.pipe( writeStream );
});

@@ -487,6 +453,6 @@ });

return new Promise(function (fulfil, reject) {
copydir(src, dest, function (err) {
if (err) {
reject(err);
return new Promise( function ( fulfil, reject ) {
copydir( src, dest, function ( err ) {
if ( err ) {
reject( err );
} else {

@@ -501,32 +467,26 @@ fulfil();

function copydirSync$1() {
var _resolvePathAndOptions3 = resolvePathAndOptions(arguments);
function copydirSync () {
var ref = resolvePathAndOptions( arguments ), src = ref.resolvedPath, readOptions = ref.options;
var src = _resolvePathAndOptions3.resolvedPath;
var readOptions = _resolvePathAndOptions3.options;
return {
to: function () {
var _resolvePathAndOptions4 = resolvePathAndOptions(arguments);
to: function to () {
var ref = resolvePathAndOptions( arguments ), dest = ref.resolvedPath, writeOptions = ref.options;
var dest = _resolvePathAndOptions4.resolvedPath;
var writeOptions = _resolvePathAndOptions4.options;
function copydir ( src, dest ) {
mkdirp.sync( dest );
function copydir(src, dest) {
mkdirp.sync(dest);
fs.readdirSync(src).forEach(function (filename) {
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);
if ( fs.statSync( srcpath ).isDirectory() ) {
return copydir( srcpath, destpath );
}
var data = fs.readFileSync(srcpath, readOptions);
fs.writeFileSync(destpath, data, writeOptions);
var data = fs.readFileSync( srcpath, readOptions );
fs.writeFileSync( destpath, data, writeOptions );
});
}
copydir(src, dest);
copydir( src, dest );
}

@@ -536,29 +496,23 @@ };

function copyFile$1() {
var _resolvePathAndOptions = resolvePathAndOptions(arguments);
function copyFile () {
var ref = resolvePathAndOptions( arguments ), src = ref.resolvedPath, readOptions = ref.options;
var src = _resolvePathAndOptions.resolvedPath;
var readOptions = _resolvePathAndOptions.options;
return {
to: function () {
var _resolvePathAndOptions2 = resolvePathAndOptions(arguments);
to: function to () {
var ref = resolvePathAndOptions( arguments ), dest = ref.resolvedPath, writeOptions = ref.options;
var dest = _resolvePathAndOptions2.resolvedPath;
var writeOptions = _resolvePathAndOptions2.options;
return new Promise(function (fulfil, reject) {
mkdirp(path.dirname(dest), function (err) {
if (err) {
reject(err);
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);
var readStream = fs.createReadStream( src, readOptions );
var writeStream = fs.createWriteStream( dest, writeOptions );
readStream.on('error', reject);
writeStream.on('error', reject);
readStream.on( 'error', reject );
writeStream.on( 'error', reject );
writeStream.on('close', fulfil);
writeStream.on( 'close', fulfil );
readStream.pipe(writeStream);
readStream.pipe( writeStream );
}

@@ -571,19 +525,13 @@ });

function copyFileSync$1() {
var _resolvePathAndOptions3 = resolvePathAndOptions(arguments);
function copyFileSync () {
var ref = resolvePathAndOptions( arguments ), src = ref.resolvedPath, readOptions = ref.options;
var src = _resolvePathAndOptions3.resolvedPath;
var readOptions = _resolvePathAndOptions3.options;
return {
to: function () {
var _resolvePathAndOptions4 = resolvePathAndOptions(arguments);
to: function to () {
var ref = resolvePathAndOptions( arguments ), dest = ref.resolvedPath, writeOptions = ref.options;
var dest = _resolvePathAndOptions4.resolvedPath;
var writeOptions = _resolvePathAndOptions4.options;
var data = fs.readFileSync( src, readOptions );
var data = fs.readFileSync(src, readOptions);
mkdirp.sync(path.dirname(dest));
fs.writeFileSync(dest, data, writeOptions);
mkdirp.sync( path.dirname( dest ) );
fs.writeFileSync( dest, data, writeOptions );
}

@@ -593,23 +541,23 @@ };

function walk(dir, callback) {
function walk ( dir, callback ) {
var results = [];
fs$1.readdir(dir, function (err, files) {
if (err) return callback(err);
fs$1.readdir( dir, function ( err, files ) {
if ( err ) return callback( err );
var pending = files.length;
if (!pending) return callback(null, results);
if ( !pending ) return callback( null, results );
files.forEach(function (file) {
file = path.resolve(dir, file);
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);
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);
results.push( file );
if ( !--pending ) callback( null, results );
}

@@ -621,8 +569,8 @@ });

function lsr$1() {
var basedir = resolvePath(arguments);
function lsr () {
var basedir = resolvePath( arguments );
return new Promise(function (fulfil, reject) {
walk(basedir, function (err, result) {
if (err) return reject(err);
return new Promise( function ( fulfil, reject ) {
walk( basedir, function ( err, result ) {
if ( err ) return reject( err );

@@ -632,7 +580,7 @@ // files should be relative to basedir

var i = result.length;
while (i--) {
result[i] = result[i].substring(index);
while ( i-- ) {
result[i] = result[i].substring( index );
}
fulfil(result);
fulfil( result );
});

@@ -642,15 +590,15 @@ });

function lsrSync$1() {
var basedir = resolvePath(arguments);
function lsrSync () {
var basedir = resolvePath( arguments );
var result = [];
function processdir(dir) {
fs$1.readdirSync(dir).forEach(function (file) {
function processdir ( dir ) {
fs$1.readdirSync( dir ).forEach( function ( file ) {
var filepath = dir + path.sep + file;
if (fs$1.statSync(filepath).isDirectory()) {
processdir(filepath);
if ( fs$1.statSync( filepath ).isDirectory() ) {
processdir( filepath );
} else {
result.push(filepath.replace(basedir + path.sep, ''));
result.push( filepath.replace( basedir + path.sep, '' ) );
}

@@ -660,13 +608,13 @@ });

processdir(basedir);
processdir( basedir );
return result;
}
function rimraf$1() {
var target = resolvePath(arguments);
function rimraf () {
var target = resolvePath( arguments );
return new Promise(function (fulfil, reject) {
_rimraf(target, function (err) {
if (err) {
reject(err);
return new Promise( function ( fulfil, reject ) {
_rimraf( target, function ( err ) {
if ( err ) {
reject( err );
} else {

@@ -679,4 +627,4 @@ fulfil();

function rimrafSync$1() {
_rimraf.sync(resolvePath(arguments));
function rimrafSync () {
_rimraf.sync( resolvePath( arguments ) );
}

@@ -686,94 +634,83 @@

function symlinkOrCopy$1() {
var _arguments = arguments;
function symlinkOrCopy () {
var arguments$1 = arguments;
if (isWindows) {
var _ret = (function () {
var _resolvePathAndOptions = resolvePathAndOptions(_arguments);
if ( isWindows ) {
var ref = resolvePathAndOptions( arguments ), src = ref.resolvedPath, readOptions = ref.options;
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;
var copyDirOrFileTo = stat( src )
.then( function ( stats ) {
return ( stats.isDirectory() ? copydir : copyFile )
.apply( null, arguments$1 )
.to;
});
return {
v: {
to: function () {
var _arguments2 = arguments;
return {
to: function to () {
var arguments$1 = arguments;
return copyDirOrFileTo.then(function (fn) {
return fn.apply(null, _arguments2);
});
}
}
};
})();
if (typeof _ret === 'object') return _ret.v;
return copyDirOrFileTo
.then(function ( fn ) {
return fn.apply(null, arguments$1);
});
}
};
}
return symlink$1.apply(null, arguments);
return symlink.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);
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$1.apply(null, arguments);
return symlinkSync.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');
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');
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');
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' );

@@ -844,28 +781,28 @@ // file descriptor sync methods

exports.Promise = Promise$1;
exports.exists = exists$1;
exports.existsSync = existsSync$1;
exports.link = link$1;
exports.linkSync = linkSync$1;
exports.rename = rename$1;
exports.renameSync = renameSync$1;
exports.mkdir = mkdir$1;
exports.mkdirSync = mkdirSync$1;
exports.open = open$1;
exports.openSync = openSync$1;
exports.symlink = symlink$1;
exports.symlinkSync = symlinkSync$1;
exports.writeFile = writeFile$1;
exports.writeFileSync = writeFileSync$1;
exports.appendFile = appendFile$1;
exports.appendFileSync = appendFileSync$1;
exports.copydir = copydir$1;
exports.copydirSync = copydirSync$1;
exports.copyFile = copyFile$1;
exports.copyFileSync = copyFileSync$1;
exports.lsr = lsr$1;
exports.lsrSync = lsrSync$1;
exports.rimraf = rimraf$1;
exports.rimrafSync = rimrafSync$1;
exports.symlinkOrCopy = symlinkOrCopy$1;
exports.symlinkOrCopySync = symlinkOrCopySync$1;
//# sourceMappingURL=sander.cjs.js.map
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

29

package.json

@@ -5,26 +5,25 @@ {

"author": "Rich Harris",
"version": "0.4.0",
"version": "0.5.0",
"license": "MIT",
"repository": "https://github.com/rich-harris/sander",
"dependencies": {
"es6-promise": "^2.0.0",
"mkdirp": "^0.5.0",
"rimraf": "^2.2.8",
"graceful-fs": "^3.0.4"
"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.es6.js",
"jsnext:main": "dist/sander.es.js",
"devDependencies": {
"buffer-crc32": "^0.2.3",
"gobble": "^0.9.2",
"gobble-babel": "^5.1.0",
"gobble-cli": "^0.4.1",
"gobble-esperanto-bundle": "^0.1.7",
"mocha": "^2.2.4"
"buffer-crc32": "^0.2.5",
"mocha": "^2.4.5",
"rollup-plugin-buble": "^0.5.0"
},
"scripts": {
"test": "mocha",
"pretest": "npm run build",
"build": "gobble build -f dist",
"prepublish": "npm run build && npm test"
"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"
},

@@ -31,0 +30,0 @@ "files": [

dist/sander.cjs.js.map

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

About

Packages

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc