autoprefixer 9.8.7 → 10.0.2

package/lib/hacks/animation.js

@@ -1,35 +1,17 @@
-"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 Animation = /*#__PURE__*/function (_Declaration) {
-  _inheritsLoose(Animation, _Declaration);
-
-  function Animation() {
-    return _Declaration.apply(this, arguments) || this;
-  }
-
-  var _proto = Animation.prototype;
+let Declaration = require('../declaration')
 
+class Animation extends Declaration {
   /**
    * Don’t add prefixes for modern values.
    */
-  _proto.check = function check(decl) {
-    return !decl.value.split(/\s+/).some(function (i) {
-      var lower = i.toLowerCase();
-      return lower === 'reverse' || lower === 'alternate-reverse';
-    });
-  };
-
-  return Animation;
-}(Declaration);
+  check (decl) {
+    return !decl.value.split(/\s+/).some(i => {
+      let lower = i.toLowerCase()
+      return lower === 'reverse' || lower === 'alternate-reverse'
+    })
+  }
+}
 
-_defineProperty(Animation, "names", ['animation', 'animation-direction']);
+Animation.names = ['animation', 'animation-direction']
 
-module.exports = Animation;
+module.exports = Animation

package/lib/hacks/appearance.js

@@ -1,39 +1,23 @@
-"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 utils = require('../utils');
-
-var Appearance = /*#__PURE__*/function (_Declaration) {
-  _inheritsLoose(Appearance, _Declaration);
-
-  function Appearance(name, prefixes, all) {
-    var _this;
-
-    _this = _Declaration.call(this, name, prefixes, all) || this;
-
-    if (_this.prefixes) {
-      _this.prefixes = utils.uniq(_this.prefixes.map(function (i) {
-        if (i === '-ms-') {
-          return '-webkit-';
-        }
-
-        return i;
-      }));
+let Declaration = require('../declaration')
+let utils = require('../utils')
+
+class Appearance extends Declaration {
+  constructor (name, prefixes, all) {
+    super(name, prefixes, all)
+
+    if (this.prefixes) {
+      this.prefixes = utils.uniq(
+        this.prefixes.map(i => {
+          if (i === '-ms-') {
+            return '-webkit-'
+          }
+          return i
+        })
+      )
     }
-
-    return _this;
   }
+}
 
-  return Appearance;
-}(Declaration);
-
-_defineProperty(Appearance, "names", ['appearance']);
+Appearance.names = ['appearance']
 
-module.exports = Appearance;
+module.exports = Appearance

package/lib/hacks/backdrop-filter.js

@@ -1,35 +1,20 @@
-"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 utils = require('../utils');
-
-var BackdropFilter = /*#__PURE__*/function (_Declaration) {
-  _inheritsLoose(BackdropFilter, _Declaration);
-
-  function BackdropFilter(name, prefixes, all) {
-    var _this;
-
-    _this = _Declaration.call(this, name, prefixes, all) || this;
-
-    if (_this.prefixes) {
-      _this.prefixes = utils.uniq(_this.prefixes.map(function (i) {
-        return i === '-ms-' ? '-webkit-' : i;
-      }));
+let Declaration = require('../declaration')
+let utils = require('../utils')
+
+class BackdropFilter extends Declaration {
+  constructor (name, prefixes, all) {
+    super(name, prefixes, all)
+
+    if (this.prefixes) {
+      this.prefixes = utils.uniq(
+        this.prefixes.map(i => {
+          return i === '-ms-' ? '-webkit-' : i
+        })
+      )
     }
-
-    return _this;
   }
+}
 
-  return BackdropFilter;
-}(Declaration);
-
-_defineProperty(BackdropFilter, "names", ['backdrop-filter']);
+BackdropFilter.names = ['backdrop-filter']
 
-module.exports = BackdropFilter;
+module.exports = BackdropFilter

package/lib/hacks/background-clip.js

@@ -1,41 +1,24 @@
-"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 utils = require('../utils');
-
-var BackgroundClip = /*#__PURE__*/function (_Declaration) {
-  _inheritsLoose(BackgroundClip, _Declaration);
-
-  function BackgroundClip(name, prefixes, all) {
-    var _this;
-
-    _this = _Declaration.call(this, name, prefixes, all) || this;
-
-    if (_this.prefixes) {
-      _this.prefixes = utils.uniq(_this.prefixes.map(function (i) {
-        return i === '-ms-' ? '-webkit-' : i;
-      }));
+let Declaration = require('../declaration')
+let utils = require('../utils')
+
+class BackgroundClip extends Declaration {
+  constructor (name, prefixes, all) {
+    super(name, prefixes, all)
+
+    if (this.prefixes) {
+      this.prefixes = utils.uniq(
+        this.prefixes.map(i => {
+          return i === '-ms-' ? '-webkit-' : i
+        })
+      )
     }
-
-    return _this;
   }
 
-  var _proto = BackgroundClip.prototype;
-
-  _proto.check = function check(decl) {
-    return decl.value.toLowerCase() === 'text';
-  };
-
-  return BackgroundClip;
-}(Declaration);
+  check (decl) {
+    return decl.value.toLowerCase() === 'text'
+  }
+}
 
-_defineProperty(BackgroundClip, "names", ['background-clip']);
+BackgroundClip.names = ['background-clip']
 
-module.exports = BackgroundClip;
+module.exports = BackgroundClip

package/lib/hacks/background-size.js

@@ -1,38 +1,23 @@
-"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 BackgroundSize = /*#__PURE__*/function (_Declaration) {
-  _inheritsLoose(BackgroundSize, _Declaration);
-
-  function BackgroundSize() {
-    return _Declaration.apply(this, arguments) || this;
-  }
-
-  var _proto = BackgroundSize.prototype;
+let Declaration = require('../declaration')
 
+class BackgroundSize extends Declaration {
   /**
    * Duplication parameter for -webkit- browsers
    */
-  _proto.set = function set(decl, prefix) {
-    var value = decl.value.toLowerCase();
-
-    if (prefix === '-webkit-' && !value.includes(' ') && value !== 'contain' && value !== 'cover') {
-      decl.value = decl.value + ' ' + decl.value;
+  set (decl, prefix) {
+    let value = decl.value.toLowerCase()
+    if (
+      prefix === '-webkit-' &&
+      !value.includes(' ') &&
+      value !== 'contain' &&
+      value !== 'cover'
+    ) {
+      decl.value = decl.value + ' ' + decl.value
     }
+    return super.set(decl, prefix)
+  }
+}
 
-    return _Declaration.prototype.set.call(this, decl, prefix);
-  };
-
-  return BackgroundSize;
-}(Declaration);
-
-_defineProperty(BackgroundSize, "names", ['background-size']);
+BackgroundSize.names = ['background-size']
 
-module.exports = BackgroundSize;
+module.exports = BackgroundSize

package/lib/hacks/block-logical.js

@@ -1,48 +1,40 @@
-"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 BlockLogical = /*#__PURE__*/function (_Declaration) {
-  _inheritsLoose(BlockLogical, _Declaration);
-
-  function BlockLogical() {
-    return _Declaration.apply(this, arguments) || this;
-  }
-
-  var _proto = BlockLogical.prototype;
+let Declaration = require('../declaration')
 
+class BlockLogical extends Declaration {
   /**
    * Use old syntax for -moz- and -webkit-
    */
-  _proto.prefixed = function prefixed(prop, prefix) {
+  prefixed (prop, prefix) {
     if (prop.includes('-start')) {
-      return prefix + prop.replace('-block-start', '-before');
+      return prefix + prop.replace('-block-start', '-before')
     }
-
-    return prefix + prop.replace('-block-end', '-after');
+    return prefix + prop.replace('-block-end', '-after')
   }
+
   /**
    * Return property name by spec
    */
-  ;
-
-  _proto.normalize = function normalize(prop) {
+  normalize (prop) {
     if (prop.includes('-before')) {
-      return prop.replace('-before', '-block-start');
+      return prop.replace('-before', '-block-start')
     }
-
-    return prop.replace('-after', '-block-end');
-  };
-
-  return BlockLogical;
-}(Declaration);
-
-_defineProperty(BlockLogical, "names", ['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']);
-
-module.exports = BlockLogical;
+    return prop.replace('-after', '-block-end')
+  }
+}
+
+BlockLogical.names = [
+  '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'
+]
+
+module.exports = BlockLogical

package/lib/hacks/border-image.js

@@ -1,33 +1,15 @@
-"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 BorderImage = /*#__PURE__*/function (_Declaration) {
-  _inheritsLoose(BorderImage, _Declaration);
-
-  function BorderImage() {
-    return _Declaration.apply(this, arguments) || this;
-  }
-
-  var _proto = BorderImage.prototype;
+let Declaration = require('../declaration')
 
+class BorderImage extends Declaration {
   /**
    * Remove fill parameter for prefixed declarations
    */
-  _proto.set = function set(decl, prefix) {
-    decl.value = decl.value.replace(/\s+fill(\s)/, '$1');
-    return _Declaration.prototype.set.call(this, decl, prefix);
-  };
-
-  return BorderImage;
-}(Declaration);
+  set (decl, prefix) {
+    decl.value = decl.value.replace(/\s+fill(\s)/, '$1')
+    return super.set(decl, prefix)
+  }
+}
 
-_defineProperty(BorderImage, "names", ['border-image']);
+BorderImage.names = ['border-image']
 
-module.exports = BorderImage;
+module.exports = BorderImage

package/lib/hacks/border-radius.js

@@ -1,62 +1,40 @@
-"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 BorderRadius = /*#__PURE__*/function (_Declaration) {
-  _inheritsLoose(BorderRadius, _Declaration);
-
-  function BorderRadius() {
-    return _Declaration.apply(this, arguments) || this;
-  }
-
-  var _proto = BorderRadius.prototype;
+let Declaration = require('../declaration')
 
+class BorderRadius extends Declaration {
   /**
    * Change syntax, when add Mozilla prefix
    */
-  _proto.prefixed = function prefixed(prop, prefix) {
+  prefixed (prop, prefix) {
     if (prefix === '-moz-') {
-      return prefix + (BorderRadius.toMozilla[prop] || prop);
+      return prefix + (BorderRadius.toMozilla[prop] || prop)
     }
-
-    return _Declaration.prototype.prefixed.call(this, prop, prefix);
+    return super.prefixed(prop, prefix)
   }
+
   /**
    * Return unprefixed version of property
    */
-  ;
-
-  _proto.normalize = function normalize(prop) {
-    return BorderRadius.toNormal[prop] || prop;
-  };
-
-  return BorderRadius;
-}(Declaration);
+  normalize (prop) {
+    return BorderRadius.toNormal[prop] || prop
+  }
+}
 
-_defineProperty(BorderRadius, "names", ['border-radius']);
+BorderRadius.names = ['border-radius']
 
-_defineProperty(BorderRadius, "toMozilla", {});
+BorderRadius.toMozilla = {}
+BorderRadius.toNormal = {}
 
-_defineProperty(BorderRadius, "toNormal", {});
+for (let ver of ['top', 'bottom']) {
+  for (let hor of ['left', 'right']) {
+    let normal = `border-${ver}-${hor}-radius`
+    let mozilla = `border-radius-${ver}${hor}`
 
-for (var _i = 0, _arr = ['top', 'bottom']; _i < _arr.length; _i++) {
-  var ver = _arr[_i];
+    BorderRadius.names.push(normal)
+    BorderRadius.names.push(mozilla)
 
-  for (var _i2 = 0, _arr2 = ['left', 'right']; _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.toMozilla[normal] = mozilla;
-    BorderRadius.toNormal[mozilla] = normal;
+    BorderRadius.toMozilla[normal] = mozilla
+    BorderRadius.toNormal[mozilla] = normal
   }
 }
 
-module.exports = BorderRadius;
+module.exports = BorderRadius

package/lib/hacks/break-props.js

@@ -1,76 +1,63 @@
-"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 BreakProps = /*#__PURE__*/function (_Declaration) {
-  _inheritsLoose(BreakProps, _Declaration);
-
-  function BreakProps() {
-    return _Declaration.apply(this, arguments) || this;
-  }
-
-  var _proto = BreakProps.prototype;
+let Declaration = require('../declaration')
 
+class BreakProps extends Declaration {
   /**
    * Change name for -webkit- and -moz- prefix
    */
-  _proto.prefixed = function prefixed(prop, prefix) {
-    return prefix + "column-" + prop;
+  prefixed (prop, prefix) {
+    return `${prefix}column-${prop}`
   }
+
   /**
    * Return property name by final spec
    */
-  ;
-
-  _proto.normalize = function normalize(prop) {
+  normalize (prop) {
     if (prop.includes('inside')) {
-      return 'break-inside';
+      return 'break-inside'
     }
-
     if (prop.includes('before')) {
-      return 'break-before';
+      return 'break-before'
     }
-
-    return 'break-after';
+    return 'break-after'
   }
+
   /**
    * Change prefixed value for avoid-column and avoid-page
    */
-  ;
-
-  _proto.set = function set(decl, prefix) {
-    if (decl.prop === 'break-inside' && decl.value === 'avoid-column' || decl.value === 'avoid-page') {
-      decl.value = 'avoid';
+  set (decl, prefix) {
+    if (
+      (decl.prop === 'break-inside' && decl.value === 'avoid-column') ||
+      decl.value === 'avoid-page'
+    ) {
+      decl.value = 'avoid'
     }
-
-    return _Declaration.prototype.set.call(this, decl, prefix);
+    return super.set(decl, prefix)
   }
+
   /**
    * Don’t prefix some values
    */
-  ;
-
-  _proto.insert = function insert(decl, prefix, prefixes) {
+  insert (decl, prefix, prefixes) {
     if (decl.prop !== 'break-inside') {
-      return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+      return super.insert(decl, prefix, prefixes)
     }
-
     if (/region/i.test(decl.value) || /page/i.test(decl.value)) {
-      return undefined;
+      return undefined
     }
-
-    return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
-  };
-
-  return BreakProps;
-}(Declaration);
-
-_defineProperty(BreakProps, "names", ['break-inside', 'page-break-inside', 'column-break-inside', 'break-before', 'page-break-before', 'column-break-before', 'break-after', 'page-break-after', 'column-break-after']);
-
-module.exports = BreakProps;
+    return super.insert(decl, prefix, prefixes)
+  }
+}
+
+BreakProps.names = [
+  'break-inside',
+  'page-break-inside',
+  'column-break-inside',
+  'break-before',
+  'page-break-before',
+  'column-break-before',
+  'break-after',
+  'page-break-after',
+  'column-break-after'
+]
+
+module.exports = BreakProps

package/lib/hacks/color-adjust.js

@@ -1,40 +1,21 @@
-"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 ColorAdjust = /*#__PURE__*/function (_Declaration) {
-  _inheritsLoose(ColorAdjust, _Declaration);
-
-  function ColorAdjust() {
-    return _Declaration.apply(this, arguments) || this;
-  }
-
-  var _proto = ColorAdjust.prototype;
+let Declaration = require('../declaration')
 
+class ColorAdjust extends Declaration {
   /**
    * Change property name for WebKit-based browsers
    */
-  _proto.prefixed = function prefixed(prop, prefix) {
-    return prefix + 'print-color-adjust';
+  prefixed (prop, prefix) {
+    return prefix + 'print-color-adjust'
   }
+
   /**
    * Return property name by spec
    */
-  ;
-
-  _proto.normalize = function normalize() {
-    return 'color-adjust';
-  };
-
-  return ColorAdjust;
-}(Declaration);
+  normalize () {
+    return 'color-adjust'
+  }
+}
 
-_defineProperty(ColorAdjust, "names", ['color-adjust', 'print-color-adjust']);
+ColorAdjust.names = ['color-adjust', 'print-color-adjust']
 
-module.exports = ColorAdjust;
+module.exports = ColorAdjust