autoprefixer 6.7.6 → 7.1.0

package/lib/hacks/align-self.js

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

package/lib/hacks/appearance.js

@@ -0,0 +1,42 @@
+'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 utils = require('../utils');
+
+var Appearance = function (_Declaration) {
+    _inherits(Appearance, _Declaration);
+
+    function Appearance(name, prefixes, all) {
+        _classCallCheck(this, Appearance);
+
+        var _this = _possibleConstructorReturn(this, _Declaration.call(this, name, prefixes, all));
+
+        if (_this.prefixes) {
+            _this.prefixes = utils.uniq(_this.prefixes.map(function (i) {
+                if (i === '-ms-') {
+                    return '-webkit-';
+                } else {
+                    return i;
+                }
+            }));
+        }
+        return _this;
+    }
+
+    return Appearance;
+}(Declaration);
+
+Object.defineProperty(Appearance, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['appearance']
+});
+
+
+module.exports = Appearance;

package/lib/hacks/background-size.js

@@ -1,32 +1,41 @@
-(function() {
-  var BackgroundSize, Declaration,
-    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"); } }
 
-  BackgroundSize = (function(superClass) {
-    extend(BackgroundSize, 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 BackgroundSize = function (_Declaration) {
+    _inherits(BackgroundSize, _Declaration);
 
     function BackgroundSize() {
-      return BackgroundSize.__super__.constructor.apply(this, arguments);
-    }
+        _classCallCheck(this, BackgroundSize);
 
-    BackgroundSize.names = ['background-size'];
+        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+    }
 
-    BackgroundSize.prototype.set = function(decl, prefix) {
-      var value;
-      value = decl.value.toLowerCase();
-      if (prefix === '-webkit-' && value.indexOf(' ') === -1 && value !== 'contain' && value !== 'cover') {
-        decl.value = decl.value + ' ' + decl.value;
-      }
-      return BackgroundSize.__super__.set.call(this, decl, prefix);
+    /**
+     * Duplication parameter for -webkit- browsers
+     */
+    BackgroundSize.prototype.set = function set(decl, prefix) {
+        var value = decl.value.toLowerCase();
+        if (prefix === '-webkit-' && value.indexOf(' ') === -1 && value !== 'contain' && value !== 'cover') {
+            decl.value = decl.value + ' ' + decl.value;
+        }
+        return _Declaration.prototype.set.call(this, decl, prefix);
     };
 
     return BackgroundSize;
+}(Declaration);
 
-  })(Declaration);
+Object.defineProperty(BackgroundSize, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['background-size']
+});
 
-  module.exports = BackgroundSize;
 
-}).call(this);
+module.exports = BackgroundSize;

package/lib/hacks/block-logical.js

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

package/lib/hacks/border-image.js

@@ -1,28 +1,38 @@
-(function() {
-  var BorderImage, Declaration,
-    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"); } }
 
-  BorderImage = (function(superClass) {
-    extend(BorderImage, 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 BorderImage = function (_Declaration) {
+    _inherits(BorderImage, _Declaration);
 
     function BorderImage() {
-      return BorderImage.__super__.constructor.apply(this, arguments);
-    }
+        _classCallCheck(this, BorderImage);
 
-    BorderImage.names = ['border-image'];
+        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+    }
 
-    BorderImage.prototype.set = function(decl, prefix) {
-      decl.value = decl.value.replace(/\s+fill(\s)/, '$1');
-      return BorderImage.__super__.set.call(this, decl, prefix);
+    /**
+     * Remove fill parameter for prefixed declarations
+     */
+    BorderImage.prototype.set = function set(decl, prefix) {
+        decl.value = decl.value.replace(/\s+fill(\s)/, '$1');
+        return _Declaration.prototype.set.call(this, decl, prefix);
     };
 
     return BorderImage;
+}(Declaration);
 
-  })(Declaration);
+Object.defineProperty(BorderImage, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['border-image']
+});
 
-  module.exports = BorderImage;
 
-}).call(this);
+module.exports = BorderImage;

package/lib/hacks/border-radius.js

@@ -1,56 +1,77 @@
-(function() {
-  var BorderRadius, Declaration,
-    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"); } }
 
-  BorderRadius = (function(superClass) {
-    var hor, i, j, len, len1, mozilla, normal, ref, ref1, ver;
+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; }
 
-    extend(BorderRadius, 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; }
 
-    function BorderRadius() {
-      return BorderRadius.__super__.constructor.apply(this, arguments);
-    }
-
-    BorderRadius.names = ['border-radius'];
+var Declaration = require('../declaration');
 
-    BorderRadius.toMozilla = {};
+var BorderRadius = function (_Declaration) {
+    _inherits(BorderRadius, _Declaration);
 
-    BorderRadius.toNormal = {};
+    function BorderRadius() {
+        _classCallCheck(this, BorderRadius);
 
-    ref = ['top', 'bottom'];
-    for (i = 0, len = ref.length; i < len; i++) {
-      ver = ref[i];
-      ref1 = ['left', 'right'];
-      for (j = 0, len1 = ref1.length; j < len1; j++) {
-        hor = ref1[j];
-        normal = "border-" + ver + "-" + hor + "-radius";
-        mozilla = "border-radius-" + ver + hor;
-        BorderRadius.names.push(normal);
-        BorderRadius.names.push(mozilla);
-        BorderRadius.toMozilla[normal] = mozilla;
-        BorderRadius.toNormal[mozilla] = normal;
-      }
+        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
     }
 
-    BorderRadius.prototype.prefixed = function(prop, prefix) {
-      if (prefix === '-moz-') {
-        return prefix + (BorderRadius.toMozilla[prop] || prop);
-      } else {
-        return BorderRadius.__super__.prefixed.apply(this, arguments);
-      }
+    /**
+     * Change syntax, when add Mozilla prefix
+     */
+    BorderRadius.prototype.prefixed = function prefixed(prop, prefix) {
+        if (prefix === '-moz-') {
+            return prefix + (BorderRadius.toMozilla[prop] || prop);
+        } else {
+            return _Declaration.prototype.prefixed.call(this, prop, prefix);
+        }
     };
 
-    BorderRadius.prototype.normalize = function(prop) {
-      return BorderRadius.toNormal[prop] || prop;
+    /**
+     * Return unprefixed version of property
+     */
+
+
+    BorderRadius.prototype.normalize = function normalize(prop) {
+        return BorderRadius.toNormal[prop] || prop;
     };
 
     return BorderRadius;
+}(Declaration);
 
-  })(Declaration);
+Object.defineProperty(BorderRadius, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['border-radius']
+});
+Object.defineProperty(BorderRadius, 'toMozilla', {
+    enumerable: true,
+    writable: true,
+    value: {}
+});
+Object.defineProperty(BorderRadius, 'toNormal', {
+    enumerable: true,
+    writable: true,
+    value: {}
+});
+var _arr = ['top', 'bottom'];
 
-  module.exports = BorderRadius;
 
-}).call(this);
+for (var _i = 0; _i < _arr.length; _i++) {
+    var ver = _arr[_i];var _arr2 = ['left', 'right'];
+
+    for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
+        var hor = _arr2[_i2];
+        var normal = 'border-' + ver + '-' + hor + '-radius';
+        var mozilla = 'border-radius-' + ver + hor;
+
+        BorderRadius.names.push(normal);
+        BorderRadius.names.push(mozilla);
+
+        BorderRadius.toMozilla[normal] = mozilla;
+        BorderRadius.toNormal[mozilla] = normal;
+    }
+}
+
+module.exports = BorderRadius;

package/lib/hacks/break-props.js

@@ -1,64 +1,89 @@
-(function() {
-  var BreakProps, Declaration,
-    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"); } }
 
-  BreakProps = (function(superClass) {
-    extend(BreakProps, 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 BreakProps = function (_Declaration) {
+    _inherits(BreakProps, _Declaration);
 
     function BreakProps() {
-      return BreakProps.__super__.constructor.apply(this, arguments);
-    }
+        _classCallCheck(this, BreakProps);
 
-    BreakProps.names = ['break-inside', 'page-break-inside', 'column-break-inside', 'break-before', 'page-break-before', 'column-break-before', 'break-after', 'page-break-after', 'column-break-after'];
+        return _possibleConstructorReturn(this, _Declaration.apply(this, arguments));
+    }
 
-    BreakProps.prototype.prefixed = function(prop, prefix) {
-      if (prefix === '-webkit-') {
-        return '-webkit-column-' + prop;
-      } else if (prefix === '-moz-') {
-        return 'page-' + prop;
-      } else {
-        return BreakProps.__super__.prefixed.apply(this, arguments);
-      }
+    /**
+     * Change name for -webkit- and -moz- prefix
+     */
+    BreakProps.prototype.prefixed = function prefixed(prop, prefix) {
+        if (prefix === '-webkit-') {
+            return '-webkit-column-' + prop;
+        } else if (prefix === '-moz-') {
+            return 'page-' + prop;
+        } else {
+            return _Declaration.prototype.prefixed.call(this, prop, prefix);
+        }
     };
 
-    BreakProps.prototype.normalize = function(prop) {
-      if (prop.indexOf('inside') !== -1) {
-        return 'break-inside';
-      } else if (prop.indexOf('before') !== -1) {
-        return 'break-before';
-      } else if (prop.indexOf('after') !== -1) {
-        return 'break-after';
-      }
+    /**
+     * Return property name by final spec
+     */
+
+
+    BreakProps.prototype.normalize = function normalize(prop) {
+        if (prop.indexOf('inside') !== -1) {
+            return 'break-inside';
+        } else if (prop.indexOf('before') !== -1) {
+            return 'break-before';
+        } else if (prop.indexOf('after') !== -1) {
+            return 'break-after';
+        }
+        return undefined;
     };
 
-    BreakProps.prototype.set = function(decl, prefix) {
-      var v;
-      v = decl.value;
-      if (decl.prop === 'break-inside' && v === 'avoid-column' || v === 'avoid-page') {
-        decl.value = 'avoid';
-      }
-      return BreakProps.__super__.set.apply(this, arguments);
+    /**
+     * Change prefixed value for avoid-column and avoid-page
+     */
+
+
+    BreakProps.prototype.set = function set(decl, prefix) {
+        var v = decl.value;
+        if (decl.prop === 'break-inside' && v === 'avoid-column' || v === 'avoid-page') {
+            decl.value = 'avoid';
+        }
+        return _Declaration.prototype.set.call(this, decl, prefix);
     };
 
-    BreakProps.prototype.insert = function(decl, prefix, prefixes) {
-      if (decl.prop !== 'break-inside') {
-        return BreakProps.__super__.insert.apply(this, arguments);
-      } else if (decl.value === 'avoid-region') {
+    /**
+     * Don’t prefix some values
+     */
 
-      } else if (decl.value === 'avoid-page' && prefix === '-webkit-') {
 
-      } else {
-        return BreakProps.__super__.insert.apply(this, arguments);
-      }
+    BreakProps.prototype.insert = function insert(decl, prefix, prefixes) {
+        if (decl.prop !== 'break-inside') {
+            return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+        } else if (decl.value === 'avoid-region') {
+            return undefined;
+        } else if (decl.value === 'avoid-page' && prefix === '-webkit-') {
+            return undefined;
+        } else {
+            return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+        }
     };
 
     return BreakProps;
+}(Declaration);
 
-  })(Declaration);
+Object.defineProperty(BreakProps, 'names', {
+    enumerable: true,
+    writable: true,
+    value: ['break-inside', 'page-break-inside', 'column-break-inside', 'break-before', 'page-break-before', 'column-break-before', 'break-after', 'page-break-after', 'column-break-after']
+});
 
-  module.exports = BreakProps;
 
-}).call(this);
+module.exports = BreakProps;