autoprefixer 6.7.6 → 7.1.0

package/lib/info.js

@@ -1,13 +1,12 @@
-(function() {
-  var browserslist, capitalize, names, prefix;
+'use strict';
 
-  browserslist = require('browserslist');
+var browserslist = require('browserslist');
 
-  capitalize = function(str) {
+function capitalize(str) {
     return str.slice(0, 1).toUpperCase() + str.slice(1);
-  };
+}
 
-  names = {
+var names = {
     ie: 'IE',
     ie_mob: 'IE Mobile',
     ios_saf: 'iOS',
@@ -16,98 +15,138 @@
     and_chr: 'Chrome for Android',
     and_ff: 'Firefox for Android',
     and_uc: 'UC for Android'
-  };
+};
 
-  prefix = function(name, prefixes) {
-    var out;
-    out = '  ' + name + ': ';
-    out += prefixes.map(function(i) {
-      return i.replace(/^-(.*)-$/g, '$1');
+var prefix = function prefix(name, prefixes) {
+    var out = '  ' + name + ': ';
+    out += prefixes.map(function (i) {
+        return i.replace(/^-(.*)-$/g, '$1');
     }).join(', ');
-    out += "\n";
+    out += '\n';
     return out;
-  };
+};
 
-  module.exports = function(prefixes) {
-    var atrules, browser, coverage, data, j, k, l, len, len1, len2, list, name, out, props, ref, ref1, ref2, ref3, ref4, ref5, round, selector, selectors, string, value, values, version, versions;
+module.exports = function (prefixes) {
     if (prefixes.browsers.selected.length === 0) {
-      return "No browsers selected";
+        return 'No browsers selected';
     }
-    versions = [];
-    ref = prefixes.browsers.selected;
-    for (j = 0, len = ref.length; j < len; j++) {
-      browser = ref[j];
-      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];
-      }
+
+    var versions = {};
+    for (var _iterator = prefixes.browsers.selected, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+        var _ref;
+
+        if (_isArray) {
+            if (_i >= _iterator.length) break;
+            _ref = _iterator[_i++];
+        } else {
+            _i = _iterator.next();
+            if (_i.done) break;
+            _ref = _i.value;
+        }
+
+        var browser = _ref;
+
+        var _browser$split = browser.split(' '),
+            name = _browser$split[0],
+            version = _browser$split[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";
+
+    var out = 'Browsers:\n';
+    for (var _browser in versions) {
+        var list = versions[_browser];
+        list = list.sort(function (a, b) {
+            return parseFloat(b) - parseFloat(a);
+        });
+        out += '  ' + _browser + ': ' + list.join(', ') + '\n';
     }
-    coverage = browserslist.coverage(prefixes.browsers.selected);
-    round = Math.round(coverage * 100) / 100.0;
-    out += "\nThese browsers account for " + round + "% of all users globally\n";
-    atrules = '';
-    ref2 = prefixes.add;
-    for (name in ref2) {
-      data = ref2[name];
-      if (name[0] === '@' && data.prefixes) {
-        atrules += prefix(name, data.prefixes);
-      }
+
+    var coverage = browserslist.coverage(prefixes.browsers.selected);
+    var round = Math.round(coverage * 100) / 100.0;
+    out += '\nThese browsers account for ' + round + '% of all users globally\n';
+
+    var atrules = '';
+    for (var name in prefixes.add) {
+        var data = prefixes.add[name];
+        if (name[0] === '@' && data.prefixes) {
+            atrules += prefix(name, data.prefixes);
+        }
     }
     if (atrules !== '') {
-      out += "\nAt-Rules:\n" + atrules;
+        out += '\nAt-Rules:\n' + atrules;
     }
-    selectors = '';
-    ref3 = prefixes.add.selectors;
-    for (k = 0, len1 = ref3.length; k < len1; k++) {
-      selector = ref3[k];
-      if (selector.prefixes) {
-        selectors += prefix(selector.name, selector.prefixes);
-      }
+
+    var selectors = '';
+    for (var _iterator2 = prefixes.add.selectors, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+        var _ref2;
+
+        if (_isArray2) {
+            if (_i2 >= _iterator2.length) break;
+            _ref2 = _iterator2[_i2++];
+        } else {
+            _i2 = _iterator2.next();
+            if (_i2.done) break;
+            _ref2 = _i2.value;
+        }
+
+        var selector = _ref2;
+
+        if (selector.prefixes) {
+            selectors += prefix(selector.name, selector.prefixes);
+        }
     }
     if (selectors !== '') {
-      out += "\nSelectors:\n" + selectors;
+        out += '\nSelectors:\n' + selectors;
     }
-    values = '';
-    props = '';
-    ref4 = prefixes.add;
-    for (name in ref4) {
-      data = ref4[name];
-      if (name[0] !== '@' && data.prefixes) {
-        props += prefix(name, data.prefixes);
-      }
-      if (!data.values) {
-        continue;
-      }
-      ref5 = data.values;
-      for (l = 0, len2 = ref5.length; l < len2; l++) {
-        value = ref5[l];
-        string = prefix(value.name, value.prefixes);
-        if (values.indexOf(string) === -1) {
-          values += string;
+
+    var values = '';
+    var props = '';
+    for (var _name in prefixes.add) {
+        var _data = prefixes.add[_name];
+        if (_name[0] !== '@' && _data.prefixes) {
+            props += prefix(_name, _data.prefixes);
+        }
+
+        if (!_data.values) {
+            continue;
+        }
+        for (var _iterator3 = _data.values, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
+            var _ref3;
+
+            if (_isArray3) {
+                if (_i3 >= _iterator3.length) break;
+                _ref3 = _iterator3[_i3++];
+            } else {
+                _i3 = _iterator3.next();
+                if (_i3.done) break;
+                _ref3 = _i3.value;
+            }
+
+            var value = _ref3;
+
+            var string = prefix(value.name, value.prefixes);
+            if (values.indexOf(string) === -1) {
+                values += string;
+            }
         }
-      }
     }
+
     if (props !== '') {
-      out += "\nProperties:\n" + props;
+        out += '\nProperties:\n' + props;
     }
     if (values !== '') {
-      out += "\nValues:\n" + values;
+        out += '\nValues:\n' + values;
     }
+
     if (atrules === '' && selectors === '' && props === '' && values === '') {
-      out += '\nAwesome! Your browsers don\'t require any vendor prefixes.' + '\nNow you can remove Autoprefixer from build steps.';
+        out += '\nAwesome! Your browsers don\'t require any vendor prefixes.' + '\nNow you can remove Autoprefixer from build steps.';
     }
-    return out;
-  };
 
-}).call(this);
+    return out;
+};

package/lib/old-selector.js

@@ -1,68 +1,94 @@
-(function() {
-  var OldSelector;
-
-  OldSelector = (function() {
-    function OldSelector(selector, prefix1) {
-      var i, len, prefix, ref;
-      this.prefix = prefix1;
-      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();
+"use strict";
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var OldSelector = function () {
+    function OldSelector(selector, prefix) {
+        _classCallCheck(this, OldSelector);
+
+        this.prefix = prefix;
+        this.prefixed = selector.prefixed(this.prefix);
+        this.regexp = selector.regexp(this.prefix);
+
+        this.prefixeds = selector.possible().map(function (x) {
+            return [selector.prefixed(x), selector.regexp(x)];
+        });
+
+        this.unprefixed = selector.name;
+        this.nameRegexp = selector.regexp();
     }
 
-    OldSelector.prototype.isHack = function(rule) {
-      var before, i, index, len, ref, ref1, regexp, rules, some, string;
-      index = rule.parent.index(rule) + 1;
-      rules = rule.parent.nodes;
-      while (index < rules.length) {
-        before = rules[index].selector;
-        if (!before) {
-          return true;
+    /**
+     * Is rule a hack without unprefixed version bottom
+     */
+
+
+    OldSelector.prototype.isHack = function isHack(rule) {
+        var index = rule.parent.index(rule) + 1;
+        var rules = rule.parent.nodes;
+
+        while (index < rules.length) {
+            var before = rules[index].selector;
+            if (!before) {
+                return true;
+            }
+
+            if (before.indexOf(this.unprefixed) !== -1 && before.match(this.nameRegexp)) {
+                return false;
+            }
+
+            var some = false;
+            for (var _iterator = this.prefixeds, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+                var _ref2;
+
+                if (_isArray) {
+                    if (_i >= _iterator.length) break;
+                    _ref2 = _iterator[_i++];
+                } else {
+                    _i = _iterator.next();
+                    if (_i.done) break;
+                    _ref2 = _i.value;
+                }
+
+                var _ref = _ref2;
+                var string = _ref[0];
+                var regexp = _ref[1];
+
+                if (before.indexOf(string) !== -1 && before.match(regexp)) {
+                    some = true;
+                    break;
+                }
+            }
+
+            if (!some) {
+                return true;
+            }
+
+            index += 1;
         }
-        if (before.indexOf(this.unprefixed) !== -1 && before.match(this.nameRegexp)) {
-          return false;
+
+        return true;
+    };
+
+    /**
+     * Does rule contain an unnecessary prefixed selector
+     */
+
+
+    OldSelector.prototype.check = function check(rule) {
+        if (rule.selector.indexOf(this.prefixed) === -1) {
+            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 (!rule.selector.match(this.regexp)) {
+            return false;
         }
-        if (!some) {
-          return true;
+        if (this.isHack(rule)) {
+            return false;
         }
-        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 true;
     };
 
     return OldSelector;
+}();
 
-  })();
-
-  module.exports = OldSelector;
-
-}).call(this);
+module.exports = OldSelector;

package/lib/old-value.js

@@ -1,30 +1,32 @@
-(function() {
-  var OldValue, utils;
+'use strict';
 
-  utils = require('./utils');
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  OldValue = (function() {
+var utils = require('./utils');
+
+var OldValue = function () {
     function OldValue(unprefixed, prefixed, string, regexp) {
-      this.unprefixed = unprefixed;
-      this.prefixed = prefixed;
-      this.string = string;
-      this.regexp = regexp;
-      this.regexp || (this.regexp = utils.regexp(this.prefixed));
-      this.string || (this.string = this.prefixed);
+        _classCallCheck(this, OldValue);
+
+        this.unprefixed = unprefixed;
+        this.prefixed = prefixed;
+        this.string = string || prefixed;
+        this.regexp = regexp || utils.regexp(prefixed);
     }
 
-    OldValue.prototype.check = function(value) {
-      if (value.indexOf(this.string) !== -1) {
-        return !!value.match(this.regexp);
-      } else {
+    /**
+     * Check, that value contain old value
+     */
+
+
+    OldValue.prototype.check = function check(value) {
+        if (value.indexOf(this.string) !== -1) {
+            return !!value.match(this.regexp);
+        }
         return false;
-      }
     };
 
     return OldValue;
+}();
 
-  })();
-
-  module.exports = OldValue;
-
-}).call(this);
+module.exports = OldValue;