autoprefixer 9.8.7 → 10.0.2

package/lib/hacks/image-rendering.js

@@ -1,71 +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 _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-var Declaration = require('../declaration');
-
-var ImageRendering = /*#__PURE__*/function (_Declaration) {
-  _inheritsLoose(ImageRendering, _Declaration);
-
-  function ImageRendering() {
-    return _Declaration.apply(this, arguments) || this;
-  }
-
-  var _proto = ImageRendering.prototype;
+let Declaration = require('../declaration')
 
+class ImageRendering extends Declaration {
   /**
    * Add hack only for crisp-edges
    */
-  _proto.check = function check(decl) {
-    return decl.value === 'pixelated';
+  check (decl) {
+    return decl.value === 'pixelated'
   }
+
   /**
    * Change property name for IE
    */
-  ;
-
-  _proto.prefixed = function prefixed(prop, prefix) {
+  prefixed (prop, prefix) {
     if (prefix === '-ms-') {
-      return '-ms-interpolation-mode';
+      return '-ms-interpolation-mode'
     }
-
-    return _Declaration.prototype.prefixed.call(this, prop, prefix);
+    return super.prefixed(prop, prefix)
   }
+
   /**
    * Change property and value for IE
    */
-  ;
-
-  _proto.set = function set(decl, prefix) {
-    if (prefix !== '-ms-') return _Declaration.prototype.set.call(this, decl, prefix);
-    decl.prop = '-ms-interpolation-mode';
-    decl.value = 'nearest-neighbor';
-    return decl;
+  set (decl, prefix) {
+    if (prefix !== '-ms-') return super.set(decl, prefix)
+    decl.prop = '-ms-interpolation-mode'
+    decl.value = 'nearest-neighbor'
+    return decl
   }
+
   /**
    * Return property name by spec
    */
-  ;
-
-  _proto.normalize = function normalize() {
-    return 'image-rendering';
+  normalize () {
+    return 'image-rendering'
   }
+
   /**
    * Warn on old value
    */
-  ;
-
-  _proto.process = function process(node, result) {
-    return _Declaration.prototype.process.call(this, node, result);
-  };
-
-  return ImageRendering;
-}(Declaration);
+  process (node, result) {
+    return super.process(node, result)
+  }
+}
 
-_defineProperty(ImageRendering, "names", ['image-rendering', 'interpolation-mode']);
+ImageRendering.names = ['image-rendering', 'interpolation-mode']
 
-module.exports = ImageRendering;
+module.exports = ImageRendering

package/lib/hacks/image-set.js

@@ -1,38 +1,18 @@
-"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 _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-var Value = require('../value');
-
-var ImageSet = /*#__PURE__*/function (_Value) {
-  _inheritsLoose(ImageSet, _Value);
-
-  function ImageSet() {
-    return _Value.apply(this, arguments) || this;
-  }
-
-  var _proto = ImageSet.prototype;
+let Value = require('../value')
 
+class ImageSet extends Value {
   /**
    * Use non-standard name for WebKit and Firefox
    */
-  _proto.replace = function replace(string, prefix) {
-    var fixed = _Value.prototype.replace.call(this, string, prefix);
-
+  replace (string, prefix) {
+    let fixed = super.replace(string, prefix)
     if (prefix === '-webkit-') {
-      fixed = fixed.replace(/("[^"]+"|'[^']+')(\s+\d+\w)/gi, 'url($1)$2');
+      fixed = fixed.replace(/("[^"]+"|'[^']+')(\s+\d+\w)/gi, 'url($1)$2')
     }
+    return fixed
+  }
+}
 
-    return fixed;
-  };
-
-  return ImageSet;
-}(Value);
-
-_defineProperty(ImageSet, "names", ['image-set']);
+ImageSet.names = ['image-set']
 
-module.exports = ImageSet;
+module.exports = ImageSet

package/lib/hacks/inline-logical.js

@@ -1,40 +1,34 @@
-"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 _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-var Declaration = require('../declaration');
-
-var InlineLogical = /*#__PURE__*/function (_Declaration) {
-  _inheritsLoose(InlineLogical, _Declaration);
-
-  function InlineLogical() {
-    return _Declaration.apply(this, arguments) || this;
-  }
-
-  var _proto = InlineLogical.prototype;
+let Declaration = require('../declaration')
 
+class InlineLogical extends Declaration {
   /**
    * Use old syntax for -moz- and -webkit-
    */
-  _proto.prefixed = function prefixed(prop, prefix) {
-    return prefix + prop.replace('-inline', '');
+  prefixed (prop, prefix) {
+    return prefix + prop.replace('-inline', '')
   }
+
   /**
    * Return property name by spec
    */
-  ;
-
-  _proto.normalize = function normalize(prop) {
-    return prop.replace(/(margin|padding|border)-(start|end)/, '$1-inline-$2');
-  };
-
-  return InlineLogical;
-}(Declaration);
-
-_defineProperty(InlineLogical, "names", ['border-inline-start', 'border-inline-end', 'margin-inline-start', 'margin-inline-end', 'padding-inline-start', 'padding-inline-end', 'border-start', 'border-end', 'margin-start', 'margin-end', 'padding-start', 'padding-end']);
-
-module.exports = InlineLogical;
+  normalize (prop) {
+    return prop.replace(/(margin|padding|border)-(start|end)/, '$1-inline-$2')
+  }
+}
+
+InlineLogical.names = [
+  'border-inline-start',
+  'border-inline-end',
+  'margin-inline-start',
+  'margin-inline-end',
+  'padding-inline-start',
+  'padding-inline-end',
+  'border-start',
+  'border-end',
+  'margin-start',
+  'margin-end',
+  'padding-start',
+  'padding-end'
+]
+
+module.exports = InlineLogical

package/lib/hacks/intrinsic.js

@@ -1,74 +1,61 @@
-"use strict";
+let OldValue = require('../old-value')
+let Value = require('../value')
 
-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 _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-var OldValue = require('../old-value');
-
-var Value = require('../value');
-
-function _regexp(name) {
-  return new RegExp("(^|[\\s,(])(" + name + "($|[\\s),]))", 'gi');
+function regexp (name) {
+  return new RegExp(`(^|[\\s,(])(${name}($|[\\s),]))`, 'gi')
 }
 
-var Intrinsic = /*#__PURE__*/function (_Value) {
-  _inheritsLoose(Intrinsic, _Value);
-
-  function Intrinsic() {
-    return _Value.apply(this, arguments) || this;
+class Intrinsic extends Value {
+  regexp () {
+    if (!this.regexpCache) this.regexpCache = regexp(this.name)
+    return this.regexpCache
   }
 
-  var _proto = Intrinsic.prototype;
-
-  _proto.regexp = function regexp() {
-    if (!this.regexpCache) this.regexpCache = _regexp(this.name);
-    return this.regexpCache;
-  };
-
-  _proto.isStretch = function isStretch() {
-    return this.name === 'stretch' || this.name === 'fill' || this.name === 'fill-available';
-  };
+  isStretch () {
+    return (
+      this.name === 'stretch' ||
+      this.name === 'fill' ||
+      this.name === 'fill-available'
+    )
+  }
 
-  _proto.replace = function replace(string, prefix) {
+  replace (string, prefix) {
     if (prefix === '-moz-' && this.isStretch()) {
-      return string.replace(this.regexp(), '$1-moz-available$3');
+      return string.replace(this.regexp(), '$1-moz-available$3')
     }
-
     if (prefix === '-webkit-' && this.isStretch()) {
-      return string.replace(this.regexp(), '$1-webkit-fill-available$3');
+      return string.replace(this.regexp(), '$1-webkit-fill-available$3')
     }
+    return super.replace(string, prefix)
+  }
 
-    return _Value.prototype.replace.call(this, string, prefix);
-  };
-
-  _proto.old = function old(prefix) {
-    var prefixed = prefix + this.name;
-
+  old (prefix) {
+    let prefixed = prefix + this.name
     if (this.isStretch()) {
       if (prefix === '-moz-') {
-        prefixed = '-moz-available';
+        prefixed = '-moz-available'
       } else if (prefix === '-webkit-') {
-        prefixed = '-webkit-fill-available';
+        prefixed = '-webkit-fill-available'
       }
     }
+    return new OldValue(this.name, prefixed, prefixed, regexp(prefixed))
+  }
 
-    return new OldValue(this.name, prefixed, prefixed, _regexp(prefixed));
-  };
-
-  _proto.add = function add(decl, prefix) {
+  add (decl, prefix) {
     if (decl.prop.includes('grid') && prefix !== '-webkit-') {
-      return undefined;
+      return undefined
     }
+    return super.add(decl, prefix)
+  }
+}
 
-    return _Value.prototype.add.call(this, decl, prefix);
-  };
-
-  return Intrinsic;
-}(Value);
-
-_defineProperty(Intrinsic, "names", ['max-content', 'min-content', 'fit-content', 'fill', 'fill-available', 'stretch']);
+Intrinsic.names = [
+  'max-content',
+  'min-content',
+  'fit-content',
+  'fill',
+  'fill-available',
+  'stretch'
+]
 
-module.exports = Intrinsic;
+module.exports = Intrinsic

package/lib/hacks/justify-content.js

@@ -1,85 +1,54 @@
-"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 _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-var flexSpec = require('./flex-spec');
-
-var Declaration = require('../declaration');
-
-var JustifyContent = /*#__PURE__*/function (_Declaration) {
-  _inheritsLoose(JustifyContent, _Declaration);
-
-  function JustifyContent() {
-    return _Declaration.apply(this, arguments) || this;
-  }
-
-  var _proto = JustifyContent.prototype;
+let flexSpec = require('./flex-spec')
+let Declaration = require('../declaration')
 
+class JustifyContent extends Declaration {
   /**
    * Change property name for 2009 and 2012 specs
    */
-  _proto.prefixed = function prefixed(prop, prefix) {
-    var spec;
-
-    var _flexSpec = flexSpec(prefix);
-
-    spec = _flexSpec[0];
-    prefix = _flexSpec[1];
-
+  prefixed (prop, prefix) {
+    let spec
+    ;[spec, prefix] = flexSpec(prefix)
     if (spec === 2009) {
-      return prefix + 'box-pack';
+      return prefix + 'box-pack'
     }
-
     if (spec === 2012) {
-      return prefix + 'flex-pack';
+      return prefix + 'flex-pack'
     }
-
-    return _Declaration.prototype.prefixed.call(this, prop, prefix);
+    return super.prefixed(prop, prefix)
   }
+
   /**
    * Return property name by final spec
    */
-  ;
-
-  _proto.normalize = function normalize() {
-    return 'justify-content';
+  normalize () {
+    return 'justify-content'
   }
+
   /**
    * Change value for 2009 and 2012 specs
    */
-  ;
-
-  _proto.set = function set(decl, prefix) {
-    var spec = flexSpec(prefix)[0];
-
+  set (decl, prefix) {
+    let spec = flexSpec(prefix)[0]
     if (spec === 2009 || spec === 2012) {
-      var value = JustifyContent.oldValues[decl.value] || decl.value;
-      decl.value = value;
-
+      let value = JustifyContent.oldValues[decl.value] || decl.value
+      decl.value = value
       if (spec !== 2009 || value !== 'distribute') {
-        return _Declaration.prototype.set.call(this, decl, prefix);
+        return super.set(decl, prefix)
       }
     } else if (spec === 'final') {
-      return _Declaration.prototype.set.call(this, decl, prefix);
+      return super.set(decl, prefix)
     }
+    return undefined
+  }
+}
 
-    return undefined;
-  };
-
-  return JustifyContent;
-}(Declaration);
-
-_defineProperty(JustifyContent, "names", ['justify-content', 'flex-pack', 'box-pack']);
+JustifyContent.names = ['justify-content', 'flex-pack', 'box-pack']
 
-_defineProperty(JustifyContent, "oldValues", {
+JustifyContent.oldValues = {
   'flex-end': 'end',
   'flex-start': 'start',
   'space-between': 'justify',
   'space-around': 'distribute'
-});
+}
 
-module.exports = JustifyContent;
+module.exports = JustifyContent

package/lib/hacks/mask-border.js

@@ -1,46 +1,38 @@
-"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 _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-var Declaration = require('../declaration');
-
-var MaskBorder = /*#__PURE__*/function (_Declaration) {
-  _inheritsLoose(MaskBorder, _Declaration);
-
-  function MaskBorder() {
-    return _Declaration.apply(this, arguments) || this;
-  }
-
-  var _proto = MaskBorder.prototype;
+let Declaration = require('../declaration')
 
+class MaskBorder extends Declaration {
   /**
    * Return property name by final spec
    */
-  _proto.normalize = function normalize() {
-    return this.name.replace('box-image', 'border');
+  normalize () {
+    return this.name.replace('box-image', 'border')
   }
+
   /**
    * Return flex property for 2012 spec
    */
-  ;
-
-  _proto.prefixed = function prefixed(prop, prefix) {
-    var result = _Declaration.prototype.prefixed.call(this, prop, prefix);
-
+  prefixed (prop, prefix) {
+    let result = super.prefixed(prop, prefix)
     if (prefix === '-webkit-') {
-      result = result.replace('border', 'box-image');
+      result = result.replace('border', 'box-image')
     }
-
-    return result;
-  };
-
-  return MaskBorder;
-}(Declaration);
-
-_defineProperty(MaskBorder, "names", ['mask-border', 'mask-border-source', 'mask-border-slice', 'mask-border-width', 'mask-border-outset', 'mask-border-repeat', 'mask-box-image', 'mask-box-image-source', 'mask-box-image-slice', 'mask-box-image-width', 'mask-box-image-outset', 'mask-box-image-repeat']);
-
-module.exports = MaskBorder;
+    return result
+  }
+}
+
+MaskBorder.names = [
+  'mask-border',
+  'mask-border-source',
+  'mask-border-slice',
+  'mask-border-width',
+  'mask-border-outset',
+  'mask-border-repeat',
+  'mask-box-image',
+  'mask-box-image-source',
+  'mask-box-image-slice',
+  'mask-box-image-width',
+  'mask-box-image-outset',
+  'mask-box-image-repeat'
+]
+
+module.exports = MaskBorder

package/lib/hacks/mask-composite.js

@@ -1,104 +1,88 @@
-"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 _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-var Declaration = require('../declaration');
-
-var MaskComposite = /*#__PURE__*/function (_Declaration) {
-  _inheritsLoose(MaskComposite, _Declaration);
-
-  function MaskComposite() {
-    return _Declaration.apply(this, arguments) || this;
-  }
-
-  var _proto = MaskComposite.prototype;
+let Declaration = require('../declaration')
 
+class MaskComposite extends Declaration {
   /**
    * Prefix mask-composite for webkit
    */
-  _proto.insert = function insert(decl, prefix, prefixes) {
-    var isCompositeProp = decl.prop === 'mask-composite';
-    var compositeValues;
+  insert (decl, prefix, prefixes) {
+    let isCompositeProp = decl.prop === 'mask-composite'
+
+    let compositeValues
 
     if (isCompositeProp) {
-      compositeValues = decl.value.split(',');
+      compositeValues = decl.value.split(',')
     } else {
-      compositeValues = decl.value.match(MaskComposite.regexp) || [];
+      compositeValues = decl.value.match(MaskComposite.regexp) || []
     }
 
-    compositeValues = compositeValues.map(function (el) {
-      return el.trim();
-    }).filter(function (el) {
-      return el;
-    });
-    var hasCompositeValues = compositeValues.length;
-    var compositeDecl;
+    compositeValues = compositeValues.map(el => el.trim()).filter(el => el)
+    let hasCompositeValues = compositeValues.length
+
+    let compositeDecl
 
     if (hasCompositeValues) {
-      compositeDecl = this.clone(decl);
-      compositeDecl.value = compositeValues.map(function (value) {
-        return MaskComposite.oldValues[value] || value;
-      }).join(', ');
+      compositeDecl = this.clone(decl)
+      compositeDecl.value = compositeValues
+        .map(value => MaskComposite.oldValues[value] || value)
+        .join(', ')
 
       if (compositeValues.includes('intersect')) {
-        compositeDecl.value += ', xor';
+        compositeDecl.value += ', xor'
       }
 
-      compositeDecl.prop = prefix + 'mask-composite';
+      compositeDecl.prop = prefix + 'mask-composite'
     }
 
     if (isCompositeProp) {
       if (!hasCompositeValues) {
-        return undefined;
+        return undefined
       }
 
       if (this.needCascade(decl)) {
-        compositeDecl.raws.before = this.calcBefore(prefixes, decl, prefix);
+        compositeDecl.raws.before = this.calcBefore(prefixes, decl, prefix)
       }
 
-      return decl.parent.insertBefore(decl, compositeDecl);
+      return decl.parent.insertBefore(decl, compositeDecl)
     }
 
-    var cloned = this.clone(decl);
-    cloned.prop = prefix + cloned.prop;
+    let cloned = this.clone(decl)
+    cloned.prop = prefix + cloned.prop
 
     if (hasCompositeValues) {
-      cloned.value = cloned.value.replace(MaskComposite.regexp, '');
+      cloned.value = cloned.value.replace(MaskComposite.regexp, '')
     }
 
     if (this.needCascade(decl)) {
-      cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
+      cloned.raws.before = this.calcBefore(prefixes, decl, prefix)
     }
 
-    decl.parent.insertBefore(decl, cloned);
+    decl.parent.insertBefore(decl, cloned)
 
     if (!hasCompositeValues) {
-      return decl;
+      return decl
     }
 
     if (this.needCascade(decl)) {
-      compositeDecl.raws.before = this.calcBefore(prefixes, decl, prefix);
+      compositeDecl.raws.before = this.calcBefore(prefixes, decl, prefix)
     }
+    return decl.parent.insertBefore(decl, compositeDecl)
+  }
+}
 
-    return decl.parent.insertBefore(decl, compositeDecl);
-  };
-
-  return MaskComposite;
-}(Declaration);
-
-_defineProperty(MaskComposite, "names", ['mask', 'mask-composite']);
+MaskComposite.names = ['mask', 'mask-composite']
 
-_defineProperty(MaskComposite, "oldValues", {
+MaskComposite.oldValues = {
   add: 'source-over',
   substract: 'source-out',
   intersect: 'source-in',
   exclude: 'xor'
-});
+}
 
-_defineProperty(MaskComposite, "regexp", new RegExp("\\s+(" + Object.keys(MaskComposite.oldValues).join('|') + ")\\b(?!\\))\\s*(?=[,])", 'ig'));
+MaskComposite.regexp = new RegExp(
+  `\\s+(${Object.keys(MaskComposite.oldValues).join(
+    '|'
+  )})\\b(?!\\))\\s*(?=[,])`,
+  'ig'
+)
 
-module.exports = MaskComposite;
+module.exports = MaskComposite