autoprefixer 6.7.6 → 7.1.0

package/lib/declaration.js

@@ -1,162 +1,253 @@
-(function() {
-  var Browsers, Declaration, Prefixer, 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"); } }
 
-  Browsers = require('./browsers');
+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; }
 
-  Declaration = (function(superClass) {
-    extend(Declaration, superClass);
+var Prefixer = require('./prefixer');
+var Browsers = require('./browsers');
+var utils = require('./utils');
+
+var Declaration = function (_Prefixer) {
+    _inherits(Declaration, _Prefixer);
 
     function Declaration() {
-      return Declaration.__super__.constructor.apply(this, arguments);
+        _classCallCheck(this, Declaration);
+
+        return _possibleConstructorReturn(this, _Prefixer.apply(this, arguments));
     }
 
-    Declaration.prototype.check = function(decl) {
-      return true;
+    /**
+     * Always true, because we already get prefixer by property name
+     */
+    Declaration.prototype.check = function check() /* decl */{
+        return true;
     };
 
-    Declaration.prototype.prefixed = function(prop, prefix) {
-      return prefix + prop;
+    /**
+     * Return prefixed version of property
+     */
+
+
+    Declaration.prototype.prefixed = function prefixed(prop, prefix) {
+        return prefix + prop;
     };
 
-    Declaration.prototype.normalize = function(prop) {
-      return prop;
+    /**
+     * Return unprefixed version of property
+     */
+
+
+    Declaration.prototype.normalize = function normalize(prop) {
+        return prop;
     };
 
-    Declaration.prototype.otherPrefixes = function(value, prefix) {
-      var j, len, other, ref;
-      ref = Browsers.prefixes();
-      for (j = 0, len = ref.length; j < len; j++) {
-        other = ref[j];
-        if (other === prefix) {
-          continue;
-        }
-        if (value.indexOf(other) !== -1) {
-          return true;
+    /**
+     * Check `value`, that it contain other prefixes, rather than `prefix`
+     */
+
+
+    Declaration.prototype.otherPrefixes = function otherPrefixes(value, prefix) {
+        for (var _iterator = Browsers.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 other = _ref;
+
+            if (other === prefix) {
+                continue;
+            }
+            if (value.indexOf(other) !== -1) {
+                return true;
+            }
         }
-      }
-      return false;
+        return false;
     };
 
-    Declaration.prototype.set = function(decl, prefix) {
-      decl.prop = this.prefixed(decl.prop, prefix);
-      return decl;
-    };
+    /**
+     * Set prefix to declaration
+     */
 
-    Declaration.prototype.needCascade = function(decl) {
-      return decl._autoprefixerCascade || (decl._autoprefixerCascade = this.all.options.cascade !== false && decl.raw('before').indexOf('\n') !== -1);
+
+    Declaration.prototype.set = function set(decl, prefix) {
+        decl.prop = this.prefixed(decl.prop, prefix);
+        return decl;
     };
 
-    Declaration.prototype.maxPrefixed = function(prefixes, decl) {
-      var j, len, max, prefix;
-      if (decl._autoprefixerMax) {
-        return decl._autoprefixerMax;
-      }
-      max = 0;
-      for (j = 0, len = prefixes.length; j < len; j++) {
-        prefix = prefixes[j];
-        prefix = utils.removeNote(prefix);
-        if (prefix.length > max) {
-          max = prefix.length;
+    /**
+     * Should we use visual cascade for prefixes
+     */
+
+
+    Declaration.prototype.needCascade = function needCascade(decl) {
+        if (!decl._autoprefixerCascade) {
+            decl._autoprefixerCascade = this.all.options.cascade !== false && decl.raw('before').indexOf('\n') !== -1;
         }
-      }
-      return decl._autoprefixerMax = max;
+        return decl._autoprefixerCascade;
     };
 
-    Declaration.prototype.calcBefore = function(prefixes, decl, prefix) {
-      var before, diff, i, j, max, ref;
-      if (prefix == null) {
-        prefix = '';
-      }
-      before = decl.raw('before');
-      max = this.maxPrefixed(prefixes, decl);
-      diff = max - utils.removeNote(prefix).length;
-      for (i = j = 0, ref = diff; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) {
-        before += ' ';
-      }
-      return before;
-    };
+    /**
+     * Return maximum length of possible prefixed property
+     */
+
 
-    Declaration.prototype.restoreBefore = function(decl) {
-      var lines, min;
-      lines = decl.raw('before').split("\n");
-      min = lines[lines.length - 1];
-      this.all.group(decl).up(function(prefixed) {
-        var array, last;
-        array = prefixed.raw('before').split("\n");
-        last = array[array.length - 1];
-        if (last.length < min.length) {
-          return min = last;
+    Declaration.prototype.maxPrefixed = function maxPrefixed(prefixes, decl) {
+        if (decl._autoprefixerMax) {
+            return decl._autoprefixerMax;
         }
-      });
-      lines[lines.length - 1] = min;
-      return decl.raws.before = lines.join("\n");
+
+        var max = 0;
+        for (var _iterator2 = prefixes, _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 prefix = _ref2;
+
+            prefix = utils.removeNote(prefix);
+            if (prefix.length > max) {
+                max = prefix.length;
+            }
+        }
+        decl._autoprefixerMax = max;
+
+        return decl._autoprefixerMax;
+    };
+
+    /**
+     * Calculate indentation to create visual cascade
+     */
+
+
+    Declaration.prototype.calcBefore = function calcBefore(prefixes, decl) {
+        var prefix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+
+        var max = this.maxPrefixed(prefixes, decl);
+        var diff = max - utils.removeNote(prefix).length;
+
+        var before = decl.raw('before');
+        before += Array(diff).fill(' ').join('');
+
+        return before;
     };
 
-    Declaration.prototype.insert = function(decl, prefix, prefixes) {
-      var already, cloned;
-      cloned = this.set(this.clone(decl), prefix);
-      if (!cloned) {
-        return;
-      }
-      already = decl.parent.some(function(i) {
-        return i.prop === cloned.prop && i.value === cloned.value;
-      });
-      if (already) {
-        return;
-      }
-      if (this.needCascade(decl)) {
-        cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
-      }
-      return decl.parent.insertBefore(decl, cloned);
+    /**
+     * Remove visual cascade
+     */
+
+
+    Declaration.prototype.restoreBefore = function restoreBefore(decl) {
+        var lines = decl.raw('before').split('\n');
+        var min = lines[lines.length - 1];
+
+        this.all.group(decl).up(function (prefixed) {
+            var array = prefixed.raw('before').split('\n');
+            var last = array[array.length - 1];
+            if (last.length < min.length) {
+                min = last;
+            }
+        });
+
+        lines[lines.length - 1] = min;
+        decl.raws.before = lines.join('\n');
     };
 
-    Declaration.prototype.isAlready = function(decl, prefixed) {
-      var already;
-      already = this.all.group(decl).up(function(i) {
-        return i.prop === prefixed;
-      });
-      already || (already = this.all.group(decl).down(function(i) {
-        return i.prop === prefixed;
-      }));
-      return already;
+    /**
+     * Clone and insert new declaration
+     */
+
+
+    Declaration.prototype.insert = function insert(decl, prefix, prefixes) {
+        var cloned = this.set(this.clone(decl), prefix);
+        if (!cloned) return undefined;
+
+        var already = decl.parent.some(function (i) {
+            return i.prop === cloned.prop && i.value === cloned.value;
+        });
+        if (already) {
+            return undefined;
+        }
+
+        if (this.needCascade(decl)) {
+            cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
+        }
+        return decl.parent.insertBefore(decl, cloned);
     };
 
-    Declaration.prototype.add = function(decl, prefix, prefixes) {
-      var prefixed;
-      prefixed = this.prefixed(decl.prop, prefix);
-      if (this.isAlready(decl, prefixed) || this.otherPrefixes(decl.value, prefix)) {
-        return;
-      }
-      return this.insert(decl, prefix, prefixes);
+    /**
+     * Did this declaration has this prefix above
+     */
+
+
+    Declaration.prototype.isAlready = function isAlready(decl, prefixed) {
+        var already = this.all.group(decl).up(function (i) {
+            return i.prop === prefixed;
+        });
+        if (!already) {
+            already = this.all.group(decl).down(function (i) {
+                return i.prop === prefixed;
+            });
+        }
+        return already;
     };
 
-    Declaration.prototype.process = function(decl) {
-      var prefixes;
-      if (this.needCascade(decl)) {
-        prefixes = Declaration.__super__.process.apply(this, arguments);
-        if (prefixes != null ? prefixes.length : void 0) {
-          this.restoreBefore(decl);
-          return decl.raws.before = this.calcBefore(prefixes, decl);
+    /**
+     * Clone and add prefixes for declaration
+     */
+
+
+    Declaration.prototype.add = function add(decl, prefix, prefixes) {
+        var prefixed = this.prefixed(decl.prop, prefix);
+        if (this.isAlready(decl, prefixed) || this.otherPrefixes(decl.value, prefix)) {
+            return undefined;
         }
-      } else {
-        return Declaration.__super__.process.apply(this, arguments);
-      }
+        return this.insert(decl, prefix, prefixes);
     };
 
-    Declaration.prototype.old = function(prop, prefix) {
-      return [this.prefixed(prop, prefix)];
+    /**
+     * Add spaces for visual cascade
+     */
+
+
+    Declaration.prototype.process = function process(decl) {
+        if (this.needCascade(decl)) {
+            var prefixes = _Prefixer.prototype.process.call(this, decl);
+            if (prefixes && prefixes.length) {
+                this.restoreBefore(decl);
+                decl.raws.before = this.calcBefore(prefixes, decl);
+            }
+        } else {
+            _Prefixer.prototype.process.call(this, decl);
+        }
     };
 
-    return Declaration;
+    /**
+     * Return list of prefixed properties to clean old prefixes
+     */
 
-  })(Prefixer);
 
-  module.exports = Declaration;
+    Declaration.prototype.old = function old(prop, prefix) {
+        return [this.prefixed(prop, prefix)];
+    };
+
+    return Declaration;
+}(Prefixer);
 
-}).call(this);
+module.exports = Declaration;

package/lib/hacks/align-content.js

@@ -1,57 +1,84 @@
-(function() {
-  var AlignContent, Declaration, 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; }
 
-  AlignContent = (function(superClass) {
-    extend(AlignContent, 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 AlignContent = function (_Declaration) {
+    _inherits(AlignContent, _Declaration);
 
     function AlignContent() {
-      return AlignContent.__super__.constructor.apply(this, arguments);
+        _classCallCheck(this, AlignContent);
+
+        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
     }
 
-    AlignContent.names = ['align-content', 'flex-line-pack'];
+    /**
+     * Change property name for 2012 spec
+     */
+    AlignContent.prototype.prefixed = function prefixed(prop, prefix) {
+        var spec = void 0;
 
-    AlignContent.oldValues = {
-      'flex-end': 'end',
-      'flex-start': 'start',
-      'space-between': 'justify',
-      'space-around': 'distribute'
-    };
+        var _flexSpec = flexSpec(prefix);
+
+        spec = _flexSpec[0];
+        prefix = _flexSpec[1];
 
-    AlignContent.prototype.prefixed = function(prop, prefix) {
-      var ref, spec;
-      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
-      if (spec === 2012) {
-        return prefix + 'flex-line-pack';
-      } else {
-        return AlignContent.__super__.prefixed.apply(this, arguments);
-      }
+        if (spec === 2012) {
+            return prefix + 'flex-line-pack';
+        } else {
+            return _Declaration.prototype.prefixed.call(this, prop, prefix);
+        }
     };
 
-    AlignContent.prototype.normalize = function(prop) {
-      return 'align-content';
+    /**
+     * Return property name by final spec
+     */
+
+
+    AlignContent.prototype.normalize = function normalize() {
+        return 'align-content';
     };
 
-    AlignContent.prototype.set = function(decl, prefix) {
-      var spec;
-      spec = flexSpec(prefix)[0];
-      if (spec === 2012) {
-        decl.value = AlignContent.oldValues[decl.value] || decl.value;
-        return AlignContent.__super__.set.call(this, decl, prefix);
-      } else if (spec === 'final') {
-        return AlignContent.__super__.set.apply(this, arguments);
-      }
+    /**
+     * Change value for 2012 spec and ignore prefix for 2009
+     */
+
+
+    AlignContent.prototype.set = function set(decl, prefix) {
+        var spec = flexSpec(prefix)[0];
+        if (spec === 2012) {
+            decl.value = AlignContent.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 AlignContent;
+}(Declaration);
 
-  })(Declaration);
+Object.defineProperty(AlignContent, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['align-content', 'flex-line-pack']
+});
+Object.defineProperty(AlignContent, 'oldValues', {
+    enumerable: true,
+    writable: true,
+    value: {
+        'flex-end': 'end',
+        'flex-start': 'start',
+        'space-between': 'justify',
+        'space-around': 'distribute'
+    }
+});
 
-  module.exports = AlignContent;
 
-}).call(this);
+module.exports = AlignContent;

package/lib/hacks/align-items.js

@@ -1,57 +1,81 @@
-(function() {
-  var AlignItems, Declaration, 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; }
 
-  AlignItems = (function(superClass) {
-    extend(AlignItems, 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 AlignItems = function (_Declaration) {
+    _inherits(AlignItems, _Declaration);
 
     function AlignItems() {
-      return AlignItems.__super__.constructor.apply(this, arguments);
+        _classCallCheck(this, AlignItems);
+
+        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
     }
 
-    AlignItems.names = ['align-items', 'flex-align', 'box-align'];
+    /**
+     * Change property name for 2009 and 2012 specs
+     */
+    AlignItems.prototype.prefixed = function prefixed(prop, prefix) {
+        var spec = void 0;
 
-    AlignItems.oldValues = {
-      'flex-end': 'end',
-      'flex-start': 'start'
-    };
+        var _flexSpec = flexSpec(prefix);
+
+        spec = _flexSpec[0];
+        prefix = _flexSpec[1];
 
-    AlignItems.prototype.prefixed = function(prop, prefix) {
-      var ref, spec;
-      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
-      if (spec === 2009) {
-        return prefix + 'box-align';
-      } else if (spec === 2012) {
-        return prefix + 'flex-align';
-      } else {
-        return AlignItems.__super__.prefixed.apply(this, arguments);
-      }
+        if (spec === 2009) {
+            return prefix + 'box-align';
+        } else if (spec === 2012) {
+            return prefix + 'flex-align';
+        } else {
+            return _Declaration.prototype.prefixed.call(this, prop, prefix);
+        }
     };
 
-    AlignItems.prototype.normalize = function(prop) {
-      return 'align-items';
+    /**
+     * Return property name by final spec
+     */
+
+
+    AlignItems.prototype.normalize = function normalize() {
+        return 'align-items';
     };
 
-    AlignItems.prototype.set = function(decl, prefix) {
-      var spec;
-      spec = flexSpec(prefix)[0];
-      if (spec === 2009 || spec === 2012) {
-        decl.value = AlignItems.oldValues[decl.value] || decl.value;
-        return AlignItems.__super__.set.call(this, decl, prefix);
-      } else {
-        return AlignItems.__super__.set.apply(this, arguments);
-      }
+    /**
+     * Change value for 2009 and 2012 specs
+     */
+
+
+    AlignItems.prototype.set = function set(decl, prefix) {
+        var spec = flexSpec(prefix)[0];
+        if (spec === 2009 || spec === 2012) {
+            decl.value = AlignItems.oldValues[decl.value] || decl.value;
+        }
+        return _Declaration.prototype.set.call(this, decl, prefix);
     };
 
     return AlignItems;
+}(Declaration);
 
-  })(Declaration);
+Object.defineProperty(AlignItems, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['align-items', 'flex-align', 'box-align']
+});
+Object.defineProperty(AlignItems, 'oldValues', {
+    enumerable: true,
+    writable: true,
+    value: {
+        'flex-end': 'end',
+        'flex-start': 'start'
+    }
+});
 
-  module.exports = AlignItems;
 
-}).call(this);
+module.exports = AlignItems;