autoprefixer 6.7.6 → 7.1.0

package/lib/hacks/gradient.js

@@ -1,368 +1,528 @@
-(function() {
-  var Gradient, OldValue, Value, isDirection, list, parser, range, 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,
-    slice = [].slice;
+'use strict';
 
-  OldValue = require('../old-value');
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-  Value = require('../value');
+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; }
 
-  parser = require('postcss-value-parser');
+var OldValue = require('../old-value');
+var Value = require('../value');
+var utils = require('../utils');
 
-  range = require('normalize-range');
+var parser = require('postcss-value-parser');
+var range = require('normalize-range');
 
-  list = require('postcss/lib/list');
+var isDirection = /top|left|right|bottom/gi;
 
-  isDirection = /top|left|right|bottom/gi;
-
-  Gradient = (function(superClass) {
-    extend(Gradient, superClass);
+var Gradient = function (_Value) {
+    _inherits(Gradient, _Value);
 
     function Gradient() {
-      return Gradient.__super__.constructor.apply(this, arguments);
+        var _temp, _this, _ret;
+
+        _classCallCheck(this, Gradient);
+
+        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+        }
+
+        return _ret = (_temp = (_this = _possibleConstructorReturn(this, _Value.call.apply(_Value, [this].concat(args))), _this), Object.defineProperty(_this, 'directions', {
+            enumerable: true,
+            writable: true,
+            value: {
+                top: 'bottom',
+                left: 'right',
+                bottom: 'top',
+                right: 'left'
+            }
+        }), Object.defineProperty(_this, 'oldDirections', {
+            enumerable: true,
+            writable: true,
+            value: {
+                'top': 'left bottom, left top',
+                'left': 'right top, left top',
+                'bottom': 'left top, left bottom',
+                'right': 'left top, right top',
+
+                'top right': 'left bottom, right top',
+                'top left': 'right bottom, left top',
+                'right top': 'left bottom, right top',
+                'right bottom': 'left top, right bottom',
+                'bottom right': 'left top, right bottom',
+                'bottom left': 'right top, left bottom',
+                'left top': 'right bottom, left top',
+                'left bottom': 'right top, left bottom'
+            }
+        }), _temp), _possibleConstructorReturn(_this, _ret);
     }
 
-    Gradient.names = ['linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient'];
-
-    Gradient.prototype.replace = function(string, prefix) {
-      var ast, changes, j, len, node, ref;
-      ast = parser(string);
-      ref = ast.nodes;
-      for (j = 0, len = ref.length; j < len; j++) {
-        node = ref[j];
-        if (node.type === 'function' && node.value === this.name) {
-          node.nodes = this.newDirection(node.nodes);
-          node.nodes = this.normalize(node.nodes);
-          if (prefix === '-webkit- old') {
-            changes = this.oldWebkit(node);
-            if (!changes) {
-              return;
+    // Direction to replace
+
+
+    // Direction to replace
+
+
+    /**
+     * Change degrees for webkit prefix
+     */
+    Gradient.prototype.replace = function replace(string, prefix) {
+        var ast = parser(string);
+        for (var _iterator = ast.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 node = _ref;
+
+            if (node.type === 'function' && node.value === this.name) {
+                node.nodes = this.newDirection(node.nodes);
+                node.nodes = this.normalize(node.nodes);
+                if (prefix === '-webkit- old') {
+                    var changes = this.oldWebkit(node);
+                    if (!changes) {
+                        return undefined;
+                    }
+                } else {
+                    node.nodes = this.convertDirection(node.nodes);
+                    node.value = prefix + node.value;
+                }
             }
-          } else {
-            node.nodes = this.convertDirection(node.nodes);
-            node.value = prefix + node.value;
-          }
         }
-      }
-      return ast.toString();
+        return ast.toString();
     };
 
-    Gradient.prototype.directions = {
-      top: 'bottom',
-      left: 'right',
-      bottom: 'top',
-      right: 'left'
-    };
+    /**
+     * Replace first token
+     */
 
-    Gradient.prototype.oldDirections = {
-      'top': 'left bottom, left top',
-      'left': 'right top, left top',
-      'bottom': 'left top, left bottom',
-      'right': 'left top, right top',
-      'top right': 'left bottom, right top',
-      'top left': 'right bottom, left top',
-      'right top': 'left bottom, right top',
-      'right bottom': 'left top, right bottom',
-      'bottom right': 'left top, right bottom',
-      'bottom left': 'right top, left bottom',
-      'left top': 'right bottom, left top',
-      'left bottom': 'right top, left bottom'
-    };
 
-    Gradient.prototype.replaceFirst = function() {
-      var params, prefix, words;
-      params = arguments[0], words = 2 <= arguments.length ? slice.call(arguments, 1) : [];
-      prefix = words.map(function(i) {
-        if (i === ' ') {
-          return {
-            type: 'space',
-            value: i
-          };
-        } else {
-          return {
-            type: 'word',
-            value: i
-          };
+    Gradient.prototype.replaceFirst = function replaceFirst(params) {
+        for (var _len2 = arguments.length, words = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+            words[_key2 - 1] = arguments[_key2];
         }
-      });
-      return prefix.concat(params.slice(1));
-    };
 
-    Gradient.prototype.normalizeUnit = function(str, full) {
-      var deg, num;
-      num = parseFloat(str);
-      deg = (num / full) * 360;
-      return deg + "deg";
+        var prefix = words.map(function (i) {
+            if (i === ' ') {
+                return { type: 'space', value: i };
+            } else {
+                return { type: 'word', value: i };
+            }
+        });
+        return prefix.concat(params.slice(1));
     };
 
-    Gradient.prototype.normalize = function(nodes) {
-      var num;
-      if (!nodes[0]) {
-        return nodes;
-      }
-      if (/-?\d+(.\d+)?grad/.test(nodes[0].value)) {
-        nodes[0].value = this.normalizeUnit(nodes[0].value, 400);
-      } else if (/-?\d+(.\d+)?rad/.test(nodes[0].value)) {
-        nodes[0].value = this.normalizeUnit(nodes[0].value, 2 * Math.PI);
-      } else if (/-?\d+(.\d+)?turn/.test(nodes[0].value)) {
-        nodes[0].value = this.normalizeUnit(nodes[0].value, 1);
-      } else if (nodes[0].value.indexOf('deg') !== -1) {
-        num = parseFloat(nodes[0].value);
-        num = range.wrap(0, 360, num);
-        nodes[0].value = num + "deg";
-      }
-      if (nodes[0].value === '0deg') {
-        nodes = this.replaceFirst(nodes, 'to', ' ', 'top');
-      } else if (nodes[0].value === '90deg') {
-        nodes = this.replaceFirst(nodes, 'to', ' ', 'right');
-      } else if (nodes[0].value === '180deg') {
-        nodes = this.replaceFirst(nodes, 'to', ' ', 'bottom');
-      } else if (nodes[0].value === '270deg') {
-        nodes = this.replaceFirst(nodes, 'to', ' ', 'left');
-      }
-      return nodes;
+    /**
+     * Convert angle unit to deg
+     */
+
+
+    Gradient.prototype.normalizeUnit = function normalizeUnit(str, full) {
+        var num = parseFloat(str);
+        var deg = num / full * 360;
+        return deg + 'deg';
     };
 
-    Gradient.prototype.newDirection = function(params) {
-      var i, j, ref;
-      if (params[0].value === 'to') {
-        return params;
-      }
-      if (!isDirection.test(params[0].value)) {
-        return params;
-      }
-      params.unshift({
-        type: 'word',
-        value: 'to'
-      }, {
-        type: 'space',
-        value: ' '
-      });
-      for (i = j = 2, ref = params.length; 2 <= ref ? j < ref : j > ref; i = 2 <= ref ? ++j : --j) {
-        if (params[i].type === 'div') {
-          break;
+    /**
+     * Normalize angle
+     */
+
+
+    Gradient.prototype.normalize = function normalize(nodes) {
+        if (!nodes[0]) {
+            return nodes;
+        }
+
+        if (/-?\d+(.\d+)?grad/.test(nodes[0].value)) {
+            nodes[0].value = this.normalizeUnit(nodes[0].value, 400);
+        } else if (/-?\d+(.\d+)?rad/.test(nodes[0].value)) {
+            nodes[0].value = this.normalizeUnit(nodes[0].value, 2 * Math.PI);
+        } else if (/-?\d+(.\d+)?turn/.test(nodes[0].value)) {
+            nodes[0].value = this.normalizeUnit(nodes[0].value, 1);
+        } else if (nodes[0].value.indexOf('deg') !== -1) {
+            var num = parseFloat(nodes[0].value);
+            num = range.wrap(0, 360, num);
+            nodes[0].value = num + 'deg';
         }
-        if (params[i].type === 'word') {
-          params[i].value = this.revertDirection(params[i].value);
+
+        if (nodes[0].value === '0deg') {
+            nodes = this.replaceFirst(nodes, 'to', ' ', 'top');
+        } else if (nodes[0].value === '90deg') {
+            nodes = this.replaceFirst(nodes, 'to', ' ', 'right');
+        } else if (nodes[0].value === '180deg') {
+            nodes = this.replaceFirst(nodes, 'to', ' ', 'bottom');
+        } else if (nodes[0].value === '270deg') {
+            nodes = this.replaceFirst(nodes, 'to', ' ', 'left');
         }
-      }
-      return params;
+
+        return nodes;
     };
 
-    Gradient.prototype.convertDirection = function(params) {
-      if (params.length > 0) {
+    /**
+     * Replace old direction to new
+     */
+
+
+    Gradient.prototype.newDirection = function newDirection(params) {
         if (params[0].value === 'to') {
-          this.fixDirection(params);
-        } else if (params[0].value.indexOf('deg') !== -1) {
-          this.fixAngle(params);
-        } else if (params[2].value === 'at') {
-          this.fixRadial(params);
+            return params;
+        }
+        if (!isDirection.test(params[0].value)) {
+            return params;
         }
-      }
-      return params;
+
+        params.unshift({
+            type: 'word',
+            value: 'to'
+        }, {
+            type: 'space',
+            value: ' '
+        });
+
+        for (var i = 2; i < params.length; i++) {
+            if (params[i].type === 'div') {
+                break;
+            }
+            if (params[i].type === 'word') {
+                params[i].value = this.revertDirection(params[i].value);
+            }
+        }
+
+        return params;
     };
 
-    Gradient.prototype.fixDirection = function(params) {
-      var i, j, ref, results;
-      params.splice(0, 2);
-      results = [];
-      for (i = j = 0, ref = params.length; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) {
-        if (params[i].type === 'div') {
-          break;
+    /**
+     * Change new direction to old
+     */
+
+
+    Gradient.prototype.convertDirection = function convertDirection(params) {
+        if (params.length > 0) {
+            if (params[0].value === 'to') {
+                this.fixDirection(params);
+            } else if (params[0].value.indexOf('deg') !== -1) {
+                this.fixAngle(params);
+            } else if (params[2].value === 'at') {
+                this.fixRadial(params);
+            }
         }
-        if (params[i].type === 'word') {
-          results.push(params[i].value = this.revertDirection(params[i].value));
-        } else {
-          results.push(void 0);
+        return params;
+    };
+
+    /**
+     * Replace `to top left` to `bottom right`
+     */
+
+
+    Gradient.prototype.fixDirection = function fixDirection(params) {
+        params.splice(0, 2);
+
+        for (var _iterator2 = params, _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 param = _ref2;
+
+            if (param.type === 'div') {
+                break;
+            }
+            if (param.type === 'word') {
+                param.value = this.revertDirection(param.value);
+            }
         }
-      }
-      return results;
     };
 
-    Gradient.prototype.fixAngle = function(params) {
-      var first;
-      first = params[0].value;
-      first = parseFloat(first);
-      first = Math.abs(450 - first) % 360;
-      first = this.roundFloat(first, 3);
-      return params[0].value = first + "deg";
+    /**
+     * Add 90 degrees
+     */
+
+
+    Gradient.prototype.fixAngle = function fixAngle(params) {
+        var first = params[0].value;
+        first = parseFloat(first);
+        first = Math.abs(450 - first) % 360;
+        first = this.roundFloat(first, 3);
+        params[0].value = first + 'deg';
     };
 
-    Gradient.prototype.fixRadial = function(params) {
-      var first, i, j, ref, second;
-      first = params[0];
-      second = [];
-      for (i = j = 4, ref = params.length; 4 <= ref ? j < ref : j > ref; i = 4 <= ref ? ++j : --j) {
-        if (params[i].type === 'div') {
-          break;
-        } else {
-          second.push(params[i]);
+    /**
+     * Fix radial direction syntax
+     */
+
+
+    Gradient.prototype.fixRadial = function fixRadial(params) {
+        var first = params[0];
+        var second = [];
+        var i = void 0;
+
+        for (i = 4; i < params.length; i++) {
+            if (params[i].type === 'div') {
+                break;
+            } else {
+                second.push(params[i]);
+            }
         }
-      }
-      return params.splice.apply(params, [0, i].concat(slice.call(second), [params[i + 2]], [first]));
+
+        params.splice.apply(params, [0, i].concat(second, [params[i + 2], first]));
     };
 
-    Gradient.prototype.revertDirection = function(word) {
-      return this.directions[word.toLowerCase()] || word;
+    Gradient.prototype.revertDirection = function revertDirection(word) {
+        return this.directions[word.toLowerCase()] || word;
     };
 
-    Gradient.prototype.roundFloat = function(float, digits) {
-      return parseFloat(float.toFixed(digits));
+    /**
+     * Round float and save digits under dot
+     */
+
+
+    Gradient.prototype.roundFloat = function roundFloat(float, digits) {
+        return parseFloat(float.toFixed(digits));
     };
 
-    Gradient.prototype.oldWebkit = function(node) {
-      var i, j, k, len, len1, nodes, param, params, string;
-      nodes = node.nodes;
-      string = parser.stringify(node.nodes);
-      if (this.name !== 'linear-gradient') {
-        return false;
-      }
-      if (nodes[0] && nodes[0].value.indexOf('deg') !== -1) {
-        return false;
-      }
-      if (string.indexOf('px') !== -1) {
-        return false;
-      }
-      if (string.indexOf('-corner') !== -1) {
-        return false;
-      }
-      if (string.indexOf('-side') !== -1) {
-        return false;
-      }
-      params = [[]];
-      for (j = 0, len = nodes.length; j < len; j++) {
-        i = nodes[j];
-        params[params.length - 1].push(i);
-        if (i.type === 'div' && i.value === ',') {
-          params.push([]);
+    /**
+     * Convert to old webkit syntax
+     */
+
+
+    Gradient.prototype.oldWebkit = function oldWebkit(node) {
+        var nodes = node.nodes;
+
+        var string = parser.stringify(node.nodes);
+
+        if (this.name !== 'linear-gradient') {
+            return false;
+        }
+        if (nodes[0] && nodes[0].value.indexOf('deg') !== -1) {
+            return false;
+        }
+        if (string.indexOf('px') !== -1) {
+            return false;
+        }
+        if (string.indexOf('-corner') !== -1) {
+            return false;
+        }
+        if (string.indexOf('-side') !== -1) {
+            return false;
         }
-      }
-      this.oldDirection(params);
-      this.colorStops(params);
-      node.nodes = [];
-      for (k = 0, len1 = params.length; k < len1; k++) {
-        param = params[k];
-        node.nodes = node.nodes.concat(param);
-      }
-      node.nodes.unshift({
-        type: 'word',
-        value: 'linear'
-      }, this.cloneDiv(node.nodes));
-      node.value = '-webkit-gradient';
-      return true;
-    };
 
-    Gradient.prototype.oldDirection = function(params) {
-      var div, j, len, node, old, ref, words;
-      div = this.cloneDiv(params[0]);
-      if (params[0][0].value !== 'to') {
-        return params.unshift([
-          {
-            type: 'word',
-            value: this.oldDirections.bottom
-          }, div
-        ]);
-      } else {
-        words = [];
-        ref = params[0].slice(2);
-        for (j = 0, len = ref.length; j < len; j++) {
-          node = ref[j];
-          if (node.type === 'word') {
-            words.push(node.value.toLowerCase());
-          }
+        var params = [[]];
+        for (var _iterator3 = nodes, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
+            var _ref3;
+
+            if (_isArray3) {
+                if (_i3 >= _iterator3.length) break;
+                _ref3 = _iterator3[_i3++];
+            } else {
+                _i3 = _iterator3.next();
+                if (_i3.done) break;
+                _ref3 = _i3.value;
+            }
+
+            var i = _ref3;
+
+            params[params.length - 1].push(i);
+            if (i.type === 'div' && i.value === ',') {
+                params.push([]);
+            }
         }
-        words = words.join(' ');
-        old = this.oldDirections[words] || words;
-        return params[0] = [
-          {
-            type: 'word',
-            value: old
-          }, div
-        ];
-      }
+
+        this.oldDirection(params);
+        this.colorStops(params);
+
+        node.nodes = [];
+        for (var _iterator4 = params, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
+            var _ref4;
+
+            if (_isArray4) {
+                if (_i4 >= _iterator4.length) break;
+                _ref4 = _iterator4[_i4++];
+            } else {
+                _i4 = _iterator4.next();
+                if (_i4.done) break;
+                _ref4 = _i4.value;
+            }
+
+            var param = _ref4;
+
+            node.nodes = node.nodes.concat(param);
+        }
+
+        node.nodes.unshift({ type: 'word', value: 'linear' }, this.cloneDiv(node.nodes));
+        node.value = '-webkit-gradient';
+
+        return true;
     };
 
-    Gradient.prototype.cloneDiv = function(params) {
-      var i, j, len;
-      for (j = 0, len = params.length; j < len; j++) {
-        i = params[j];
-        if (i.type === 'div' && i.value === ',') {
-          return i;
+    /**
+     * Change direction syntax to old webkit
+     */
+
+
+    Gradient.prototype.oldDirection = function oldDirection(params) {
+        var div = this.cloneDiv(params[0]);
+
+        if (params[0][0].value !== 'to') {
+            return params.unshift([{ type: 'word', value: this.oldDirections.bottom }, div]);
+        } else {
+            var _words = [];
+            for (var _iterator5 = params[0].slice(2), _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
+                var _ref5;
+
+                if (_isArray5) {
+                    if (_i5 >= _iterator5.length) break;
+                    _ref5 = _iterator5[_i5++];
+                } else {
+                    _i5 = _iterator5.next();
+                    if (_i5.done) break;
+                    _ref5 = _i5.value;
+                }
+
+                var node = _ref5;
+
+                if (node.type === 'word') {
+                    _words.push(node.value.toLowerCase());
+                }
+            }
+
+            _words = _words.join(' ');
+            var old = this.oldDirections[_words] || _words;
+
+            params[0] = [{ type: 'word', value: old }, div];
+            return params[0];
         }
-      }
-      return {
-        type: 'div',
-        value: ',',
-        after: ' '
-      };
     };
 
-    Gradient.prototype.colorStops = function(params) {
-      var color, div, i, j, len, param, pos, results, stop;
-      results = [];
-      for (i = j = 0, len = params.length; j < len; i = ++j) {
-        param = params[i];
-        if (i === 0) {
-          continue;
+    /**
+     * Get div token from exists parameters
+     */
+
+
+    Gradient.prototype.cloneDiv = function cloneDiv(params) {
+        for (var _iterator6 = params, _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {
+            var _ref6;
+
+            if (_isArray6) {
+                if (_i6 >= _iterator6.length) break;
+                _ref6 = _iterator6[_i6++];
+            } else {
+                _i6 = _iterator6.next();
+                if (_i6.done) break;
+                _ref6 = _i6.value;
+            }
+
+            var i = _ref6;
+
+            if (i.type === 'div' && i.value === ',') {
+                return i;
+            }
         }
-        color = parser.stringify(param[0]);
-        if (param[1] && param[1].type === 'word') {
-          pos = param[1].value;
-        } else if (param[2] && param[2].type === 'word') {
-          pos = param[2].value;
+        return { type: 'div', value: ',', after: ' ' };
+    };
+
+    /**
+     * Change colors syntax to old webkit
+     */
+
+
+    Gradient.prototype.colorStops = function colorStops(params) {
+        var result = [];
+        for (var i = 0; i < params.length; i++) {
+            var pos = void 0;
+            var param = params[i];
+            var item = void 0;
+            if (i === 0) {
+                continue;
+            }
+
+            var color = parser.stringify(param[0]);
+            if (param[1] && param[1].type === 'word') {
+                pos = param[1].value;
+            } else if (param[2] && param[2].type === 'word') {
+                pos = param[2].value;
+            }
+
+            var stop = void 0;
+            if (i === 1 && (!pos || pos === '0%')) {
+                stop = 'from(' + color + ')';
+            } else if (i === params.length - 1 && (!pos || pos === '100%')) {
+                stop = 'to(' + color + ')';
+            } else if (pos) {
+                stop = 'color-stop(' + pos + ', ' + color + ')';
+            } else {
+                stop = 'color-stop(' + color + ')';
+            }
+
+            var div = param[param.length - 1];
+            params[i] = [{ type: 'word', value: stop }];
+            if (div.type === 'div' && div.value === ',') {
+                item = params[i].push(div);
+            }
+            result.push(item);
         }
-        stop = i === 1 && (!pos || pos === '0%') ? "from(" + color + ")" : i === params.length - 1 && (!pos || pos === '100%') ? "to(" + color + ")" : pos ? "color-stop(" + pos + ", " + color + ")" : "color-stop(" + color + ")";
-        div = param[param.length - 1];
-        params[i] = [
-          {
-            type: 'word',
-            value: stop
-          }
-        ];
-        if (div.type === 'div' && div.value === ',') {
-          results.push(params[i].push(div));
+        return result;
+    };
+
+    /**
+     * Remove old WebKit gradient too
+     */
+
+
+    Gradient.prototype.old = function old(prefix) {
+        if (prefix === '-webkit-') {
+            var type = this.name === 'linear-gradient' ? 'linear' : 'radial';
+            var string = '-gradient';
+            var regexp = utils.regexp('-webkit-(' + type + '-gradient|gradient\\(\\s*' + type + ')', false);
+
+            return new OldValue(this.name, prefix + this.name, string, regexp);
         } else {
-          results.push(void 0);
+            return _Value.prototype.old.call(this, prefix);
         }
-      }
-      return results;
     };
 
-    Gradient.prototype.old = function(prefix) {
-      var regexp, string, type;
-      if (prefix === '-webkit-') {
-        type = this.name === 'linear-gradient' ? 'linear' : 'radial';
-        string = '-gradient';
-        regexp = utils.regexp("-webkit-(" + type + "-gradient|gradient\\(\\s*" + type + ")", false);
-        return new OldValue(this.name, prefix + this.name, string, regexp);
-      } else {
-        return Gradient.__super__.old.apply(this, arguments);
-      }
-    };
+    /**
+     * Do not add non-webkit prefixes for list-style and object
+     */
 
-    Gradient.prototype.add = function(decl, prefix) {
-      var p;
-      p = decl.prop;
-      if (p.indexOf('mask') !== -1) {
-        if (prefix === '-webkit-' || prefix === '-webkit- old') {
-          return Gradient.__super__.add.apply(this, arguments);
-        }
-      } else if (p === 'list-style' || p === 'list-style-image' || p === 'content') {
-        if (prefix === '-webkit-' || prefix === '-webkit- old') {
-          return Gradient.__super__.add.apply(this, arguments);
+
+    Gradient.prototype.add = function add(decl, prefix) {
+        var p = decl.prop;
+        if (p.indexOf('mask') !== -1) {
+            if (prefix === '-webkit-' || prefix === '-webkit- old') {
+                return _Value.prototype.add.call(this, decl, prefix);
+            }
+        } else if (p === 'list-style' || p === 'list-style-image' || p === 'content') {
+            if (prefix === '-webkit-' || prefix === '-webkit- old') {
+                return _Value.prototype.add.call(this, decl, prefix);
+            }
+        } else {
+            return _Value.prototype.add.call(this, decl, prefix);
         }
-      } else {
-        return Gradient.__super__.add.apply(this, arguments);
-      }
+        return undefined;
     };
 
     return Gradient;
+}(Value);
 
-  })(Value);
+Object.defineProperty(Gradient, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient']
+});
 
-  module.exports = Gradient;
 
-}).call(this);
+module.exports = Gradient;