autoprefixer 6.7.6 → 7.1.0

package/lib/at-rule.js

@@ -1,51 +1,68 @@
-(function() {
-  var AtRule, Prefixer,
-    extend = 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; },
-    hasProp = {}.hasOwnProperty;
+'use strict';
 
-  Prefixer = require('./prefixer');
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  AtRule = (function(superClass) {
-    extend(AtRule, superClass);
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Prefixer = require('./prefixer');
+
+var AtRule = function (_Prefixer) {
+    _inherits(AtRule, _Prefixer);
 
     function AtRule() {
-      return AtRule.__super__.constructor.apply(this, arguments);
+        _classCallCheck(this, AtRule);
+
+        return _possibleConstructorReturn(this, _Prefixer.apply(this, arguments));
     }
 
-    AtRule.prototype.add = function(rule, prefix) {
-      var already, cloned, prefixed;
-      prefixed = prefix + rule.name;
-      already = rule.parent.some(function(i) {
-        return i.name === prefixed && i.params === rule.params;
-      });
-      if (already) {
-        return;
-      }
-      cloned = this.clone(rule, {
-        name: prefixed
-      });
-      return rule.parent.insertBefore(rule, cloned);
-    };
+    /**
+     * Clone and add prefixes for at-rule
+     */
+    AtRule.prototype.add = function add(rule, prefix) {
+        var prefixed = prefix + rule.name;
 
-    AtRule.prototype.process = function(node) {
-      var j, len, parent, prefix, ref, results;
-      parent = this.parentPrefix(node);
-      ref = this.prefixes;
-      results = [];
-      for (j = 0, len = ref.length; j < len; j++) {
-        prefix = ref[j];
-        if (parent && parent !== prefix) {
-          continue;
+        var already = rule.parent.some(function (i) {
+            return i.name === prefixed && i.params === rule.params;
+        });
+        if (already) {
+            return undefined;
         }
-        results.push(this.add(node, prefix));
-      }
-      return results;
+
+        var cloned = this.clone(rule, { name: prefixed });
+        return rule.parent.insertBefore(rule, cloned);
     };
 
-    return AtRule;
+    /**
+     * Clone node with prefixes
+     */
+
 
-  })(Prefixer);
+    AtRule.prototype.process = function process(node) {
+        var parent = this.parentPrefix(node);
 
-  module.exports = AtRule;
+        for (var _iterator = this.prefixes, _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 prefix = _ref;
+
+            if (!parent || parent === prefix) {
+                this.add(node, prefix);
+            }
+        }
+    };
+
+    return AtRule;
+}(Prefixer);
 
-}).call(this);
+module.exports = AtRule;

package/lib/autoprefixer.js

@@ -1,92 +1,118 @@
-(function() {
-  var Browsers, Prefixes, browserslist, cache, isPlainObject, postcss, timeCapsule,
-    slice = [].slice;
+'use strict';
 
-  browserslist = require('browserslist');
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
 
-  postcss = require('postcss');
+var browserslist = require('browserslist');
+var postcss = require('postcss');
 
-  Browsers = require('./browsers');
+var Browsers = require('./browsers');
+var Prefixes = require('./prefixes');
 
-  Prefixes = require('./prefixes');
-
-  isPlainObject = function(obj) {
+function isPlainObject(obj) {
     return Object.prototype.toString.apply(obj) === '[object Object]';
-  };
+}
 
-  cache = {};
+var cache = {};
 
-  timeCapsule = function(result, prefixes) {
+function timeCapsule(result, prefixes) {
     if (prefixes.browsers.selected.length === 0) {
-      return;
+        return;
     }
     if (prefixes.add.selectors.length > 0) {
-      return;
+        return;
     }
     if (Object.keys(prefixes.add).length > 2) {
-      return;
+        return;
     }
-    return result.warn('Greetings, time traveller. ' + 'We are in the golden age of prefix-less CSS, ' + 'where Autoprefixer is no longer needed for your stylesheet.');
-  };
 
-  module.exports = postcss.plugin('autoprefixer', function() {
-    var loadPrefixes, options, plugin, reqs;
-    reqs = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+    result.warn('Greetings, time traveller. ' + 'We are in the golden age of prefix-less CSS, ' + 'where Autoprefixer is no longer needed for your stylesheet.');
+}
+
+module.exports = postcss.plugin('autoprefixer', function () {
+    for (var _len = arguments.length, reqs = Array(_len), _key = 0; _key < _len; _key++) {
+        reqs[_key] = arguments[_key];
+    }
+
+    var options = void 0;
     if (reqs.length === 1 && isPlainObject(reqs[0])) {
-      options = reqs[0];
-      reqs = void 0;
-    } else if (reqs.length === 0 || (reqs.length === 1 && (reqs[0] == null))) {
-      reqs = void 0;
-    } else if (reqs.length <= 2 && (reqs[0] instanceof Array || (reqs[0] == null))) {
-      options = reqs[1];
-      reqs = reqs[0];
-    } else if (typeof reqs[reqs.length - 1] === 'object') {
-      options = reqs.pop();
+        options = reqs[0];
+        reqs = undefined;
+    } else if (reqs.length === 0 || reqs.length === 1 && !reqs[0]) {
+        reqs = undefined;
+    } else if (reqs.length <= 2 && (reqs[0] instanceof Array || !reqs[0])) {
+        options = reqs[1];
+        reqs = reqs[0];
+    } else if (_typeof(reqs[reqs.length - 1]) === 'object') {
+        options = reqs.pop();
     }
-    options || (options = {});
+
+    if (!options) {
+        options = {};
+    }
+
     if (options.browser) {
-      throw new Error('Change `browser` option to `browsers` in Autoprefixer');
+        throw new Error('Change `browser` option to `browsers` in Autoprefixer');
+    }
+
+    if (options.browsers) {
+        reqs = options.browsers;
     }
-    if (options.browsers != null) {
-      reqs = options.browsers;
+
+    if (typeof options.grid === 'undefined') {
+        options.grid = false;
     }
-    loadPrefixes = function(opts) {
-      var browsers, key, stats;
-      stats = options.stats;
-      browsers = new Browsers(module.exports.data.browsers, reqs, opts, stats);
-      key = browsers.selected.join(', ') + JSON.stringify(options);
-      return cache[key] || (cache[key] = new Prefixes(module.exports.data.prefixes, browsers, options));
+
+    var loadPrefixes = function loadPrefixes(opts) {
+        var data = module.exports.data;
+        var browsers = new Browsers(data.browsers, reqs, opts, options.stats);
+        var key = browsers.selected.join(', ') + JSON.stringify(options);
+
+        if (!cache[key]) {
+            cache[key] = new Prefixes(data.prefixes, browsers, options);
+        }
+
+        return cache[key];
     };
-    plugin = function(css, result) {
-      var prefixes, ref;
-      prefixes = loadPrefixes({
-        from: (ref = css.source) != null ? ref.input.file : void 0,
-        env: options.env
-      });
-      timeCapsule(result, prefixes);
-      if (options.remove !== false) {
-        prefixes.processor.remove(css);
-      }
-      if (options.add !== false) {
-        return prefixes.processor.add(css, result);
-      }
+
+    var plugin = function plugin(css, result) {
+        var prefixes = loadPrefixes({
+            from: css.source && css.source.input.file,
+            env: options.env
+        });
+        timeCapsule(result, prefixes);
+        if (options.remove !== false) {
+            prefixes.processor.remove(css);
+        }
+        if (options.add !== false) {
+            prefixes.processor.add(css, result);
+        }
     };
+
     plugin.options = options;
-    plugin.info = function(opts) {
-      return require('./info')(loadPrefixes(opts));
+
+    plugin.info = function (opts) {
+        return require('./info')(loadPrefixes(opts));
     };
+
     return plugin;
-  });
+});
 
-  module.exports.data = {
-    browsers: require('caniuse-db/data.json').agents,
+/**
+ * Autoprefixer data
+ */
+module.exports.data = {
+    browsers: require('caniuse-lite').agents,
     prefixes: require('../data/prefixes')
-  };
+};
 
-  module.exports.defaults = browserslist.defaults;
+/**
+ * Autoprefixer default browsers
+ */
+module.exports.defaults = browserslist.defaults;
 
-  module.exports.info = function() {
+/**
+ * Inspect with default Autoprefixer
+ */
+module.exports.info = function () {
     return module.exports().info();
-  };
-
-}).call(this);
+};

package/lib/brackets.js

@@ -1,46 +1,66 @@
-(function() {
-  var brackets, last;
+'use strict';
 
-  last = function(array) {
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+var last = function last(array) {
     return array[array.length - 1];
-  };
-
-  brackets = {
-    parse: function(str) {
-      var current, j, len, stack, sym;
-      current = [''];
-      stack = [current];
-      for (j = 0, len = str.length; j < len; j++) {
-        sym = str[j];
-        if (sym === '(') {
-          current = [''];
-          last(stack).push(current);
-          stack.push(current);
-        } else if (sym === ')') {
-          stack.pop();
-          current = last(stack);
-          current.push('');
-        } else {
-          current[current.length - 1] += sym;
+};
+
+var brackets = {
+
+    /**
+     * Parse string to nodes tree
+     */
+    parse: function parse(str) {
+        var current = [''];
+        var stack = [current];
+
+        for (var i = 0; i < str.length; i++) {
+            var sym = str[i];
+            if (sym === '(') {
+                current = [''];
+                last(stack).push(current);
+                stack.push(current);
+            } else if (sym === ')') {
+                stack.pop();
+                current = last(stack);
+                current.push('');
+            } else {
+                current[current.length - 1] += sym;
+            }
         }
-      }
-      return stack[0];
+
+        return stack[0];
     },
-    stringify: function(ast) {
-      var i, j, len, result;
-      result = '';
-      for (j = 0, len = ast.length; j < len; j++) {
-        i = ast[j];
-        if (typeof i === 'object') {
-          result += '(' + brackets.stringify(i) + ')';
-        } else {
-          result += i;
+
+
+    /**
+     * Generate output string by nodes tree
+     */
+    stringify: function stringify(ast) {
+        var result = '';
+        for (var _iterator = ast, _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 i = _ref;
+
+            if ((typeof i === 'undefined' ? 'undefined' : _typeof(i)) === 'object') {
+                result += '(' + brackets.stringify(i) + ')';
+            } else {
+                result += i;
+            }
         }
-      }
-      return result;
+        return result;
     }
-  };
-
-  module.exports = brackets;
+};
 
-}).call(this);
+module.exports = brackets;

package/lib/browsers.js

@@ -1,86 +1,123 @@
-(function() {
-  var Browsers, browserslist, utils;
+'use strict';
 
-  browserslist = require('browserslist');
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  utils = require('./utils');
+var browserslist = require('browserslist');
 
-  Browsers = (function() {
-    Browsers.prefixes = function() {
-      var data, i, name;
-      if (this.prefixesCache) {
-        return this.prefixesCache;
-      }
-      data = require('caniuse-db/data.json').agents;
-      return this.prefixesCache = utils.uniq((function() {
-        var results;
-        results = [];
-        for (name in data) {
-          i = data[name];
-          results.push("-" + i.prefix + "-");
+var utils = require('./utils');
+
+var Browsers = function () {
+
+    /**
+     * Return all prefixes for default browser data
+     */
+    Browsers.prefixes = function prefixes() {
+        if (this.prefixesCache) {
+            return this.prefixesCache;
+        }
+
+        var data = require('caniuse-lite').agents;
+
+        this.prefixesCache = [];
+        for (var name in data) {
+            this.prefixesCache.push('-' + data[name].prefix + '-');
         }
-        return results;
-      })()).sort(function(a, b) {
-        return b.length - a.length;
-      });
+
+        this.prefixesCache = utils.uniq(this.prefixesCache).sort(function (a, b) {
+            return b.length - a.length;
+        });
+
+        return this.prefixesCache;
     };
 
-    Browsers.withPrefix = function(value) {
-      if (!this.prefixesRegexp) {
-        this.prefixesRegexp = RegExp("" + (this.prefixes().join('|')));
-      }
-      return this.prefixesRegexp.test(value);
+    /**
+     * Check is value contain any possibe prefix
+     */
+
+
+    Browsers.withPrefix = function withPrefix(value) {
+        if (!this.prefixesRegexp) {
+            this.prefixesRegexp = new RegExp(this.prefixes().join('|'));
+        }
+
+        return this.prefixesRegexp.test(value);
     };
 
-    function Browsers(data1, requirements, options, stats) {
-      this.data = data1;
-      this.options = options;
-      this.stats = stats;
-      this.selected = this.parse(requirements);
+    function Browsers(data, requirements, options, stats) {
+        _classCallCheck(this, Browsers);
+
+        this.data = data;
+        this.options = options || {};
+        this.stats = stats;
+        this.selected = this.parse(requirements);
     }
 
-    Browsers.prototype.parse = function(requirements) {
-      var ref, ref1;
-      return browserslist(requirements, {
-        stats: this.stats,
-        path: (ref = this.options) != null ? ref.from : void 0,
-        env: (ref1 = this.options) != null ? ref1.env : void 0
-      });
-    };
+    /**
+     * Return browsers selected by requirements
+     */
 
-    Browsers.prototype.browsers = function(criteria) {
-      var browser, data, ref, selected, versions;
-      selected = [];
-      ref = this.data;
-      for (browser in ref) {
-        data = ref[browser];
-        versions = criteria(data).map(function(version) {
-          return browser + " " + version;
+
+    Browsers.prototype.parse = function parse(requirements) {
+        return browserslist(requirements, {
+            stats: this.stats,
+            path: this.options.from,
+            env: this.options.env
         });
-        selected = selected.concat(versions);
-      }
-      return selected;
     };
 
-    Browsers.prototype.prefix = function(browser) {
-      var data, name, prefix, ref, version;
-      ref = browser.split(' '), name = ref[0], version = ref[1];
-      data = this.data[name];
-      if (data.prefix_exceptions) {
-        prefix = data.prefix_exceptions[version];
-      }
-      prefix || (prefix = data.prefix);
-      return '-' + prefix + '-';
+    /**
+     * Select major browsers versions by criteria
+     */
+
+
+    Browsers.prototype.browsers = function browsers(criteria) {
+        var _this = this;
+
+        var selected = [];
+
+        var _loop = function _loop(browser) {
+            var data = _this.data[browser];
+            var versions = criteria(data).map(function (version) {
+                return browser + ' ' + version;
+            });
+            selected = selected.concat(versions);
+        };
+
+        for (var browser in this.data) {
+            _loop(browser);
+        }
+        return selected;
     };
 
-    Browsers.prototype.isSelected = function(browser) {
-      return this.selected.indexOf(browser) !== -1;
+    /**
+     * Return prefix for selected browser
+     */
+
+
+    Browsers.prototype.prefix = function prefix(browser) {
+        var _browser$split = browser.split(' '),
+            name = _browser$split[0],
+            version = _browser$split[1];
+
+        var data = this.data[name];
+
+        var prefix = data.prefix_exceptions && data.prefix_exceptions[version];
+        if (!prefix) {
+            prefix = data.prefix;
+        }
+        return '-' + prefix + '-';
     };
 
-    return Browsers;
+    /**
+     * Is browser is selected by requirements
+     */
+
 
-  })();
+    Browsers.prototype.isSelected = function isSelected(browser) {
+        return this.selected.indexOf(browser) !== -1;
+    };
 
-  module.exports = Browsers;
+    return Browsers;
+}();
 
-}).call(this);
+module.exports = Browsers;