added all files to project

node_modules/stylelint/lib/rules/selector-max-class/README.md

@@ -0,0 +1,58 @@
+# selector-max-class
+
+Limit the number of classes in a selector.
+
+<!-- prettier-ignore -->
+```css
+div .foo.bar[data-val] > a.baz {}
+/*  ↑   ↑                 ↑
+    ↑   ↑                 ↑
+    1   2                 3  -- this selector contains three classes */
+```
+
+This rule resolves nested selectors before counting the number of classes in a selector. Each selector in a [selector list](https://www.w3.org/TR/selectors4/#selector-list) is evaluated separately.
+
+The `:not()` pseudo-class is also evaluated separately. The rule processes the argument as if it were an independent selector, and the result does not count toward the total for the entire selector.
+
+## Options
+
+`int`: Maximum classes allowed.
+
+For example, with `2`:
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+.foo.bar.baz {}
+```
+
+<!-- prettier-ignore -->
+```css
+.foo .bar {
+  & > .baz {}
+}
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+div {}
+```
+
+<!-- prettier-ignore -->
+```css
+.foo .bar {}
+```
+
+<!-- prettier-ignore -->
+```css
+.foo.bar,
+.lorem.ipsum {} /* each selector in a selector list is evaluated separately */
+```
+
+<!-- prettier-ignore -->
+```css
+.foo .bar :not(.lorem.ipsum) {} /* `.lorem.ipsum` is inside `:not()`, so it is evaluated separately */
+```

node_modules/stylelint/lib/rules/selector-max-class/index.js

@@ -0,0 +1,71 @@
+// @ts-nocheck
+
+'use strict';
+
+const isContextFunctionalPseudoClass = require('../../utils/isContextFunctionalPseudoClass');
+const isNonNegativeInteger = require('../../utils/isNonNegativeInteger');
+const isStandardSyntaxRule = require('../../utils/isStandardSyntaxRule');
+const parseSelector = require('../../utils/parseSelector');
+const report = require('../../utils/report');
+const resolvedNestedSelector = require('postcss-resolve-nested-selector');
+const ruleMessages = require('../../utils/ruleMessages');
+const validateOptions = require('../../utils/validateOptions');
+
+const ruleName = 'selector-max-class';
+
+const messages = ruleMessages(ruleName, {
+	expected: (selector, max) =>
+		`Expected "${selector}" to have no more than ${max} ${max === 1 ? 'class' : 'classes'}`,
+});
+
+function rule(max) {
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: max,
+			possible: isNonNegativeInteger,
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		function checkSelector(selectorNode, ruleNode) {
+			const count = selectorNode.reduce((total, childNode) => {
+				// Only traverse inside actual selectors and context functional pseudo-classes
+				if (childNode.type === 'selector' || isContextFunctionalPseudoClass(childNode)) {
+					checkSelector(childNode, ruleNode);
+				}
+
+				return (total += childNode.type === 'class' ? 1 : 0);
+			}, 0);
+
+			if (selectorNode.type !== 'root' && selectorNode.type !== 'pseudo' && count > max) {
+				report({
+					ruleName,
+					result,
+					node: ruleNode,
+					message: messages.expected(selectorNode, max),
+					word: selectorNode,
+				});
+			}
+		}
+
+		root.walkRules((ruleNode) => {
+			if (!isStandardSyntaxRule(ruleNode)) {
+				return;
+			}
+
+			ruleNode.selectors.forEach((selector) => {
+				resolvedNestedSelector(selector, ruleNode).forEach((resolvedSelector) => {
+					parseSelector(resolvedSelector, result, ruleNode, (container) =>
+						checkSelector(container, ruleNode),
+					);
+				});
+			});
+		});
+	};
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+module.exports = rule;