create-docusaurus 0.0.0-4378 → 0.0.0-4379

package/templates/facebook/node_modules/autoprefixer/lib/hacks/place-self.js

@@ -0,0 +1,55 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var utils = require('./grid-utils');
+
+var PlaceSelf = /*#__PURE__*/function (_Declaration) {
+  _inheritsLoose(PlaceSelf, _Declaration);
+
+  function PlaceSelf() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = PlaceSelf.prototype;
+
+  /**
+   * Translate place-self to separate -ms- prefixed properties
+   */
+  _proto.insert = function insert(decl, prefix, prefixes) {
+    if (prefix !== '-ms-') return _Declaration.prototype.insert.call(this, decl, prefix, prefixes); // prevent doubling of prefixes
+
+    if (decl.parent.some(function (i) {
+      return i.prop === '-ms-grid-row-align';
+    })) {
+      return undefined;
+    }
+
+    var _utils$parse = utils.parse(decl),
+        _utils$parse$ = _utils$parse[0],
+        first = _utils$parse$[0],
+        second = _utils$parse$[1];
+
+    if (second) {
+      utils.insertDecl(decl, 'grid-row-align', first);
+      utils.insertDecl(decl, 'grid-column-align', second);
+    } else {
+      utils.insertDecl(decl, 'grid-row-align', first);
+      utils.insertDecl(decl, 'grid-column-align', first);
+    }
+
+    return undefined;
+  };
+
+  return PlaceSelf;
+}(Declaration);
+
+_defineProperty(PlaceSelf, "names", ['place-self']);
+
+module.exports = PlaceSelf;

package/templates/facebook/node_modules/autoprefixer/lib/hacks/placeholder-shown.js

@@ -0,0 +1,36 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Selector = require('../selector');
+
+var PlaceholderShown = /*#__PURE__*/function (_Selector) {
+  _inheritsLoose(PlaceholderShown, _Selector);
+
+  function PlaceholderShown() {
+    return _Selector.apply(this, arguments) || this;
+  }
+
+  var _proto = PlaceholderShown.prototype;
+
+  /**
+   * Return different selectors depend on prefix
+   */
+  _proto.prefixed = function prefixed(prefix) {
+    if (prefix === '-ms-') {
+      return ':-ms-input-placeholder';
+    }
+
+    return ":" + prefix + "placeholder-shown";
+  };
+
+  return PlaceholderShown;
+}(Selector);
+
+_defineProperty(PlaceholderShown, "names", [':placeholder-shown']);
+
+module.exports = PlaceholderShown;

package/templates/facebook/node_modules/autoprefixer/lib/hacks/placeholder.js

@@ -0,0 +1,56 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Selector = require('../selector');
+
+var Placeholder = /*#__PURE__*/function (_Selector) {
+  _inheritsLoose(Placeholder, _Selector);
+
+  function Placeholder() {
+    return _Selector.apply(this, arguments) || this;
+  }
+
+  var _proto = Placeholder.prototype;
+
+  /**
+   * Add old mozilla to possible prefixes
+   */
+  _proto.possible = function possible() {
+    return _Selector.prototype.possible.call(this).concat(['-moz- old', '-ms- old']);
+  }
+  /**
+   * Return different selectors depend on prefix
+   */
+  ;
+
+  _proto.prefixed = function prefixed(prefix) {
+    if (prefix === '-webkit-') {
+      return '::-webkit-input-placeholder';
+    }
+
+    if (prefix === '-ms-') {
+      return '::-ms-input-placeholder';
+    }
+
+    if (prefix === '-ms- old') {
+      return ':-ms-input-placeholder';
+    }
+
+    if (prefix === '-moz- old') {
+      return ':-moz-placeholder';
+    }
+
+    return "::" + prefix + "placeholder";
+  };
+
+  return Placeholder;
+}(Selector);
+
+_defineProperty(Placeholder, "names", ['::placeholder']);
+
+module.exports = Placeholder;

package/templates/facebook/node_modules/autoprefixer/lib/hacks/text-decoration-skip-ink.js

@@ -0,0 +1,38 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var TextDecorationSkipInk = /*#__PURE__*/function (_Declaration) {
+  _inheritsLoose(TextDecorationSkipInk, _Declaration);
+
+  function TextDecorationSkipInk() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = TextDecorationSkipInk.prototype;
+
+  /**
+   * Change prefix for ink value
+   */
+  _proto.set = function set(decl, prefix) {
+    if (decl.prop === 'text-decoration-skip-ink' && decl.value === 'auto') {
+      decl.prop = prefix + 'text-decoration-skip';
+      decl.value = 'ink';
+      return decl;
+    } else {
+      return _Declaration.prototype.set.call(this, decl, prefix);
+    }
+  };
+
+  return TextDecorationSkipInk;
+}(Declaration);
+
+_defineProperty(TextDecorationSkipInk, "names", ['text-decoration-skip-ink', 'text-decoration-skip']);
+
+module.exports = TextDecorationSkipInk;

package/templates/facebook/node_modules/autoprefixer/lib/hacks/text-decoration.js

@@ -0,0 +1,36 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var BASIC = ['none', 'underline', 'overline', 'line-through', 'blink', 'inherit', 'initial', 'unset'];
+
+var TextDecoration = /*#__PURE__*/function (_Declaration) {
+  _inheritsLoose(TextDecoration, _Declaration);
+
+  function TextDecoration() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = TextDecoration.prototype;
+
+  /**
+   * Do not add prefixes for basic values.
+   */
+  _proto.check = function check(decl) {
+    return decl.value.split(/\s+/).some(function (i) {
+      return !BASIC.includes(i);
+    });
+  };
+
+  return TextDecoration;
+}(Declaration);
+
+_defineProperty(TextDecoration, "names", ['text-decoration']);
+
+module.exports = TextDecoration;

package/templates/facebook/node_modules/autoprefixer/lib/hacks/text-emphasis-position.js

@@ -0,0 +1,33 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var TextEmphasisPosition = /*#__PURE__*/function (_Declaration) {
+  _inheritsLoose(TextEmphasisPosition, _Declaration);
+
+  function TextEmphasisPosition() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = TextEmphasisPosition.prototype;
+
+  _proto.set = function set(decl, prefix) {
+    if (prefix === '-webkit-') {
+      decl.value = decl.value.replace(/\s*(right|left)\s*/i, '');
+    }
+
+    return _Declaration.prototype.set.call(this, decl, prefix);
+  };
+
+  return TextEmphasisPosition;
+}(Declaration);
+
+_defineProperty(TextEmphasisPosition, "names", ['text-emphasis-position']);
+
+module.exports = TextEmphasisPosition;

package/templates/facebook/node_modules/autoprefixer/lib/hacks/transform-decl.js

@@ -0,0 +1,105 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var TransformDecl = /*#__PURE__*/function (_Declaration) {
+  _inheritsLoose(TransformDecl, _Declaration);
+
+  function TransformDecl() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = TransformDecl.prototype;
+
+  /**
+   * Recursively check all parents for @keyframes
+   */
+  _proto.keyframeParents = function keyframeParents(decl) {
+    var parent = decl.parent;
+
+    while (parent) {
+      if (parent.type === 'atrule' && parent.name === 'keyframes') {
+        return true;
+      }
+
+      var _parent = parent;
+      parent = _parent.parent;
+    }
+
+    return false;
+  }
+  /**
+   * Is transform contain 3D commands
+   */
+  ;
+
+  _proto.contain3d = function contain3d(decl) {
+    if (decl.prop === 'transform-origin') {
+      return false;
+    }
+
+    for (var _iterator = _createForOfIteratorHelperLoose(TransformDecl.functions3d), _step; !(_step = _iterator()).done;) {
+      var func = _step.value;
+
+      if (decl.value.includes(func + "(")) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+  /**
+   * Replace rotateZ to rotate for IE 9
+   */
+  ;
+
+  _proto.set = function set(decl, prefix) {
+    decl = _Declaration.prototype.set.call(this, decl, prefix);
+
+    if (prefix === '-ms-') {
+      decl.value = decl.value.replace(/rotatez/gi, 'rotate');
+    }
+
+    return decl;
+  }
+  /**
+   * Don't add prefix for IE in keyframes
+   */
+  ;
+
+  _proto.insert = function insert(decl, prefix, prefixes) {
+    if (prefix === '-ms-') {
+      if (!this.contain3d(decl) && !this.keyframeParents(decl)) {
+        return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+      }
+    } else if (prefix === '-o-') {
+      if (!this.contain3d(decl)) {
+        return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+      }
+    } else {
+      return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+    }
+
+    return undefined;
+  };
+
+  return TransformDecl;
+}(Declaration);
+
+_defineProperty(TransformDecl, "names", ['transform', 'transform-origin']);
+
+_defineProperty(TransformDecl, "functions3d", ['matrix3d', 'translate3d', 'translateZ', 'scale3d', 'scaleZ', 'rotate3d', 'rotateX', 'rotateY', 'perspective']);
+
+module.exports = TransformDecl;

package/templates/facebook/node_modules/autoprefixer/lib/hacks/user-select.js

@@ -0,0 +1,36 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var UserSelect = /*#__PURE__*/function (_Declaration) {
+  _inheritsLoose(UserSelect, _Declaration);
+
+  function UserSelect() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = UserSelect.prototype;
+
+  /**
+   * Change prefixed value for IE
+   */
+  _proto.set = function set(decl, prefix) {
+    if (prefix === '-ms-' && decl.value === 'contain') {
+      decl.value = 'element';
+    }
+
+    return _Declaration.prototype.set.call(this, decl, prefix);
+  };
+
+  return UserSelect;
+}(Declaration);
+
+_defineProperty(UserSelect, "names", ['user-select']);
+
+module.exports = UserSelect;

package/templates/facebook/node_modules/autoprefixer/lib/hacks/writing-mode.js

@@ -0,0 +1,59 @@
+"use strict";
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _defaults(subClass, superClass); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var Declaration = require('../declaration');
+
+var WritingMode = /*#__PURE__*/function (_Declaration) {
+  _inheritsLoose(WritingMode, _Declaration);
+
+  function WritingMode() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = WritingMode.prototype;
+
+  _proto.insert = function insert(decl, prefix, prefixes) {
+    if (prefix === '-ms-') {
+      var cloned = this.set(this.clone(decl), prefix);
+
+      if (this.needCascade(decl)) {
+        cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
+      }
+
+      var direction = 'ltr';
+      decl.parent.nodes.forEach(function (i) {
+        if (i.prop === 'direction') {
+          if (i.value === 'rtl' || i.value === 'ltr') direction = i.value;
+        }
+      });
+      cloned.value = WritingMode.msValues[direction][decl.value] || decl.value;
+      return decl.parent.insertBefore(decl, cloned);
+    }
+
+    return _Declaration.prototype.insert.call(this, decl, prefix, prefixes);
+  };
+
+  return WritingMode;
+}(Declaration);
+
+_defineProperty(WritingMode, "names", ['writing-mode']);
+
+_defineProperty(WritingMode, "msValues", {
+  ltr: {
+    'horizontal-tb': 'lr-tb',
+    'vertical-rl': 'tb-rl',
+    'vertical-lr': 'tb-lr'
+  },
+  rtl: {
+    'horizontal-tb': 'rl-tb',
+    'vertical-rl': 'bt-rl',
+    'vertical-lr': 'bt-lr'
+  }
+});
+
+module.exports = WritingMode;

package/templates/facebook/node_modules/autoprefixer/lib/info.js

@@ -0,0 +1,149 @@
+"use strict";
+
+function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var browserslist = require('browserslist');
+
+function capitalize(str) {
+  return str.slice(0, 1).toUpperCase() + str.slice(1);
+}
+
+var NAMES = {
+  ie: 'IE',
+  ie_mob: 'IE Mobile',
+  ios_saf: 'iOS',
+  op_mini: 'Opera Mini',
+  op_mob: 'Opera Mobile',
+  and_chr: 'Chrome for Android',
+  and_ff: 'Firefox for Android',
+  and_uc: 'UC for Android'
+};
+
+function prefix(name, prefixes, note) {
+  var out = "  " + name;
+  if (note) out += ' *';
+  out += ': ';
+  out += prefixes.map(function (i) {
+    return i.replace(/^-(.*)-$/g, '$1');
+  }).join(', ');
+  out += '\n';
+  return out;
+}
+
+module.exports = function (prefixes) {
+  if (prefixes.browsers.selected.length === 0) {
+    return 'No browsers selected';
+  }
+
+  var versions = {};
+
+  for (var _iterator = _createForOfIteratorHelperLoose(prefixes.browsers.selected), _step; !(_step = _iterator()).done;) {
+    var _browser = _step.value;
+
+    var parts = _browser.split(' ');
+
+    var _name2 = parts[0];
+    var version = parts[1];
+    _name2 = NAMES[_name2] || capitalize(_name2);
+
+    if (versions[_name2]) {
+      versions[_name2].push(version);
+    } else {
+      versions[_name2] = [version];
+    }
+  }
+
+  var out = 'Browsers:\n';
+
+  for (var browser in versions) {
+    var list = versions[browser];
+    list = list.sort(function (a, b) {
+      return parseFloat(b) - parseFloat(a);
+    });
+    out += "  " + browser + ": " + list.join(', ') + "\n";
+  }
+
+  var coverage = browserslist.coverage(prefixes.browsers.selected);
+  var round = Math.round(coverage * 100) / 100.0;
+  out += "\nThese browsers account for " + round + "% of all users globally\n";
+  var atrules = [];
+
+  for (var name in prefixes.add) {
+    var data = prefixes.add[name];
+
+    if (name[0] === '@' && data.prefixes) {
+      atrules.push(prefix(name, data.prefixes));
+    }
+  }
+
+  if (atrules.length > 0) {
+    out += "\nAt-Rules:\n" + atrules.sort().join('');
+  }
+
+  var selectors = [];
+
+  for (var _iterator2 = _createForOfIteratorHelperLoose(prefixes.add.selectors), _step2; !(_step2 = _iterator2()).done;) {
+    var selector = _step2.value;
+
+    if (selector.prefixes) {
+      selectors.push(prefix(selector.name, selector.prefixes));
+    }
+  }
+
+  if (selectors.length > 0) {
+    out += "\nSelectors:\n" + selectors.sort().join('');
+  }
+
+  var values = [];
+  var props = [];
+  var hadGrid = false;
+
+  for (var _name in prefixes.add) {
+    var _data = prefixes.add[_name];
+
+    if (_name[0] !== '@' && _data.prefixes) {
+      var grid = _name.indexOf('grid-') === 0;
+      if (grid) hadGrid = true;
+      props.push(prefix(_name, _data.prefixes, grid));
+    }
+
+    if (!Array.isArray(_data.values)) {
+      continue;
+    }
+
+    for (var _iterator3 = _createForOfIteratorHelperLoose(_data.values), _step3; !(_step3 = _iterator3()).done;) {
+      var value = _step3.value;
+
+      var _grid = value.name.includes('grid');
+
+      if (_grid) hadGrid = true;
+      var string = prefix(value.name, value.prefixes, _grid);
+
+      if (!values.includes(string)) {
+        values.push(string);
+      }
+    }
+  }
+
+  if (props.length > 0) {
+    out += "\nProperties:\n" + props.sort().join('');
+  }
+
+  if (values.length > 0) {
+    out += "\nValues:\n" + values.sort().join('');
+  }
+
+  if (hadGrid) {
+    out += '\n* - Prefixes will be added only on grid: true option.\n';
+  }
+
+  if (!atrules.length && !selectors.length && !props.length && !values.length) {
+    out += '\nAwesome! Your browsers don\'t require any vendor prefixes.' + '\nNow you can remove Autoprefixer from build steps.';
+  }
+
+  return out;
+};