autoprefixer 6.7.7 → 7.1.1

package/lib/hacks/cross-fade.js

@@ -1,53 +1,56 @@
-(function() {
-  var CrossFade, OldValue, Value, list, 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';
 
-  OldValue = require('../old-value');
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  Value = require('../value');
+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; }
 
-  utils = require('../utils');
+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; }
 
-  list = require('postcss/lib/list');
+var Value = require('../value');
+var list = require('postcss/lib/list');
 
-  CrossFade = (function(superClass) {
-    extend(CrossFade, superClass);
+var CrossFade = function (_Value) {
+    _inherits(CrossFade, _Value);
 
     function CrossFade() {
-      return CrossFade.__super__.constructor.apply(this, arguments);
+        _classCallCheck(this, CrossFade);
+
+        return _possibleConstructorReturn(this, _Value.apply(this, arguments));
     }
 
-    CrossFade.names = ['cross-fade'];
-
-    CrossFade.prototype.replace = function(string, prefix) {
-      return list.space(string).map((function(_this) {
-        return function(value) {
-          var after, args, close, match;
-          if (value.slice(0, +_this.name.length + 1 || 9e9) !== _this.name + '(') {
-            return value;
-          }
-          close = value.lastIndexOf(')');
-          after = value.slice(close + 1);
-          args = value.slice(_this.name.length + 1, +(close - 1) + 1 || 9e9);
-          if (prefix === '-webkit-') {
-            match = args.match(/\d*.?\d+%?/);
-            if (match) {
-              args = args.slice(match[0].length).trim();
-              args += ', ' + match[0];
-            } else {
-              args += ', 0.5';
+    CrossFade.prototype.replace = function replace(string, prefix) {
+        var _this2 = this;
+
+        return list.space(string).map(function (value) {
+            if (value.slice(0, +_this2.name.length + 1) !== _this2.name + '(') {
+                return value;
+            }
+
+            var close = value.lastIndexOf(')');
+            var after = value.slice(close + 1);
+            var args = value.slice(_this2.name.length + 1, close);
+
+            if (prefix === '-webkit-') {
+                var match = args.match(/\d*.?\d+%?/);
+                if (match) {
+                    args = args.slice(match[0].length).trim();
+                    args += ', ' + match[0];
+                } else {
+                    args += ', 0.5';
+                }
             }
-          }
-          return prefix + _this.name + '(' + args + ')' + after;
-        };
-      })(this)).join(' ');
+            return prefix + _this2.name + '(' + args + ')' + after;
+        }).join(' ');
     };
 
     return CrossFade;
+}(Value);
 
-  })(Value);
+Object.defineProperty(CrossFade, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['cross-fade']
+});
 
-  module.exports = CrossFade;
 
-}).call(this);
+module.exports = CrossFade;

package/lib/hacks/display-flex.js

@@ -1,52 +1,102 @@
-(function() {
-  var DisplayFlex, OldValue, Value, flexSpec,
-    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';
 
-  flexSpec = require('./flex-spec');
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  OldValue = require('../old-value');
+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; }
 
-  Value = require('../value');
+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; }
 
-  DisplayFlex = (function(superClass) {
-    extend(DisplayFlex, superClass);
+var flexSpec = require('./flex-spec');
+var OldValue = require('../old-value');
+var Value = require('../value');
 
-    DisplayFlex.names = ['display-flex', 'inline-flex'];
+var DisplayFlex = function (_Value) {
+    _inherits(DisplayFlex, _Value);
 
     function DisplayFlex(name, prefixes) {
-      DisplayFlex.__super__.constructor.apply(this, arguments);
-      if (name === 'display-flex') {
-        this.name = 'flex';
-      }
+        _classCallCheck(this, DisplayFlex);
+
+        var _this = _possibleConstructorReturn(this, _Value.call(this, name, prefixes));
+
+        if (name === 'display-flex') {
+            _this.name = 'flex';
+        }
+        return _this;
     }
 
-    DisplayFlex.prototype.check = function(decl) {
-      return decl.prop === 'display' && decl.value === this.name;
+    /**
+     * Faster check for flex value
+     */
+
+
+    DisplayFlex.prototype.check = function check(decl) {
+        return decl.prop === 'display' && decl.value === this.name;
     };
 
-    DisplayFlex.prototype.prefixed = function(prefix) {
-      var ref, spec;
-      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
-      return prefix + (spec === 2009 ? this.name === 'flex' ? 'box' : 'inline-box' : spec === 2012 ? this.name === 'flex' ? 'flexbox' : 'inline-flexbox' : spec === 'final' ? this.name : void 0);
+    /**
+     * Return value by spec
+     */
+
+
+    DisplayFlex.prototype.prefixed = function prefixed(prefix) {
+        var spec = void 0,
+            value = void 0;
+
+        var _flexSpec = flexSpec(prefix);
+
+        spec = _flexSpec[0];
+        prefix = _flexSpec[1];
+
+
+        if (spec === 2009) {
+            if (this.name === 'flex') {
+                value = 'box';
+            } else {
+                value = 'inline-box';
+            }
+        } else if (spec === 2012) {
+            if (this.name === 'flex') {
+                value = 'flexbox';
+            } else {
+                value = 'inline-flexbox';
+            }
+        } else if (spec === 'final') {
+            value = this.name;
+        }
+
+        return prefix + value;
     };
 
-    DisplayFlex.prototype.replace = function(string, prefix) {
-      return this.prefixed(prefix);
+    /**
+     * Add prefix to value depend on flebox spec version
+     */
+
+
+    DisplayFlex.prototype.replace = function replace(string, prefix) {
+        return this.prefixed(prefix);
     };
 
-    DisplayFlex.prototype.old = function(prefix) {
-      var prefixed;
-      prefixed = this.prefixed(prefix);
-      if (prefixed) {
-        return new OldValue(this.name, prefixed);
-      }
+    /**
+     * Change value for old specs
+     */
+
+
+    DisplayFlex.prototype.old = function old(prefix) {
+        var prefixed = this.prefixed(prefix);
+        if (prefixed) {
+            return new OldValue(this.name, prefixed);
+        }
+        return undefined;
     };
 
     return DisplayFlex;
+}(Value);
 
-  })(Value);
+Object.defineProperty(DisplayFlex, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['display-flex', 'inline-flex']
+});
 
-  module.exports = DisplayFlex;
 
-}).call(this);
+module.exports = DisplayFlex;

package/lib/hacks/display-grid.js

@@ -1,34 +1,44 @@
-(function() {
-  var DisplayGrid, OldValue, Value, flexSpec,
-    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';
 
-  flexSpec = require('./flex-spec');
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  OldValue = require('../old-value');
+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; }
 
-  Value = require('../value');
+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; }
 
-  DisplayGrid = (function(superClass) {
-    extend(DisplayGrid, superClass);
+var Value = require('../value');
 
-    DisplayGrid.names = ['display-grid', 'inline-grid'];
+var DisplayGrid = function (_Value) {
+    _inherits(DisplayGrid, _Value);
 
     function DisplayGrid(name, prefixes) {
-      DisplayGrid.__super__.constructor.apply(this, arguments);
-      if (name === 'display-grid') {
-        this.name = 'grid';
-      }
+        _classCallCheck(this, DisplayGrid);
+
+        var _this = _possibleConstructorReturn(this, _Value.call(this, name, prefixes));
+
+        if (name === 'display-grid') {
+            _this.name = 'grid';
+        }
+        return _this;
     }
 
-    DisplayGrid.prototype.check = function(decl) {
-      return decl.prop === 'display' && decl.value === this.name;
+    /**
+     * Faster check for flex value
+     */
+
+
+    DisplayGrid.prototype.check = function check(decl) {
+        return decl.prop === 'display' && decl.value === this.name;
     };
 
     return DisplayGrid;
+}(Value);
 
-  })(Value);
+Object.defineProperty(DisplayGrid, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['display-grid', 'inline-grid']
+});
 
-  module.exports = DisplayGrid;
 
-}).call(this);
+module.exports = DisplayGrid;

package/lib/hacks/filter-value.js

@@ -1,72 +1,93 @@
-(function() {
-  var FilterValue, OldFilterValue, OldValue, Value, 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';
 
-  OldValue = require('../old-value');
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  Value = require('../value');
+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; }
 
-  utils = require('../utils');
+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; }
 
-  OldFilterValue = (function(superClass) {
-    extend(OldFilterValue, superClass);
+var OldValue = require('../old-value');
+var Value = require('../value');
+var utils = require('../utils');
+
+var OldFilterValue = function (_OldValue) {
+    _inherits(OldFilterValue, _OldValue);
 
     function OldFilterValue() {
-      return OldFilterValue.__super__.constructor.apply(this, arguments);
+        _classCallCheck(this, OldFilterValue);
+
+        return _possibleConstructorReturn(this, _OldValue.apply(this, arguments));
     }
 
-    OldFilterValue.prototype.clean = function(decl) {
-      return decl.value = utils.editList(decl.value, (function(_this) {
-        return function(props) {
-          if (props.every(function(i) {
-            return i.indexOf(_this.unprefixed) !== 0;
-          })) {
-            return props;
-          }
-          return props.filter(function(i) {
-            return i.indexOf(_this.prefixed) === -1;
-          });
-        };
-      })(this));
+    /**
+     * Clean -webkit-filter from properties list
+     */
+    OldFilterValue.prototype.clean = function clean(decl) {
+        var _this2 = this;
+
+        decl.value = utils.editList(decl.value, function (props) {
+            if (props.every(function (i) {
+                return i.indexOf(_this2.unprefixed) !== 0;
+            })) {
+                return props;
+            }
+            return props.filter(function (i) {
+                return i.indexOf(_this2.prefixed) === -1;
+            });
+        });
     };
 
     return OldFilterValue;
+}(OldValue);
 
-  })(OldValue);
+var FilterValue = function (_Value) {
+    _inherits(FilterValue, _Value);
 
-  FilterValue = (function(superClass) {
-    extend(FilterValue, superClass);
+    function FilterValue(name, prefixes) {
+        _classCallCheck(this, FilterValue);
 
-    FilterValue.names = ['filter', 'filter-function'];
+        var _this3 = _possibleConstructorReturn(this, _Value.call(this, name, prefixes));
 
-    function FilterValue(name, prefixes) {
-      FilterValue.__super__.constructor.apply(this, arguments);
-      if (name === 'filter-function') {
-        this.name = 'filter';
-      }
+        if (name === 'filter-function') {
+            _this3.name = 'filter';
+        }
+        return _this3;
     }
 
-    FilterValue.prototype.replace = function(value, prefix) {
-      if (prefix === '-webkit-' && value.indexOf('filter(') === -1) {
-        if (value.indexOf('-webkit-filter') === -1) {
-          return FilterValue.__super__.replace.apply(this, arguments) + ', ' + value;
+    /**
+     * Use prefixed and unprefixed filter for WebKit
+     */
+
+
+    FilterValue.prototype.replace = function replace(value, prefix) {
+        if (prefix === '-webkit-' && value.indexOf('filter(') === -1) {
+            if (value.indexOf('-webkit-filter') === -1) {
+                return _Value.prototype.replace.call(this, value, prefix) + ', ' + value;
+            } else {
+                return value;
+            }
         } else {
-          return value;
+            return _Value.prototype.replace.call(this, value, prefix);
         }
-      } else {
-        return FilterValue.__super__.replace.apply(this, arguments);
-      }
     };
 
-    FilterValue.prototype.old = function(prefix) {
-      return new OldFilterValue(this.name, prefix + this.name);
+    /**
+     * Clean -webkit-filter
+     */
+
+
+    FilterValue.prototype.old = function old(prefix) {
+        return new OldFilterValue(this.name, prefix + this.name);
     };
 
     return FilterValue;
+}(Value);
 
-  })(Value);
+Object.defineProperty(FilterValue, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['filter', 'filter-function']
+});
 
-  module.exports = FilterValue;
 
-}).call(this);
+module.exports = FilterValue;

package/lib/hacks/filter.js

@@ -1,29 +1,38 @@
-(function() {
-  var Declaration, Filter,
-    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';
 
-  Declaration = require('../declaration');
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  Filter = (function(superClass) {
-    extend(Filter, 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 Declaration = require('../declaration');
+
+var Filter = function (_Declaration) {
+    _inherits(Filter, _Declaration);
 
     function Filter() {
-      return Filter.__super__.constructor.apply(this, arguments);
-    }
+        _classCallCheck(this, Filter);
 
-    Filter.names = ['filter'];
+        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+    }
 
-    Filter.prototype.check = function(decl) {
-      var v;
-      v = decl.value;
-      return v.toLowerCase().indexOf('alpha(') === -1 && v.indexOf('DXImageTransform.Microsoft') === -1 && v.indexOf('data:image/svg+xml') === -1;
+    /**
+     * Check is it Internet Explorer filter
+     */
+    Filter.prototype.check = function check(decl) {
+        var v = decl.value;
+        return v.toLowerCase().indexOf('alpha(') === -1 && v.indexOf('DXImageTransform.Microsoft') === -1 && v.indexOf('data:image/svg+xml') === -1;
     };
 
     return Filter;
+}(Declaration);
 
-  })(Declaration);
+Object.defineProperty(Filter, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['filter']
+});
 
-  module.exports = Filter;
 
-}).call(this);
+module.exports = Filter;

package/lib/hacks/flex-basis.js

@@ -1,47 +1,77 @@
-(function() {
-  var Declaration, FlexBasis, flexSpec,
-    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';
 
-  flexSpec = require('./flex-spec');
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  Declaration = require('../declaration');
+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; }
 
-  FlexBasis = (function(superClass) {
-    extend(FlexBasis, superClass);
+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 flexSpec = require('./flex-spec');
+var Declaration = require('../declaration');
+
+var FlexBasis = function (_Declaration) {
+    _inherits(FlexBasis, _Declaration);
 
     function FlexBasis() {
-      return FlexBasis.__super__.constructor.apply(this, arguments);
-    }
+        _classCallCheck(this, FlexBasis);
 
-    FlexBasis.names = ['flex-basis', 'flex-preferred-size'];
+        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+    }
 
-    FlexBasis.prototype.normalize = function() {
-      return 'flex-basis';
+    /**
+     * Return property name by final spec
+     */
+    FlexBasis.prototype.normalize = function normalize() {
+        return 'flex-basis';
     };
 
-    FlexBasis.prototype.prefixed = function(prop, prefix) {
-      var ref, spec;
-      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
-      if (spec === 2012) {
-        return prefix + 'flex-preferred-size';
-      } else {
-        return FlexBasis.__super__.prefixed.apply(this, arguments);
-      }
+    /**
+     * Return flex property for 2012 spec
+     */
+
+
+    FlexBasis.prototype.prefixed = function prefixed(prop, prefix) {
+        var spec = void 0;
+
+        var _flexSpec = flexSpec(prefix);
+
+        spec = _flexSpec[0];
+        prefix = _flexSpec[1];
+
+        if (spec === 2012) {
+            return prefix + 'flex-preferred-size';
+        } else {
+            return _Declaration.prototype.prefixed.call(this, prop, prefix);
+        }
     };
 
-    FlexBasis.prototype.set = function(decl, prefix) {
-      var ref, spec;
-      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
-      if (spec === 2012 || spec === 'final') {
-        return FlexBasis.__super__.set.apply(this, arguments);
-      }
+    /**
+     * Ignore 2009 spec and use flex property for 2012
+     */
+
+
+    FlexBasis.prototype.set = function set(decl, prefix) {
+        var spec = void 0;
+
+        var _flexSpec2 = flexSpec(prefix);
+
+        spec = _flexSpec2[0];
+        prefix = _flexSpec2[1];
+
+        if (spec === 2012 || spec === 'final') {
+            return _Declaration.prototype.set.call(this, decl, prefix);
+        }
+        return undefined;
     };
 
     return FlexBasis;
+}(Declaration);
 
-  })(Declaration);
+Object.defineProperty(FlexBasis, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['flex-basis', 'flex-preferred-size']
+});
 
-  module.exports = FlexBasis;
 
-}).call(this);
+module.exports = FlexBasis;