autoprefixer 6.7.6 → 7.1.0

package/lib/hacks/image-rendering.js

@@ -1,53 +1,83 @@
-(function() {
-  var Declaration, ImageRendering,
-    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"); } }
 
-  ImageRendering = (function(superClass) {
-    extend(ImageRendering, 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 ImageRendering = function (_Declaration) {
+    _inherits(ImageRendering, _Declaration);
 
     function ImageRendering() {
-      return ImageRendering.__super__.constructor.apply(this, arguments);
-    }
+        _classCallCheck(this, ImageRendering);
 
-    ImageRendering.names = ['image-rendering', 'interpolation-mode'];
+        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+    }
 
-    ImageRendering.prototype.check = function(decl) {
-      return decl.value === 'pixelated';
+    /**
+     * Add hack only for crisp-edges
+     */
+    ImageRendering.prototype.check = function check(decl) {
+        return decl.value === 'pixelated';
     };
 
-    ImageRendering.prototype.prefixed = function(prop, prefix) {
-      if (prefix === '-ms-') {
-        return '-ms-interpolation-mode';
-      } else {
-        return ImageRendering.__super__.prefixed.apply(this, arguments);
-      }
+    /**
+     * Change property name for IE
+     */
+
+
+    ImageRendering.prototype.prefixed = function prefixed(prop, prefix) {
+        if (prefix === '-ms-') {
+            return '-ms-interpolation-mode';
+        } else {
+            return _Declaration.prototype.prefixed.call(this, prop, prefix);
+        }
     };
 
-    ImageRendering.prototype.set = function(decl, prefix) {
-      if (prefix === '-ms-') {
-        decl.prop = '-ms-interpolation-mode';
-        decl.value = 'nearest-neighbor';
-        return decl;
-      } else {
-        return ImageRendering.__super__.set.apply(this, arguments);
-      }
+    /**
+     * Change property and value for IE
+     */
+
+
+    ImageRendering.prototype.set = function set(decl, prefix) {
+        if (prefix === '-ms-') {
+            decl.prop = '-ms-interpolation-mode';
+            decl.value = 'nearest-neighbor';
+            return decl;
+        } else {
+            return _Declaration.prototype.set.call(this, decl, prefix);
+        }
     };
 
-    ImageRendering.prototype.normalize = function(prop) {
-      return 'image-rendering';
+    /**
+     * Return property name by spec
+     */
+
+
+    ImageRendering.prototype.normalize = function normalize() {
+        return 'image-rendering';
     };
 
-    ImageRendering.prototype.process = function(node, result) {
-      return ImageRendering.__super__.process.apply(this, arguments);
+    /**
+     * Warn on old value
+     */
+
+
+    ImageRendering.prototype.process = function process(node, result) {
+        return _Declaration.prototype.process.call(this, node, result);
     };
 
     return ImageRendering;
+}(Declaration);
 
-  })(Declaration);
+Object.defineProperty(ImageRendering, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['image-rendering', 'interpolation-mode']
+});
 
-  module.exports = ImageRendering;
 
-}).call(this);
+module.exports = ImageRendering;

package/lib/hacks/image-set.js

@@ -1,33 +1,41 @@
-(function() {
-  var ImageSet, Value, list,
-    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';
 
-  list = require('postcss/lib/list');
+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; }
 
-  ImageSet = (function(superClass) {
-    extend(ImageSet, 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 Value = require('../value');
+
+var ImageSet = function (_Value) {
+    _inherits(ImageSet, _Value);
 
     function ImageSet() {
-      return ImageSet.__super__.constructor.apply(this, arguments);
-    }
+        _classCallCheck(this, ImageSet);
 
-    ImageSet.names = ['image-set'];
+        return _possibleConstructorReturn(this, _Value.apply(this, arguments));
+    }
 
-    ImageSet.prototype.replace = function(string, prefix) {
-      if (prefix === '-webkit-') {
-        return ImageSet.__super__.replace.apply(this, arguments).replace(/("[^"]+"|'[^']+')(\s+\d+\w)/gi, 'url($1)$2');
-      } else {
-        return ImageSet.__super__.replace.apply(this, arguments);
-      }
+    /**
+     * Use non-standard name for WebKit and Firefox
+     */
+    ImageSet.prototype.replace = function replace(string, prefix) {
+        if (prefix === '-webkit-') {
+            return _Value.prototype.replace.call(this, string, prefix).replace(/("[^"]+"|'[^']+')(\s+\d+\w)/gi, 'url($1)$2');
+        } else {
+            return _Value.prototype.replace.call(this, string, prefix);
+        }
     };
 
     return ImageSet;
+}(Value);
 
-  })(Value);
+Object.defineProperty(ImageSet, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['image-set']
+});
 
-  module.exports = ImageSet;
 
-}).call(this);
+module.exports = ImageSet;

package/lib/hacks/inline-logical.js

@@ -1,31 +1,46 @@
-(function() {
-  var Declaration, InlineLogical,
-    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"); } }
 
-  InlineLogical = (function(superClass) {
-    extend(InlineLogical, 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 InlineLogical = function (_Declaration) {
+    _inherits(InlineLogical, _Declaration);
 
     function InlineLogical() {
-      return InlineLogical.__super__.constructor.apply(this, arguments);
-    }
+        _classCallCheck(this, InlineLogical);
 
-    InlineLogical.names = ['border-inline-start', 'border-inline-end', 'margin-inline-start', 'margin-inline-end', 'padding-inline-start', 'padding-inline-end', 'border-start', 'border-end', 'margin-start', 'margin-end', 'padding-start', 'padding-end'];
+        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+    }
 
-    InlineLogical.prototype.prefixed = function(prop, prefix) {
-      return prefix + prop.replace('-inline', '');
+    /**
+     * Use old syntax for -moz- and -webkit-
+     */
+    InlineLogical.prototype.prefixed = function prefixed(prop, prefix) {
+        return prefix + prop.replace('-inline', '');
     };
 
-    InlineLogical.prototype.normalize = function(prop) {
-      return prop.replace(/(margin|padding|border)-(start|end)/, '$1-inline-$2');
+    /**
+     * Return property name by spec
+     */
+
+
+    InlineLogical.prototype.normalize = function normalize(prop) {
+        return prop.replace(/(margin|padding|border)-(start|end)/, '$1-inline-$2');
     };
 
     return InlineLogical;
+}(Declaration);
 
-  })(Declaration);
+Object.defineProperty(InlineLogical, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['border-inline-start', 'border-inline-end', 'margin-inline-start', 'margin-inline-end', 'padding-inline-start', 'padding-inline-end', 'border-start', 'border-end', 'margin-start', 'margin-end', 'padding-start', 'padding-end']
+});
 
-  module.exports = InlineLogical;
 
-}).call(this);
+module.exports = InlineLogical;

package/lib/hacks/intrinsic.js

@@ -0,0 +1,66 @@
+'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 OldValue = require('../old-value');
+var Value = require('../value');
+
+function _regexp(name) {
+    return new RegExp('(^|[\\s,(])(' + name + '($|[\\s),]))', 'gi');
+}
+
+var Intrinsic = function (_Value) {
+    _inherits(Intrinsic, _Value);
+
+    function Intrinsic() {
+        _classCallCheck(this, Intrinsic);
+
+        return _possibleConstructorReturn(this, _Value.apply(this, arguments));
+    }
+
+    Intrinsic.prototype.regexp = function regexp() {
+        if (!this.regexpCache) this.regexpCache = _regexp(this.name);
+        return this.regexpCache;
+    };
+
+    Intrinsic.prototype.isStretch = function isStretch() {
+        return this.name === 'stretch' || this.name === 'fill' || this.name === 'fill-available';
+    };
+
+    Intrinsic.prototype.replace = function replace(string, prefix) {
+        if (prefix === '-moz-' && this.isStretch()) {
+            return string.replace(this.regexp(), '$1-moz-available$3');
+        } else if (prefix === '-webkit-' && this.isStretch()) {
+            return string.replace(this.regexp(), '$1-webkit-fill-available$3');
+        } else {
+            return _Value.prototype.replace.call(this, string, prefix);
+        }
+    };
+
+    Intrinsic.prototype.old = function old(prefix) {
+        var prefixed = prefix + this.name;
+        if (this.isStretch()) {
+            if (prefix === '-moz-') {
+                prefixed = '-moz-available';
+            } else if (prefix === '-webkit-') {
+                prefixed = '-webkit-fill-available';
+            }
+        }
+        return new OldValue(this.name, prefixed, prefixed, _regexp(prefixed));
+    };
+
+    return Intrinsic;
+}(Value);
+
+Object.defineProperty(Intrinsic, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['max-content', 'min-content', 'fit-content', 'fill', 'fill-available', 'stretch']
+});
+
+
+module.exports = Intrinsic;

package/lib/hacks/justify-content.js

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

package/lib/hacks/mask-border.js

@@ -1,35 +1,50 @@
-(function() {
-  var Declaration, MaskBorder,
-    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"); } }
 
-  MaskBorder = (function(superClass) {
-    extend(MaskBorder, 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 MaskBorder = function (_Declaration) {
+    _inherits(MaskBorder, _Declaration);
 
     function MaskBorder() {
-      return MaskBorder.__super__.constructor.apply(this, arguments);
-    }
+        _classCallCheck(this, MaskBorder);
 
-    MaskBorder.names = ['mask-border', 'mask-border-source', 'mask-border-slice', 'mask-border-width', 'mask-border-outset', 'mask-border-repeat', 'mask-box-image', 'mask-box-image-source', 'mask-box-image-slice', 'mask-box-image-width', 'mask-box-image-outset', 'mask-box-image-repeat'];
+        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+    }
 
-    MaskBorder.prototype.normalize = function() {
-      return this.name.replace('box-image', 'border');
+    /**
+     * Return property name by final spec
+     */
+    MaskBorder.prototype.normalize = function normalize() {
+        return this.name.replace('box-image', 'border');
     };
 
-    MaskBorder.prototype.prefixed = function(prop, prefix) {
-      if (prefix === '-webkit-') {
-        return MaskBorder.__super__.prefixed.apply(this, arguments).replace('border', 'box-image');
-      } else {
-        return MaskBorder.__super__.prefixed.apply(this, arguments);
-      }
+    /**
+     * Return flex property for 2012 spec
+     */
+
+
+    MaskBorder.prototype.prefixed = function prefixed(prop, prefix) {
+        if (prefix === '-webkit-') {
+            return _Declaration.prototype.prefixed.call(this, prop, prefix).replace('border', 'box-image');
+        } else {
+            return _Declaration.prototype.prefixed.call(this, prop, prefix);
+        }
     };
 
     return MaskBorder;
+}(Declaration);
 
-  })(Declaration);
+Object.defineProperty(MaskBorder, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['mask-border', 'mask-border-source', 'mask-border-slice', 'mask-border-width', 'mask-border-outset', 'mask-border-repeat', 'mask-box-image', 'mask-box-image-source', 'mask-box-image-slice', 'mask-box-image-width', 'mask-box-image-outset', 'mask-box-image-repeat']
+});
 
-  module.exports = MaskBorder;
 
-}).call(this);
+module.exports = MaskBorder;

package/lib/hacks/order.js

@@ -1,52 +1,75 @@
-(function() {
-  var Declaration, Order, 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; }
 
-  Order = (function(superClass) {
-    extend(Order, 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 Order = function (_Declaration) {
+    _inherits(Order, _Declaration);
 
     function Order() {
-      return Order.__super__.constructor.apply(this, arguments);
+        _classCallCheck(this, Order);
+
+        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
     }
 
-    Order.names = ['order', 'flex-order', 'box-ordinal-group'];
-
-    Order.prototype.prefixed = function(prop, prefix) {
-      var ref, spec;
-      ref = flexSpec(prefix), spec = ref[0], prefix = ref[1];
-      if (spec === 2009) {
-        return prefix + 'box-ordinal-group';
-      } else if (spec === 2012) {
-        return prefix + 'flex-order';
-      } else {
-        return Order.__super__.prefixed.apply(this, arguments);
-      }
+    /**
+     * Change property name for 2009 and 2012 specs
+     */
+    Order.prototype.prefixed = function prefixed(prop, prefix) {
+        var spec = void 0;
+
+        var _flexSpec = flexSpec(prefix);
+
+        spec = _flexSpec[0];
+        prefix = _flexSpec[1];
+
+        if (spec === 2009) {
+            return prefix + 'box-ordinal-group';
+        } else if (spec === 2012) {
+            return prefix + 'flex-order';
+        } else {
+            return _Declaration.prototype.prefixed.call(this, prop, prefix);
+        }
     };
 
-    Order.prototype.normalize = function(prop) {
-      return 'order';
+    /**
+     * Return property name by final spec
+     */
+
+
+    Order.prototype.normalize = function normalize() {
+        return 'order';
     };
 
-    Order.prototype.set = function(decl, prefix) {
-      var spec;
-      spec = flexSpec(prefix)[0];
-      if (spec === 2009) {
-        decl.value = (parseInt(decl.value) + 1).toString();
-        return Order.__super__.set.call(this, decl, prefix);
-      } else {
-        return Order.__super__.set.apply(this, arguments);
-      }
+    /**
+     * Fix value for 2009 spec
+     */
+
+
+    Order.prototype.set = function set(decl, prefix) {
+        var spec = flexSpec(prefix)[0];
+        if (spec === 2009 && /\d/.test(decl.value)) {
+            decl.value = (parseInt(decl.value) + 1).toString();
+            return _Declaration.prototype.set.call(this, decl, prefix);
+        } else {
+            return _Declaration.prototype.set.call(this, decl, prefix);
+        }
     };
 
     return Order;
+}(Declaration);
 
-  })(Declaration);
+Object.defineProperty(Order, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['order', 'flex-order', 'box-ordinal-group']
+});
 
-  module.exports = Order;
 
-}).call(this);
+module.exports = Order;