autoprefixer 6.7.7 → 7.1.1

package/lib/resolution.js

@@ -1,98 +1,158 @@
-(function() {
-  var Prefixer, Resolution, n2f, regexp, split, utils,
-    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"); } }
 
-  utils = require('./utils');
+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; }
 
-  n2f = require('num2fraction');
+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; }
 
-  regexp = /(min|max)-resolution\s*:\s*\d*\.?\d+(dppx|dpi)/gi;
+var Prefixer = require('./prefixer');
+var utils = require('./utils');
 
-  split = /(min|max)-resolution(\s*:\s*)(\d*\.?\d+)(dppx|dpi)/i;
+var n2f = require('num2fraction');
 
-  Resolution = (function(superClass) {
-    extend(Resolution, superClass);
+var regexp = /(min|max)-resolution\s*:\s*\d*\.?\d+(dppx|dpi)/gi;
+var split = /(min|max)-resolution(\s*:\s*)(\d*\.?\d+)(dppx|dpi)/i;
+
+var Resolution = function (_Prefixer) {
+    _inherits(Resolution, _Prefixer);
 
     function Resolution() {
-      return Resolution.__super__.constructor.apply(this, arguments);
+        _classCallCheck(this, Resolution);
+
+        return _possibleConstructorReturn(this, _Prefixer.apply(this, arguments));
     }
 
-    Resolution.prototype.prefixName = function(prefix, name) {
-      return name = prefix === '-moz-' ? name + '--moz-device-pixel-ratio' : prefix + name + '-device-pixel-ratio';
+    /**
+     * Return prefixed query name
+     */
+    Resolution.prototype.prefixName = function prefixName(prefix, name) {
+        var newName = prefix === '-moz-' ? name + '--moz-device-pixel-ratio' : prefix + name + '-device-pixel-ratio';
+        return newName;
     };
 
-    Resolution.prototype.prefixQuery = function(prefix, name, colon, value, units) {
-      if (units === 'dpi') {
-        value = Number(value / 96);
-      }
-      if (prefix === '-o-') {
-        value = n2f(value);
-      }
-      return this.prefixName(prefix, name) + colon + value;
-    };
+    /**
+     * Return prefixed query
+     */
 
-    Resolution.prototype.clean = function(rule) {
-      var j, len, prefix, ref;
-      if (!this.bad) {
-        this.bad = [];
-        ref = this.prefixes;
-        for (j = 0, len = ref.length; j < len; j++) {
-          prefix = ref[j];
-          this.bad.push(this.prefixName(prefix, 'min'));
-          this.bad.push(this.prefixName(prefix, 'max'));
+
+    Resolution.prototype.prefixQuery = function prefixQuery(prefix, name, colon, value, units) {
+        if (units === 'dpi') {
+            value = Number(value / 96);
         }
-      }
-      return rule.params = utils.editList(rule.params, (function(_this) {
-        return function(queries) {
-          return queries.filter(function(query) {
-            return _this.bad.every(function(i) {
-              return query.indexOf(i) === -1;
-            });
-          });
-        };
-      })(this));
+        if (prefix === '-o-') {
+            value = n2f(value);
+        }
+        return this.prefixName(prefix, name) + colon + value;
     };
 
-    Resolution.prototype.process = function(rule) {
-      var parent, prefixes;
-      parent = this.parentPrefix(rule);
-      prefixes = parent ? [parent] : this.prefixes;
-      return rule.params = utils.editList(rule.params, (function(_this) {
-        return function(origin, prefixed) {
-          var j, k, len, len1, prefix, processed, query;
-          for (j = 0, len = origin.length; j < len; j++) {
-            query = origin[j];
-            if (query.indexOf('min-resolution') === -1 && query.indexOf('max-resolution') === -1) {
-              prefixed.push(query);
-              continue;
+    /**
+     * Remove prefixed queries
+     */
+
+
+    Resolution.prototype.clean = function clean(rule) {
+        var _this2 = this;
+
+        if (!this.bad) {
+            this.bad = [];
+            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;
+
+                this.bad.push(this.prefixName(prefix, 'min'));
+                this.bad.push(this.prefixName(prefix, 'max'));
             }
-            for (k = 0, len1 = prefixes.length; k < len1; k++) {
-              prefix = prefixes[k];
-              if (prefix === '-moz-' && rule.params.indexOf('dpi') !== -1) {
-                continue;
-              } else {
-                processed = query.replace(regexp, function(str) {
-                  var parts;
-                  parts = str.match(split);
-                  return _this.prefixQuery(prefix, parts[1], parts[2], parts[3], parts[4]);
+        }
+
+        rule.params = utils.editList(rule.params, function (queries) {
+            return queries.filter(function (query) {
+                return _this2.bad.every(function (i) {
+                    return query.indexOf(i) === -1;
                 });
-                prefixed.push(processed);
-              }
-            }
-            prefixed.push(query);
-          }
-          return utils.uniq(prefixed);
-        };
-      })(this));
+            });
+        });
     };
 
-    return Resolution;
+    /**
+     * Add prefixed queries
+     */
 
-  })(Prefixer);
 
-  module.exports = Resolution;
+    Resolution.prototype.process = function process(rule) {
+        var _this3 = this;
+
+        var parent = this.parentPrefix(rule);
+        var prefixes = parent ? [parent] : this.prefixes;
+
+        rule.params = utils.editList(rule.params, function (origin, prefixed) {
+            for (var _iterator2 = origin, _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 query = _ref2;
+
+                if (query.indexOf('min-resolution') === -1 && query.indexOf('max-resolution') === -1) {
+                    prefixed.push(query);
+                    continue;
+                }
+
+                var _loop = function _loop(prefix) {
+                    if (prefix === '-moz-' && rule.params.indexOf('dpi') !== -1) {
+                        return 'continue';
+                    } else {
+                        var processed = query.replace(regexp, function (str) {
+                            var parts = str.match(split);
+                            return _this3.prefixQuery(prefix, parts[1], parts[2], parts[3], parts[4]);
+                        });
+                        prefixed.push(processed);
+                    }
+                };
+
+                for (var _iterator3 = prefixes, _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 prefix = _ref3;
+
+                    var _ret = _loop(prefix);
+
+                    if (_ret === 'continue') continue;
+                }
+                prefixed.push(query);
+            }
+
+            return utils.uniq(prefixed);
+        });
+    };
+
+    return Resolution;
+}(Prefixer);
 
-}).call(this);
+module.exports = Resolution;

package/lib/selector.js

@@ -1,117 +1,178 @@
-(function() {
-  var Browsers, OldSelector, Prefixer, Selector, utils,
-    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';
 
-  OldSelector = require('./old-selector');
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  Prefixer = require('./prefixer');
+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; }
 
-  Browsers = require('./browsers');
+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; }
 
-  utils = require('./utils');
+var OldSelector = require('./old-selector');
+var Prefixer = require('./prefixer');
+var Browsers = require('./browsers');
+var utils = require('./utils');
 
-  Selector = (function(superClass) {
-    extend(Selector, superClass);
+var Selector = function (_Prefixer) {
+    _inherits(Selector, _Prefixer);
 
-    function Selector(name1, prefixes, all) {
-      this.name = name1;
-      this.prefixes = prefixes;
-      this.all = all;
-      this.regexpCache = {};
+    function Selector(name, prefixes, all) {
+        _classCallCheck(this, Selector);
+
+        var _this = _possibleConstructorReturn(this, _Prefixer.call(this, name, prefixes, all));
+
+        _this.regexpCache = {};
+        return _this;
     }
 
-    Selector.prototype.check = function(rule) {
-      if (rule.selector.indexOf(this.name) !== -1) {
-        return !!rule.selector.match(this.regexp());
-      } else {
-        return false;
-      }
+    /**
+     * Is rule selectors need to be prefixed
+     */
+
+
+    Selector.prototype.check = function check(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);
+    /**
+     * Return prefixed version of selector
+     */
+
+
+    Selector.prototype.prefixed = function prefixed(prefix) {
+        return this.name.replace(/^([^\w]*)/, '$1' + prefix);
     };
 
-    Selector.prototype.regexp = function(prefix) {
-      var name;
-      if (this.regexpCache[prefix]) {
+    /**
+     * Lazy loadRegExp for name
+     */
+
+
+    Selector.prototype.regexp = function regexp(prefix) {
+        if (this.regexpCache[prefix]) {
+            return this.regexpCache[prefix];
+        }
+
+        var name = prefix ? this.prefixed(prefix) : this.name;
+        this.regexpCache[prefix] = new RegExp('(^|[^:"\'=])' + utils.escapeRegexp(name), 'gi');
         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();
-    };
+    /**
+     * All possible prefixes
+     */
 
-    Selector.prototype.prefixeds = function(rule) {
-      var i, len, prefix, prefixeds, 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.possible = function possible() {
+        return Browsers.prefixes();
     };
 
-    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.nodes[index];
-        if (before.type !== 'rule') {
-          return false;
+    /**
+     * Return all possible selector prefixes
+     */
+
+
+    Selector.prototype.prefixeds = function prefixeds(rule) {
+        if (rule._autoprefixerPrefixeds) {
+            return rule._autoprefixerPrefixeds;
         }
-        some = false;
-        for (key in prefixeds) {
-          prefixed = prefixeds[key];
-          if (before.selector === prefixed) {
-            if (prefix === key) {
-              return true;
+
+        var prefixeds = {};
+        for (var _iterator = this.possible(), _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 {
-              some = true;
-              break;
+                _i = _iterator.next();
+                if (_i.done) break;
+                _ref = _i.value;
             }
-          }
-        }
-        if (!some) {
-          return false;
+
+            var prefix = _ref;
+
+            prefixeds[prefix] = this.replace(rule.selector, prefix);
         }
-        index -= 1;
-      }
-      return false;
+
+        rule._autoprefixerPrefixeds = prefixeds;
+        return rule._autoprefixerPrefixeds;
     };
 
-    Selector.prototype.replace = function(selector, prefix) {
-      return selector.replace(this.regexp(), '$1' + this.prefixed(prefix));
+    /**
+     * Is rule already prefixed before
+     */
+
+
+    Selector.prototype.already = function already(rule, prefixeds, prefix) {
+        var index = rule.parent.index(rule) - 1;
+
+        while (index >= 0) {
+            var before = rule.parent.nodes[index];
+
+            if (before.type !== 'rule') {
+                return false;
+            }
+
+            var some = false;
+            for (var key in prefixeds) {
+                var 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.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);
+    /**
+     * Replace selectors by prefixed one
+     */
+
+
+    Selector.prototype.replace = function replace(selector, prefix) {
+        return selector.replace(this.regexp(), '$1' + this.prefixed(prefix));
     };
 
-    Selector.prototype.old = function(prefix) {
-      return new OldSelector(this, prefix);
+    /**
+     * Clone and add prefixes for at-rule
+     */
+
+
+    Selector.prototype.add = function add(rule, prefix) {
+        var prefixeds = this.prefixeds(rule);
+
+        if (this.already(rule, prefixeds, prefix)) {
+            return;
+        }
+
+        var cloned = this.clone(rule, { selector: prefixeds[prefix] });
+        rule.parent.insertBefore(rule, cloned);
     };
 
-    return Selector;
+    /**
+     * Return function to fast find prefixed selector
+     */
 
-  })(Prefixer);
 
-  module.exports = Selector;
+    Selector.prototype.old = function old(prefix) {
+        return new OldSelector(this, prefix);
+    };
+
+    return Selector;
+}(Prefixer);
 
-}).call(this);
+module.exports = Selector;