create-docusaurus 0.0.0-4376 → 0.0.0-4383

package/templates/facebook/node_modules/stylelint/lib/utils/isContextFunctionalPseudoClass.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const keywordSets = require('../reference/keywordSets');
+
+/**
+ * Check whether a node is a context-functional pseudo-class (i.e. either a logical combination
+ * or a 'aNPlusBOfSNotationPseudoClasses' / tree-structural pseudo-class)
+ *
+ * @param {import('postcss-selector-parser').Pseudo} node postcss-selector-parser node (of type pseudo)
+ * @return {boolean} If `true`, the node is a context-functional pseudo-class
+ */
+module.exports = function isContextFunctionalPseudoClass(node) {
+	if (node.type === 'pseudo') {
+		const normalisedParentName = node.value.toLowerCase().replace(/:+/, '');
+
+		return (
+			keywordSets.logicalCombinationsPseudoClasses.has(normalisedParentName) ||
+			keywordSets.aNPlusBOfSNotationPseudoClasses.has(normalisedParentName)
+		);
+	}
+
+	return false;
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isCounterIncrementCustomIdentValue.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const keywordSets = require('../reference/keywordSets');
+
+/**
+ * Check value is a custom ident
+ *
+ * @param {string} value
+ */
+module.exports = function (value) {
+	const valueLowerCase = value.toLowerCase();
+
+	if (
+		keywordSets.counterIncrementKeywords.has(valueLowerCase) ||
+		Number.isFinite(Number.parseInt(valueLowerCase))
+	) {
+		return false;
+	}
+
+	return true;
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isCounterResetCustomIdentValue.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const keywordSets = require('../reference/keywordSets');
+
+/**
+ * Check value is a custom ident
+ *
+ * @param {string} value
+ */
+module.exports = function (value) {
+	const valueLowerCase = value.toLowerCase();
+
+	if (
+		keywordSets.counterResetKeywords.has(valueLowerCase) ||
+		Number.isFinite(Number.parseInt(valueLowerCase))
+	) {
+		return false;
+	}
+
+	return true;
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isCustomElement.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const htmlTags = require('html-tags');
+const keywordSets = require('../reference/keywordSets');
+const mathMLTags = require('mathml-tag-names');
+const svgTags = require('svg-tags');
+
+/**
+ * Check whether a type selector is a custom element
+ *
+ * @param {string} selector
+ * @returns {boolean}
+ */
+module.exports = function (selector) {
+	if (!/^[a-z]/.test(selector)) {
+		return false;
+	}
+
+	if (!selector.includes('-')) {
+		return false;
+	}
+
+	const selectorLowerCase = selector.toLowerCase();
+
+	if (selectorLowerCase !== selector) {
+		return false;
+	}
+
+	if (svgTags.includes(selectorLowerCase)) {
+		return false;
+	}
+
+	if (htmlTags.includes(selectorLowerCase)) {
+		return false;
+	}
+
+	if (keywordSets.nonStandardHtmlTags.has(selectorLowerCase)) {
+		return false;
+	}
+
+	if (mathMLTags.includes(selectorLowerCase)) {
+		return false;
+	}
+
+	return true;
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isCustomMediaQuery.js

@@ -0,0 +1,10 @@
+'use strict';
+
+/**
+ * Check whether a media query is a custom
+ * @param {string} mediaQuery
+ * @returns {boolean}
+ */
+module.exports = function (mediaQuery) {
+	return mediaQuery.startsWith('--');
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isCustomProperty.js

@@ -0,0 +1,10 @@
+'use strict';
+
+/**
+ * Check whether a property is a custom one
+ * @param {string} property
+ * @returns {boolean}
+ */
+module.exports = function (property) {
+	return property.startsWith('--');
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isCustomPropertySet.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const _ = require('lodash');
+const hasBlock = require('../utils/hasBlock');
+
+/**
+ * Check whether a Node is a custom property set
+ *
+ * @param {import('postcss').Rule} node
+ * @returns {boolean}
+ */
+module.exports = function (node) {
+	const selector = _.get(node, 'raws.selector.raw', node.selector);
+
+	return (
+		node.type === 'rule' && hasBlock(node) && selector.startsWith('--') && selector.endsWith(':')
+	);
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isCustomSelector.js

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * Check whether a selector is a custom one
+ *
+ * @param {string} selector
+ * @returns {boolean}
+ */
+module.exports = function (selector) {
+	return selector.startsWith(':--');
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isFirstNested.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const { isComment, hasSource } = require('./typeGuards');
+
+/**
+ * @param {import('postcss').Node} statement
+ * @returns {boolean}
+ */
+module.exports = function (statement) {
+	const parentNode = statement.parent;
+
+	if (parentNode === undefined || parentNode.type === 'root') {
+		return false;
+	}
+
+	if (statement === parentNode.first) {
+		return true;
+	}
+
+	/*
+	 * Search for the statement in the parent's nodes, ignoring comment
+	 * nodes on the same line as the parent's opening brace.
+	 */
+
+	const parentNodes = parentNode.nodes;
+
+	if (!parentNodes) {
+		return false;
+	}
+
+	const firstNode = parentNodes[0];
+
+	if (
+		!isComment(firstNode) ||
+		(typeof firstNode.raws.before === 'string' && firstNode.raws.before.includes('\n'))
+	) {
+		return false;
+	}
+
+	if (!hasSource(firstNode) || !firstNode.source.start) {
+		return false;
+	}
+
+	const openingBraceLine = firstNode.source.start.line;
+
+	if (!firstNode.source.end || openingBraceLine !== firstNode.source.end.line) {
+		return false;
+	}
+
+	for (let i = 1; i < parentNodes.length; i++) {
+		const node = parentNodes[i];
+
+		if (node === statement) {
+			return true;
+		}
+
+		if (
+			!isComment(node) ||
+			(hasSource(node) && node.source.end && node.source.end.line !== openingBraceLine)
+		) {
+			return false;
+		}
+	}
+
+	/* istanbul ignore next: Should always return in the loop */
+	return false;
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isFirstNodeOfRoot.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const { isRoot } = require('./typeGuards');
+
+/**
+ * @param {import('postcss').Node} node
+ * @returns {boolean}
+ */
+module.exports = function (node) {
+	if (isRoot(node)) return false;
+
+	const parentNode = node.parent;
+
+	return isRoot(parentNode) && node === parentNode.first;
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isKeyframeRule.js

@@ -0,0 +1,13 @@
+'use strict';
+
+/**
+ * Check if a rule is a keyframe one
+ *
+ * @param {import('postcss').Rule} rule
+ * @returns {boolean}
+ */
+module.exports = function (rule) {
+	const parent = rule.parent;
+
+	return parent.type === 'atrule' && parent.name.toLowerCase() === 'keyframes';
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isKeyframeSelector.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const keywordSets = require('../reference/keywordSets');
+
+/**
+ * Check whether a string is a keyframe selector.
+ *
+ * @param {string} selector
+ * @returns {boolean}
+ */
+module.exports = function (selector) {
+	if (keywordSets.keyframeSelectorKeywords.has(selector)) {
+		return true;
+	}
+
+	// Percentages
+	if (/^(?:\d+\.?\d*|\d*\.?\d+)%$/.test(selector)) {
+		return true;
+	}
+
+	return false;
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isLessVariable.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const hasBlock = require('./hasBlock');
+
+/**
+ * @param {import('postcss').AtRule | import('postcss-less').AtRule} atRule
+ * @returns {boolean}
+ */
+module.exports = function (atRule) {
+	return (
+		(atRule.type === 'atrule' && 'variable' in atRule && atRule.variable && !hasBlock(atRule)) ||
+		false
+	);
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isMap.js

@@ -0,0 +1,44 @@
+'use strict';
+
+/** @typedef {import('postcss-value-parser').Node} ValueNode */
+
+/**
+ * @param {ValueNode | undefined} valueNode
+ * @returns {boolean}
+ */
+module.exports = function (valueNode) {
+	if (!valueNode) {
+		return false;
+	}
+
+	if (valueNode.type !== 'function' || !valueNode.nodes || valueNode.value) {
+		return false;
+	}
+
+	// It's necessary to remove comments and spaces if they are present
+	const cleanNodes = valueNode.nodes.filter(
+		(node) => node.type !== 'comment' && node.type !== 'space',
+	);
+
+	// Map without comments and spaces will have the structure like $map (prop: value, prop2: value)
+	//                                                                     ↑  ↑   ↑  ↑
+	//                                                                     0  1   2  3
+	if (cleanNodes[0] && cleanNodes[0].type !== 'word' && cleanNodes[0].type !== 'string') {
+		return false;
+	}
+
+	if (cleanNodes[1] && cleanNodes[1].value !== ':') {
+		return false;
+	}
+
+	// There is no need to check type or value of this node since it could be anything
+	if (!cleanNodes[2]) {
+		return false;
+	}
+
+	if (cleanNodes[3] && cleanNodes[3].value !== ',') {
+		return false;
+	}
+
+	return true;
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isMathFunction.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const MATH_FUNCTIONS = require('../reference/mathFunctions');
+
+/**
+ * Check whether a node is math function
+ *
+ * @param {import('postcss-value-parser').Node} node postcss-value-parser node
+ * @return {boolean} If `true`, the node is math function
+ */
+module.exports = function isMathFunction(node) {
+	return node.type === 'function' && MATH_FUNCTIONS.includes(node.value.toLowerCase());
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isNonNegativeInteger.js

@@ -0,0 +1,17 @@
+'use strict';
+
+// TODO: We need this polyfill because of the support of Node 10.
+//       When we will drop Node 10, please remove this polyfill.
+//       See <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger>
+const isInteger =
+	Number.isInteger ||
+	function (value) {
+		return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
+	};
+
+/**
+ * @param {unknown} value
+ */
+module.exports = function (value) {
+	return isInteger(value) && typeof value === 'number' && value >= 0;
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isNumbery.js

@@ -0,0 +1,13 @@
+'use strict';
+
+/**
+ * Check whether it's a number or a number-like string:
+ * i.e. when coerced to a number it == itself.
+ *
+ * @param {string | number} value
+ */
+module.exports = function (value) {
+	/* eslint-disable eqeqeq */
+	return value.toString().trim().length !== 0 && Number(value) == value;
+	/* eslint-enable eqeqeq */
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isOnlyWhitespace.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const isWhitespace = require('./isWhitespace');
+
+/**
+ * Returns a Boolean indicating whether the the input string is only whitespace.
+ *
+ * @param {string} input
+ * @returns {boolean}
+ */
+module.exports = function (input) {
+	let isOnlyWhitespace = true;
+
+	for (let i = 0, l = input.length; i < l; i++) {
+		if (!isWhitespace(input[i])) {
+			isOnlyWhitespace = false;
+			break;
+		}
+	}
+
+	return isOnlyWhitespace;
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isRangeContextMediaFeature.js

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * Check whether a media feature is a range context one
+ *
+ * @param {string} mediaFeature feature
+ * @return {boolean} If `true`, media feature is a range context one
+ */
+module.exports = function (mediaFeature) {
+	return mediaFeature.includes('=') || mediaFeature.includes('<') || mediaFeature.includes('>');
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isScssVariable.js

@@ -0,0 +1,21 @@
+'use strict';
+
+/**
+ * Check whether a property is SCSS variable
+ *
+ * @param {string} property
+ * @returns {boolean}
+ */
+module.exports = function (property) {
+	// SCSS var (e.g. $var: x), list (e.g. $list: (x)) or map (e.g. $map: (key:value))
+	if (property.startsWith('$')) {
+		return true;
+	}
+
+	// SCSS var within a namespace (e.g. namespace.$var: x)
+	if (property.includes('.$')) {
+		return true;
+	}
+
+	return false;
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isSharedLineComment.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const _ = require('lodash');
+const getNextNonSharedLineCommentNode = require('./getNextNonSharedLineCommentNode');
+const getPreviousNonSharedLineCommentNode = require('./getPreviousNonSharedLineCommentNode');
+
+/** @typedef {import('postcss').Node} PostcssNode */
+
+/**
+ *
+ * @param {PostcssNode | void} a
+ * @param {PostcssNode | void} b
+ */
+function nodesShareLines(a, b) {
+	return _.get(a, 'source.end.line') === _.get(b, 'source.start.line');
+}
+
+/**
+ * @param {PostcssNode} node
+ * @returns {boolean}
+ */
+module.exports = function isSharedLineComment(node) {
+	if (node.type !== 'comment') {
+		return false;
+	}
+
+	const previousNonSharedLineCommentNode = getPreviousNonSharedLineCommentNode(node);
+
+	if (nodesShareLines(previousNonSharedLineCommentNode, node)) {
+		return true;
+	}
+
+	const nextNonSharedLineCommentNode = getNextNonSharedLineCommentNode(node);
+
+	if (nextNonSharedLineCommentNode && nodesShareLines(node, nextNonSharedLineCommentNode)) {
+		return true;
+	}
+
+	const parentNode = node.parent;
+
+	// It's a first child and located on the same line as block start
+	if (
+		parentNode !== undefined &&
+		parentNode.type !== 'root' &&
+		parentNode.index(node) === 0 &&
+		node.raws.before !== undefined &&
+		!node.raws.before.includes('\n')
+	) {
+		return true;
+	}
+
+	return false;
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isSingleLineString.js

@@ -0,0 +1,12 @@
+'use strict';
+
+/**
+ * Check if a string is a single line (i.e. does not contain
+ * any newline characters).
+ *
+ * @param {string} input
+ * @return {boolean}
+ */
+module.exports = function (input) {
+	return !/[\n\r]/.test(input);
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isStandardSyntaxAtRule.js

@@ -0,0 +1,29 @@
+'use strict';
+
+/**
+ * Check whether a at-rule is standard
+ *
+ * @param {import('postcss').AtRule | import('postcss-less').AtRule} atRule postcss at-rule node
+ * @return {boolean} If `true`, the declaration is standard
+ */
+module.exports = function (atRule) {
+	// Ignore scss `@content` inside mixins
+	if (!atRule.nodes && atRule.params === '') {
+		return false;
+	}
+
+	// Ignore Less mixins
+	if ('mixin' in atRule && atRule.mixin) {
+		return false;
+	}
+
+	// Ignore Less detached ruleset `@detached-ruleset: { background: red; }; .top { @detached-ruleset(); }`
+	if (
+		('variable' in atRule && atRule.variable) ||
+		(!atRule.nodes && atRule.raws.afterName === '' && atRule.params[0] === '(')
+	) {
+		return false;
+	}
+
+	return true;
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isStandardSyntaxCombinator.js

@@ -0,0 +1,34 @@
+'use strict';
+
+/**
+ * Check whether a combinator is standard
+ *
+ * @param {import('postcss-selector-parser').Combinator} node postcss-selector-parser node (of type combinator)
+ * @return {boolean} If `true`, the combinator is standard
+ */
+module.exports = function (node) {
+	// if it's not a combinator, then it's not a standard combinator
+	if (node.type !== 'combinator') {
+		return false;
+	}
+
+	// Ignore reference combinators like `/deep/`
+	if (node.value.startsWith('/') || node.value.endsWith('/')) {
+		return false;
+	}
+
+	// ignore the combinators that are the first or last node in their container
+	if (node.parent !== undefined && node.parent !== null) {
+		const parent = node.parent;
+
+		if (node === parent.first) {
+			return false;
+		}
+
+		if (node === parent.last) {
+			return false;
+		}
+	}
+
+	return true;
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isStandardSyntaxDeclaration.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const isScssVariable = require('./isScssVariable');
+const { isRoot } = require('./typeGuards');
+
+/**
+ * @param {string} [lang]
+ */
+function isStandardSyntaxLang(lang) {
+	return lang && (lang === 'css' || lang === 'custom-template' || lang === 'template-literal');
+}
+
+/**
+ * Check whether a declaration is standard
+ *
+ * @param {import('postcss').Declaration | import('postcss-less').Declaration} decl
+ */
+module.exports = function (decl) {
+	const prop = decl.prop;
+	const parent = decl.parent;
+
+	// Declarations belong in a declaration block or standard CSS source
+	if (
+		isRoot(parent) &&
+		parent.source &&
+		!isStandardSyntaxLang(
+			/** @type {import('postcss').NodeSource & {lang?: string}} */ (parent.source).lang,
+		)
+	) {
+		return false;
+	}
+
+	// SCSS var
+	if (isScssVariable(prop)) {
+		return false;
+	}
+
+	// Less var (e.g. @var: x), but exclude variable interpolation (e.g. @{var})
+	if (prop[0] === '@' && prop[1] !== '{') {
+		return false;
+	}
+
+	// Sass nested properties (e.g. border: { style: solid; color: red; })
+	if (
+		// @ts-ignore TODO TYPES selector does not exists
+		parent.selector &&
+		// @ts-ignore
+		parent.selector[parent.selector.length - 1] === ':' &&
+		// @ts-ignore
+		parent.selector.substring(0, 2) !== '--'
+	) {
+		return false;
+	}
+
+	// Less &:extend
+	if ('extend' in decl && decl.extend) {
+		return false;
+	}
+
+	return true;
+};

package/templates/facebook/node_modules/stylelint/lib/utils/isStandardSyntaxFunction.js

@@ -0,0 +1,16 @@
+'use strict';
+
+/**
+ * Check whether a function is standard
+ *
+ * @param {import('postcss-value-parser').Node} node
+ * @returns {boolean}
+ */
+module.exports = function (node) {
+	// Function nodes without names are things in parentheses like Sass lists
+	if (!node.value) {
+		return false;
+	}
+
+	return true;
+};