added all files to project

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

@@ -0,0 +1,100 @@
+# selector-class-pattern
+
+Specify a pattern for class selectors.
+
+<!-- prettier-ignore -->
+```css
+    .foo, #bar.baz span, #hoo[disabled] { color: pink; }
+/** ↑         ↑
+ * These class selectors */
+```
+
+This rule ignores non-outputting Less mixin definitions and called Less mixins.
+
+Escaped selectors (e.g. `.u-size-11\/12\@sm`) are parsed as escaped twice (e.g. `.u-size-11\\/12\\@sm`). Your RegExp should account for that.
+
+## Options
+
+`regex|string`
+
+A string will be translated into a RegExp like so `new RegExp(yourString)` — so be sure to escape properly.
+
+The selector value _after `.`_ will be checked. No need to include `.` in your pattern.
+
+Given the string:
+
+```js
+"foo-[a-z]+";
+
+```
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+.foop {}
+```
+
+<!-- prettier-ignore -->
+```css
+.foo-BAR {}
+```
+
+<!-- prettier-ignore -->
+```css
+div > #zing + .foo-BAR {}
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+.foo-bar {}
+```
+
+<!-- prettier-ignore -->
+```css
+div > #zing + .foo-bar {}
+```
+
+<!-- prettier-ignore -->
+```css
+#foop {}
+```
+
+<!-- prettier-ignore -->
+```css
+[foo='bar'] {}
+```
+
+## Optional secondary options
+
+### `resolveNestedSelectors: true | false` (default: `false`)
+
+This option will resolve nested selectors with `&` interpolation.
+
+For example, with `true`.
+
+Given the string:
+
+```
+"^[A-Z]+$"
+```
+
+The following patterns are considered violations:
+
+<!-- prettier-ignore -->
+```css
+.A {
+  &__B {} /* resolved to ".A__B" */
+}
+```
+
+The following patterns are _not_ considered violations:
+
+<!-- prettier-ignore -->
+```css
+.A {
+  &B {} /* resolved to ".AB" */
+}
+```

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

@@ -0,0 +1,121 @@
+// @ts-nocheck
+
+'use strict';
+
+const _ = require('lodash');
+const isKeyframeSelector = require('../../utils/isKeyframeSelector');
+const isStandardSyntaxRule = require('../../utils/isStandardSyntaxRule');
+const isStandardSyntaxSelector = require('../../utils/isStandardSyntaxSelector');
+const parseSelector = require('../../utils/parseSelector');
+const report = require('../../utils/report');
+const resolveNestedSelector = require('postcss-resolve-nested-selector');
+const ruleMessages = require('../../utils/ruleMessages');
+const validateOptions = require('../../utils/validateOptions');
+
+const ruleName = 'selector-class-pattern';
+
+const messages = ruleMessages(ruleName, {
+	expected: (selectorValue, pattern) =>
+		`Expected class selector ".${selectorValue}" to match pattern "${pattern}"`,
+});
+
+function rule(pattern, options) {
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: pattern,
+				possible: [_.isRegExp, _.isString],
+			},
+			{
+				actual: options,
+				possible: {
+					resolveNestedSelectors: _.isBoolean,
+				},
+				optional: true,
+			},
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		const shouldResolveNestedSelectors = _.get(options, 'resolveNestedSelectors');
+		const normalizedPattern = _.isString(pattern) ? new RegExp(pattern) : pattern;
+
+		root.walkRules((ruleNode) => {
+			const selector = ruleNode.selector;
+			const selectors = ruleNode.selectors;
+
+			if (!isStandardSyntaxRule(ruleNode)) {
+				return;
+			}
+
+			if (selectors.some((s) => isKeyframeSelector(s))) {
+				return;
+			}
+
+			// Only bother resolving selectors that have an interpolating &
+			if (shouldResolveNestedSelectors && hasInterpolatingAmpersand(selector)) {
+				resolveNestedSelector(selector, ruleNode).forEach((nestedSelector) => {
+					if (!isStandardSyntaxSelector(nestedSelector)) {
+						return;
+					}
+
+					parseSelector(nestedSelector, result, ruleNode, (s) => checkSelector(s, ruleNode));
+				});
+			} else {
+				parseSelector(selector, result, ruleNode, (s) => checkSelector(s, ruleNode));
+			}
+		});
+
+		function checkSelector(fullSelector, ruleNode) {
+			fullSelector.walkClasses((classNode) => {
+				const value = classNode.value;
+				const sourceIndex = classNode.sourceIndex;
+
+				if (normalizedPattern.test(value)) {
+					return;
+				}
+
+				report({
+					result,
+					ruleName,
+					message: messages.expected(value, pattern),
+					node: ruleNode,
+					index: sourceIndex,
+				});
+			});
+		}
+	};
+}
+
+// An "interpolating ampersand" means an "&" used to interpolate
+// within another simple selector, rather than an "&" that
+// stands on its own as a simple selector
+function hasInterpolatingAmpersand(selector) {
+	for (let i = 0, l = selector.length; i < l; i++) {
+		if (selector[i] !== '&') {
+			continue;
+		}
+
+		if (selector[i - 1] !== undefined && !isCombinator(selector[i - 1])) {
+			return true;
+		}
+
+		if (selector[i + 1] !== undefined && !isCombinator(selector[i + 1])) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function isCombinator(x) {
+	return /[\s+>~]/.test(x);
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+module.exports = rule;