autoprefixer 6.7.6 → 7.1.0

package/lib/hacks/grid-column-align.js

@@ -0,0 +1,55 @@
+'use strict';
+
+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) : subClass.__proto__ = superClass; }
+
+var Declaration = require('../declaration');
+
+var GridColumnAlign = function (_Declaration) {
+    _inherits(GridColumnAlign, _Declaration);
+
+    function GridColumnAlign() {
+        _classCallCheck(this, GridColumnAlign);
+
+        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+    }
+
+    /**
+     * Do not prefix flexbox values
+     */
+    GridColumnAlign.prototype.check = function check(decl) {
+        return decl.value.indexOf('flex-') === -1 && decl.value !== 'baseline';
+    };
+
+    /**
+     * Change property name for IE
+     */
+
+
+    GridColumnAlign.prototype.prefixed = function prefixed(prop, prefix) {
+        return prefix + 'grid-column-align';
+    };
+
+    /**
+     * Change IE property back
+     */
+
+
+    GridColumnAlign.prototype.normalize = function normalize() {
+        return 'justify-self';
+    };
+
+    return GridColumnAlign;
+}(Declaration);
+
+Object.defineProperty(GridColumnAlign, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['grid-column-align']
+});
+
+
+module.exports = GridColumnAlign;

package/lib/hacks/grid-end.js

@@ -1,46 +1,71 @@
-(function() {
-  var Declaration, GridEnd,
-    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"); } }
 
-  GridEnd = (function(superClass) {
-    extend(GridEnd, 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 GridEnd = function (_Declaration) {
+    _inherits(GridEnd, _Declaration);
 
     function GridEnd() {
-      return GridEnd.__super__.constructor.apply(this, arguments);
-    }
+        _classCallCheck(this, GridEnd);
 
-    GridEnd.names = ['grid-row-end', 'grid-column-end', 'grid-row-span', 'grid-column-span'];
+        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+    }
 
-    GridEnd.prototype.check = function(decl) {
-      return decl.value.indexOf('span') !== -1;
+    /**
+     * Do not add prefix for unsupported value in IE
+     */
+    GridEnd.prototype.check = function check(decl) {
+        return decl.value.indexOf('span') !== -1;
     };
 
-    GridEnd.prototype.normalize = function(prop) {
-      return prop.replace(/(-span|-end)/, '');
+    /**
+     * Return a final spec property
+     */
+
+
+    GridEnd.prototype.normalize = function normalize(prop) {
+        return prop.replace(/(-span|-end)/, '');
     };
 
-    GridEnd.prototype.prefixed = function(prop, prefix) {
-      if (prefix === '-ms-') {
-        return prefix + prop.replace('-end', '-span');
-      } else {
-        return GridEnd.__super__.prefixed.call(this, prop, prefix);
-      }
+    /**
+     * Change property name for IE
+     */
+
+
+    GridEnd.prototype.prefixed = function prefixed(prop, prefix) {
+        if (prefix === '-ms-') {
+            return prefix + prop.replace('-end', '-span');
+        } else {
+            return _Declaration.prototype.prefixed.call(this, prop, prefix);
+        }
     };
 
-    GridEnd.prototype.set = function(decl, prefix) {
-      if (prefix === '-ms-') {
-        decl.value = decl.value.replace(/span\s/i, '');
-      }
-      return GridEnd.__super__.set.call(this, decl, prefix);
+    /**
+     * Change repeating syntax for IE
+     */
+
+
+    GridEnd.prototype.set = function set(decl, prefix) {
+        if (prefix === '-ms-') {
+            decl.value = decl.value.replace(/span\s/i, '');
+        }
+        return _Declaration.prototype.set.call(this, decl, prefix);
     };
 
     return GridEnd;
+}(Declaration);
 
-  })(Declaration);
+Object.defineProperty(GridEnd, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['grid-row-end', 'grid-column-end', 'grid-row-span', 'grid-column-span']
+});
 
-  module.exports = GridEnd;
 
-}).call(this);
+module.exports = GridEnd;

package/lib/hacks/grid-row-align.js

@@ -1,35 +1,55 @@
-(function() {
-  var Declaration, GridRowAlign,
-    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"); } }
 
-  GridRowAlign = (function(superClass) {
-    extend(GridRowAlign, 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 GridRowAlign = function (_Declaration) {
+    _inherits(GridRowAlign, _Declaration);
 
     function GridRowAlign() {
-      return GridRowAlign.__super__.constructor.apply(this, arguments);
-    }
+        _classCallCheck(this, GridRowAlign);
 
-    GridRowAlign.names = ['grid-row-align'];
+        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+    }
 
-    GridRowAlign.prototype.check = function(decl) {
-      return decl.value.indexOf('flex-') === -1 && decl.value !== 'baseline';
+    /**
+     * Do not prefix flexbox values
+     */
+    GridRowAlign.prototype.check = function check(decl) {
+        return decl.value.indexOf('flex-') === -1 && decl.value !== 'baseline';
     };
 
-    GridRowAlign.prototype.prefixed = function(prop, prefix) {
-      return prefix + 'grid-row-align';
+    /**
+     * Change property name for IE
+     */
+
+
+    GridRowAlign.prototype.prefixed = function prefixed(prop, prefix) {
+        return prefix + 'grid-row-align';
     };
 
-    GridRowAlign.prototype.normalize = function(prop) {
-      return 'align-self';
+    /**
+     * Change IE property back
+     */
+
+
+    GridRowAlign.prototype.normalize = function normalize() {
+        return 'align-self';
     };
 
     return GridRowAlign;
+}(Declaration);
 
-  })(Declaration);
+Object.defineProperty(GridRowAlign, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['grid-row-align']
+});
 
-  module.exports = GridRowAlign;
 
-}).call(this);
+module.exports = GridRowAlign;

package/lib/hacks/grid-start.js

@@ -1,71 +1,103 @@
-(function() {
-  var Declaration, GridStart,
-    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"); } }
 
-  GridStart = (function(superClass) {
-    extend(GridStart, 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 GridStart = function (_Declaration) {
+    _inherits(GridStart, _Declaration);
 
     function GridStart() {
-      return GridStart.__super__.constructor.apply(this, arguments);
-    }
+        _classCallCheck(this, GridStart);
 
-    GridStart.names = ['grid-row-start', 'grid-column-start', 'grid-row', 'grid-column'];
+        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+    }
 
-    GridStart.prototype.check = function(decl) {
-      return decl.value.indexOf('/') === -1 || decl.value.indexOf('span') !== -1;
+    /**
+     * Do not add prefix for unsupported value in IE
+     */
+    GridStart.prototype.check = function check(decl) {
+        return decl.value.indexOf('/') === -1 || decl.value.indexOf('span') !== -1;
     };
 
-    GridStart.prototype.normalize = function(prop) {
-      return prop.replace('-start', '');
-    };
+    /**
+     * Return a final spec property
+     */
 
-    GridStart.prototype.prefixed = function(prop, prefix) {
-      if (prefix === '-ms-') {
-        return prefix + prop.replace('-start', '');
-      } else {
-        return GridStart.__super__.prefixed.call(this, prop, prefix);
-      }
+
+    GridStart.prototype.normalize = function normalize(prop) {
+        return prop.replace('-start', '');
     };
 
-    GridStart.prototype.insert = function(decl, prefix, prefixes) {
-      var parts;
-      parts = this.splitValue(decl, prefix);
-      if (parts.length === 2) {
-        decl.cloneBefore({
-          prop: '-ms-' + decl.prop + '-span',
-          value: parts[1]
-        });
-      }
-      return GridStart.__super__.insert.call(this, decl, prefix, prefixes);
+    /**
+     * Change property name for IE
+     */
+
+
+    GridStart.prototype.prefixed = function prefixed(prop, prefix) {
+        if (prefix === '-ms-') {
+            return prefix + prop.replace('-start', '');
+        } else {
+            return _Declaration.prototype.prefixed.call(this, prop, prefix);
+        }
     };
 
-    GridStart.prototype.set = function(decl, prefix) {
-      var parts;
-      parts = this.splitValue(decl, prefix);
-      if (parts.length === 2) {
-        decl.value = parts[0];
-      }
-      return GridStart.__super__.set.call(this, decl, prefix);
+    /**
+     * Split one value to two
+     */
+
+
+    GridStart.prototype.insert = function insert(decl, prefix, prefixes) {
+        var parts = this.splitValue(decl, prefix);
+        if (parts.length === 2) {
+            decl.cloneBefore({
+                prop: '-ms-' + decl.prop + '-span',
+                value: parts[1]
+            });
+        }
+        return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
     };
 
-    GridStart.prototype.splitValue = function(decl, prefix) {
-      var parts;
-      if (prefix === '-ms-' && decl.prop.indexOf('-start') === -1) {
-        parts = decl.value.split(/\s*\/\s*span\s+/);
+    /**
+     * Change value for combine property
+     */
+
+
+    GridStart.prototype.set = function set(decl, prefix) {
+        var parts = this.splitValue(decl, prefix);
         if (parts.length === 2) {
-          return parts;
+            decl.value = parts[0];
+        }
+        return _Declaration.prototype.set.call(this, decl, prefix);
+    };
+
+    /**
+     * If property contains start and end
+     */
+
+
+    GridStart.prototype.splitValue = function splitValue(decl, prefix) {
+        if (prefix === '-ms-' && decl.prop.indexOf('-start') === -1) {
+            var parts = decl.value.split(/\s*\/\s*span\s+/);
+            if (parts.length === 2) {
+                return parts;
+            }
         }
-      }
-      return false;
+        return false;
     };
 
     return GridStart;
+}(Declaration);
 
-  })(Declaration);
+Object.defineProperty(GridStart, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['grid-row-start', 'grid-column-start', 'grid-row', 'grid-column']
+});
 
-  module.exports = GridStart;
 
-}).call(this);
+module.exports = GridStart;

package/lib/hacks/grid-template.js

@@ -1,77 +1,113 @@
-(function() {
-  var Declaration, GridTemplate, parser,
-    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';
 
-  parser = require('postcss-value-parser');
+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; }
 
-  GridTemplate = (function(superClass) {
-    extend(GridTemplate, 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 parser = require('postcss-value-parser');
+
+var Declaration = require('../declaration');
+
+var GridTemplate = function (_Declaration) {
+    _inherits(GridTemplate, _Declaration);
 
     function GridTemplate() {
-      return GridTemplate.__super__.constructor.apply(this, arguments);
-    }
+        _classCallCheck(this, GridTemplate);
 
-    GridTemplate.names = ['grid-template-rows', 'grid-template-columns', 'grid-rows', 'grid-columns'];
+        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+    }
 
-    GridTemplate.prototype.prefixed = function(prop, prefix) {
-      if (prefix === '-ms-') {
-        return prefix + prop.replace('template-', '');
-      } else {
-        return GridTemplate.__super__.prefixed.call(this, prop, prefix);
-      }
+    /**
+     * Change property name for IE
+     */
+    GridTemplate.prototype.prefixed = function prefixed(prop, prefix) {
+        if (prefix === '-ms-') {
+            return prefix + prop.replace('template-', '');
+        } else {
+            return _Declaration.prototype.prefixed.call(this, prop, prefix);
+        }
     };
 
-    GridTemplate.prototype.normalize = function(prop) {
-      return prop.replace(/^grid-(rows|columns)/, 'grid-template-$1');
+    /**
+     * Change IE property back
+     */
+
+
+    GridTemplate.prototype.normalize = function normalize(prop) {
+        return prop.replace(/^grid-(rows|columns)/, 'grid-template-$1');
     };
 
-    GridTemplate.prototype.walkRepeat = function(node) {
-      var count, first, fixed, i, j, len, ref;
-      fixed = [];
-      ref = node.nodes;
-      for (j = 0, len = ref.length; j < len; j++) {
-        i = ref[j];
-        if (i.nodes) {
-          this.walkRepeat(i);
-        }
-        fixed.push(i);
-        if (i.type === 'function' && i.value === 'repeat') {
-          first = i.nodes.shift();
-          if (first) {
-            count = first.value;
-            i.nodes.shift();
-            i.value = '';
-            fixed.push({
-              type: 'word',
-              value: "[" + count + "]"
-            });
-          }
+    /**
+     * Recursive part of changeRepeat
+     */
+
+
+    GridTemplate.prototype.walkRepeat = function walkRepeat(node) {
+        var fixed = [];
+        for (var _iterator = node.nodes, _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 i = _ref;
+
+            if (i.nodes) {
+                this.walkRepeat(i);
+            }
+            fixed.push(i);
+            if (i.type === 'function' && i.value === 'repeat') {
+                var first = i.nodes.shift();
+                if (first) {
+                    var count = first.value;
+                    i.nodes.shift();
+                    i.value = '';
+                    fixed.push({ type: 'word', value: '[' + count + ']' });
+                }
+            }
         }
-      }
-      return node.nodes = fixed;
+        node.nodes = fixed;
     };
 
-    GridTemplate.prototype.changeRepeat = function(value) {
-      var ast;
-      ast = parser(value);
-      this.walkRepeat(ast);
-      return ast.toString();
+    /**
+     * IE repeating syntax
+     */
+
+
+    GridTemplate.prototype.changeRepeat = function changeRepeat(value) {
+        var ast = parser(value);
+        this.walkRepeat(ast);
+        return ast.toString();
     };
 
-    GridTemplate.prototype.set = function(decl, prefix) {
-      if (prefix === '-ms-' && decl.value.indexOf('repeat(') !== -1) {
-        decl.value = this.changeRepeat(decl.value);
-      }
-      return GridTemplate.__super__.set.call(this, decl, prefix);
+    /**
+     * Change repeating syntax for IE
+     */
+
+
+    GridTemplate.prototype.set = function set(decl, prefix) {
+        if (prefix === '-ms-' && decl.value.indexOf('repeat(') !== -1) {
+            decl.value = this.changeRepeat(decl.value);
+        }
+        return _Declaration.prototype.set.call(this, decl, prefix);
     };
 
     return GridTemplate;
+}(Declaration);
 
-  })(Declaration);
+Object.defineProperty(GridTemplate, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['grid-template-rows', 'grid-template-columns', 'grid-rows', 'grid-columns']
+});
 
-  module.exports = GridTemplate;
 
-}).call(this);
+module.exports = GridTemplate;