autoprefixer 6.7.6 → 7.1.0

package/lib/utils.js

@@ -1,57 +1,93 @@
-(function() {
-  var list;
+'use strict';
 
-  list = require('postcss/lib/list');
+var list = require('postcss/lib/list');
 
-  module.exports = {
-    error: function(text) {
-      var err;
-      err = new Error(text);
-      err.autoprefixer = true;
-      throw err;
+module.exports = {
+
+    /**
+     * Throw special error, to tell beniary,
+     * that this error is from Autoprefixer.
+     */
+    error: function error(text) {
+        var err = new Error(text);
+        err.autoprefixer = true;
+        throw err;
     },
-    uniq: function(array) {
-      var filtered, i, j, len;
-      filtered = [];
-      for (j = 0, len = array.length; j < len; j++) {
-        i = array[j];
-        if (filtered.indexOf(i) === -1) {
-          filtered.push(i);
+
+
+    /**
+     * Return array, that doesn’t contain duplicates.
+     */
+    uniq: function uniq(array) {
+        var filtered = [];
+        for (var _iterator = array, _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 (filtered.indexOf(i) === -1) {
+                filtered.push(i);
+            }
         }
-      }
-      return filtered;
+        return filtered;
     },
-    removeNote: function(string) {
-      if (string.indexOf(' ') === -1) {
-        return string;
-      } else {
-        return string.split(' ')[0];
-      }
+
+
+    /**
+     * Return "-webkit-" on "-webkit- old"
+     */
+    removeNote: function removeNote(string) {
+        if (string.indexOf(' ') === -1) {
+            return string;
+        } else {
+            return string.split(' ')[0];
+        }
     },
-    escapeRegexp: function(string) {
-      return string.replace(/[.?*+\^\$\[\]\\(){}|\-]/g, '\\$&');
+
+
+    /**
+     * Escape RegExp symbols
+     */
+    escapeRegexp: function escapeRegexp(string) {
+        return string.replace(/[.?*+\^\$\[\]\\(){}|\-]/g, '\\$&');
     },
-    regexp: function(word, escape) {
-      if (escape == null) {
-        escape = true;
-      }
-      if (escape) {
-        word = this.escapeRegexp(word);
-      }
-      return RegExp("(^|[\\s,(])(" + word + "($|[\\s(,]))", "gi");
+
+
+    /**
+     * Return regexp to check, that CSS string contain word
+     */
+    regexp: function regexp(word) {
+        var escape = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+
+        if (escape) {
+            word = this.escapeRegexp(word);
+        }
+        return new RegExp('(^|[\\s,(])(' + word + '($|[\\s(,]))', 'gi');
     },
-    editList: function(value, callback) {
-      var changed, join, origin;
-      origin = list.comma(value);
-      changed = callback(origin, []);
-      if (origin === changed) {
-        return value;
-      } else {
-        join = value.match(/,\s*/);
-        join = join ? join[0] : ', ';
-        return changed.join(join);
-      }
-    }
-  };
 
-}).call(this);
+
+    /**
+     * Change comma list
+     */
+    editList: function editList(value, callback) {
+        var origin = list.comma(value);
+        var changed = callback(origin, []);
+
+        if (origin === changed) {
+            return value;
+        } else {
+            var join = value.match(/,\s*/);
+            join = join ? join[0] : ', ';
+            return changed.join(join);
+        }
+    }
+};

package/lib/value.js

@@ -1,108 +1,146 @@
-(function() {
-  var OldValue, Prefixer, Value, utils, vendor,
-    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"); } }
 
-  OldValue = require('./old-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; }
 
-  vendor = require('postcss/lib/vendor');
+var Prefixer = require('./prefixer');
+var OldValue = require('./old-value');
+var utils = require('./utils');
 
-  Value = (function(superClass) {
-    extend(Value, superClass);
+var vendor = require('postcss/lib/vendor');
+
+var Value = function (_Prefixer) {
+    _inherits(Value, _Prefixer);
 
     function Value() {
-      return Value.__super__.constructor.apply(this, arguments);
+        _classCallCheck(this, Value);
+
+        return _possibleConstructorReturn(this, _Prefixer.apply(this, arguments));
     }
 
-    Value.save = function(prefixes, decl) {
-      var already, cloned, prefix, prefixed, prop, propPrefix, ref, results, rule, trimmed, value;
-      prop = decl.prop;
-      ref = decl._autoprefixerValues;
-      results = [];
-      for (prefix in ref) {
-        value = ref[prefix];
-        if (value === decl.value) {
-          continue;
-        }
-        propPrefix = vendor.prefix(prop);
-        if (propPrefix === prefix) {
-          results.push(decl.value = value);
-        } else if (propPrefix === '-pie-') {
-          continue;
-        } else {
-          prefixed = prefixes.prefixed(prop, prefix);
-          rule = decl.parent;
-          if (rule.every(function(i) {
-            return i.prop !== prefixed;
-          })) {
-            trimmed = value.replace(/\s+/, ' ');
-            already = rule.some(function(i) {
-              return i.prop === decl.prop && i.value.replace(/\s+/, ' ') === trimmed;
-            });
-            if (!already) {
-              cloned = this.clone(decl, {
-                value: value
-              });
-              results.push(decl.parent.insertBefore(decl, cloned));
+    /**
+     * Clone decl for each prefixed values
+     */
+    Value.save = function save(prefixes, decl) {
+        var _this2 = this;
+
+        var prop = decl.prop;
+        var result = [];
+
+        for (var prefix in decl._autoprefixerValues) {
+            var value = decl._autoprefixerValues[prefix];
+
+            if (value === decl.value) {
+                continue;
+            }
+
+            var item = void 0;
+            var propPrefix = vendor.prefix(prop);
+
+            if (propPrefix === prefix) {
+                item = decl.value = value;
+            } else if (propPrefix === '-pie-') {
+                continue;
             } else {
-              results.push(void 0);
+                (function () {
+                    var prefixed = prefixes.prefixed(prop, prefix);
+                    var rule = decl.parent;
+                    if (rule.every(function (i) {
+                        return i.prop !== prefixed;
+                    })) {
+                        var trimmed = value.replace(/\s+/, ' ');
+                        var already = rule.some(function (i) {
+                            return i.prop === decl.prop && i.value.replace(/\s+/, ' ') === trimmed;
+                        });
+
+                        if (!already) {
+                            var cloned = _this2.clone(decl, { value: value });
+                            item = decl.parent.insertBefore(decl, cloned);
+                        }
+                    }
+                })();
             }
-          } else {
-            results.push(void 0);
-          }
+
+            result.push(item);
         }
-      }
-      return results;
-    };
 
-    Value.prototype.check = function(decl) {
-      var value;
-      value = decl.value;
-      if (value.indexOf(this.name) !== -1) {
-        return !!value.match(this.regexp());
-      } else {
-        return false;
-      }
+        return result;
     };
 
-    Value.prototype.regexp = function() {
-      return this.regexpCache || (this.regexpCache = utils.regexp(this.name));
+    /**
+     * Is declaration need to be prefixed
+     */
+
+
+    Value.prototype.check = function check(decl) {
+        var value = decl.value;
+        if (value.indexOf(this.name) !== -1) {
+            return !!value.match(this.regexp());
+        } else {
+            return false;
+        }
     };
 
-    Value.prototype.replace = function(string, prefix) {
-      return string.replace(this.regexp(), '$1' + prefix + '$2');
+    /**
+     * Lazy regexp loading
+     */
+
+
+    Value.prototype.regexp = function regexp() {
+        return this.regexpCache || (this.regexpCache = utils.regexp(this.name));
     };
 
-    Value.prototype.value = function(decl) {
-      if (decl.raws.value && decl.raws.value.value === decl.value) {
-        return decl.raws.value.raw;
-      } else {
-        return decl.value;
-      }
+    /**
+     * Add prefix to values in string
+     */
+
+
+    Value.prototype.replace = function replace(string, prefix) {
+        return string.replace(this.regexp(), '$1' + prefix + '$2');
     };
 
-    Value.prototype.add = function(decl, prefix) {
-      var value;
-      decl._autoprefixerValues || (decl._autoprefixerValues = {});
-      value = decl._autoprefixerValues[prefix] || this.value(decl);
-      value = this.replace(value, prefix);
-      if (value) {
-        return decl._autoprefixerValues[prefix] = value;
-      }
+    /**
+     * Get value with comments if it was not changed
+     */
+
+
+    Value.prototype.value = function value(decl) {
+        if (decl.raws.value && decl.raws.value.value === decl.value) {
+            return decl.raws.value.raw;
+        } else {
+            return decl.value;
+        }
     };
 
-    Value.prototype.old = function(prefix) {
-      return new OldValue(this.name, prefix + this.name);
+    /**
+     * Save values with next prefixed token
+     */
+
+
+    Value.prototype.add = function add(decl, prefix) {
+        if (!decl._autoprefixerValues) {
+            decl._autoprefixerValues = {};
+        }
+        var value = decl._autoprefixerValues[prefix] || this.value(decl);
+        value = this.replace(value, prefix);
+        if (value) {
+            decl._autoprefixerValues[prefix] = value;
+        }
     };
 
-    return Value;
+    /**
+     * Return function to fast find prefixed value
+     */
+
 
-  })(Prefixer);
+    Value.prototype.old = function old(prefix) {
+        return new OldValue(this.name, prefix + this.name);
+    };
 
-  module.exports = Value;
+    return Value;
+}(Prefixer);
 
-}).call(this);
+module.exports = Value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autoprefixer",
-  "version": "6.7.6",
+  "version": "7.1.0",
   "description": "Parse CSS and add vendor prefixes to CSS rules using values from the Can I Use website",
   "keywords": [
     "autoprefixer",
@@ -13,33 +13,73 @@
   "license": "MIT",
   "repository": "postcss/autoprefixer",
   "dependencies": {
-    "browserslist": "^1.7.5",
-    "caniuse-db": "^1.0.30000628",
+    "browserslist": "^2.1.2",
+    "caniuse-lite": "^1.0.30000669",
     "normalize-range": "^0.1.2",
     "num2fraction": "^1.2.2",
-    "postcss": "^5.2.15",
+    "postcss": "^6.0.1",
     "postcss-value-parser": "^3.2.3"
   },
   "devDependencies": {
-    "browserify": "^14.1.0",
+    "babel-eslint": "^7.2.3",
+    "babel-plugin-transform-class-properties": "^6.24.1",
+    "babel-preset-env": "^1.4.0",
+    "browserify": "^14.3.0",
+    "eslint": "^3.19.0",
     "eslint-config-postcss": "^2.0.2",
-    "fs-extra": "^2.0.0",
+    "fs-extra": "^3.0.1",
     "gulp": "^3.9.1",
-    "gulp-coffee": "^2.3.3",
-    "gulp-eslint": "^3.0.1",
+    "gulp-babel": "^6.1.2",
+    "gulp-coffee": "^2.3.4",
     "gulp-json-editor": "^2.2.1",
-    "gulp-mocha": "^3.0.1",
     "gulp-replace": "^0.5.4",
-    "mocha": "^3.2.0",
-    "should": "^11.2.0",
+    "jest": "^20.0.1",
+    "lint-staged": "^3.4.1",
+    "pre-commit": "^1.2.2",
     "vinyl-source-stream": "^1.1.0",
-    "coffee-script": "^1.12.4"
+    "babel-register": "^6.24.0"
   },
   "scripts": {
-    "test": "gulp"
+    "lint-staged": "lint-staged",
+    "lint": "eslint *.js lib/*.js data/*.js test/*.js",
+    "test": "jest && npm run lint && gulp"
   },
+  "lint-staged": {
+    "*.js": "eslint"
+  },
+  "pre-commit": [
+    "lint-staged"
+  ],
   "eslintConfig": {
-    "extends": "eslint-config-postcss/es5"
+    "extends": "eslint-config-postcss",
+    "parser": "babel-eslint",
+    "rules": {
+      "complexity": "off",
+      "camelcase": "off"
+    },
+    "env": {
+      "jest": true
+    }
+  },
+  "babel": {
+    "presets": [
+      [
+        "env", {
+          "targets": {
+            "browsers": "last 1 version",
+            "node": 4
+          },
+          "loose": true
+        }
+      ]
+    ],
+    "plugins": [
+      [
+        "transform-class-properties", {
+          "spec": true
+        }
+      ]
+    ]
   },
   "main": "lib/autoprefixer"
 }

package/lib/hacks/justify-items.js

@@ -1,31 +0,0 @@
-(function() {
-  var Declaration, JustifyItems,
-    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;
-
-  Declaration = require('../declaration');
-
-  JustifyItems = (function(superClass) {
-    extend(JustifyItems, superClass);
-
-    function JustifyItems() {
-      return JustifyItems.__super__.constructor.apply(this, arguments);
-    }
-
-    JustifyItems.names = ['justify-items', 'grid-column-align'];
-
-    JustifyItems.prototype.prefixed = function(prop, prefix) {
-      return prefix + (prefix === '-ms-' ? 'grid-column-align' : prop);
-    };
-
-    JustifyItems.prototype.normalize = function(prop) {
-      return 'justify-items';
-    };
-
-    return JustifyItems;
-
-  })(Declaration);
-
-  module.exports = JustifyItems;
-
-}).call(this);

package/lib/hacks/stretch.js

@@ -1,45 +0,0 @@
-(function() {
-  var OldValue, Stretch, Value,
-    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;
-
-  OldValue = require('../old-value');
-
-  Value = require('../value');
-
-  Stretch = (function(superClass) {
-    extend(Stretch, superClass);
-
-    function Stretch() {
-      return Stretch.__super__.constructor.apply(this, arguments);
-    }
-
-    Stretch.names = ['stretch', 'fill', 'fill-available'];
-
-    Stretch.prototype.replace = function(string, prefix) {
-      if (prefix === '-moz-') {
-        return string.replace(this.regexp(), '$1-moz-available$3');
-      } else if (prefix === '-webkit-') {
-        return string.replace(this.regexp(), '$1-webkit-fill-available$3');
-      } else {
-        return Stretch.__super__.replace.apply(this, arguments);
-      }
-    };
-
-    Stretch.prototype.old = function(prefix) {
-      if (prefix === '-moz-') {
-        return new OldValue(this.name, '-moz-available');
-      } else if (prefix === '-webkit-') {
-        return new OldValue(this.name, '-webkit-fill-available');
-      } else {
-        return Stretch.__super__.old.apply(this, arguments);
-      }
-    };
-
-    return Stretch;
-
-  })(Value);
-
-  module.exports = Stretch;
-
-}).call(this);