@alexlit/lint-kit 166.0.1 → 167.0.0

package/packages/config-eslint/node_modules/eslint/lib/rules/no-invalid-regexp.js

@@ -1,243 +0,0 @@
-/**
- * @fileoverview Validate strings passed to the RegExp constructor
- * @author Michael Ficarra
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const RegExpValidator = require("@eslint-community/regexpp").RegExpValidator;
-const validator = new RegExpValidator();
-const validFlags = "dgimsuvy";
-const undefined1 = void 0;
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		defaultOptions: [{}],
-
-		docs: {
-			description:
-				"Disallow invalid regular expression strings in `RegExp` constructors",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-invalid-regexp",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					allowConstructorFlags: {
-						type: "array",
-						items: {
-							type: "string",
-						},
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			regexMessage: "{{message}}.",
-		},
-	},
-
-	create(context) {
-		const [{ allowConstructorFlags }] = context.options;
-		let allowedFlags = [];
-
-		if (allowConstructorFlags) {
-			const temp = allowConstructorFlags
-				.join("")
-				.replace(new RegExp(`[${validFlags}]`, "gu"), "");
-
-			if (temp) {
-				allowedFlags = [...new Set(temp)];
-			}
-		}
-
-		/**
-		 * Reports error with the provided message.
-		 * @param {ASTNode} node The node holding the invalid RegExp
-		 * @param {string} message The message to report.
-		 * @returns {void}
-		 */
-		function report(node, message) {
-			context.report({
-				node,
-				messageId: "regexMessage",
-				data: { message },
-			});
-		}
-
-		/**
-		 * Check if node is a string
-		 * @param {ASTNode} node node to evaluate
-		 * @returns {boolean} True if its a string
-		 * @private
-		 */
-		function isString(node) {
-			return (
-				node &&
-				node.type === "Literal" &&
-				typeof node.value === "string"
-			);
-		}
-
-		/**
-		 * Gets flags of a regular expression created by the given `RegExp()` or `new RegExp()` call
-		 * Examples:
-		 *     new RegExp(".")         // => ""
-		 *     new RegExp(".", "gu")   // => "gu"
-		 *     new RegExp(".", flags)  // => null
-		 * @param {ASTNode} node `CallExpression` or `NewExpression` node
-		 * @returns {string|null} flags if they can be determined, `null` otherwise
-		 * @private
-		 */
-		function getFlags(node) {
-			if (node.arguments.length < 2) {
-				return "";
-			}
-
-			if (isString(node.arguments[1])) {
-				return node.arguments[1].value;
-			}
-
-			return null;
-		}
-
-		/**
-		 * Check syntax error in a given pattern.
-		 * @param {string} pattern The RegExp pattern to validate.
-		 * @param {Object} flags The RegExp flags to validate.
-		 * @param {boolean} [flags.unicode] The Unicode flag.
-		 * @param {boolean} [flags.unicodeSets] The UnicodeSets flag.
-		 * @returns {string|null} The syntax error.
-		 */
-		function validateRegExpPattern(pattern, flags) {
-			try {
-				validator.validatePattern(
-					pattern,
-					undefined1,
-					undefined1,
-					flags,
-				);
-				return null;
-			} catch (err) {
-				return err.message;
-			}
-		}
-
-		/**
-		 * Check syntax error in a given flags.
-		 * @param {string|null} flags The RegExp flags to validate.
-		 * @param {string|null} flagsToCheck The RegExp invalid flags.
-		 * @param {string} allFlags all valid and allowed flags.
-		 * @returns {string|null} The syntax error.
-		 */
-		function validateRegExpFlags(flags, flagsToCheck, allFlags) {
-			const duplicateFlags = [];
-
-			if (typeof flagsToCheck === "string") {
-				for (const flag of flagsToCheck) {
-					if (allFlags.includes(flag)) {
-						duplicateFlags.push(flag);
-					}
-				}
-			}
-
-			/*
-			 * `regexpp` checks the combination of `u` and `v` flags when parsing `Pattern` according to `ecma262`,
-			 * but this rule may check only the flag when the pattern is unidentifiable, so check it here.
-			 * https://tc39.es/ecma262/multipage/text-processing.html#sec-parsepattern
-			 */
-			if (flags && flags.includes("u") && flags.includes("v")) {
-				return "Regex 'u' and 'v' flags cannot be used together";
-			}
-
-			if (duplicateFlags.length > 0) {
-				return `Duplicate flags ('${duplicateFlags.join("")}') supplied to RegExp constructor`;
-			}
-
-			if (!flagsToCheck) {
-				return null;
-			}
-
-			return `Invalid flags supplied to RegExp constructor '${flagsToCheck}'`;
-		}
-
-		return {
-			"CallExpression, NewExpression"(node) {
-				if (
-					node.callee.type !== "Identifier" ||
-					node.callee.name !== "RegExp"
-				) {
-					return;
-				}
-
-				const flags = getFlags(node);
-				let flagsToCheck = flags;
-				const allFlags =
-					allowedFlags.length > 0
-						? validFlags.split("").concat(allowedFlags)
-						: validFlags.split("");
-
-				if (flags) {
-					allFlags.forEach(flag => {
-						flagsToCheck = flagsToCheck.replace(flag, "");
-					});
-				}
-
-				let message = validateRegExpFlags(
-					flags,
-					flagsToCheck,
-					allFlags,
-				);
-
-				if (message) {
-					report(node, message);
-					return;
-				}
-
-				if (!isString(node.arguments[0])) {
-					return;
-				}
-
-				const pattern = node.arguments[0].value;
-
-				message =
-					// If flags are unknown, report the regex only if its pattern is invalid both with and without the "u" flag
-					flags === null
-						? validateRegExpPattern(pattern, {
-								unicode: true,
-								unicodeSets: false,
-							}) &&
-							validateRegExpPattern(pattern, {
-								unicode: false,
-								unicodeSets: true,
-							}) &&
-							validateRegExpPattern(pattern, {
-								unicode: false,
-								unicodeSets: false,
-							})
-						: validateRegExpPattern(pattern, {
-								unicode: flags.includes("u"),
-								unicodeSets: flags.includes("v"),
-							});
-
-				if (message) {
-					report(node, message);
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-invalid-this.js

@@ -1,178 +0,0 @@
-/**
- * @fileoverview A rule to disallow `this` keywords in contexts where the value of `this` is `undefined`.
- * @author Toru Nagashima
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Determines if the given code path is a code path with lexical `this` binding.
- * That is, if `this` within the code path refers to `this` of surrounding code path.
- * @param {CodePath} codePath Code path.
- * @param {ASTNode} node Node that started the code path.
- * @returns {boolean} `true` if it is a code path with lexical `this` binding.
- */
-function isCodePathWithLexicalThis(codePath, node) {
-	return (
-		codePath.origin === "function" &&
-		node.type === "ArrowFunctionExpression"
-	);
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		dialects: ["javascript", "typescript"],
-		language: "javascript",
-		type: "suggestion",
-
-		defaultOptions: [{ capIsConstructor: true }],
-
-		docs: {
-			description:
-				"Disallow use of `this` in contexts where the value of `this` is `undefined`",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-invalid-this",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					capIsConstructor: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			unexpectedThis: "Unexpected 'this'.",
-		},
-	},
-
-	create(context) {
-		const [{ capIsConstructor }] = context.options;
-		const stack = [],
-			sourceCode = context.sourceCode;
-
-		/**
-		 * Gets the current checking context.
-		 *
-		 * The return value has a flag that whether or not `this` keyword is valid.
-		 * The flag is initialized when got at the first time.
-		 * @returns {{valid: boolean}}
-		 *   an object which has a flag that whether or not `this` keyword is valid.
-		 */
-		stack.getCurrent = function () {
-			const current = this.at(-1);
-
-			if (!current.init) {
-				current.init = true;
-				current.valid = !astUtils.isDefaultThisBinding(
-					current.node,
-					sourceCode,
-					{ capIsConstructor },
-				);
-			}
-			return current;
-		};
-
-		return {
-			onCodePathStart(codePath, node) {
-				if (isCodePathWithLexicalThis(codePath, node)) {
-					return;
-				}
-
-				if (codePath.origin === "program") {
-					const scope = sourceCode.getScope(node);
-					const features =
-						context.languageOptions.parserOptions.ecmaFeatures ||
-						{};
-
-					// `this` at the top level of scripts always refers to the global object
-					stack.push({
-						init: true,
-						node,
-						valid: !(
-							node.sourceType === "module" ||
-							(features.globalReturn &&
-								scope.childScopes[0].isStrict)
-						),
-					});
-
-					return;
-				}
-
-				/*
-				 * `init: false` means that `valid` isn't determined yet.
-				 * Most functions don't use `this`, and the calculation for `valid`
-				 * is relatively costly, so we'll calculate it lazily when the first
-				 * `this` within the function is traversed. A special case are non-strict
-				 * functions, because `this` refers to the global object and therefore is
-				 * always valid, so we can set `init: true` right away.
-				 */
-				stack.push({
-					init: !sourceCode.getScope(node).isStrict,
-					node,
-					valid: true,
-				});
-			},
-
-			onCodePathEnd(codePath, node) {
-				if (isCodePathWithLexicalThis(codePath, node)) {
-					return;
-				}
-
-				stack.pop();
-			},
-
-			"AccessorProperty > *.value"(node) {
-				stack.push({
-					init: true,
-					node,
-					valid: true,
-				});
-			},
-
-			"AccessorProperty:exit"() {
-				stack.pop();
-			},
-
-			// Reports if `this` of the current context is invalid.
-			ThisExpression(node) {
-				// Special case: skip `this` if it's the value of an AccessorProperty
-				if (
-					node.parent.type === "AccessorProperty" &&
-					node.parent.value === node
-				) {
-					return;
-				}
-
-				const current = stack.getCurrent();
-
-				if (current && !current.valid) {
-					context.report({
-						node,
-						messageId: "unexpectedThis",
-					});
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-irregular-whitespace.js

@@ -1,292 +0,0 @@
-/**
- * @fileoverview Rule to disallow whitespace that is not a tab or space, whitespace inside strings and comments are allowed
- * @author Jonathan Kingston
- * @author Christophe Porteneuve
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Constants
-//------------------------------------------------------------------------------
-
-const ALL_IRREGULARS =
-	/[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000\u2028\u2029]/u;
-const IRREGULAR_WHITESPACE =
-	/[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000]+/gu;
-const IRREGULAR_LINE_TERMINATORS = /[\u2028\u2029]/gu;
-const LINE_BREAK = astUtils.createGlobalLinebreakMatcher();
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		defaultOptions: [
-			{
-				skipComments: false,
-				skipJSXText: false,
-				skipRegExps: false,
-				skipStrings: true,
-				skipTemplates: false,
-			},
-		],
-
-		docs: {
-			description: "Disallow irregular whitespace",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-irregular-whitespace",
-		},
-
-		schema: [
-			{
-				type: "object",
-				properties: {
-					skipComments: {
-						type: "boolean",
-					},
-					skipStrings: {
-						type: "boolean",
-					},
-					skipTemplates: {
-						type: "boolean",
-					},
-					skipRegExps: {
-						type: "boolean",
-					},
-					skipJSXText: {
-						type: "boolean",
-					},
-				},
-				additionalProperties: false,
-			},
-		],
-
-		messages: {
-			noIrregularWhitespace: "Irregular whitespace not allowed.",
-		},
-	},
-
-	create(context) {
-		const [
-			{
-				skipComments,
-				skipStrings,
-				skipRegExps,
-				skipTemplates,
-				skipJSXText,
-			},
-		] = context.options;
-
-		const sourceCode = context.sourceCode;
-		const commentNodes = sourceCode.getAllComments();
-
-		// Module store of errors that we have found
-		let errors = [];
-
-		/**
-		 * Removes errors that occur inside the given node
-		 * @param {ASTNode} node to check for matching errors.
-		 * @returns {void}
-		 * @private
-		 */
-		function removeWhitespaceError(node) {
-			const locStart = node.loc.start;
-			const locEnd = node.loc.end;
-
-			errors = errors.filter(
-				({ loc: { start: errorLocStart } }) =>
-					errorLocStart.line < locStart.line ||
-					(errorLocStart.line === locStart.line &&
-						errorLocStart.column < locStart.column) ||
-					(errorLocStart.line === locEnd.line &&
-						errorLocStart.column >= locEnd.column) ||
-					errorLocStart.line > locEnd.line,
-			);
-		}
-
-		/**
-		 * Checks literal nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
-		 * @param {ASTNode} node to check for matching errors.
-		 * @returns {void}
-		 * @private
-		 */
-		function removeInvalidNodeErrorsInLiteral(node) {
-			const shouldCheckStrings =
-				skipStrings && typeof node.value === "string";
-			const shouldCheckRegExps = skipRegExps && Boolean(node.regex);
-
-			if (shouldCheckStrings || shouldCheckRegExps) {
-				// If we have irregular characters remove them from the errors list
-				if (ALL_IRREGULARS.test(node.raw)) {
-					removeWhitespaceError(node);
-				}
-			}
-		}
-
-		/**
-		 * Checks template string literal nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
-		 * @param {ASTNode} node to check for matching errors.
-		 * @returns {void}
-		 * @private
-		 */
-		function removeInvalidNodeErrorsInTemplateLiteral(node) {
-			if (typeof node.value.raw === "string") {
-				if (ALL_IRREGULARS.test(node.value.raw)) {
-					removeWhitespaceError(node);
-				}
-			}
-		}
-
-		/**
-		 * Checks comment nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
-		 * @param {ASTNode} node to check for matching errors.
-		 * @returns {void}
-		 * @private
-		 */
-		function removeInvalidNodeErrorsInComment(node) {
-			if (ALL_IRREGULARS.test(node.value)) {
-				removeWhitespaceError(node);
-			}
-		}
-
-		/**
-		 * Checks JSX nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
-		 * @param {ASTNode} node to check for matching errors.
-		 * @returns {void}
-		 * @private
-		 */
-		function removeInvalidNodeErrorsInJSXText(node) {
-			if (ALL_IRREGULARS.test(node.raw)) {
-				removeWhitespaceError(node);
-			}
-		}
-
-		/**
-		 * Checks the program source for irregular whitespace
-		 * @param {ASTNode} node The program node
-		 * @returns {void}
-		 * @private
-		 */
-		function checkForIrregularWhitespace(node) {
-			const sourceLines = sourceCode.lines;
-
-			sourceLines.forEach((sourceLine, lineIndex) => {
-				const lineNumber = lineIndex + 1;
-				let match;
-
-				while (
-					(match = IRREGULAR_WHITESPACE.exec(sourceLine)) !== null
-				) {
-					errors.push({
-						node,
-						messageId: "noIrregularWhitespace",
-						loc: {
-							start: {
-								line: lineNumber,
-								column: match.index,
-							},
-							end: {
-								line: lineNumber,
-								column: match.index + match[0].length,
-							},
-						},
-					});
-				}
-			});
-		}
-
-		/**
-		 * Checks the program source for irregular line terminators
-		 * @param {ASTNode} node The program node
-		 * @returns {void}
-		 * @private
-		 */
-		function checkForIrregularLineTerminators(node) {
-			const source = sourceCode.getText(),
-				sourceLines = sourceCode.lines,
-				linebreaks = source.match(LINE_BREAK);
-			let lastLineIndex = -1,
-				match;
-
-			while ((match = IRREGULAR_LINE_TERMINATORS.exec(source)) !== null) {
-				const lineIndex =
-					linebreaks.indexOf(match[0], lastLineIndex + 1) || 0;
-
-				errors.push({
-					node,
-					messageId: "noIrregularWhitespace",
-					loc: {
-						start: {
-							line: lineIndex + 1,
-							column: sourceLines[lineIndex].length,
-						},
-						end: {
-							line: lineIndex + 2,
-							column: 0,
-						},
-					},
-				});
-
-				lastLineIndex = lineIndex;
-			}
-		}
-
-		/**
-		 * A no-op function to act as placeholder for comment accumulation when the `skipComments` option is `false`.
-		 * @returns {void}
-		 * @private
-		 */
-		function noop() {}
-
-		const nodes = {};
-
-		if (ALL_IRREGULARS.test(sourceCode.getText())) {
-			nodes.Program = function (node) {
-				/*
-				 * As we can easily fire warnings for all white space issues with
-				 * all the source its simpler to fire them here.
-				 * This means we can check all the application code without having
-				 * to worry about issues caused in the parser tokens.
-				 * When writing this code also evaluating per node was missing out
-				 * connecting tokens in some cases.
-				 * We can later filter the errors when they are found to be not an
-				 * issue in nodes we don't care about.
-				 */
-				checkForIrregularWhitespace(node);
-				checkForIrregularLineTerminators(node);
-			};
-
-			nodes.Literal = removeInvalidNodeErrorsInLiteral;
-			nodes.TemplateElement = skipTemplates
-				? removeInvalidNodeErrorsInTemplateLiteral
-				: noop;
-			nodes.JSXText = skipJSXText
-				? removeInvalidNodeErrorsInJSXText
-				: noop;
-			nodes["Program:exit"] = function () {
-				if (skipComments) {
-					// First strip errors occurring in comment nodes.
-					commentNodes.forEach(removeInvalidNodeErrorsInComment);
-				}
-
-				// If we have any errors remaining report on them
-				errors.forEach(error => context.report(error));
-			};
-		} else {
-			nodes.Program = noop;
-		}
-
-		return nodes;
-	},
-};