pleeease 0.0.2

data/node_modules/pleeease/node_modules/autoprefixer/lib/hacks/transform-value.js

@@ -0,0 +1,31 @@
+(function() {
+  var TransformValue, Value,
+    __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; };
+
+  Value = require('../value');
+
+  TransformValue = (function(_super) {
+    __extends(TransformValue, _super);
+
+    function TransformValue() {
+      return TransformValue.__super__.constructor.apply(this, arguments);
+    }
+
+    TransformValue.names = ['transform'];
+
+    TransformValue.prototype.replace = function(value, prefix) {
+      if (prefix === '-ms-') {
+        return value;
+      } else {
+        return TransformValue.__super__.replace.apply(this, arguments);
+      }
+    };
+
+    return TransformValue;
+
+  })(Value);
+
+  module.exports = TransformValue;
+
+}).call(this);

data/node_modules/pleeease/node_modules/autoprefixer/lib/hacks/transition.js

@@ -0,0 +1,37 @@
+(function() {
+  var OldValue, Transition, Value,
+    __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; };
+
+  OldValue = require('../old-value');
+
+  Value = require('../value');
+
+  Transition = (function(_super) {
+    __extends(Transition, _super);
+
+    function Transition() {
+      return Transition.__super__.constructor.apply(this, arguments);
+    }
+
+    Transition.names = ['flex', 'flex-grow', 'flex-shrink', 'flex-basis'];
+
+    Transition.prototype.prefixed = function(prefix) {
+      return this.all.prefixed(this.name, prefix);
+    };
+
+    Transition.prototype.replace = function(string, prefix) {
+      return string.replace(this.regexp(), '$1' + this.prefixed(prefix) + '$3');
+    };
+
+    Transition.prototype.old = function(prefix) {
+      return new OldValue(this.prefixed(prefix));
+    };
+
+    return Transition;
+
+  })(Value);
+
+  module.exports = Transition;
+
+}).call(this);

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

@@ -0,0 +1,114 @@
+(function() {
+  var capitalize, names, prefix;
+
+  capitalize = function(str) {
+    return str.slice(0, 1).toUpperCase() + str.slice(1);
+  };
+
+  names = {
+    ie: 'IE',
+    ff: 'Firefox',
+    ios: 'iOS'
+  };
+
+  prefix = function(name, transition, prefixes) {
+    var out;
+    out = '  ' + name + (transition ? '*' : '') + ': ';
+    out += prefixes.map(function(i) {
+      return i.replace(/^-(.*)-$/g, '$1');
+    }).join(', ');
+    out += "\n";
+    return out;
+  };
+
+  module.exports = function(prefixes) {
+    var atrules, browser, data, list, name, needTransition, out, props, selector, selectors, string, transitionProp, useTransition, value, values, version, versions, _i, _j, _k, _len, _len1, _len2, _ref, _ref1, _ref2, _ref3, _ref4, _ref5, _ref6;
+    if (prefixes.browsers.selected.length === 0) {
+      return "No browsers selected";
+    }
+    versions = [];
+    _ref = prefixes.browsers.selected;
+    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+      browser = _ref[_i];
+      _ref1 = browser.split(' '), name = _ref1[0], version = _ref1[1];
+      name = names[name] || capitalize(name);
+      if (versions[name]) {
+        versions[name].push(version);
+      } else {
+        versions[name] = [version];
+      }
+    }
+    out = "Browsers:\n";
+    for (browser in versions) {
+      list = versions[browser];
+      list = list.sort(function(a, b) {
+        return parseFloat(b) - parseFloat(a);
+      });
+      out += '  ' + browser + ': ' + list.join(', ') + "\n";
+    }
+    atrules = '';
+    _ref2 = prefixes.add;
+    for (name in _ref2) {
+      data = _ref2[name];
+      if (name[0] === '@' && data.prefixes) {
+        atrules += prefix(name, false, data.prefixes);
+      }
+    }
+    if (atrules !== '') {
+      out += "\nAt-Rules:\n" + atrules;
+    }
+    selectors = '';
+    _ref3 = prefixes.add.selectors;
+    for (_j = 0, _len1 = _ref3.length; _j < _len1; _j++) {
+      selector = _ref3[_j];
+      if (selector.prefixes) {
+        selectors += prefix(selector.name, false, selector.prefixes);
+      }
+    }
+    if (selectors !== '') {
+      out += "\nSelectors:\n" + selectors;
+    }
+    values = '';
+    props = '';
+    useTransition = false;
+    needTransition = (_ref4 = prefixes.add.transition) != null ? _ref4.prefixes : void 0;
+    _ref5 = prefixes.add;
+    for (name in _ref5) {
+      data = _ref5[name];
+      if (name[0] !== '@' && data.prefixes) {
+        transitionProp = needTransition && prefixes.data[name].transition;
+        if (transitionProp) {
+          useTransition = true;
+        }
+        props += prefix(name, transitionProp, data.prefixes);
+      }
+      if (!data.values) {
+        continue;
+      }
+      if (prefixes.transitionProps.some(function(i) {
+        return i === name;
+      })) {
+        continue;
+      }
+      _ref6 = data.values;
+      for (_k = 0, _len2 = _ref6.length; _k < _len2; _k++) {
+        value = _ref6[_k];
+        string = prefix(value.name, false, value.prefixes);
+        if (values.indexOf(string) === -1) {
+          values += string;
+        }
+      }
+    }
+    if (useTransition) {
+      props += "  * - can be used in transition\n";
+    }
+    if (props !== '') {
+      out += "\nProperties:\n" + props;
+    }
+    if (values !== '') {
+      out += "\nValues:\n" + values;
+    }
+    return out;
+  };
+
+}).call(this);

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

@@ -0,0 +1,40 @@
+(function() {
+  var Keyframes, Prefixer,
+    __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; };
+
+  Prefixer = require('./prefixer');
+
+  Keyframes = (function(_super) {
+    __extends(Keyframes, _super);
+
+    function Keyframes() {
+      return Keyframes.__super__.constructor.apply(this, arguments);
+    }
+
+    Keyframes.prototype.check = function(atRule) {
+      return atRule.name === 'keyframes';
+    };
+
+    Keyframes.prototype.add = function(atRule, prefix) {
+      var already, cloned, prefixed;
+      prefixed = prefix + atRule.name;
+      already = atRule.parent.some(function(i) {
+        return i.name === prefixed && i.params === atRule.params;
+      });
+      if (already) {
+        return;
+      }
+      cloned = this.clone(atRule, {
+        name: prefixed
+      });
+      return atRule.parent.insertBefore(atRule, cloned);
+    };
+
+    return Keyframes;
+
+  })(Prefixer);
+
+  module.exports = Keyframes;
+
+}).call(this);

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

@@ -0,0 +1,68 @@
+(function() {
+  var OldSelector;
+
+  OldSelector = (function() {
+    function OldSelector(selector, prefix) {
+      var _i, _len, _ref;
+      this.prefix = prefix;
+      this.prefixed = selector.prefixed(this.prefix);
+      this.regexp = selector.regexp(this.prefix);
+      this.prefixeds = [];
+      _ref = selector.possible();
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        prefix = _ref[_i];
+        this.prefixeds.push([selector.prefixed(prefix), selector.regexp(prefix)]);
+      }
+      this.unprefixed = selector.name;
+      this.nameRegexp = selector.regexp();
+    }
+
+    OldSelector.prototype.isHack = function(rule) {
+      var before, index, regexp, rules, some, string, _i, _len, _ref, _ref1;
+      index = rule.parent.index(rule) + 1;
+      rules = rule.parent.rules;
+      while (index < rules.length) {
+        before = rules[index].selector;
+        if (!before) {
+          return true;
+        }
+        if (before.indexOf(this.unprefixed) !== -1 && before.match(this.nameRegexp)) {
+          return false;
+        }
+        some = false;
+        _ref = this.prefixeds;
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          _ref1 = _ref[_i], string = _ref1[0], regexp = _ref1[1];
+          if (before.indexOf(string) !== -1 && before.match(regexp)) {
+            some = true;
+            break;
+          }
+        }
+        if (!some) {
+          return true;
+        }
+        index += 1;
+      }
+      return true;
+    };
+
+    OldSelector.prototype.check = function(rule) {
+      if (rule.selector.indexOf(this.prefixed) === -1) {
+        return false;
+      }
+      if (!rule.selector.match(this.regexp)) {
+        return false;
+      }
+      if (this.isHack(rule)) {
+        return false;
+      }
+      return true;
+    };
+
+    return OldSelector;
+
+  })();
+
+  module.exports = OldSelector;
+
+}).call(this);

data/node_modules/pleeease/node_modules/autoprefixer/lib/old-value.js

@@ -0,0 +1,29 @@
+(function() {
+  var OldValue, utils;
+
+  utils = require('./utils');
+
+  OldValue = (function() {
+    function OldValue(name, string, regexp) {
+      this.name = name;
+      this.string = string;
+      this.regexp = regexp;
+      this.regexp || (this.regexp = utils.regexp(this.name));
+      this.string || (this.string = this.name);
+    }
+
+    OldValue.prototype.check = function(value) {
+      if (value.indexOf(this.string) !== -1) {
+        return !!value.match(this.regexp);
+      } else {
+        return false;
+      }
+    };
+
+    return OldValue;
+
+  })();
+
+  module.exports = OldValue;
+
+}).call(this);

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

@@ -0,0 +1,88 @@
+(function() {
+  var Browsers, Prefixer, utils, vendor;
+
+  Browsers = require('./browsers');
+
+  vendor = require('postcss/lib/vendor');
+
+  utils = require('./utils');
+
+  Prefixer = (function() {
+    Prefixer.hack = function(klass) {
+      var name, _i, _len, _ref, _results;
+      this.hacks || (this.hacks = {});
+      _ref = klass.names;
+      _results = [];
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        name = _ref[_i];
+        _results.push(this.hacks[name] = klass);
+      }
+      return _results;
+    };
+
+    Prefixer.load = function(name, prefixes, all) {
+      var klass, _ref;
+      klass = (_ref = this.hacks) != null ? _ref[name] : void 0;
+      if (klass) {
+        return new klass(name, prefixes, all);
+      } else {
+        return new this(name, prefixes, all);
+      }
+    };
+
+    Prefixer.clone = function(node, overrides) {
+      var cloned;
+      cloned = node.clone(overrides);
+      delete cloned._autoprefixerPrefix;
+      delete cloned._autoprefixerValues;
+      return cloned;
+    };
+
+    function Prefixer(name, prefixes, all) {
+      this.name = name;
+      this.prefixes = prefixes;
+      this.all = all;
+    }
+
+    Prefixer.prototype.parentPrefix = function(node) {
+      var prefix;
+      prefix = node._autoprefixerPrefix != null ? node._autoprefixerPrefix : node.type === 'decl' && node.prop[0] === '-' ? vendor.prefix(node.prop) : node.type === 'root' ? false : node.type === 'rule' && node.selector.indexOf(':-') !== -1 ? node.selector.match(/:(-\w+-)/)[1] : node.type === 'atrule' && node.name[0] === '-' ? vendor.prefix(node.name) : this.parentPrefix(node.parent);
+      if (Browsers.prefixes().indexOf(prefix) === -1) {
+        prefix = false;
+      }
+      return node._autoprefixerPrefix = prefix;
+    };
+
+    Prefixer.prototype.process = function(node) {
+      var parent, prefix, prefixes, _i, _j, _len, _len1, _ref;
+      if (!this.check(node)) {
+        return;
+      }
+      parent = this.parentPrefix(node);
+      prefixes = [];
+      _ref = this.prefixes;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        prefix = _ref[_i];
+        if (parent && parent !== utils.removeNote(prefix)) {
+          continue;
+        }
+        prefixes.push(prefix);
+      }
+      for (_j = 0, _len1 = prefixes.length; _j < _len1; _j++) {
+        prefix = prefixes[_j];
+        this.add(node, prefix, prefixes);
+      }
+      return prefixes;
+    };
+
+    Prefixer.prototype.clone = function(node, overrides) {
+      return Prefixer.clone(node, overrides);
+    };
+
+    return Prefixer;
+
+  })();
+
+  module.exports = Prefixer;
+
+}).call(this);

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

@@ -0,0 +1,334 @@
+(function() {
+  var Browsers, Declaration, Keyframes, Prefixes, Processor, Selector, Value, declsCache, utils, vendor;
+
+  utils = require('./utils');
+
+  vendor = require('postcss/lib/vendor');
+
+  Declaration = require('./declaration');
+
+  Processor = require('./processor');
+
+  Keyframes = require('./keyframes');
+
+  Browsers = require('./browsers');
+
+  Selector = require('./selector');
+
+  Value = require('./value');
+
+  Selector.hack(require('./hacks/fullscreen'));
+
+  Selector.hack(require('./hacks/placeholder'));
+
+  Declaration.hack(require('./hacks/flex'));
+
+  Declaration.hack(require('./hacks/order'));
+
+  Declaration.hack(require('./hacks/filter'));
+
+  Declaration.hack(require('./hacks/flex-flow'));
+
+  Declaration.hack(require('./hacks/flex-grow'));
+
+  Declaration.hack(require('./hacks/flex-wrap'));
+
+  Declaration.hack(require('./hacks/align-self'));
+
+  Declaration.hack(require('./hacks/flex-basis'));
+
+  Declaration.hack(require('./hacks/align-items'));
+
+  Declaration.hack(require('./hacks/flex-shrink'));
+
+  Declaration.hack(require('./hacks/break-inside'));
+
+  Declaration.hack(require('./hacks/border-image'));
+
+  Declaration.hack(require('./hacks/align-content'));
+
+  Declaration.hack(require('./hacks/border-radius'));
+
+  Declaration.hack(require('./hacks/transform-decl'));
+
+  Declaration.hack(require('./hacks/flex-direction'));
+
+  Declaration.hack(require('./hacks/justify-content'));
+
+  Value.hack(require('./hacks/gradient'));
+
+  Value.hack(require('./hacks/transition'));
+
+  Value.hack(require('./hacks/display-flex'));
+
+  Value.hack(require('./hacks/fill-available'));
+
+  Value.hack(require('./hacks/transform-value'));
+
+  declsCache = {};
+
+  Prefixes = (function() {
+    function Prefixes(data, browsers, options) {
+      var _ref;
+      this.data = data;
+      this.browsers = browsers;
+      this.options = options != null ? options : {};
+      _ref = this.preprocess(this.select(this.data)), this.add = _ref[0], this.remove = _ref[1];
+      this.processor = new Processor(this);
+    }
+
+    Prefixes.prototype.transitionProps = ['transition', 'transition-property'];
+
+    Prefixes.prototype.select = function(list) {
+      var add, all, data, name, notes, selected;
+      selected = {
+        add: {},
+        remove: {}
+      };
+      for (name in list) {
+        data = list[name];
+        add = data.browsers.map(function(i) {
+          var params;
+          params = i.split(' ');
+          return {
+            browser: params[0] + ' ' + params[1],
+            note: params[2]
+          };
+        });
+        notes = add.filter(function(i) {
+          return i.note;
+        }).map((function(_this) {
+          return function(i) {
+            return _this.browsers.prefix(i.browser) + ' ' + i.note;
+          };
+        })(this));
+        notes = utils.uniq(notes);
+        add = add.filter((function(_this) {
+          return function(i) {
+            return _this.browsers.isSelected(i.browser);
+          };
+        })(this)).map((function(_this) {
+          return function(i) {
+            var prefix;
+            prefix = _this.browsers.prefix(i.browser);
+            if (i.note) {
+              return prefix + ' ' + i.note;
+            } else {
+              return prefix;
+            }
+          };
+        })(this));
+        add = this.sort(utils.uniq(add));
+        all = data.browsers.map((function(_this) {
+          return function(i) {
+            return _this.browsers.prefix(i);
+          };
+        })(this));
+        if (data.mistakes) {
+          all = all.concat(data.mistakes);
+        }
+        all = all.concat(notes);
+        all = utils.uniq(all);
+        if (add.length) {
+          selected.add[name] = add;
+          if (add.length < all.length) {
+            selected.remove[name] = all.filter(function(i) {
+              return add.indexOf(i) === -1;
+            });
+          }
+        } else {
+          selected.remove[name] = all;
+        }
+      }
+      return selected;
+    };
+
+    Prefixes.prototype.sort = function(prefixes) {
+      return prefixes.sort(function(a, b) {
+        var aLength, bLength;
+        aLength = utils.removeNote(a).length;
+        bLength = utils.removeNote(b).length;
+        if (aLength === bLength) {
+          return b.length - a.length;
+        } else {
+          return bLength - aLength;
+        }
+      });
+    };
+
+    Prefixes.prototype.preprocess = function(selected) {
+      var add, name, old, olds, prefix, prefixed, prefixes, prop, props, remove, selector, value, values, _i, _j, _k, _l, _len, _len1, _len2, _len3, _len4, _len5, _len6, _m, _n, _o, _ref, _ref1, _ref2;
+      add = {
+        selectors: []
+      };
+      _ref = selected.add;
+      for (name in _ref) {
+        prefixes = _ref[name];
+        if (name === '@keyframes') {
+          add[name] = new Keyframes(name, prefixes, this);
+        } else if (this.data[name].selector) {
+          add.selectors.push(Selector.load(name, prefixes, this));
+        } else {
+          props = this.data[name].transition ? this.transitionProps : this.data[name].props;
+          if (props) {
+            value = Value.load(name, prefixes, this);
+            for (_i = 0, _len = props.length; _i < _len; _i++) {
+              prop = props[_i];
+              if (!add[prop]) {
+                add[prop] = {
+                  values: []
+                };
+              }
+              add[prop].values.push(value);
+            }
+          }
+          if (!this.data[name].props) {
+            values = ((_ref1 = add[name]) != null ? _ref1.values : void 0) || [];
+            add[name] = Declaration.load(name, prefixes, this);
+            add[name].values = values;
+          }
+        }
+      }
+      remove = {
+        selectors: []
+      };
+      _ref2 = selected.remove;
+      for (name in _ref2) {
+        prefixes = _ref2[name];
+        if (this.data[name].selector) {
+          selector = Selector.load(name, prefixes);
+          for (_j = 0, _len1 = prefixes.length; _j < _len1; _j++) {
+            prefix = prefixes[_j];
+            remove.selectors.push(selector.old(prefix));
+          }
+        } else if (name[0] === '@') {
+          for (_k = 0, _len2 = prefixes.length; _k < _len2; _k++) {
+            prefix = prefixes[_k];
+            prefixed = '@' + prefix + name.slice(1);
+            remove[prefixed] = {
+              remove: true
+            };
+          }
+        } else {
+          props = this.data[name].transition ? this.transitionProps : this.data[name].props;
+          if (props) {
+            value = Value.load(name, [], this);
+            for (_l = 0, _len3 = prefixes.length; _l < _len3; _l++) {
+              prefix = prefixes[_l];
+              old = value.old(prefix);
+              if (old) {
+                for (_m = 0, _len4 = props.length; _m < _len4; _m++) {
+                  prop = props[_m];
+                  if (!remove[prop]) {
+                    remove[prop] = {};
+                  }
+                  if (!remove[prop].values) {
+                    remove[prop].values = [];
+                  }
+                  remove[prop].values.push(old);
+                }
+              }
+            }
+          }
+          if (!this.data[name].props) {
+            for (_n = 0, _len5 = prefixes.length; _n < _len5; _n++) {
+              prefix = prefixes[_n];
+              prop = vendor.unprefixed(name);
+              olds = this.decl(name).old(name, prefix);
+              for (_o = 0, _len6 = olds.length; _o < _len6; _o++) {
+                prefixed = olds[_o];
+                if (!remove[prefixed]) {
+                  remove[prefixed] = {};
+                }
+                remove[prefixed].remove = true;
+              }
+            }
+          }
+        }
+      }
+      return [add, remove];
+    };
+
+    Prefixes.prototype.decl = function(prop) {
+      var decl;
+      decl = declsCache[prop];
+      if (decl) {
+        return decl;
+      } else {
+        return declsCache[prop] = Declaration.load(prop);
+      }
+    };
+
+    Prefixes.prototype.unprefixed = function(prop) {
+      prop = vendor.unprefixed(prop);
+      return this.decl(prop).normalize(prop);
+    };
+
+    Prefixes.prototype.prefixed = function(prop, prefix) {
+      prop = vendor.unprefixed(prop);
+      return this.decl(prop).prefixed(prop, prefix);
+    };
+
+    Prefixes.prototype.values = function(type, prop) {
+      var data, global, values, _ref, _ref1;
+      data = this[type];
+      global = (_ref = data['*']) != null ? _ref.values : void 0;
+      values = (_ref1 = data[prop]) != null ? _ref1.values : void 0;
+      if (global && values) {
+        return utils.uniq(global.concat(values));
+      } else {
+        return global || values || [];
+      }
+    };
+
+    Prefixes.prototype.group = function(decl) {
+      var checker, index, length, rule, unprefixed;
+      rule = decl.parent;
+      index = rule.index(decl);
+      length = rule.decls.length;
+      unprefixed = this.unprefixed(decl.prop);
+      checker = (function(_this) {
+        return function(step, callback) {
+          var other;
+          index += step;
+          while (index >= 0 && index < length) {
+            other = rule.decls[index];
+            if (other.type === 'decl') {
+              if (step === -1 && other.prop === unprefixed) {
+                if (!Browsers.withPrefix(other.value)) {
+                  break;
+                }
+              }
+              if (_this.unprefixed(other.prop) !== unprefixed) {
+                break;
+              } else if (callback(other) === true) {
+                return true;
+              }
+              if (step === +1 && other.prop === unprefixed) {
+                if (!Browsers.withPrefix(other.value)) {
+                  break;
+                }
+              }
+            }
+            index += step;
+          }
+          return false;
+        };
+      })(this);
+      return {
+        up: function(callback) {
+          return checker(-1, callback);
+        },
+        down: function(callback) {
+          return checker(+1, callback);
+        }
+      };
+    };
+
+    return Prefixes;
+
+  })();
+
+  module.exports = Prefixes;
+
+}).call(this);