create-docusaurus 0.0.0-4378 → 0.0.0-4379

package/templates/facebook/node_modules/autoprefixer/lib/at-rule.js

@@ -0,0 +1,62 @@
+"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); }
+
+var Prefixer = require('./prefixer');
+
+var AtRule = /*#__PURE__*/function (_Prefixer) {
+  _inheritsLoose(AtRule, _Prefixer);
+
+  function AtRule() {
+    return _Prefixer.apply(this, arguments) || this;
+  }
+
+  var _proto = AtRule.prototype;
+
+  /**
+     * Clone and add prefixes for at-rule
+     */
+  _proto.add = function add(rule, prefix) {
+    var prefixed = prefix + rule.name;
+    var already = rule.parent.some(function (i) {
+      return i.name === prefixed && i.params === rule.params;
+    });
+
+    if (already) {
+      return undefined;
+    }
+
+    var cloned = this.clone(rule, {
+      name: prefixed
+    });
+    return rule.parent.insertBefore(rule, cloned);
+  }
+  /**
+     * Clone node with prefixes
+     */
+  ;
+
+  _proto.process = function process(node) {
+    var parent = this.parentPrefix(node);
+
+    for (var _iterator = _createForOfIteratorHelperLoose(this.prefixes), _step; !(_step = _iterator()).done;) {
+      var prefix = _step.value;
+
+      if (!parent || parent === prefix) {
+        this.add(node, prefix);
+      }
+    }
+  };
+
+  return AtRule;
+}(Prefixer);
+
+module.exports = AtRule;

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

@@ -0,0 +1,150 @@
+"use strict";
+
+var browserslist = require('browserslist');
+
+var postcss = require('postcss');
+
+var agents = require('caniuse-lite').agents;
+
+var pico = require('picocolors');
+
+var Browsers = require('./browsers');
+
+var Prefixes = require('./prefixes');
+
+var data = require('../data/prefixes');
+
+var info = require('./info');
+
+var WARNING = '\n' + '  Replace Autoprefixer `browsers` option to Browserslist config.\n' + '  Use `browserslist` key in `package.json` or `.browserslistrc` file.\n' + '\n' + '  Using `browsers` option can cause errors. Browserslist config \n' + '  can be used for Babel, Autoprefixer, postcss-normalize and other tools.\n' + '\n' + '  If you really need to use option, rename it to `overrideBrowserslist`.\n' + '\n' + '  Learn more at:\n' + '  https://github.com/browserslist/browserslist#readme\n' + '  https://twitter.com/browserslist\n' + '\n';
+
+function isPlainObject(obj) {
+  return Object.prototype.toString.apply(obj) === '[object Object]';
+}
+
+var cache = {};
+
+function timeCapsule(result, prefixes) {
+  if (prefixes.browsers.selected.length === 0) {
+    return;
+  }
+
+  if (prefixes.add.selectors.length > 0) {
+    return;
+  }
+
+  if (Object.keys(prefixes.add).length > 2) {
+    return;
+  }
+  /* istanbul ignore next */
+
+
+  result.warn('Greetings, time traveller. ' + 'We are in the golden age of prefix-less CSS, ' + 'where Autoprefixer is no longer needed for your stylesheet.');
+}
+
+module.exports = postcss.plugin('autoprefixer', function () {
+  for (var _len = arguments.length, reqs = new Array(_len), _key = 0; _key < _len; _key++) {
+    reqs[_key] = arguments[_key];
+  }
+
+  var options;
+
+  if (reqs.length === 1 && isPlainObject(reqs[0])) {
+    options = reqs[0];
+    reqs = undefined;
+  } else if (reqs.length === 0 || reqs.length === 1 && !reqs[0]) {
+    reqs = undefined;
+  } else if (reqs.length <= 2 && (Array.isArray(reqs[0]) || !reqs[0])) {
+    options = reqs[1];
+    reqs = reqs[0];
+  } else if (typeof reqs[reqs.length - 1] === 'object') {
+    options = reqs.pop();
+  }
+
+  if (!options) {
+    options = {};
+  }
+
+  if (options.browser) {
+    throw new Error('Change `browser` option to `overrideBrowserslist` in Autoprefixer');
+  } else if (options.browserslist) {
+    throw new Error('Change `browserslist` option to `overrideBrowserslist` in Autoprefixer');
+  }
+
+  if (options.overrideBrowserslist) {
+    reqs = options.overrideBrowserslist;
+  } else if (options.browsers) {
+    if (typeof console !== 'undefined' && console.warn) {
+      console.warn(pico.red(WARNING.replace(/`[^`]+`/g, function (i) {
+        return pico.yellow(i.slice(1, -1));
+      })));
+    }
+
+    reqs = options.browsers;
+  }
+
+  var brwlstOpts = {
+    ignoreUnknownVersions: options.ignoreUnknownVersions,
+    stats: options.stats,
+    env: options.env
+  };
+
+  function loadPrefixes(opts) {
+    var d = module.exports.data;
+    var browsers = new Browsers(d.browsers, reqs, opts, brwlstOpts);
+    var key = browsers.selected.join(', ') + JSON.stringify(options);
+
+    if (!cache[key]) {
+      cache[key] = new Prefixes(d.prefixes, browsers, options);
+    }
+
+    return cache[key];
+  }
+
+  function plugin(css, result) {
+    var prefixes = loadPrefixes({
+      from: css.source && css.source.input.file,
+      env: options.env
+    });
+    timeCapsule(result, prefixes);
+
+    if (options.remove !== false) {
+      prefixes.processor.remove(css, result);
+    }
+
+    if (options.add !== false) {
+      prefixes.processor.add(css, result);
+    }
+  }
+
+  plugin.options = options;
+  plugin.browsers = reqs;
+
+  plugin.info = function (opts) {
+    opts = opts || {};
+    opts.from = opts.from || process.cwd();
+    return info(loadPrefixes(opts));
+  };
+
+  return plugin;
+});
+/**
+ * Autoprefixer data
+ */
+
+module.exports.data = {
+  browsers: agents,
+  prefixes: data
+};
+/**
+ * Autoprefixer default browsers
+ */
+
+module.exports.defaults = browserslist.defaults;
+/**
+ * Inspect with default Autoprefixer
+ */
+
+module.exports.info = function () {
+  return module.exports().info();
+};

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

@@ -0,0 +1,64 @@
+"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; }
+
+function last(array) {
+  return array[array.length - 1];
+}
+
+var brackets = {
+  /**
+     * Parse string to nodes tree
+     */
+  parse: function parse(str) {
+    var current = [''];
+    var stack = [current];
+
+    for (var _iterator = _createForOfIteratorHelperLoose(str), _step; !(_step = _iterator()).done;) {
+      var sym = _step.value;
+
+      if (sym === '(') {
+        current = [''];
+        last(stack).push(current);
+        stack.push(current);
+        continue;
+      }
+
+      if (sym === ')') {
+        stack.pop();
+        current = last(stack);
+        current.push('');
+        continue;
+      }
+
+      current[current.length - 1] += sym;
+    }
+
+    return stack[0];
+  },
+
+  /**
+     * Generate output string by nodes tree
+     */
+  stringify: function stringify(ast) {
+    var result = '';
+
+    for (var _iterator2 = _createForOfIteratorHelperLoose(ast), _step2; !(_step2 = _iterator2()).done;) {
+      var i = _step2.value;
+
+      if (typeof i === 'object') {
+        result += "(" + brackets.stringify(i) + ")";
+        continue;
+      }
+
+      result += i;
+    }
+
+    return result;
+  }
+};
+module.exports = brackets;

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

@@ -0,0 +1,96 @@
+"use strict";
+
+var browserslist = require('browserslist');
+
+var agents = require('caniuse-lite').agents;
+
+var utils = require('./utils');
+
+var Browsers = /*#__PURE__*/function () {
+  /**
+     * Return all prefixes for default browser data
+     */
+  Browsers.prefixes = function prefixes() {
+    if (this.prefixesCache) {
+      return this.prefixesCache;
+    }
+
+    this.prefixesCache = [];
+
+    for (var name in agents) {
+      this.prefixesCache.push("-" + agents[name].prefix + "-");
+    }
+
+    this.prefixesCache = utils.uniq(this.prefixesCache).sort(function (a, b) {
+      return b.length - a.length;
+    });
+    return this.prefixesCache;
+  }
+  /**
+     * Check is value contain any possible prefix
+     */
+  ;
+
+  Browsers.withPrefix = function withPrefix(value) {
+    if (!this.prefixesRegexp) {
+      this.prefixesRegexp = new RegExp(this.prefixes().join('|'));
+    }
+
+    return this.prefixesRegexp.test(value);
+  };
+
+  function Browsers(data, requirements, options, browserslistOpts) {
+    this.data = data;
+    this.options = options || {};
+    this.browserslistOpts = browserslistOpts || {};
+    this.selected = this.parse(requirements);
+  }
+  /**
+     * Return browsers selected by requirements
+     */
+
+
+  var _proto = Browsers.prototype;
+
+  _proto.parse = function parse(requirements) {
+    var opts = {};
+
+    for (var i in this.browserslistOpts) {
+      opts[i] = this.browserslistOpts[i];
+    }
+
+    opts.path = this.options.from;
+    return browserslist(requirements, opts);
+  }
+  /**
+     * Return prefix for selected browser
+     */
+  ;
+
+  _proto.prefix = function prefix(browser) {
+    var _browser$split = browser.split(' '),
+        name = _browser$split[0],
+        version = _browser$split[1];
+
+    var data = this.data[name];
+    var prefix = data.prefix_exceptions && data.prefix_exceptions[version];
+
+    if (!prefix) {
+      prefix = data.prefix;
+    }
+
+    return "-" + prefix + "-";
+  }
+  /**
+     * Is browser is selected by requirements
+     */
+  ;
+
+  _proto.isSelected = function isSelected(browser) {
+    return this.selected.includes(browser);
+  };
+
+  return Browsers;
+}();
+
+module.exports = Browsers;

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

@@ -0,0 +1,243 @@
+"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); }
+
+var Prefixer = require('./prefixer');
+
+var Browsers = require('./browsers');
+
+var utils = require('./utils');
+
+var Declaration = /*#__PURE__*/function (_Prefixer) {
+  _inheritsLoose(Declaration, _Prefixer);
+
+  function Declaration() {
+    return _Prefixer.apply(this, arguments) || this;
+  }
+
+  var _proto = Declaration.prototype;
+
+  /**
+     * Always true, because we already get prefixer by property name
+     */
+  _proto.check = function check()
+  /* decl */
+  {
+    return true;
+  }
+  /**
+     * Return prefixed version of property
+     */
+  ;
+
+  _proto.prefixed = function prefixed(prop, prefix) {
+    return prefix + prop;
+  }
+  /**
+     * Return unprefixed version of property
+     */
+  ;
+
+  _proto.normalize = function normalize(prop) {
+    return prop;
+  }
+  /**
+     * Check `value`, that it contain other prefixes, rather than `prefix`
+     */
+  ;
+
+  _proto.otherPrefixes = function otherPrefixes(value, prefix) {
+    for (var _iterator = _createForOfIteratorHelperLoose(Browsers.prefixes()), _step; !(_step = _iterator()).done;) {
+      var other = _step.value;
+
+      if (other === prefix) {
+        continue;
+      }
+
+      if (value.includes(other)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+  /**
+     * Set prefix to declaration
+     */
+  ;
+
+  _proto.set = function set(decl, prefix) {
+    decl.prop = this.prefixed(decl.prop, prefix);
+    return decl;
+  }
+  /**
+     * Should we use visual cascade for prefixes
+     */
+  ;
+
+  _proto.needCascade = function needCascade(decl) {
+    if (!decl._autoprefixerCascade) {
+      decl._autoprefixerCascade = this.all.options.cascade !== false && decl.raw('before').includes('\n');
+    }
+
+    return decl._autoprefixerCascade;
+  }
+  /**
+     * Return maximum length of possible prefixed property
+     */
+  ;
+
+  _proto.maxPrefixed = function maxPrefixed(prefixes, decl) {
+    if (decl._autoprefixerMax) {
+      return decl._autoprefixerMax;
+    }
+
+    var max = 0;
+
+    for (var _iterator2 = _createForOfIteratorHelperLoose(prefixes), _step2; !(_step2 = _iterator2()).done;) {
+      var prefix = _step2.value;
+      prefix = utils.removeNote(prefix);
+
+      if (prefix.length > max) {
+        max = prefix.length;
+      }
+    }
+
+    decl._autoprefixerMax = max;
+    return decl._autoprefixerMax;
+  }
+  /**
+     * Calculate indentation to create visual cascade
+     */
+  ;
+
+  _proto.calcBefore = function calcBefore(prefixes, decl, prefix) {
+    if (prefix === void 0) {
+      prefix = '';
+    }
+
+    var max = this.maxPrefixed(prefixes, decl);
+    var diff = max - utils.removeNote(prefix).length;
+    var before = decl.raw('before');
+
+    if (diff > 0) {
+      before += Array(diff).fill(' ').join('');
+    }
+
+    return before;
+  }
+  /**
+     * Remove visual cascade
+     */
+  ;
+
+  _proto.restoreBefore = function restoreBefore(decl) {
+    var lines = decl.raw('before').split('\n');
+    var min = lines[lines.length - 1];
+    this.all.group(decl).up(function (prefixed) {
+      var array = prefixed.raw('before').split('\n');
+      var last = array[array.length - 1];
+
+      if (last.length < min.length) {
+        min = last;
+      }
+    });
+    lines[lines.length - 1] = min;
+    decl.raws.before = lines.join('\n');
+  }
+  /**
+     * Clone and insert new declaration
+     */
+  ;
+
+  _proto.insert = function insert(decl, prefix, prefixes) {
+    var cloned = this.set(this.clone(decl), prefix);
+    if (!cloned) return undefined;
+    var already = decl.parent.some(function (i) {
+      return i.prop === cloned.prop && i.value === cloned.value;
+    });
+
+    if (already) {
+      return undefined;
+    }
+
+    if (this.needCascade(decl)) {
+      cloned.raws.before = this.calcBefore(prefixes, decl, prefix);
+    }
+
+    return decl.parent.insertBefore(decl, cloned);
+  }
+  /**
+     * Did this declaration has this prefix above
+     */
+  ;
+
+  _proto.isAlready = function isAlready(decl, prefixed) {
+    var already = this.all.group(decl).up(function (i) {
+      return i.prop === prefixed;
+    });
+
+    if (!already) {
+      already = this.all.group(decl).down(function (i) {
+        return i.prop === prefixed;
+      });
+    }
+
+    return already;
+  }
+  /**
+     * Clone and add prefixes for declaration
+     */
+  ;
+
+  _proto.add = function add(decl, prefix, prefixes, result) {
+    var prefixed = this.prefixed(decl.prop, prefix);
+
+    if (this.isAlready(decl, prefixed) || this.otherPrefixes(decl.value, prefix)) {
+      return undefined;
+    }
+
+    return this.insert(decl, prefix, prefixes, result);
+  }
+  /**
+     * Add spaces for visual cascade
+     */
+  ;
+
+  _proto.process = function process(decl, result) {
+    if (!this.needCascade(decl)) {
+      _Prefixer.prototype.process.call(this, decl, result);
+
+      return;
+    }
+
+    var prefixes = _Prefixer.prototype.process.call(this, decl, result);
+
+    if (!prefixes || !prefixes.length) {
+      return;
+    }
+
+    this.restoreBefore(decl);
+    decl.raws.before = this.calcBefore(prefixes, decl);
+  }
+  /**
+     * Return list of prefixed properties to clean old prefixes
+     */
+  ;
+
+  _proto.old = function old(prop, prefix) {
+    return [this.prefixed(prop, prefix)];
+  };
+
+  return Declaration;
+}(Prefixer);
+
+module.exports = Declaration;

package/templates/facebook/node_modules/autoprefixer/lib/hacks/align-content.js

@@ -0,0 +1,79 @@
+"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 flexSpec = require('./flex-spec');
+
+var Declaration = require('../declaration');
+
+var AlignContent = /*#__PURE__*/function (_Declaration) {
+  _inheritsLoose(AlignContent, _Declaration);
+
+  function AlignContent() {
+    return _Declaration.apply(this, arguments) || this;
+  }
+
+  var _proto = AlignContent.prototype;
+
+  /**
+   * Change property name for 2012 spec
+   */
+  _proto.prefixed = function prefixed(prop, prefix) {
+    var spec;
+
+    var _flexSpec = flexSpec(prefix);
+
+    spec = _flexSpec[0];
+    prefix = _flexSpec[1];
+
+    if (spec === 2012) {
+      return prefix + 'flex-line-pack';
+    }
+
+    return _Declaration.prototype.prefixed.call(this, prop, prefix);
+  }
+  /**
+   * Return property name by final spec
+   */
+  ;
+
+  _proto.normalize = function normalize() {
+    return 'align-content';
+  }
+  /**
+   * Change value for 2012 spec and ignore prefix for 2009
+   */
+  ;
+
+  _proto.set = function set(decl, prefix) {
+    var spec = flexSpec(prefix)[0];
+
+    if (spec === 2012) {
+      decl.value = AlignContent.oldValues[decl.value] || decl.value;
+      return _Declaration.prototype.set.call(this, decl, prefix);
+    }
+
+    if (spec === 'final') {
+      return _Declaration.prototype.set.call(this, decl, prefix);
+    }
+
+    return undefined;
+  };
+
+  return AlignContent;
+}(Declaration);
+
+_defineProperty(AlignContent, "names", ['align-content', 'flex-line-pack']);
+
+_defineProperty(AlignContent, "oldValues", {
+  'flex-end': 'end',
+  'flex-start': 'start',
+  'space-between': 'justify',
+  'space-around': 'distribute'
+});
+
+module.exports = AlignContent;