autoprefixer 6.7.6 → 7.1.0

package/data/prefixes.js

@@ -1,669 +1,703 @@
-(function() {
-  var add, backdropFilter, bckgrndImgOpts, boxdecorbreak, crispedges, cursorsGrab, cursorsNewer, decoration, devdaptation, elementFunction, feature, filterFunction, flexbox, fullscreen, gradients, grid, logicalProps, prefix, readOnly, resolution, result, sort, textAlignLast, textSizeAdjust, textSpacing, transforms3d, userSelectNone, writingMode,
-    slice = [].slice;
-
-  sort = function(array) {
-    return array.sort(function(a, b) {
-      var d;
-      a = a.split(' ');
-      b = b.split(' ');
-      if (a[0] > b[0]) {
+'use strict';
+
+var unpack = require('caniuse-lite').feature;
+
+var browsersSort = function browsersSort(a, b) {
+    a = a.split(' ');
+    b = b.split(' ');
+    if (a[0] > b[0]) {
         return 1;
-      } else if (a[0] < b[0]) {
+    } else if (a[0] < b[0]) {
         return -1;
-      } else {
-        d = parseFloat(a[1]) - parseFloat(b[1]);
-        if (d > 0) {
-          return 1;
-        } else if (d < 0) {
-          return -1;
-        } else {
-          return 0;
-        }
-      }
-    });
-  };
+    } else {
+        return Math.sign(parseFloat(a[1]) - parseFloat(b[1]));
+    }
+};
+
+// Convert Can I Use data
+function f(data, opts, callback) {
+    data = unpack(data);
 
-  feature = function(data, opts, callback) {
-    var browser, match, need, ref, ref1, support, version, versions;
     if (!callback) {
-      ref = [opts, {}], callback = ref[0], opts = ref[1];
+        var _ref = [opts, {}];
+        callback = _ref[0];
+        opts = _ref[1];
     }
-    match = opts.match || /\sx($|\s)/;
-    need = [];
-    ref1 = data.stats;
-    for (browser in ref1) {
-      versions = ref1[browser];
-      for (version in versions) {
-        support = versions[version];
-        if (support.match(match)) {
-          need.push(browser + ' ' + version);
+
+    var match = opts.match || /\sx($|\s)/;
+    var need = [];
+
+    for (var browser in data.stats) {
+        var versions = data.stats[browser];
+        for (var version in versions) {
+            var support = versions[version];
+            if (support.match(match)) {
+                need.push(browser + ' ' + version);
+            }
         }
-      }
     }
-    return callback(sort(need));
-  };
-
-  result = {};
-
-  prefix = function() {
-    var data, i, j, k, len, name, names, results;
-    names = 2 <= arguments.length ? slice.call(arguments, 0, j = arguments.length - 1) : (j = 0, []), data = arguments[j++];
-    results = [];
-    for (k = 0, len = names.length; k < len; k++) {
-      name = names[k];
-      result[name] = {};
-      results.push((function() {
-        var results1;
-        results1 = [];
-        for (i in data) {
-          results1.push(result[name][i] = data[i]);
+
+    callback(need.sort(browsersSort));
+}
+
+// Add data for all properties
+var result = {};
+
+var prefix = function prefix(names, data) {
+    for (var _iterator = names, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+        var _ref2;
+
+        if (_isArray) {
+            if (_i >= _iterator.length) break;
+            _ref2 = _iterator[_i++];
+        } else {
+            _i = _iterator.next();
+            if (_i.done) break;
+            _ref2 = _i.value;
         }
-        return results1;
-      })());
+
+        var name = _ref2;
+
+        result[name] = Object.assign({}, data);
     }
-    return results;
-  };
-
-  add = function() {
-    var data, j, k, len, name, names, results;
-    names = 2 <= arguments.length ? slice.call(arguments, 0, j = arguments.length - 1) : (j = 0, []), data = arguments[j++];
-    results = [];
-    for (k = 0, len = names.length; k < len; k++) {
-      name = names[k];
-      results.push(result[name].browsers = sort(result[name].browsers.concat(data.browsers)));
+};
+
+var add = function add(names, data) {
+    for (var _iterator2 = names, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+        var _ref3;
+
+        if (_isArray2) {
+            if (_i2 >= _iterator2.length) break;
+            _ref3 = _iterator2[_i2++];
+        } else {
+            _i2 = _iterator2.next();
+            if (_i2.done) break;
+            _ref3 = _i2.value;
+        }
+
+        var name = _ref3;
+
+        result[name].browsers = result[name].browsers.concat(data.browsers).sort(browsersSort);
     }
-    return results;
-  };
+};
 
-  module.exports = result;
+module.exports = result;
 
-  feature(require('caniuse-db/features-json/border-radius.json'), function(browsers) {
-    return prefix('border-radius', 'border-top-left-radius', 'border-top-right-radius', 'border-bottom-right-radius', 'border-bottom-left-radius', {
-      mistakes: ['-khtml-', '-ms-', '-o-'],
-      browsers: browsers,
-      feature: 'border-radius'
+// Border Radius
+f(require('caniuse-lite/data/features/border-radius.js'), function (browsers) {
+    return prefix(['border-radius', 'border-top-left-radius', 'border-top-right-radius', 'border-bottom-right-radius', 'border-bottom-left-radius'], {
+        mistakes: ['-khtml-', '-ms-', '-o-'],
+        feature: 'border-radius',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/css-boxshadow.json'), function(browsers) {
-    return prefix('box-shadow', {
-      mistakes: ['-khtml-'],
-      browsers: browsers,
-      feature: 'css-boxshadow'
+// Box Shadow
+f(require('caniuse-lite/data/features/css-boxshadow.js'), function (browsers) {
+    return prefix(['box-shadow'], {
+        mistakes: ['-khtml-'],
+        feature: 'css-boxshadow',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/css-animation.json'), function(browsers) {
-    return prefix('animation', 'animation-name', 'animation-duration', 'animation-delay', 'animation-direction', 'animation-fill-mode', 'animation-iteration-count', 'animation-play-state', 'animation-timing-function', '@keyframes', {
-      mistakes: ['-khtml-', '-ms-'],
-      browsers: browsers,
-      feature: 'css-animation'
+// Animation
+f(require('caniuse-lite/data/features/css-animation.js'), function (browsers) {
+    return prefix(['animation', 'animation-name', 'animation-duration', 'animation-delay', 'animation-direction', 'animation-fill-mode', 'animation-iteration-count', 'animation-play-state', 'animation-timing-function', '@keyframes'], {
+        mistakes: ['-khtml-', '-ms-'],
+        feature: 'css-animation',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/css-transitions.json'), function(browsers) {
-    return prefix('transition', 'transition-property', 'transition-duration', 'transition-delay', 'transition-timing-function', {
-      mistakes: ['-khtml-', '-ms-'],
-      browsers: browsers,
-      feature: 'css-transitions'
+// Transition
+f(require('caniuse-lite/data/features/css-transitions.js'), function (browsers) {
+    return prefix(['transition', 'transition-property', 'transition-duration', 'transition-delay', 'transition-timing-function'], {
+        mistakes: ['-khtml-', '-ms-'],
+        browsers: browsers,
+        feature: 'css-transitions'
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/transforms2d.json'), function(browsers) {
-    return prefix('transform', 'transform-origin', {
-      browsers: browsers,
-      feature: 'transforms2d'
+// Transform 2D
+f(require('caniuse-lite/data/features/transforms2d.js'), function (browsers) {
+    return prefix(['transform', 'transform-origin'], {
+        feature: 'transforms2d',
+        browsers: browsers
     });
-  });
+});
 
-  transforms3d = require('caniuse-db/features-json/transforms3d.json');
+// Transform 3D
+var transforms3d = require('caniuse-lite/data/features/transforms3d.js');
 
-  feature(transforms3d, function(browsers) {
-    prefix('perspective', 'perspective-origin', {
-      browsers: browsers,
-      feature: 'transforms3d'
+f(transforms3d, function (browsers) {
+    prefix(['perspective', 'perspective-origin'], {
+        feature: 'transforms3d',
+        browsers: browsers
     });
-    return prefix('transform-style', {
-      mistakes: ['-ms-', '-o-'],
-      browsers: browsers,
-      feature: 'transforms3d'
+    return prefix(['transform-style'], {
+        mistakes: ['-ms-', '-o-'],
+        browsers: browsers,
+        feature: 'transforms3d'
     });
-  });
+});
 
-  feature(transforms3d, {
-    match: /y\sx|y\s#2/
-  }, function(browsers) {
-    return prefix('backface-visibility', {
-      mistakes: ['-ms-', '-o-'],
-      browsers: browsers,
-      feature: 'transforms3d'
+f(transforms3d, { match: /y\sx|y\s#2/ }, function (browsers) {
+    return prefix(['backface-visibility'], {
+        mistakes: ['-ms-', '-o-'],
+        feature: 'transforms3d',
+        browsers: browsers
     });
-  });
+});
 
-  gradients = require('caniuse-db/features-json/css-gradients.json');
+// Gradients
+var gradients = require('caniuse-lite/data/features/css-gradients.js');
 
-  feature(gradients, {
-    match: /y\sx/
-  }, function(browsers) {
-    return prefix('linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient', {
-      props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'],
-      mistakes: ['-ms-'],
-      browsers: browsers,
-      feature: 'css-gradients'
+f(gradients, { match: /y\sx/ }, function (browsers) {
+    return prefix(['linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient'], {
+        props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'],
+        mistakes: ['-ms-'],
+        feature: 'css-gradients',
+        browsers: browsers
     });
-  });
+});
 
-  feature(gradients, {
-    match: /a\sx/
-  }, function(browsers) {
-    browsers = browsers.map(function(i) {
-      if (/op/.test(i)) {
-        return i;
-      } else {
-        return i + " old";
-      }
+f(gradients, { match: /a\sx/ }, function (browsers) {
+    browsers = browsers.map(function (i) {
+        if (/op/.test(i)) {
+            return i;
+        } else {
+            return i + ' old';
+        }
     });
-    return add('linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient', {
-      browsers: browsers,
-      feature: 'css-gradients'
+    return add(['linear-gradient', 'repeating-linear-gradient', 'radial-gradient', 'repeating-radial-gradient'], {
+        feature: 'css-gradients',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/css3-boxsizing.json'), function(browsers) {
-    return prefix('box-sizing', {
-      browsers: browsers,
-      feature: 'css3-boxsizing'
+// Box sizing
+f(require('caniuse-lite/data/features/css3-boxsizing.js'), function (browsers) {
+    return prefix(['box-sizing'], {
+        feature: 'css3-boxsizing',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/css-filters.json'), function(browsers) {
-    return prefix('filter', {
-      browsers: browsers,
-      feature: 'css-filters'
+// Filter Effects
+f(require('caniuse-lite/data/features/css-filters.js'), function (browsers) {
+    return prefix(['filter'], {
+        feature: 'css-filters',
+        browsers: browsers
     });
-  });
-
-  filterFunction = require('caniuse-db/features-json/css-filter-function.json');
+});
 
-  feature(filterFunction, function(browsers) {
-    return prefix('filter-function', {
-      props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'],
-      browsers: browsers,
-      feature: 'css-filter-function'
+// filter() function
+f(require('caniuse-lite/data/features/css-filter-function.js'), function (browsers) {
+    return prefix(['filter-function'], {
+        props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'],
+        feature: 'css-filter-function',
+        browsers: browsers
     });
-  });
-
-  backdropFilter = require('caniuse-db/features-json/css-backdrop-filter.json');
+});
 
-  feature(backdropFilter, function(browsers) {
-    return prefix('backdrop-filter', {
-      browsers: browsers,
-      feature: 'css-backdrop-filter'
+// Backdrop-filter
+f(require('caniuse-lite/data/features/css-backdrop-filter.js'), function (browsers) {
+    return prefix(['backdrop-filter'], {
+        feature: 'css-backdrop-filter',
+        browsers: browsers
     });
-  });
+});
 
-  elementFunction = require('caniuse-db/features-json/css-element-function.json');
-
-  feature(elementFunction, function(browsers) {
-    return prefix('element', {
-      props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'],
-      browsers: browsers,
-      feature: 'css-element-function'
+// element() function
+f(require('caniuse-lite/data/features/css-element-function.js'), function (browsers) {
+    return prefix(['element'], {
+        props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'],
+        feature: 'css-element-function',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/multicolumn.json'), function(browsers) {
-    prefix('columns', 'column-width', 'column-gap', 'column-rule', 'column-rule-color', 'column-rule-width', {
-      browsers: browsers,
-      feature: 'multicolumn'
-    });
-    return prefix('column-count', 'column-rule-style', 'column-span', 'column-fill', 'break-before', 'break-after', 'break-inside', {
-      browsers: browsers,
-      feature: 'multicolumn'
+// Multicolumns
+f(require('caniuse-lite/data/features/multicolumn.js'), function (browsers) {
+    prefix(['columns', 'column-width', 'column-gap', 'column-rule', 'column-rule-color', 'column-rule-width'], {
+        feature: 'multicolumn',
+        browsers: browsers
     });
-  });
 
-  userSelectNone = require('caniuse-db/features-json/user-select-none.json');
-
-  feature(userSelectNone, function(browsers) {
-    return prefix('user-select', {
-      mistakes: ['-khtml-'],
-      browsers: browsers,
-      feature: 'user-select-none'
+    prefix(['column-count', 'column-rule-style', 'column-span', 'column-fill', 'break-before', 'break-after', 'break-inside'], {
+        feature: 'multicolumn',
+        browsers: browsers
     });
-  });
+});
 
-  flexbox = require('caniuse-db/features-json/flexbox.json');
+// User select
+f(require('caniuse-lite/data/features/user-select-none.js'), function (browsers) {
+    return prefix(['user-select'], {
+        mistakes: ['-khtml-'],
+        feature: 'user-select-none',
+        browsers: browsers
+    });
+});
 
-  feature(flexbox, {
-    match: /a\sx/
-  }, function(browsers) {
-    browsers = browsers.map(function(i) {
-      if (/ie|firefox/.test(i)) {
-        return i;
-      } else {
-        return i + " 2009";
-      }
+// Flexible Box Layout
+var flexbox = require('caniuse-lite/data/features/flexbox.js');
+f(flexbox, { match: /a\sx/ }, function (browsers) {
+    browsers = browsers.map(function (i) {
+        if (/ie|firefox/.test(i)) {
+            return i;
+        } else {
+            return i + ' 2009';
+        }
     });
-    prefix('display-flex', 'inline-flex', {
-      props: ['display'],
-      browsers: browsers,
-      feature: 'flexbox'
+    prefix(['display-flex', 'inline-flex'], {
+        props: ['display'],
+        feature: 'flexbox',
+        browsers: browsers
     });
-    prefix('flex', 'flex-grow', 'flex-shrink', 'flex-basis', {
-      browsers: browsers,
-      feature: 'flexbox'
+    prefix(['flex', 'flex-grow', 'flex-shrink', 'flex-basis'], {
+        feature: 'flexbox',
+        browsers: browsers
     });
-    return prefix('flex-direction', 'flex-wrap', 'flex-flow', 'justify-content', 'order', 'align-items', 'align-self', 'align-content', {
-      browsers: browsers,
-      feature: 'flexbox'
+    prefix(['flex-direction', 'flex-wrap', 'flex-flow', 'justify-content', 'order', 'align-items', 'align-self', 'align-content'], {
+        feature: 'flexbox',
+        browsers: browsers
     });
-  });
+});
 
-  feature(flexbox, {
-    match: /y\sx/
-  }, function(browsers) {
-    add('display-flex', 'inline-flex', {
-      browsers: browsers,
-      feature: 'flexbox'
+f(flexbox, { match: /y\sx/ }, function (browsers) {
+    add(['display-flex', 'inline-flex'], {
+        feature: 'flexbox',
+        browsers: browsers
     });
-    add('flex', 'flex-grow', 'flex-shrink', 'flex-basis', {
-      browsers: browsers,
-      feature: 'flexbox'
+    add(['flex', 'flex-grow', 'flex-shrink', 'flex-basis'], {
+        feature: 'flexbox',
+        browsers: browsers
     });
-    return add('flex-direction', 'flex-wrap', 'flex-flow', 'justify-content', 'order', 'align-items', 'align-self', 'align-content', {
-      browsers: browsers,
-      feature: 'flexbox'
+    add(['flex-direction', 'flex-wrap', 'flex-flow', 'justify-content', 'order', 'align-items', 'align-self', 'align-content'], {
+        feature: 'flexbox',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/calc.json'), function(browsers) {
-    return prefix('calc', {
-      props: ['*'],
-      browsers: browsers,
-      feature: 'calc'
+// calc() unit
+f(require('caniuse-lite/data/features/calc.js'), function (browsers) {
+    return prefix(['calc'], {
+        props: ['*'],
+        feature: 'calc',
+        browsers: browsers
     });
-  });
-
-  bckgrndImgOpts = require('caniuse-db/features-json/background-img-opts.json');
+});
 
-  feature(bckgrndImgOpts, function(browsers) {
-    return prefix('background-clip', 'background-origin', 'background-size', {
-      browsers: browsers,
-      feature: 'background-img-opts'
+// Background options
+f(require('caniuse-lite/data/features/background-img-opts.js'), function (browsers) {
+    return prefix(['background-clip', 'background-origin', 'background-size'], {
+        feature: 'background-img-opts',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/font-feature.json'), function(browsers) {
-    return prefix('font-feature-settings', 'font-variant-ligatures', 'font-language-override', {
-      browsers: browsers,
-      feature: 'font-feature'
+// Font feature settings
+f(require('caniuse-lite/data/features/font-feature.js'), function (browsers) {
+    return prefix(['font-feature-settings', 'font-variant-ligatures', 'font-language-override'], {
+        feature: 'font-feature',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/font-kerning.json'), function(browsers) {
-    return prefix('font-kerning', {
-      browsers: browsers,
-      feature: 'font-kerning'
+// CSS font-kerning property
+f(require('caniuse-lite/data/features/font-kerning.js'), function (browsers) {
+    return prefix(['font-kerning'], {
+        feature: 'font-kerning',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/border-image.json'), function(browsers) {
-    return prefix('border-image', {
-      browsers: browsers,
-      feature: 'border-image'
+// Border image
+f(require('caniuse-lite/data/features/border-image.js'), function (browsers) {
+    return prefix(['border-image'], {
+        feature: 'border-image',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/css-selection.json'), function(browsers) {
-    return prefix('::selection', {
-      selector: true,
-      browsers: browsers,
-      feature: 'css-selection'
+// Selection selector
+f(require('caniuse-lite/data/features/css-selection.js'), function (browsers) {
+    return prefix(['::selection'], {
+        selector: true,
+        feature: 'css-selection',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/css-placeholder.json'), function(browsers) {
-    browsers = browsers.map(function(i) {
-      var name, ref, version;
-      ref = i.split(' '), name = ref[0], version = ref[1];
-      if (name === 'firefox' && parseFloat(version) <= 18) {
-        return i + ' old';
-      } else {
-        return i;
-      }
+// Placeholder selector
+f(require('caniuse-lite/data/features/css-placeholder.js'), function (browsers) {
+    browsers = browsers.map(function (i) {
+        var _i$split = i.split(' '),
+            name = _i$split[0],
+            version = _i$split[1];
+
+        if (name === 'firefox' && parseFloat(version) <= 18) {
+            return i + ' old';
+        } else {
+            return i;
+        }
     });
-    return prefix('::placeholder', {
-      selector: true,
-      browsers: browsers,
-      feature: 'css-placeholder'
+
+    prefix(['::placeholder'], {
+        selector: true,
+        feature: 'css-placeholder',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/css-hyphens.json'), function(browsers) {
-    return prefix('hyphens', {
-      browsers: browsers,
-      feature: 'css-hyphens'
+// Hyphenation
+f(require('caniuse-lite/data/features/css-hyphens.js'), function (browsers) {
+    return prefix(['hyphens'], {
+        feature: 'css-hyphens',
+        browsers: browsers
     });
-  });
+});
 
-  fullscreen = require('caniuse-db/features-json/fullscreen.json');
+// Fullscreen selector
+var fullscreen = require('caniuse-lite/data/features/fullscreen.js');
 
-  feature(fullscreen, function(browsers) {
-    return prefix(':fullscreen', {
-      selector: true,
-      browsers: browsers,
-      feature: 'fullscreen'
+f(fullscreen, function (browsers) {
+    return prefix([':fullscreen'], {
+        selector: true,
+        feature: 'fullscreen',
+        browsers: browsers
     });
-  });
+});
 
-  feature(fullscreen, {
-    match: /x(\s#2|$)/
-  }, function(browsers) {
-    return prefix('::backdrop', {
-      selector: true,
-      browsers: browsers,
-      feature: 'fullscreen'
+f(fullscreen, { match: /x(\s#2|$)/ }, function (browsers) {
+    return prefix(['::backdrop'], {
+        selector: true,
+        feature: 'fullscreen',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/css3-tabsize.json'), function(browsers) {
-    return prefix('tab-size', {
-      browsers: browsers,
-      feature: 'css3-tabsize'
+// Tab size
+f(require('caniuse-lite/data/features/css3-tabsize.js'), function (browsers) {
+    return prefix(['tab-size'], {
+        feature: 'css3-tabsize',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/intrinsic-width.json'), function(browsers) {
-    return prefix('max-content', 'min-content', 'fit-content', 'fill', 'fill-available', 'stretch', {
-      props: ['width', 'min-width', 'max-width', 'height', 'min-height', 'max-height', 'inline-size', 'min-inline-size', 'max-inline-size', 'block-size', 'min-block-size', 'max-block-size'],
-      browsers: browsers,
-      feature: 'intrinsic-width'
+// Intrinsic & extrinsic sizing
+f(require('caniuse-lite/data/features/intrinsic-width.js'), function (browsers) {
+    return prefix(['max-content', 'min-content', 'fit-content', 'fill', 'fill-available', 'stretch'], {
+        props: ['width', 'min-width', 'max-width', 'height', 'min-height', 'max-height', 'inline-size', 'min-inline-size', 'max-inline-size', 'block-size', 'min-block-size', 'max-block-size', 'grid-template', 'grid-template-rows', 'grid-template-columns'],
+        feature: 'intrinsic-width',
+        browsers: browsers
     });
-  });
-
-  cursorsNewer = require('caniuse-db/features-json/css3-cursors-newer.json');
+});
 
-  feature(cursorsNewer, function(browsers) {
-    return prefix('zoom-in', 'zoom-out', {
-      props: ['cursor'],
-      browsers: browsers,
-      feature: 'css3-cursors-newer'
+// Zoom cursors
+f(require('caniuse-lite/data/features/css3-cursors-newer.js'), function (browsers) {
+    return prefix(['zoom-in', 'zoom-out'], {
+        props: ['cursor'],
+        feature: 'css3-cursors-newer',
+        browsers: browsers
     });
-  });
-
-  cursorsGrab = require('caniuse-db/features-json/css3-cursors-grab.json');
+});
 
-  feature(cursorsGrab, function(browsers) {
-    return prefix('grab', 'grabbing', {
-      props: ['cursor'],
-      browsers: browsers,
-      feature: 'css3-cursors-grab'
+// Grab cursors
+f(require('caniuse-lite/data/features/css3-cursors-grab.js'), function (browsers) {
+    return prefix(['grab', 'grabbing'], {
+        props: ['cursor'],
+        feature: 'css3-cursors-grab',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/css-sticky.json'), function(browsers) {
-    return prefix('sticky', {
-      props: ['position'],
-      browsers: browsers,
-      feature: 'css-sticky'
+// Sticky position
+f(require('caniuse-lite/data/features/css-sticky.js'), function (browsers) {
+    return prefix(['sticky'], {
+        props: ['position'],
+        feature: 'css-sticky',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/pointer.json'), function(browsers) {
-    return prefix('touch-action', {
-      browsers: browsers,
-      feature: 'pointer'
+// Pointer Events
+f(require('caniuse-lite/data/features/pointer.js'), function (browsers) {
+    return prefix(['touch-action'], {
+        feature: 'pointer',
+        browsers: browsers
     });
-  });
+});
 
-  decoration = require('caniuse-db/features-json/text-decoration.json');
+// Text decoration
+var decoration = require('caniuse-lite/data/features/text-decoration.js');
 
-  feature(decoration, function(browsers) {
-    return prefix('text-decoration-style', 'text-decoration-color', 'text-decoration-line', {
-      browsers: browsers,
-      feature: 'text-decoration'
+f(decoration, function (browsers) {
+    return prefix(['text-decoration-style', 'text-decoration-color', 'text-decoration-line'], {
+        feature: 'text-decoration',
+        browsers: browsers
     });
-  });
+});
 
-  feature(decoration, {
-    match: /x.*#[23]/
-  }, function(browsers) {
-    return prefix('text-decoration-skip', {
-      browsers: browsers,
-      feature: 'text-decoration'
+f(decoration, { match: /x.*#[23]/ }, function (browsers) {
+    return prefix(['text-decoration-skip'], {
+        feature: 'text-decoration',
+        browsers: browsers
     });
-  });
+});
 
-  textSizeAdjust = require('caniuse-db/features-json/text-size-adjust.json');
-
-  feature(textSizeAdjust, function(browsers) {
-    return prefix('text-size-adjust', {
-      browsers: browsers,
-      feature: 'text-size-adjust'
+// Text Size Adjust
+f(require('caniuse-lite/data/features/text-size-adjust.js'), function (browsers) {
+    return prefix(['text-size-adjust'], {
+        feature: 'text-size-adjust',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/css-masks.json'), function(browsers) {
-    prefix('mask-clip', 'mask-composite', 'mask-image', 'mask-origin', 'mask-repeat', 'mask-border-repeat', 'mask-border-source', {
-      browsers: browsers,
-      feature: 'css-masks'
+// CSS Masks
+f(require('caniuse-lite/data/features/css-masks.js'), function (browsers) {
+    prefix(['mask-clip', 'mask-composite', 'mask-image', 'mask-origin', 'mask-repeat', 'mask-border-repeat', 'mask-border-source'], {
+        feature: 'css-masks',
+        browsers: browsers
     });
-    return prefix('mask', 'mask-position', 'mask-size', 'mask-border', 'mask-border-outset', 'mask-border-width', 'mask-border-slice', {
-      browsers: browsers,
-      feature: 'css-masks'
+    prefix(['mask', 'mask-position', 'mask-size', 'mask-border', 'mask-border-outset', 'mask-border-width', 'mask-border-slice'], {
+        feature: 'css-masks',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/css-clip-path.json'), function(browsers) {
-    return prefix('clip-path', {
-      browsers: browsers,
-      feature: 'css-clip-path'
+// CSS clip-path property
+f(require('caniuse-lite/data/features/css-clip-path.js'), function (browsers) {
+    return prefix(['clip-path'], {
+        feature: 'css-clip-path',
+        browsers: browsers
     });
-  });
-
-  boxdecorbreak = require('caniuse-db/features-json/css-boxdecorationbreak.json');
+});
 
-  feature(boxdecorbreak, function(browsers) {
-    return prefix('box-decoration-break', {
-      browsers: browsers,
-      feature: 'css-boxdecorationbreak'
+// Fragmented Borders and Backgrounds
+f(require('caniuse-lite/data/features/css-boxdecorationbreak.js'), function (browsers) {
+    return prefix(['box-decoration-break'], {
+        feature: 'css-boxdecorationbreak',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/object-fit.json'), function(browsers) {
-    return prefix('object-fit', 'object-position', {
-      browsers: browsers,
-      feature: 'object-fit'
+// CSS3 object-fit/object-position
+f(require('caniuse-lite/data/features/object-fit.js'), function (browsers) {
+    return prefix(['object-fit', 'object-position'], {
+        feature: 'object-fit',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/css-shapes.json'), function(browsers) {
-    return prefix('shape-margin', 'shape-outside', 'shape-image-threshold', {
-      browsers: browsers,
-      feature: 'css-shapes'
+// CSS Shapes
+f(require('caniuse-lite/data/features/css-shapes.js'), function (browsers) {
+    return prefix(['shape-margin', 'shape-outside', 'shape-image-threshold'], {
+        feature: 'css-shapes',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/text-overflow.json'), function(browsers) {
-    return prefix('text-overflow', {
-      browsers: browsers,
-      feature: 'text-overflow'
+// CSS3 text-overflow
+f(require('caniuse-lite/data/features/text-overflow.js'), function (browsers) {
+    return prefix(['text-overflow'], {
+        feature: 'text-overflow',
+        browsers: browsers
     });
-  });
+});
 
-  devdaptation = require('caniuse-db/features-json/css-deviceadaptation.json');
-
-  feature(devdaptation, function(browsers) {
-    return prefix('@viewport', {
-      browsers: browsers,
-      feature: 'css-deviceadaptation'
+// Viewport at-rule
+f(require('caniuse-lite/data/features/css-deviceadaptation.js'), function (browsers) {
+    return prefix(['@viewport'], {
+        feature: 'css-deviceadaptation',
+        browsers: browsers
     });
-  });
-
-  resolution = require('caniuse-db/features-json/css-media-resolution.json');
+});
 
-  feature(resolution, {
-    match: /( x($| )|a #3)/
-  }, function(browsers) {
-    return prefix('@resolution', {
-      browsers: browsers,
-      feature: 'css-media-resolution'
+// Resolution Media Queries
+var resolut = require('caniuse-lite/data/features/css-media-resolution.js');
+f(resolut, { match: /( x($| )|a #3)/ }, function (browsers) {
+    return prefix(['@resolution'], {
+        feature: 'css-media-resolution',
+        browsers: browsers
     });
-  });
+});
 
-  textAlignLast = require('caniuse-db/features-json/css-text-align-last.json');
-
-  feature(textAlignLast, function(browsers) {
-    return prefix('text-align-last', {
-      browsers: browsers,
-      feature: 'css-text-align-last'
+// CSS text-align-last
+f(require('caniuse-lite/data/features/css-text-align-last.js'), function (browsers) {
+    return prefix(['text-align-last'], {
+        feature: 'css-text-align-last',
+        browsers: browsers
     });
-  });
+});
 
-  crispedges = require('caniuse-db/features-json/css-crisp-edges.json');
+// Crisp Edges Image Rendering Algorithm
+var crispedges = require('caniuse-lite/data/features/css-crisp-edges.js');
 
-  feature(crispedges, {
-    match: /y x|a x #1/
-  }, function(browsers) {
-    return prefix('pixelated', {
-      props: ['image-rendering'],
-      browsers: browsers,
-      feature: 'css-crisp-edges'
+f(crispedges, { match: /y x|a x #1/ }, function (browsers) {
+    return prefix(['pixelated'], {
+        props: ['image-rendering'],
+        feature: 'css-crisp-edges',
+        browsers: browsers
     });
-  });
+});
 
-  feature(crispedges, {
-    match: /a x #2/
-  }, function(browsers) {
-    return prefix('image-rendering', {
-      browsers: browsers,
-      feature: 'css-crisp-edges'
-    });
-  });
+f(crispedges, { match: /a x #2/ }, function (browsers) {
+    return prefix(['image-rendering'], {
+        feature: 'css-crisp-edges',
+        browsers: browsers
+    });
+});
 
-  logicalProps = require('caniuse-db/features-json/css-logical-props.json');
+// Logical Properties
+var logicalProps = require('caniuse-lite/data/features/css-logical-props.js');
 
-  feature(logicalProps, function(browsers) {
-    return prefix('border-inline-start', 'border-inline-end', 'margin-inline-start', 'margin-inline-end', 'padding-inline-start', 'padding-inline-end', {
-      browsers: browsers,
-      feature: 'css-logical-props'
+f(logicalProps, function (browsers) {
+    return prefix(['border-inline-start', 'border-inline-end', 'margin-inline-start', 'margin-inline-end', 'padding-inline-start', 'padding-inline-end'], {
+        feature: 'css-logical-props',
+        browsers: browsers
     });
-  });
+});
 
-  feature(logicalProps, {
-    match: /x\s#2/
-  }, function(browsers) {
-    return prefix('border-block-start', 'border-block-end', 'margin-block-start', 'margin-block-end', 'padding-block-start', 'padding-block-end', {
-      browsers: browsers,
-      feature: 'css-logical-props'
+f(logicalProps, { match: /x\s#2/ }, function (browsers) {
+    return prefix(['border-block-start', 'border-block-end', 'margin-block-start', 'margin-block-end', 'padding-block-start', 'padding-block-end'], {
+        feature: 'css-logical-props',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/css-appearance.json'), function(browsers) {
-    return prefix('appearance', {
-      browsers: browsers,
-      feature: 'css-appearance'
+// CSS appearance
+var appearance = require('caniuse-lite/data/features/css-appearance.js');
+f(appearance, { match: /#2|x/ }, function (browsers) {
+    return prefix(['appearance'], {
+        feature: 'css-appearance',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/css-snappoints.json'), function(browsers) {
-    return prefix('scroll-snap-type', 'scroll-snap-coordinate', 'scroll-snap-destination', 'scroll-snap-points-x', 'scroll-snap-points-y', {
-      browsers: browsers,
-      feature: 'css-snappoints'
+// CSS Scroll snap points
+f(require('caniuse-lite/data/features/css-snappoints.js'), function (browsers) {
+    return prefix(['scroll-snap-type', 'scroll-snap-coordinate', 'scroll-snap-destination', 'scroll-snap-points-x', 'scroll-snap-points-y'], {
+        feature: 'css-snappoints',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/css-regions.json'), function(browsers) {
-    return prefix('flow-into', 'flow-from', 'region-fragment', {
-      browsers: browsers,
-      feature: 'css-regions'
+// CSS Regions
+f(require('caniuse-lite/data/features/css-regions.js'), function (browsers) {
+    return prefix(['flow-into', 'flow-from', 'region-fragment'], {
+        feature: 'css-regions',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/css-image-set.json'), function(browsers) {
-    return prefix('image-set', {
-      props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'],
-      browsers: browsers,
-      feature: 'css-image-set'
+// CSS image-set
+f(require('caniuse-lite/data/features/css-image-set.js'), function (browsers) {
+    return prefix(['image-set'], {
+        props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'],
+        feature: 'css-image-set',
+        browsers: browsers
     });
-  });
-
-  writingMode = require('caniuse-db/features-json/css-writing-mode.json');
+});
 
-  feature(writingMode, {
-    match: /a|x/
-  }, function(browsers) {
-    return prefix('writing-mode', {
-      browsers: browsers,
-      feature: 'css-writing-mode'
+// Writing Mode
+var writingMode = require('caniuse-lite/data/features/css-writing-mode.js');
+f(writingMode, { match: /a|x/ }, function (browsers) {
+    return prefix(['writing-mode'], {
+        feature: 'css-writing-mode',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/css-cross-fade.json'), function(browsers) {
-    return prefix('cross-fade', {
-      props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'],
-      browsers: browsers,
-      feature: 'css-cross-fade'
+// Cross-Fade Function
+f(require('caniuse-lite/data/features/css-cross-fade.js'), function (browsers) {
+    return prefix(['cross-fade'], {
+        props: ['background', 'background-image', 'border-image', 'mask', 'list-style', 'list-style-image', 'content', 'mask-image'],
+        feature: 'css-cross-fade',
+        browsers: browsers
     });
-  });
+});
 
-  readOnly = require('caniuse-db/features-json/css-read-only-write.json');
-
-  feature(readOnly, function(browsers) {
-    return prefix(':read-only', ':read-write', {
-      selector: true,
-      browsers: browsers,
-      feature: 'css-read-only-write'
+// Read Only selector
+f(require('caniuse-lite/data/features/css-read-only-write.js'), function (browsers) {
+    return prefix([':read-only', ':read-write'], {
+        selector: true,
+        feature: 'css-read-only-write',
+        browsers: browsers
     });
-  });
+});
 
-  feature(require('caniuse-db/features-json/text-emphasis.json'), function(browsers) {
-    return prefix('text-emphasis', 'text-emphasis-position', 'text-emphasis-style', 'text-emphasis-color', {
-      browsers: browsers,
-      feature: 'text-emphasis'
+// Text Emphasize
+f(require('caniuse-lite/data/features/text-emphasis.js'), function (browsers) {
+    return prefix(['text-emphasis', 'text-emphasis-position', 'text-emphasis-style', 'text-emphasis-color'], {
+        feature: 'text-emphasis',
+        browsers: browsers
     });
-  });
+});
 
-  grid = require('caniuse-db/features-json/css-grid.json');
+// CSS Grid Layout
+var grid = require('caniuse-lite/data/features/css-grid.js');
 
-  feature(grid, function(browsers) {
-    prefix('display-grid', 'inline-grid', {
-      props: ['display'],
-      browsers: browsers,
-      feature: 'css-grid'
+f(grid, function (browsers) {
+    prefix(['display-grid', 'inline-grid'], {
+        props: ['display'],
+        feature: 'css-grid',
+        browsers: browsers
     });
-    return prefix('grid-template-columns', 'grid-template-rows', 'grid-row-start', 'grid-column-start', 'grid-row-end', 'grid-column-end', 'grid-row', 'grid-column', {
-      browsers: browsers,
-      feature: 'css-grid'
+    prefix(['grid-template-columns', 'grid-template-rows', 'grid-row-start', 'grid-column-start', 'grid-row-end', 'grid-column-end', 'grid-row', 'grid-column'], {
+        feature: 'css-grid',
+        browsers: browsers
     });
-  });
+});
 
-  feature(grid, {
-    match: /a x/
-  }, function(browsers) {
-    return prefix('justify-items', 'grid-row-align', {
-      browsers: browsers,
-      feature: 'css-grid'
+f(grid, { match: /a x/ }, function (browsers) {
+    return prefix(['grid-column-align', 'grid-row-align'], {
+        feature: 'css-grid',
+        browsers: browsers
     });
-  });
-
-  textSpacing = require('caniuse-db/features-json/css-text-spacing.json');
+});
 
-  feature(textSpacing, function(browsers) {
-    return prefix('text-spacing', {
-      browsers: browsers,
-      feature: 'css-text-spacing'
+// CSS text-spacing
+f(require('caniuse-lite/data/features/css-text-spacing.js'), function (browsers) {
+    return prefix(['text-spacing'], {
+        feature: 'css-text-spacing',
+        browsers: browsers
     });
-  });
-
-  feature(require('caniuse-db/features-json/css-any-link.json'), function(browsers) {
-    return prefix(':any-link', {
-      selector: true,
-      browsers: browsers,
-      feature: 'css-any-link'
+});
+
+// :any-link selector
+f(require('caniuse-lite/data/features/css-any-link.js'), function (browsers) {
+    return prefix([':any-link'], {
+        selector: true,
+        feature: 'css-any-link',
+        browsers: browsers
     });
-  });
+});
 
-}).call(this);
+// unicode-bidi
+var bidi = require('caniuse-lite/data/features/css-unicode-bidi.js');
+
+f(bidi, function (browsers) {
+    return prefix(['isolate'], {
+        props: ['unicode-bidi'],
+        feature: 'css-unicode-bidi',
+        browsers: browsers
+    });
+});
+
+f(bidi, { match: /y x|a x #2/ }, function (browsers) {
+    return prefix(['plaintext'], {
+        props: ['unicode-bidi'],
+        feature: 'css-unicode-bidi',
+        browsers: browsers
+    });
+});
+
+f(bidi, { match: /y x/ }, function (browsers) {
+    return prefix(['isolate-override'], {
+        props: ['unicode-bidi'],
+        feature: 'css-unicode-bidi',
+        browsers: browsers
+    });
+});