added all files to project

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

@@ -0,0 +1,105 @@
+# selector-max-id
+
+Limit the number of ID selectors in a selector.
+
+<!-- prettier-ignore -->
+```css
+    #foo {}
+/** ↑
+ * This type of selector */
+```
+
+This rule resolves nested selectors before counting the number of ID selectors. 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 universal selectors allowed.
+
+For example, with `2`:
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+#foo #bar #baz {}
+```
+
+<!-- prettier-ignore -->
+```css
+#foo #bar {
+  & #baz {}
+}
+```
+
+<!-- prettier-ignore -->
+```css
+#foo #bar {
+  & > #bar {}
+}
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+#foo {}
+```
+
+<!-- prettier-ignore -->
+```css
+#foo #bar {}
+```
+
+<!-- prettier-ignore -->
+```css
+.foo #foo {}
+```
+
+<!-- prettier-ignore -->
+```css
+#foo.foo #bar {}
+```
+
+<!-- prettier-ignore -->
+```css
+/* each selector in a selector list is evaluated separately */
+#foo,
+#baz #quux {}
+```
+
+<!-- prettier-ignore -->
+```css
+/* `#bar` is inside `:not()`, so it is evaluated separately */
+#foo #bar:not(#baz) {}
+```
+
+### `ignoreContextFunctionalPseudoClasses: ["/regex/", /regex/, "non-regex"]`
+
+Ignore selectors inside of specified [functional pseudo-classes](https://drafts.csswg.org/selectors-4/#pseudo-classes) that provide [evaluation contexts](https://drafts.csswg.org/selectors-4/#specificity-rules).
+
+Given:
+
+```js
+[":not", /^:(h|H)as$/];
+```
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+a:matches(#foo) {}
+```
+
+While the following patters are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+a:not(#foo) {}
+```
+
+<!-- prettier-ignore -->
+```css
+a:has(#foo) {}
+```

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

@@ -0,0 +1,95 @@
+// @ts-nocheck
+
+'use strict';
+
+const _ = require('lodash');
+const isContextFunctionalPseudoClass = require('../../utils/isContextFunctionalPseudoClass');
+const isNonNegativeInteger = require('../../utils/isNonNegativeInteger');
+const isStandardSyntaxRule = require('../../utils/isStandardSyntaxRule');
+const optionsMatches = require('../../utils/optionsMatches');
+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-id';
+
+const messages = ruleMessages(ruleName, {
+	expected: (selector, max) =>
+		`Expected "${selector}" to have no more than ${max} ID ${max === 1 ? 'selector' : 'selectors'}`,
+});
+
+function rule(max, options) {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: max,
+				possible: isNonNegativeInteger,
+			},
+			{
+				actual: options,
+				possible: {
+					ignoreContextFunctionalPseudoClasses: [_.isString, _.isRegExp],
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		function checkSelector(selectorNode, ruleNode) {
+			const count = selectorNode.reduce((total, childNode) => {
+				// Only traverse inside actual selectors and context functional pseudo-classes that are not part of ignored functional pseudo-classes
+				if (
+					childNode.type === 'selector' ||
+					(isContextFunctionalPseudoClass(childNode) &&
+						!isIgnoredContextFunctionalPseudoClass(childNode))
+				) {
+					checkSelector(childNode, ruleNode);
+				}
+
+				return (total += childNode.type === 'id' ? 1 : 0);
+			}, 0);
+
+			if (selectorNode.type !== 'root' && selectorNode.type !== 'pseudo' && count > max) {
+				report({
+					ruleName,
+					result,
+					node: ruleNode,
+					message: messages.expected(selectorNode, max),
+					word: selectorNode,
+				});
+			}
+		}
+
+		function isIgnoredContextFunctionalPseudoClass(node) {
+			return (
+				node.type === 'pseudo' &&
+				optionsMatches(options, 'ignoreContextFunctionalPseudoClasses', node.value)
+			);
+		}
+
+		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;