pleeease 0.0.2

data/node_modules/pleeease/node_modules/autoprefixer/node_modules/fs-extra/lib/copy.js

@@ -0,0 +1,79 @@
+"use strict"
+
+var fs = require('fs')
+  , ncp = require('ncp').ncp
+  , path = require('path')
+  , mkdir = require('./mkdir'),
+    create = require('./create')
+
+module.exports.copy = copy;
+module.exports.copySync = copySync;
+
+var BUF_LENGTH = 64 * 1024
+var _buff = new Buffer(BUF_LENGTH)
+
+var copyFileSync = function(srcFile, destFile) {
+  var bytesRead, fdr, fdw, pos;
+  fdr = fs.openSync(srcFile, 'r');
+  fdw = fs.openSync(destFile, 'w');
+  bytesRead = 1;
+  pos = 0;
+  while (bytesRead > 0) {
+    bytesRead = fs.readSync(fdr, _buff, 0, BUF_LENGTH, pos);
+    fs.writeSync(fdw, _buff, 0, bytesRead);
+    pos += bytesRead;
+  }
+  fs.closeSync(fdr);
+  return fs.closeSync(fdw);
+}
+
+function copy(src, dest, filter, callback) {
+  if( typeof filter === "function" && !callback) {
+    callback = filter;
+    filter = null;
+  }
+  callback = callback || function(){}
+
+  fs.lstat(src, function(err, stats) {
+    if (err) return callback(err)
+
+    var dir = null
+    if (stats.isDirectory()) {
+      var parts = dest.split(path.sep)
+      parts.pop()
+      dir = parts.join(path.sep)
+    } else {
+      dir = path.dirname(dest)
+    }
+
+    fs.exists(dir, function(dirExists) {
+      if (dirExists) return ncp(src, dest, {filter: filter}, callback);
+      mkdir.mkdirs(dir, function(err) {
+        if (err) return callback(err)
+        ncp(src, dest, {filter: filter}, callback);
+      })
+    })
+  })
+}
+
+function copySync(src, dest, filter) {
+  filter = filter || function () { return true; };
+  var stats = fs.lstatSync(src),
+      destExists = fs.exists(dest),
+      performCopy = false;
+  if (stats.isFile()) {
+    if (filter instanceof RegExp) performCopy = filter.test(src);
+    else if (typeof filter === "function") performCopy = filter(src);
+    if(performCopy) {
+      if (!destExists) create.createFileSync(dest);
+      copyFileSync(src, dest);
+    }
+  }
+  else if (stats.isDirectory()) {
+    if (!destExists) mkdir.mkdirsSync(dest);
+    var contents = fs.readdirSync(src);
+    contents.forEach(function (content) {
+      copySync(src + "/" + content, dest + "/" + content, filter);
+    });
+  }
+}

data/node_modules/pleeease/node_modules/autoprefixer/node_modules/fs-extra/lib/create.js

@@ -0,0 +1,55 @@
+"use strict"
+
+var mkdir = require('./mkdir')
+  , path = require('path')
+  , fs = require('fs')
+  , exists = fs.exists || path.exists
+  , existsSync = fs.existsSync || path.existsSync
+
+function createFile (file, callback) {
+  function makeFile() {
+    fs.writeFile(file, '', function(err) {
+      if (err)
+        callback(err)
+      else
+        callback(null);
+    })
+  }
+
+  exists(file, function(fileExists) {
+    if (fileExists)
+      return callback(null);
+    else {
+      var dir = path.dirname(file);
+
+      exists(dir, function(dirExists) {
+        if (!dirExists) {
+          mkdir.mkdirs(dir, function(err) {
+            if (err)
+              callback(err)
+            else
+              makeFile();
+          })
+        } else {
+          makeFile();
+        }
+      })
+    }
+  })
+}
+
+
+function createFileSync (file) {
+  if (existsSync(file))
+    return;
+
+  var dir = path.dirname(file);
+  if (!existsSync(dir))
+    mkdir.mkdirsSync(dir);
+
+  fs.writeFileSync(file, '');
+}
+
+
+module.exports.createFile = createFile;
+module.exports.createFileSync = createFileSync;

data/node_modules/pleeease/node_modules/autoprefixer/node_modules/fs-extra/lib/ensure.js

@@ -0,0 +1,4 @@
+'use strict'
+
+var me = module.exports
+

data/node_modules/pleeease/node_modules/autoprefixer/node_modules/fs-extra/lib/index.js

@@ -0,0 +1,137 @@
+"use strict"
+
+var fs = null
+  , path = require('path')
+  , jsonFile = require('jsonfile')
+  , json = require('./json')
+  , fse = {};
+
+try {
+  // optional dependency
+  fs = require("graceful-fs")
+} catch (er) {
+  fs = require("fs")
+}
+
+Object.keys(fs).forEach(function(key) {
+  var func = fs[key];
+  if (typeof func == 'function')
+    fse[key] = func;
+});
+
+fs = fse;
+
+// copy
+
+fs.copy = require('./copy').copy;
+fs.copySync = require('./copy').copySync;
+
+
+// remove
+
+var remove = require('./remove');
+fs.remove = remove.remove;
+fs.removeSync = remove.removeSync;
+fs['delete'] = fs.remove
+fs.deleteSync = fs.removeSync
+
+// mkdir
+
+var mkdir = require('./mkdir')
+fs.mkdirs = mkdir.mkdirs
+fs.mkdirsSync = mkdir.mkdirsSync
+fs.mkdirp = mkdir.mkdirs
+fs.mkdirpSync = mkdir.mkdirsSync
+
+// create
+
+var create = require('./create')
+fs.createFile = create.createFile;
+fs.createFileSync = create.createFileSync;
+
+
+// ensure
+
+var ensure = require('./ensure')
+fs.ensureFile = create.createFile
+fs.ensureFileSync = create.createFileSync
+
+fs.ensureDir = mkdir.mkdirs
+fs.ensureDirSync = mkdir.mkdirsSync
+
+
+// move
+
+var move = require('./move')
+fs.move = function(src, dest, opts, callback) {
+  if (typeof opts == 'function') {
+    callback = opts
+    opts = {}
+  }
+
+  if (opts.mkdirp == null) opts.mkdirp = true
+  if (opts.clobber == null) opts.clobber = false
+
+  move(src, dest, opts, callback)
+}
+
+//deprecated
+fs.touch = function touch() {
+  console.log('fs.touch() is deprecated. Please use fs.createFile().')
+  fs.createFile.apply(null, arguments)
+}
+
+fs.touchSync = function touchSync() {
+  console.log('fs.touchSync() is deprecated. Please use fs.createFileSync().')
+  fs.createFileSync.apply(null, arguments)
+}
+
+// output
+
+var output = require('./output');
+fs.outputFile = output.outputFile;
+fs.outputFileSync = output.outputFileSync;
+
+// read
+
+/*fs.readTextFile = function(file, callback) {
+  return fs.readFile(file, 'utf8', callback)
+}
+
+fs.readTextFileSync = function(file, callback) {
+  return fs.readFileSync(file, 'utf8')
+}*/
+
+// json files
+
+fs.readJsonFile = jsonFile.readFile;
+fs.readJSONFile = jsonFile.readFile;
+fs.readJsonFileSync = jsonFile.readFileSync;
+fs.readJSONFileSync = jsonFile.readFileSync;
+
+fs.readJson = jsonFile.readFile;
+fs.readJSON = jsonFile.readFile;
+fs.readJsonSync = jsonFile.readFileSync;
+fs.readJSONSync = jsonFile.readFileSync;
+
+fs.outputJsonSync = json.outputJsonSync;
+fs.outputJSONSync = json.outputJsonSync;
+fs.outputJson = json.outputJson;
+fs.outputJSON = json.outputJson;
+
+fs.writeJsonFile = jsonFile.writeFile;
+fs.writeJSONFile = jsonFile.writeFile;
+fs.writeJsonFileSync = jsonFile.writeFileSync;
+fs.writeJSONFileSync = jsonFile.writeFileSync;
+
+fs.writeJson = jsonFile.writeFile;
+fs.writeJSON = jsonFile.writeFile;
+fs.writeJsonSync = jsonFile.writeFileSync;
+fs.writeJSONSync = jsonFile.writeFileSync;
+
+
+module.exports = fs
+
+jsonFile.spaces = 2; //set to 2
+module.exports.jsonfile = jsonFile; //so users of fs-extra can modify jsonFile.spaces;
+

data/node_modules/pleeease/node_modules/autoprefixer/node_modules/fs-extra/lib/json.js

@@ -0,0 +1,30 @@
+"use strict"
+
+var jsonFile = require('jsonfile')
+  , fs = require('fs')
+  , mkdir = require('./mkdir')
+  , path = require('path')
+
+var me = module.exports
+
+me.outputJsonSync = function(file, data) {
+  var dir = path.dirname(file)
+
+  if (!fs.existsSync(dir))
+    mkdir.mkdirsSync(dir)
+
+  jsonFile.writeFileSync(file, data)
+}
+
+me.outputJson = function(file, data, callback) {
+  var dir = path.dirname(file)
+
+  fs.exists(dir, function(itDoes) {
+    if (itDoes) return jsonFile.writeFile(file, data, callback)
+
+    mkdir.mkdirs(dir, function(err) {
+      if (err) return callback(err)
+      jsonFile.writeFile(file, data, callback)
+    })
+  })
+}

data/node_modules/pleeease/node_modules/autoprefixer/node_modules/fs-extra/lib/mkdir.js

@@ -0,0 +1,8 @@
+"use strict"
+
+var mkdirp = require('mkdirp');
+
+module.exports.mkdirs = mkdirp;
+module.exports.mkdirsSync = mkdirp.sync;
+
+

data/node_modules/pleeease/node_modules/autoprefixer/node_modules/fs-extra/lib/move.js

@@ -0,0 +1,108 @@
+//most (all at this time) of this code was written by Andrew Kelley
+//licensed under the BSD license: see https://github.com/andrewrk/node-mv/blob/master/package.json
+
+var fs = require('fs');
+var ncp = require('ncp').ncp;
+var path = require('path');
+var rimraf = require('rimraf');
+var mkdirp = require('mkdirp');
+
+module.exports = mv;
+
+function mv(source, dest, options, cb){
+  if (typeof options === 'function') {
+    cb = options;
+    options = {};
+  }
+  var shouldMkdirp = !!options.mkdirp;
+  var clobber = options.clobber !== false;
+  var limit = options.limit || 16;
+
+  if (shouldMkdirp) {
+    mkdirs();
+  } else {
+    doRename();
+  }
+
+  function mkdirs() {
+    mkdirp(path.dirname(dest), function(err) {
+      if (err) return cb(err);
+      doRename();
+    });
+  }
+
+  function doRename() {
+    if (clobber) {
+      fs.rename(source, dest, function(err) {
+        if (!err) return cb();
+        if (err.code !== 'EXDEV') return cb(err);
+        moveFileAcrossDevice(source, dest, clobber, limit, cb);
+      });
+    } else {
+      fs.link(source, dest, function(err) {
+        if (err) {
+          if (err.code === 'EXDEV') {
+            moveFileAcrossDevice(source, dest, clobber, limit, cb);
+            return;
+          }
+          if (err.code === 'EISDIR' || err.code === 'EPERM') {
+            moveDirAcrossDevice(source, dest, clobber, limit, cb);
+            return;
+          }
+          cb(err);
+          return;
+        }
+        fs.unlink(source, cb);
+      });
+    }
+  }
+}
+
+function moveFileAcrossDevice(source, dest, clobber, limit, cb) {
+  var outFlags = clobber ? 'w' : 'wx';
+  var ins = fs.createReadStream(source);
+  var outs = fs.createWriteStream(dest, {flags: outFlags});
+  ins.on('error', function(err){
+    ins.destroy();
+    outs.destroy();
+    outs.removeListener('close', onClose);
+    if (err.code === 'EISDIR' || err.code === 'EPERM') {
+      moveDirAcrossDevice(source, dest, clobber, limit, cb);
+    } else {
+      cb(err);
+    }
+  });
+  outs.on('error', function(err){
+    ins.destroy();
+    outs.destroy();
+    outs.removeListener('close', onClose);
+    cb(err);
+  });
+  outs.once('close', onClose);
+  ins.pipe(outs);
+  function onClose(){
+    fs.unlink(source, cb);
+  }
+}
+
+function moveDirAcrossDevice(source, dest, clobber, limit, cb) {
+  var options = {
+    stopOnErr: true,
+    clobber: false,
+    limit: limit,
+  };
+  if (clobber) {
+    rimraf(dest, function(err) {
+      if (err) return cb(err);
+      startNcp();
+    });
+  } else {
+    startNcp();
+  }
+  function startNcp() {
+    ncp(source, dest, options, function(errList) {
+      if (errList) return cb(errList[0]);
+      rimraf(source, cb);
+    });
+  }
+}

data/node_modules/pleeease/node_modules/autoprefixer/node_modules/fs-extra/lib/output.js

@@ -0,0 +1,37 @@
+"use strict"
+
+var mkdir = require('./mkdir')
+  , path = require('path')
+  , fs = require('fs')
+  , exists = fs.exists || path.exists
+  , existsSync = fs.existsSync || path.existsSync
+
+function outputFile (file, data, encoding, callback) {
+  if (typeof encoding === 'function') {
+    callback = encoding
+    encoding = 'utf8'
+  }
+
+  var dir = path.dirname(file)
+  exists(dir, function(itDoes) {
+    if (itDoes) return fs.writeFile(file, data, encoding, callback)
+
+    mkdir.mkdirs(dir, function(err) {
+      if (err) return callback(err)
+
+      fs.writeFile(file, data, encoding, callback)
+    })
+  })
+}
+
+
+function outputFileSync (file, data, encoding) {
+  var dir = path.dirname(file)
+  if (existsSync(dir)) return fs.writeFileSync.apply(fs, arguments)
+  mkdir.mkdirsSync(dir)
+  fs.writeFileSync.apply(fs, arguments)
+}
+
+
+module.exports.outputFile = outputFile;
+module.exports.outputFileSync = outputFileSync;