autoprefixer 8.6.5 → 9.1.0

package/lib/hacks/align-self.js

@@ -12,72 +12,71 @@ var flexSpec = require('./flex-spec');
 var Declaration = require('../declaration');
 
 var AlignSelf = function (_Declaration) {
-    _inherits(AlignSelf, _Declaration);
+  _inherits(AlignSelf, _Declaration);
 
-    function AlignSelf() {
-        _classCallCheck(this, AlignSelf);
+  function AlignSelf() {
+    _classCallCheck(this, AlignSelf);
 
-        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
-    }
+    return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+  }
 
-    /**
-     * Change property name for 2012 specs
-     */
-    AlignSelf.prototype.prefixed = function prefixed(prop, prefix) {
-        var spec = void 0;
+  /**
+   * Change property name for 2012 specs
+   */
+  AlignSelf.prototype.prefixed = function prefixed(prop, prefix) {
+    var spec = void 0;
 
-        var _flexSpec = flexSpec(prefix);
+    var _flexSpec = flexSpec(prefix);
 
-        spec = _flexSpec[0];
-        prefix = _flexSpec[1];
+    spec = _flexSpec[0];
+    prefix = _flexSpec[1];
 
-        if (spec === 2012) {
-            return prefix + 'flex-item-align';
-        } else {
-            return _Declaration.prototype.prefixed.call(this, prop, prefix);
-        }
-    };
+    if (spec === 2012) {
+      return prefix + 'flex-item-align';
+    } else {
+      return _Declaration.prototype.prefixed.call(this, prop, prefix);
+    }
+  };
 
-    /**
-     * Return property name by final spec
-     */
+  /**
+   * Return property name by final spec
+   */
 
 
-    AlignSelf.prototype.normalize = function normalize() {
-        return 'align-self';
-    };
+  AlignSelf.prototype.normalize = function normalize() {
+    return 'align-self';
+  };
 
-    /**
-     * Change value for 2012 spec and ignore prefix for 2009
-     */
+  /**
+   * Change value for 2012 spec and ignore prefix for 2009
+   */
 
 
-    AlignSelf.prototype.set = function set(decl, prefix) {
-        var spec = flexSpec(prefix)[0];
-        if (spec === 2012) {
-            decl.value = AlignSelf.oldValues[decl.value] || decl.value;
-            return _Declaration.prototype.set.call(this, decl, prefix);
-        } else if (spec === 'final') {
-            return _Declaration.prototype.set.call(this, decl, prefix);
-        }
-        return undefined;
-    };
+  AlignSelf.prototype.set = function set(decl, prefix) {
+    var spec = flexSpec(prefix)[0];
+    if (spec === 2012) {
+      decl.value = AlignSelf.oldValues[decl.value] || decl.value;
+      return _Declaration.prototype.set.call(this, decl, prefix);
+    } else if (spec === 'final') {
+      return _Declaration.prototype.set.call(this, decl, prefix);
+    }
+    return undefined;
+  };
 
-    return AlignSelf;
+  return AlignSelf;
 }(Declaration);
 
 Object.defineProperty(AlignSelf, 'names', {
-    enumerable: true,
-    writable: true,
-    value: ['align-self', 'flex-item-align']
+  enumerable: true,
+  writable: true,
+  value: ['align-self', 'flex-item-align']
 });
 Object.defineProperty(AlignSelf, 'oldValues', {
-    enumerable: true,
-    writable: true,
-    value: {
-        'flex-end': 'end',
-        'flex-start': 'start'
-    }
+  enumerable: true,
+  writable: true,
+  value: {
+    'flex-end': 'end',
+    'flex-start': 'start' }
 });
 
 

package/lib/hacks/animation.js

@@ -11,31 +11,31 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
 var Declaration = require('../declaration');
 
 var Animation = function (_Declaration) {
-    _inherits(Animation, _Declaration);
+  _inherits(Animation, _Declaration);
 
-    function Animation() {
-        _classCallCheck(this, Animation);
+  function Animation() {
+    _classCallCheck(this, Animation);
 
-        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
-    }
+    return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+  }
 
-    /**
-     * Don’t add prefixes for modern values.
-     */
-    Animation.prototype.check = function check(decl) {
-        return !decl.value.split(/\s+/).some(function (i) {
-            var lower = i.toLowerCase();
-            return lower === 'reverse' || lower === 'alternate-reverse';
-        });
-    };
+  /**
+   * Don’t add prefixes for modern values.
+   */
+  Animation.prototype.check = function check(decl) {
+    return !decl.value.split(/\s+/).some(function (i) {
+      var lower = i.toLowerCase();
+      return lower === 'reverse' || lower === 'alternate-reverse';
+    });
+  };
 
-    return Animation;
+  return Animation;
 }(Declaration);
 
 Object.defineProperty(Animation, 'names', {
-    enumerable: true,
-    writable: true,
-    value: ['animation', 'animation-direction']
+  enumerable: true,
+  writable: true,
+  value: ['animation', 'animation-direction']
 });
 
 

package/lib/hacks/appearance.js

@@ -12,32 +12,32 @@ var Declaration = require('../declaration');
 var utils = require('../utils');
 
 var Appearance = function (_Declaration) {
-    _inherits(Appearance, _Declaration);
+  _inherits(Appearance, _Declaration);
 
-    function Appearance(name, prefixes, all) {
-        _classCallCheck(this, Appearance);
+  function Appearance(name, prefixes, all) {
+    _classCallCheck(this, Appearance);
 
-        var _this = _possibleConstructorReturn(this, _Declaration.call(this, name, prefixes, all));
+    var _this = _possibleConstructorReturn(this, _Declaration.call(this, name, prefixes, all));
 
-        if (_this.prefixes) {
-            _this.prefixes = utils.uniq(_this.prefixes.map(function (i) {
-                if (i === '-ms-') {
-                    return '-webkit-';
-                } else {
-                    return i;
-                }
-            }));
+    if (_this.prefixes) {
+      _this.prefixes = utils.uniq(_this.prefixes.map(function (i) {
+        if (i === '-ms-') {
+          return '-webkit-';
+        } else {
+          return i;
         }
-        return _this;
+      }));
     }
+    return _this;
+  }
 
-    return Appearance;
+  return Appearance;
 }(Declaration);
 
 Object.defineProperty(Appearance, 'names', {
-    enumerable: true,
-    writable: true,
-    value: ['appearance']
+  enumerable: true,
+  writable: true,
+  value: ['appearance']
 });
 
 

package/lib/hacks/background-clip.js

@@ -0,0 +1,48 @@
+'use strict';
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+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) : _defaults(subClass, superClass); }
+
+var Declaration = require('../declaration');
+var utils = require('../utils');
+
+var BackgroundClip = function (_Declaration) {
+  _inherits(BackgroundClip, _Declaration);
+
+  function BackgroundClip(name, prefixes, all) {
+    _classCallCheck(this, BackgroundClip);
+
+    var _this = _possibleConstructorReturn(this, _Declaration.call(this, name, prefixes, all));
+
+    if (_this.prefixes) {
+      _this.prefixes = utils.uniq(_this.prefixes.map(function (i) {
+        if (i === '-ms-') {
+          return '-webkit-';
+        } else {
+          return i;
+        }
+      }));
+    }
+    return _this;
+  }
+
+  BackgroundClip.prototype.check = function check(decl) {
+    return decl.value.toLowerCase() === 'text';
+  };
+
+  return BackgroundClip;
+}(Declaration);
+
+Object.defineProperty(BackgroundClip, 'names', {
+  enumerable: true,
+  writable: true,
+  value: ['background-clip']
+});
+
+
+module.exports = BackgroundClip;

package/lib/hacks/background-size.js

@@ -11,32 +11,32 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
 var Declaration = require('../declaration');
 
 var BackgroundSize = function (_Declaration) {
-    _inherits(BackgroundSize, _Declaration);
+  _inherits(BackgroundSize, _Declaration);
 
-    function BackgroundSize() {
-        _classCallCheck(this, BackgroundSize);
+  function BackgroundSize() {
+    _classCallCheck(this, BackgroundSize);
 
-        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+    return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+  }
+
+  /**
+   * Duplication parameter for -webkit- browsers
+   */
+  BackgroundSize.prototype.set = function set(decl, prefix) {
+    var value = decl.value.toLowerCase();
+    if (prefix === '-webkit-' && value.indexOf(' ') === -1 && value !== 'contain' && value !== 'cover') {
+      decl.value = decl.value + ' ' + decl.value;
     }
+    return _Declaration.prototype.set.call(this, decl, prefix);
+  };
 
-    /**
-     * Duplication parameter for -webkit- browsers
-     */
-    BackgroundSize.prototype.set = function set(decl, prefix) {
-        var value = decl.value.toLowerCase();
-        if (prefix === '-webkit-' && value.indexOf(' ') === -1 && value !== 'contain' && value !== 'cover') {
-            decl.value = decl.value + ' ' + decl.value;
-        }
-        return _Declaration.prototype.set.call(this, decl, prefix);
-    };
-
-    return BackgroundSize;
+  return BackgroundSize;
 }(Declaration);
 
 Object.defineProperty(BackgroundSize, 'names', {
-    enumerable: true,
-    writable: true,
-    value: ['background-size']
+  enumerable: true,
+  writable: true,
+  value: ['background-size']
 });
 
 

package/lib/hacks/block-logical.js

@@ -11,41 +11,45 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
 var Declaration = require('../declaration');
 
 var BlockLogical = function (_Declaration) {
-    _inherits(BlockLogical, _Declaration);
-
-    function BlockLogical() {
-        _classCallCheck(this, BlockLogical);
-
-        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+  _inherits(BlockLogical, _Declaration);
+
+  function BlockLogical() {
+    _classCallCheck(this, BlockLogical);
+
+    return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+  }
+
+  /**
+   * Use old syntax for -moz- and -webkit-
+   */
+  BlockLogical.prototype.prefixed = function prefixed(prop, prefix) {
+    if (prop.indexOf('-start') !== -1) {
+      return prefix + prop.replace('-block-start', '-before');
+    } else {
+      return prefix + prop.replace('-block-end', '-after');
     }
+  };
 
-    /**
-     * Use old syntax for -moz- and -webkit-
-     */
-    BlockLogical.prototype.prefixed = function prefixed(prop, prefix) {
-        return prefix + (prop.indexOf('-start') !== -1 ? prop.replace('-block-start', '-before') : prop.replace('-block-end', '-after'));
-    };
+  /**
+   * Return property name by spec
+   */
 
-    /**
-     * Return property name by spec
-     */
 
+  BlockLogical.prototype.normalize = function normalize(prop) {
+    if (prop.indexOf('-before') !== -1) {
+      return prop.replace('-before', '-block-start');
+    } else {
+      return prop.replace('-after', '-block-end');
+    }
+  };
 
-    BlockLogical.prototype.normalize = function normalize(prop) {
-        if (prop.indexOf('-before') !== -1) {
-            return prop.replace('-before', '-block-start');
-        } else {
-            return prop.replace('-after', '-block-end');
-        }
-    };
-
-    return BlockLogical;
+  return BlockLogical;
 }(Declaration);
 
 Object.defineProperty(BlockLogical, 'names', {
-    enumerable: true,
-    writable: true,
-    value: ['border-block-start', 'border-block-end', 'margin-block-start', 'margin-block-end', 'padding-block-start', 'padding-block-end', 'border-before', 'border-after', 'margin-before', 'margin-after', 'padding-before', 'padding-after']
+  enumerable: true,
+  writable: true,
+  value: ['border-block-start', 'border-block-end', 'margin-block-start', 'margin-block-end', 'padding-block-start', 'padding-block-end', 'border-before', 'border-after', 'margin-before', 'margin-after', 'padding-before', 'padding-after']
 });
 
 

package/lib/hacks/border-image.js

@@ -11,29 +11,29 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
 var Declaration = require('../declaration');
 
 var BorderImage = function (_Declaration) {
-    _inherits(BorderImage, _Declaration);
+  _inherits(BorderImage, _Declaration);
 
-    function BorderImage() {
-        _classCallCheck(this, BorderImage);
+  function BorderImage() {
+    _classCallCheck(this, BorderImage);
 
-        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
-    }
+    return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+  }
 
-    /**
-     * Remove fill parameter for prefixed declarations
-     */
-    BorderImage.prototype.set = function set(decl, prefix) {
-        decl.value = decl.value.replace(/\s+fill(\s)/, '$1');
-        return _Declaration.prototype.set.call(this, decl, prefix);
-    };
+  /**
+   * Remove fill parameter for prefixed declarations
+   */
+  BorderImage.prototype.set = function set(decl, prefix) {
+    decl.value = decl.value.replace(/\s+fill(\s)/, '$1');
+    return _Declaration.prototype.set.call(this, decl, prefix);
+  };
 
-    return BorderImage;
+  return BorderImage;
 }(Declaration);
 
 Object.defineProperty(BorderImage, 'names', {
-    enumerable: true,
-    writable: true,
-    value: ['border-image']
+  enumerable: true,
+  writable: true,
+  value: ['border-image']
 });
 
 

package/lib/hacks/border-radius.js

@@ -11,69 +11,69 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
 var Declaration = require('../declaration');
 
 var BorderRadius = function (_Declaration) {
-    _inherits(BorderRadius, _Declaration);
-
-    function BorderRadius() {
-        _classCallCheck(this, BorderRadius);
-
-        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+  _inherits(BorderRadius, _Declaration);
+
+  function BorderRadius() {
+    _classCallCheck(this, BorderRadius);
+
+    return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+  }
+
+  /**
+   * Change syntax, when add Mozilla prefix
+   */
+  BorderRadius.prototype.prefixed = function prefixed(prop, prefix) {
+    if (prefix === '-moz-') {
+      return prefix + (BorderRadius.toMozilla[prop] || prop);
+    } else {
+      return _Declaration.prototype.prefixed.call(this, prop, prefix);
     }
+  };
 
-    /**
-     * Change syntax, when add Mozilla prefix
-     */
-    BorderRadius.prototype.prefixed = function prefixed(prop, prefix) {
-        if (prefix === '-moz-') {
-            return prefix + (BorderRadius.toMozilla[prop] || prop);
-        } else {
-            return _Declaration.prototype.prefixed.call(this, prop, prefix);
-        }
-    };
+  /**
+   * Return unprefixed version of property
+   */
 
-    /**
-     * Return unprefixed version of property
-     */
 
+  BorderRadius.prototype.normalize = function normalize(prop) {
+    return BorderRadius.toNormal[prop] || prop;
+  };
 
-    BorderRadius.prototype.normalize = function normalize(prop) {
-        return BorderRadius.toNormal[prop] || prop;
-    };
-
-    return BorderRadius;
+  return BorderRadius;
 }(Declaration);
 
 Object.defineProperty(BorderRadius, 'names', {
-    enumerable: true,
-    writable: true,
-    value: ['border-radius']
+  enumerable: true,
+  writable: true,
+  value: ['border-radius']
 });
 Object.defineProperty(BorderRadius, 'toMozilla', {
-    enumerable: true,
-    writable: true,
-    value: {}
+  enumerable: true,
+  writable: true,
+  value: {}
 });
 Object.defineProperty(BorderRadius, 'toNormal', {
-    enumerable: true,
-    writable: true,
-    value: {}
+  enumerable: true,
+  writable: true,
+  value: {}
 });
 var _arr = ['top', 'bottom'];
 
 
 for (var _i = 0; _i < _arr.length; _i++) {
-    var ver = _arr[_i];var _arr2 = ['left', 'right'];
+  var ver = _arr[_i];var _arr2 = ['left', 'right'];
 
-    for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
-        var hor = _arr2[_i2];
-        var normal = 'border-' + ver + '-' + hor + '-radius';
-        var mozilla = 'border-radius-' + ver + hor;
+  for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
+    var hor = _arr2[_i2];
+    var normal = 'border-' + ver + '-' + hor + '-radius';
+    var mozilla = 'border-radius-' + ver + hor;
 
-        BorderRadius.names.push(normal);
-        BorderRadius.names.push(mozilla);
+    BorderRadius.names.push(normal);
+    BorderRadius.names.push(mozilla);
 
-        BorderRadius.toMozilla[normal] = mozilla;
-        BorderRadius.toNormal[mozilla] = normal;
-    }
+    BorderRadius.toMozilla[normal] = mozilla;
+    BorderRadius.toNormal[mozilla] = normal;
+  }
 }
 
 module.exports = BorderRadius;