pleeease 0.0.2

data/node_modules/pleeease/node_modules/autoprefixer/lib/processor.js

@@ -0,0 +1,105 @@
+(function() {
+  var Processor, Value, utils, vendor;
+
+  vendor = require('postcss/lib/vendor');
+
+  Value = require('./value');
+
+  utils = require('./utils');
+
+  Processor = (function() {
+    function Processor(prefixes) {
+      this.prefixes = prefixes;
+    }
+
+    Processor.prototype.add = function(css) {
+      var prefixer, selector, _i, _len, _ref;
+      prefixer = this.prefixes.add['@keyframes'];
+      if (prefixer) {
+        css.eachAtRule(function(rule) {
+          return prefixer.process(rule);
+        });
+      }
+      _ref = this.prefixes.add.selectors;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        selector = _ref[_i];
+        css.eachRule(function(rule) {
+          return selector.process(rule);
+        });
+      }
+      css.eachDecl((function(_this) {
+        return function(decl) {
+          var prefix;
+          prefix = _this.prefixes.add[decl.prop];
+          if (prefix && prefix.prefixes) {
+            return prefix.process(decl);
+          }
+        };
+      })(this));
+      return css.eachDecl((function(_this) {
+        return function(decl) {
+          var unprefixed, value, _j, _len1, _ref1;
+          unprefixed = _this.prefixes.unprefixed(decl.prop);
+          _ref1 = _this.prefixes.values('add', unprefixed);
+          for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
+            value = _ref1[_j];
+            value.process(decl);
+          }
+          return Value.save(_this.prefixes, decl);
+        };
+      })(this));
+    };
+
+    Processor.prototype.remove = function(css) {
+      var checker, _i, _len, _ref;
+      css.eachAtRule((function(_this) {
+        return function(rule, i) {
+          if (_this.prefixes.remove['@' + rule.name]) {
+            return rule.parent.remove(i);
+          }
+        };
+      })(this));
+      _ref = this.prefixes.remove.selectors;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        checker = _ref[_i];
+        css.eachRule((function(_this) {
+          return function(rule, i) {
+            if (checker.check(rule)) {
+              return rule.parent.remove(i);
+            }
+          };
+        })(this));
+      }
+      return css.eachDecl((function(_this) {
+        return function(decl, i) {
+          var notHack, rule, unprefixed, _j, _len1, _ref1, _ref2;
+          rule = decl.parent;
+          unprefixed = _this.prefixes.unprefixed(decl.prop);
+          if ((_ref1 = _this.prefixes.remove[decl.prop]) != null ? _ref1.remove : void 0) {
+            notHack = _this.prefixes.group(decl).down(function(i) {
+              return i.prop === unprefixed;
+            });
+            if (notHack) {
+              rule.remove(i);
+              return;
+            }
+          }
+          _ref2 = _this.prefixes.values('remove', unprefixed);
+          for (_j = 0, _len1 = _ref2.length; _j < _len1; _j++) {
+            checker = _ref2[_j];
+            if (checker.check(decl.value)) {
+              rule.remove(i);
+              return;
+            }
+          }
+        };
+      })(this));
+    };
+
+    return Processor;
+
+  })();
+
+  module.exports = Processor;
+
+}).call(this);

data/node_modules/pleeease/node_modules/autoprefixer/lib/selector.js

@@ -0,0 +1,117 @@
+(function() {
+  var Browsers, OldSelector, Prefixer, Selector, utils,
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  OldSelector = require('./old-selector');
+
+  Prefixer = require('./prefixer');
+
+  Browsers = require('./browsers');
+
+  utils = require('./utils');
+
+  Selector = (function(_super) {
+    __extends(Selector, _super);
+
+    function Selector(name, prefixes, all) {
+      this.name = name;
+      this.prefixes = prefixes;
+      this.all = all;
+      this.regexpCache = {};
+    }
+
+    Selector.prototype.check = function(rule) {
+      if (rule.selector.indexOf(this.name) !== -1) {
+        return !!rule.selector.match(this.regexp());
+      } else {
+        return false;
+      }
+    };
+
+    Selector.prototype.prefixed = function(prefix) {
+      return this.name.replace(/^([^\w]*)/, '$1' + prefix);
+    };
+
+    Selector.prototype.regexp = function(prefix) {
+      var name;
+      if (this.regexpCache[prefix]) {
+        return this.regexpCache[prefix];
+      }
+      name = prefix ? this.prefixed(prefix) : this.name;
+      return this.regexpCache[prefix] = RegExp("(^|[^:\"'=])" + (utils.escapeRegexp(name)), "gi");
+    };
+
+    Selector.prototype.possible = function() {
+      return Browsers.prefixes();
+    };
+
+    Selector.prototype.prefixeds = function(rule) {
+      var prefix, prefixeds, _i, _len, _ref;
+      if (rule._autoprefixerPrefixeds) {
+        return rule._autoprefixerPrefixeds;
+      }
+      prefixeds = {};
+      _ref = this.possible();
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        prefix = _ref[_i];
+        prefixeds[prefix] = this.replace(rule.selector, prefix);
+      }
+      return rule._autoprefixerPrefixeds = prefixeds;
+    };
+
+    Selector.prototype.already = function(rule, prefixeds, prefix) {
+      var before, index, key, prefixed, some;
+      index = rule.parent.index(rule) - 1;
+      while (index >= 0) {
+        before = rule.parent.rules[index];
+        if (before.type !== 'rule') {
+          return false;
+        }
+        some = false;
+        for (key in prefixeds) {
+          prefixed = prefixeds[key];
+          if (before.selector === prefixed) {
+            if (prefix === key) {
+              return true;
+            } else {
+              some = true;
+              break;
+            }
+          }
+        }
+        if (!some) {
+          return false;
+        }
+        index -= 1;
+      }
+      return false;
+    };
+
+    Selector.prototype.replace = function(selector, prefix) {
+      return selector.replace(this.regexp(), '$1' + this.prefixed(prefix));
+    };
+
+    Selector.prototype.add = function(rule, prefix) {
+      var cloned, prefixeds;
+      prefixeds = this.prefixeds(rule);
+      if (this.already(rule, prefixeds, prefix)) {
+        return;
+      }
+      cloned = this.clone(rule, {
+        selector: prefixeds[prefix]
+      });
+      return rule.parent.insertBefore(rule, cloned);
+    };
+
+    Selector.prototype.old = function(prefix) {
+      return new OldSelector(this, prefix);
+    };
+
+    return Selector;
+
+  })(Prefixer);
+
+  module.exports = Selector;
+
+}).call(this);

data/node_modules/pleeease/node_modules/autoprefixer/lib/updater.js

@@ -0,0 +1,234 @@
+(function() {
+  var coffee, fs, https;
+
+  coffee = require('coffee-script');
+
+  https = require('https');
+
+  fs = require('fs');
+
+  module.exports = {
+    browsers: {
+      firefox: 'ff',
+      chrome: 'chrome',
+      safari: 'safari',
+      ios_saf: 'ios',
+      opera: 'opera',
+      ie: 'ie',
+      bb: 'bb',
+      android: 'android'
+    },
+    run: function() {
+      var i, updaters, _i, _len, _ref, _results;
+      updaters = __dirname + '/../updaters/';
+      _ref = fs.readdirSync(updaters).sort();
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        i = _ref[_i];
+        if (!i.match(/\.(coffee|js)$/)) {
+          continue;
+        }
+        _results.push(require(updaters + i).apply(this));
+      }
+      return _results;
+    },
+    requests: 0,
+    doneCallbacks: [],
+    requestCallbacks: [],
+    done: function(callback) {
+      this.doneCallbacks || (this.doneCallbacks = []);
+      return this.doneCallbacks.push(callback);
+    },
+    error: function(message) {
+      process.stderr.write("\n" + message + "\n");
+      return process.exit(1);
+    },
+    request: function(callback) {
+      this.requestCallbacks || (this.requestCallbacks = []);
+      return this.requestCallbacks.push(callback);
+    },
+    github: function(path, callback) {
+      var url;
+      this.requests += 1;
+      url = "https://raw.githubusercontent.com/" + path;
+      return https.get(url, (function(_this) {
+        return function(res) {
+          var data;
+          data = '';
+          res.on('data', function(chunk) {
+            return data += chunk;
+          });
+          return res.on('end', function() {
+            var e, func, title, _i, _j, _len, _len1, _ref, _ref1, _results;
+            try {
+              callback(JSON.parse(data));
+            } catch (_error) {
+              e = _error;
+              title = data.match(/<title>([^<]+)<\/title>/);
+              if (title) {
+                _this.error("" + title[1] + " on " + url);
+              } else {
+                _this.error("Parsing error in " + url + ":\n" + e.message);
+              }
+            }
+            _this.requests -= 1;
+            _ref = _this.requestCallbacks;
+            for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+              func = _ref[_i];
+              func();
+            }
+            if (_this.requests === 0) {
+              _ref1 = _this.doneCallbacks.reverse();
+              _results = [];
+              for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
+                func = _ref1[_j];
+                _results.push(func());
+              }
+              return _results;
+            }
+          });
+        };
+      })(this));
+    },
+    sort: function(browsers) {
+      return browsers.sort(function(a, b) {
+        a = a.split(' ');
+        b = b.split(' ');
+        if (a[0] > b[0]) {
+          return 1;
+        } else if (a[0] < b[0]) {
+          return -1;
+        } else {
+          return parseFloat(a[1]) - parseFloat(b[1]);
+        }
+      });
+    },
+    parse: function(data, opts) {
+      var browser, interval, match, need, support, version, versions, _i, _len, _ref, _ref1;
+      match = opts.full ? /y\sx($|\s)/ : /\sx($|\s)/;
+      need = [];
+      _ref = data.stats;
+      for (browser in _ref) {
+        versions = _ref[browser];
+        for (interval in versions) {
+          support = versions[interval];
+          _ref1 = interval.split('-');
+          for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+            version = _ref1[_i];
+            if (this.browsers[browser] && support.match(match)) {
+              version = version.replace(/\.0$/, '');
+              need.push(this.browsers[browser] + ' ' + version);
+            }
+          }
+        }
+      }
+      return this.sort(need);
+    },
+    feature: function(file, opts, callback) {
+      var url, _ref;
+      if (!callback) {
+        _ref = [opts, {}], callback = _ref[0], opts = _ref[1];
+      }
+      url = "Fyrd/caniuse/master/features-json/" + file + ".json";
+      return this.github(url, (function(_this) {
+        return function(data) {
+          return callback(_this.parse(data, opts));
+        };
+      })(this));
+    },
+    fork: function(fork, file, opts, callback) {
+      var branch, url, user, _ref, _ref1;
+      if (!callback) {
+        _ref = [opts, {}], callback = _ref[0], opts = _ref[1];
+      }
+      _ref1 = fork.split(':'), user = _ref1[0], branch = _ref1[1];
+      branch || (branch = 'master');
+      url = "" + user + "/caniuse/" + branch + "/features-json/" + file + ".json";
+      return this.github(url, (function(_this) {
+        return function(data) {
+          return callback(_this.parse(data, opts));
+        };
+      })(this));
+    },
+    all: function(callback) {
+      var browsers, data, list, name, version, _i, _len, _ref;
+      browsers = require('../data/browsers');
+      list = [];
+      for (name in browsers) {
+        data = browsers[name];
+        _ref = data.versions;
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          version = _ref[_i];
+          list.push(name + ' ' + version);
+        }
+      }
+      return callback(this.sort(list));
+    },
+    map: function(browsers, callback) {
+      var browser, name, version, _i, _len, _ref, _results;
+      _results = [];
+      for (_i = 0, _len = browsers.length; _i < _len; _i++) {
+        browser = browsers[_i];
+        _ref = browser.split(' '), name = _ref[0], version = _ref[1];
+        version = parseFloat(version);
+        _results.push(callback(browser, name, version));
+      }
+      return _results;
+    },
+    stringify: function(obj, indent) {
+      var key, local, processed, value;
+      if (indent == null) {
+        indent = '';
+      }
+      if (obj instanceof Array) {
+        local = indent + '  ';
+        return ("[\n" + local) + obj.map((function(_this) {
+          return function(i) {
+            return _this.stringify(i, local);
+          };
+        })(this)).join("\n" + local) + ("\n" + indent + "]");
+      } else if (typeof obj === 'object') {
+        local = indent + '  ';
+        processed = [];
+        for (key in obj) {
+          value = obj[key];
+          if (key.match(/'|-|@|:/)) {
+            key = "\"" + key + "\"";
+          }
+          value = this.stringify(value, local);
+          if (value[0] !== "\n") {
+            value = ' ' + value;
+          }
+          processed.push(key + ':' + value);
+        }
+        return "\n" + local + processed.join("\n" + local) + "\n";
+      } else {
+        return JSON.stringify(obj);
+      }
+    },
+    changed: [],
+    save: function(name, json) {
+      var content, file, key, sorted, _i, _len, _ref;
+      sorted = {};
+      _ref = Object.keys(json).sort();
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        key = _ref[_i];
+        sorted[key] = json[key];
+      }
+      file = __dirname + ("/../data/" + name);
+      content = "# Don't edit this files, because it's autogenerated.\n" + "# See updaters/ dir for generator. " + "Run `bin/autoprefixer --update` to update." + "\n\n";
+      content += "module.exports =" + this.stringify(sorted) + ";\n";
+      if (fs.existsSync(file + '.js')) {
+        file += '.js';
+        content = coffee.compile(content);
+      } else {
+        file += '.coffee';
+      }
+      if (fs.readFileSync(file).toString() !== content) {
+        this.changed.push(name);
+        return fs.writeFileSync(file, content);
+      }
+    }
+  };
+
+}).call(this);