@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/regexDollarEscapes.js

@@ -0,0 +1,91 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/regexDollarEscapes.ts
+const replacementPattern = /\$(?:[$&'`]|\d{1,2}|<[^>]+>)|\$(?![$&'`\d])|.+?(?=\$|$)/gu;
+function adjustPosition(_unescaped, escaped, unescapedPos) {
+	let escapedIndex = 0;
+	let unescapedIndex = 0;
+	while (unescapedIndex < unescapedPos && escapedIndex < escaped.length) {
+		if (escaped[escapedIndex] === "\\") escapedIndex += 2;
+		else escapedIndex += 1;
+		unescapedIndex += 1;
+	}
+	return escapedIndex;
+}
+function findUnescapedDollars(replacementString) {
+	const issues = [];
+	let match;
+	replacementPattern.lastIndex = 0;
+	while ((match = replacementPattern.exec(replacementString)) !== null) if (match[0] === "$") issues.push({
+		end: match.index + 1,
+		start: match.index
+	});
+	return issues;
+}
+function isRegExpArgument(argument, typeChecker) {
+	if (argument.kind === ts$1.SyntaxKind.RegularExpressionLiteral) return true;
+	if (argument.kind === ts$1.SyntaxKind.NewExpression || argument.kind === ts$1.SyntaxKind.CallExpression) {
+		const callOrNew = argument;
+		if (callOrNew.expression.kind === ts$1.SyntaxKind.Identifier && callOrNew.expression.text === "RegExp") return true;
+	}
+	return typeChecker.getTypeAtLocation(argument).getSymbol()?.getName() === "RegExp";
+}
+function isStringType(node, typeChecker) {
+	return (typeChecker.getTypeAtLocation(node).flags & ts$1.TypeFlags.StringLike) !== 0;
+}
+var regexDollarEscapes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports replacement strings with unescaped `$` that should use `$$`.",
+		id: "regexDollarEscapes",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { unescapedDollar: {
+		primary: "This unescaped `$` is an invalid substitution pattern matcher. Use `$$` to represent a literal `$` in replacement strings.",
+		secondary: ["In `String.prototype.replace()` and `String.prototype.replaceAll()`, `$` is a special character used for substitution patterns like `$&`, `$1`, etc.", "To include a literal `$` in the replacement, escape it as `$$`."],
+		suggestions: ["Escape the `$` as `$$` if it is meant to be output as a `$`.", "Correct the substitution pattern if it is meant to be used as one."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+			if (node.expression.kind !== ts$1.SyntaxKind.PropertyAccessExpression) return;
+			const propertyAccess = node.expression;
+			const methodName = propertyAccess.name.text;
+			if (methodName !== "replace" && methodName !== "replaceAll") return;
+			const args = node.arguments;
+			if (args.length < 2) return;
+			const regexpArgument = args[0];
+			const stringLiteral = args[1];
+			if (!isRegExpArgument(regexpArgument, typeChecker) || !isStringType(propertyAccess.expression, typeChecker) || stringLiteral.kind !== ts$1.SyntaxKind.StringLiteral) return;
+			const replacementValue = stringLiteral.text;
+			const issues = findUnescapedDollars(replacementValue);
+			if (!issues.length) return;
+			const stringStart = stringLiteral.getStart(sourceFile);
+			const rawText = stringLiteral.getText(sourceFile);
+			const quote = rawText[0];
+			for (const issue of issues) {
+				const adjustedStart = adjustPosition(replacementValue, rawText.slice(1, -1), issue.start);
+				const adjustedEnd = adjustPosition(replacementValue, rawText.slice(1, -1), issue.end);
+				const reportStart = stringStart + 1 + adjustedStart;
+				const reportEnd = stringStart + 1 + adjustedEnd;
+				context.report({
+					fix: {
+						range: {
+							begin: reportStart,
+							end: reportEnd
+						},
+						text: quote === "`" ? "\\$\\$" : "$$"
+					},
+					message: "unescapedDollar",
+					range: {
+						begin: reportStart,
+						end: reportEnd
+					}
+				});
+			}
+		} } };
+	}
+});
+//#endregion
+export { regexDollarEscapes_default as default };
+
+//# sourceMappingURL=regexDollarEscapes.js.map

package/lib/rules/regexDuplicateCharacterClassCharacters.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports duplicate characters in regular expression character classes.";
+    readonly id: "regexDuplicateCharacterClassCharacters";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "duplicate" | "includedInRange", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexDuplicateCharacterClassCharacters.d.ts.map

package/lib/rules/regexDuplicateCharacterClassCharacters.js

@@ -0,0 +1,128 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { parseRegExpLiteral, visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexDuplicateCharacterClassCharacters.ts
+function adjustPositionForEscapes(escaped, unescapedPos) {
+	let escapedIndex = 0;
+	let unescapedIndex = 0;
+	while (unescapedIndex < unescapedPos && escapedIndex < escaped.length) {
+		if (escaped[escapedIndex] === "\\" && escaped[escapedIndex + 1] === "\\") escapedIndex += 2;
+		else escapedIndex += 1;
+		unescapedIndex += 1;
+	}
+	return escapedIndex;
+}
+function findDuplicatesInCharacterClass(characterClass) {
+	const issues = [];
+	const seenCharacters = /* @__PURE__ */ new Map();
+	const seenRanges = [];
+	for (const element of characterClass.elements) switch (element.type) {
+		case "Character": {
+			const existing = seenCharacters.get(element.value);
+			if (existing) issues.push({
+				duplicate: element,
+				end: element.end,
+				original: existing,
+				start: element.start
+			});
+			else seenCharacters.set(element.value, element);
+			break;
+		}
+		case "CharacterClassRange": {
+			const duplicateRange = seenRanges.find((range) => range.min.value === element.min.value && range.max.value === element.max.value);
+			if (duplicateRange) issues.push({
+				duplicate: element,
+				end: element.end,
+				original: duplicateRange,
+				start: element.start
+			});
+			else seenRanges.push(element);
+			break;
+		}
+	}
+	for (const [value, element] of seenCharacters) for (const range of seenRanges) if (value >= range.min.value && value <= range.max.value) {
+		if (!issues.some((issue) => issue.duplicate === element)) issues.push({
+			duplicate: element,
+			end: element.end,
+			original: range,
+			start: element.start
+		});
+	}
+	return issues;
+}
+function findIssues(pattern, flags) {
+	const issues = [];
+	let ast;
+	try {
+		ast = parseRegExpLiteral(new RegExp(pattern, flags));
+	} catch {
+		return issues;
+	}
+	visitRegExpAST(ast, { onCharacterClassEnter(ccNode) {
+		const duplicates = findDuplicatesInCharacterClass(ccNode);
+		issues.push(...duplicates);
+	} });
+	return issues;
+}
+var regexDuplicateCharacterClassCharacters_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports duplicate characters in regular expression character classes.",
+		id: "regexDuplicateCharacterClassCharacters",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		duplicate: {
+			primary: "Duplicate character '{{ character }}' in character class.",
+			secondary: ["This character appears multiple times in the character class and only one occurrence is needed."],
+			suggestions: ["Remove the duplicate character."]
+		},
+		includedInRange: {
+			primary: "Character '{{ character }}' is already included in range '{{ range }}'.",
+			secondary: ["This character is redundant because it falls within the specified range."],
+			suggestions: ["Remove the redundant character."]
+		}
+	},
+	setup(context) {
+		function checkPattern(flags, pattern, start) {
+			const issues = findIssues(pattern, flags);
+			for (const issue of issues) {
+				const isCharacterInRange = issue.duplicate.type === "Character" && issue.original.type === "CharacterClassRange";
+				const adjustedStart = adjustPositionForEscapes(pattern, issue.start - 1);
+				const adjustedEnd = adjustPositionForEscapes(pattern, issue.end - 1);
+				const [message, range] = isCharacterInRange ? ["includedInRange", issue.original.raw] : ["duplicate", ""];
+				context.report({
+					data: {
+						character: issue.duplicate.raw,
+						range
+					},
+					message,
+					range: {
+						begin: start + 1 + adjustedStart,
+						end: start + 1 + adjustedEnd
+					}
+				});
+			}
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			const patternUnescaped = construction.pattern.replace(/\\\\/g, "\\");
+			checkPattern(construction.flags, patternUnescaped, construction.start);
+		}
+		function checkRegexLiteral(node, services) {
+			const details = getRegExpLiteralDetails(node, services);
+			checkPattern(details.flags, details.pattern, details.start - 1);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexDuplicateCharacterClassCharacters_default as default };
+
+//# sourceMappingURL=regexDuplicateCharacterClassCharacters.js.map

package/lib/rules/regexEmptyAlternatives.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports empty alternatives in regular expressions that may indicate a mistake.";
+    readonly id: "regexEmptyAlternatives";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "emptyAlternative", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexEmptyAlternatives.d.ts.map

package/lib/rules/regexEmptyAlternatives.js

@@ -0,0 +1,140 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/regexEmptyAlternatives.ts
+function findEmptyAlternativesInGroup(pattern, groupStart, groupEnd, results) {
+	let contentStart = groupStart;
+	if ([
+		"?!",
+		"?:",
+		"?="
+	].includes(pattern.slice(groupStart, groupStart + 2)) || ["?<!", "?<="].includes(pattern.slice(groupStart, groupStart + 3))) if (pattern.slice(groupStart, groupStart + 3).startsWith("?<")) contentStart = groupStart + 3;
+	else contentStart = groupStart + 2;
+	else if (pattern[groupStart] === "?" && pattern[groupStart + 1] === "<") {
+		const closeAngle = pattern.indexOf(">", groupStart + 2);
+		if (closeAngle !== -1 && closeAngle < groupEnd) contentStart = closeAngle + 1;
+	}
+	const pipePositions = [];
+	for (let i = contentStart; i < groupEnd; i++) switch (pattern[i]) {
+		case "(": {
+			const parenthesisEnd = findMatchingParenthesis(pattern, i);
+			if (parenthesisEnd !== -1) {
+				findEmptyAlternativesInGroup(pattern, i + 1, parenthesisEnd, results);
+				i = parenthesisEnd;
+			}
+			break;
+		}
+		case "\\":
+			i++;
+			break;
+		case "|":
+			pipePositions.push(i);
+			break;
+	}
+	if (!pipePositions.length) return;
+	const alternativeBoundaries = [];
+	let currentStart = contentStart;
+	for (const pipePos of pipePositions) {
+		alternativeBoundaries.push({
+			end: pipePos,
+			start: currentStart
+		});
+		currentStart = pipePos + 1;
+	}
+	alternativeBoundaries.push({
+		end: groupEnd,
+		start: currentStart
+	});
+	for (let i = 0; i < alternativeBoundaries.length; i++) {
+		const boundary = alternativeBoundaries[i];
+		if (!boundary) continue;
+		const { end, start } = boundary;
+		if (isAlternativeEmpty(pattern, start, end)) {
+			const isLast = i === alternativeBoundaries.length - 1;
+			const lastPipePosition = pipePositions.at(-1);
+			if (isLast && lastPipePosition === void 0) continue;
+			results.push(isLast ? lastPipePosition : start);
+		}
+	}
+}
+function findEmptyAlternativeStarts(pattern) {
+	const emptyAlternativeStarts = [];
+	findEmptyAlternativesInGroup(pattern, 0, pattern.length, emptyAlternativeStarts);
+	return emptyAlternativeStarts;
+}
+function findMatchingParenthesis(pattern, openIndex) {
+	let depth = 1;
+	let charClassDepth = 0;
+	for (let i = openIndex + 1; i < pattern.length; i++) {
+		const char = pattern[i];
+		if (char === "\\") {
+			i++;
+			continue;
+		}
+		if (charClassDepth > 0) {
+			if (char === "]") charClassDepth--;
+			continue;
+		}
+		if (char === "[") {
+			charClassDepth++;
+			continue;
+		}
+		if (char === "(") depth++;
+		else if (char === ")") {
+			depth--;
+			if (depth === 0) return i;
+		}
+	}
+	return -1;
+}
+function isAlternativeEmpty(pattern, start, end) {
+	for (let i = start; i < end; i++) if (pattern[i].trim() !== "") return false;
+	return true;
+}
+var regexEmptyAlternatives_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports empty alternatives in regular expressions that may indicate a mistake.",
+		id: "regexEmptyAlternatives",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { emptyAlternative: {
+		primary: "Empty alternative in regular expression may be a mistake.",
+		secondary: ["Empty alternatives match zero characters and are often unintentional.", "If intentional, consider using a quantifier like `?` instead."],
+		suggestions: ["Remove the empty alternative or use a quantifier."]
+	} },
+	setup(context) {
+		function checkRegexLiteral(node, services) {
+			const { pattern, start } = getRegExpLiteralDetails(node, services);
+			const emptyAlternativeStarts = findEmptyAlternativeStarts(pattern);
+			for (const alternativeStart of emptyAlternativeStarts) context.report({
+				message: "emptyAlternative",
+				range: {
+					begin: start + alternativeStart,
+					end: start + alternativeStart + 1
+				}
+			});
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			const emptyAlternativeStarts = findEmptyAlternativeStarts(construction.pattern);
+			for (const alternativeStart of emptyAlternativeStarts) context.report({
+				message: "emptyAlternative",
+				range: {
+					begin: construction.start + 1 + alternativeStart,
+					end: construction.start + 1 + alternativeStart + 1
+				}
+			});
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexEmptyAlternatives_default as default };
+
+//# sourceMappingURL=regexEmptyAlternatives.js.map

package/lib/rules/regexEmptyCapturingGroups.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports capturing groups that only capture empty strings.";
+    readonly id: "regexEmptyCapturingGroups";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "emptyCapture", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexEmptyCapturingGroups.d.ts.map

package/lib/rules/regexEmptyCapturingGroups.js

@@ -0,0 +1,67 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { parseRegExpLiteral, visitRegExpAST } from "@eslint-community/regexpp";
+import { isZeroLength } from "regexp-ast-analysis";
+//#region src/rules/regexEmptyCapturingGroups.ts
+function findEmptyCapturingGroups(pattern, flags) {
+	const results = [];
+	let ast;
+	try {
+		ast = parseRegExpLiteral(new RegExp(pattern, flags));
+	} catch {
+		return results;
+	}
+	visitRegExpAST(ast, { onCapturingGroupEnter(node) {
+		if (node.name) return;
+		if (isZeroLength(node, ast.flags)) results.push(node);
+	} });
+	return results;
+}
+var regexEmptyCapturingGroups_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports capturing groups that only capture empty strings.",
+		id: "regexEmptyCapturingGroups",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { emptyCapture: {
+		primary: "This capturing group captures only empty strings.",
+		secondary: ["This capturing group will only ever match zero-length text.", "It may indicate a mistake in the pattern."],
+		suggestions: ["Add content to the capturing group.", "Convert the capturing group to a non-capturing group."]
+	} },
+	setup(context) {
+		function checkRegexLiteral(node, services) {
+			const { flags, pattern, start } = getRegExpLiteralDetails(node, services);
+			const emptyGroups = findEmptyCapturingGroups(pattern, flags);
+			for (const group of emptyGroups) context.report({
+				message: "emptyCapture",
+				range: {
+					begin: start + group.start - 1,
+					end: start + group.end - 1
+				}
+			});
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			const emptyGroups = findEmptyCapturingGroups(construction.pattern.replace(/\\\\/g, "\\"), construction.flags);
+			for (const group of emptyGroups) context.report({
+				message: "emptyCapture",
+				range: {
+					begin: construction.start + group.start,
+					end: construction.start + group.end
+				}
+			});
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexEmptyCapturingGroups_default as default };
+
+//# sourceMappingURL=regexEmptyCapturingGroups.js.map

package/lib/rules/regexEmptyCharacterClasses.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports character classes that match no characters.";
+    readonly id: "regexEmptyCharacterClasses";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "empty", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexEmptyCharacterClasses.d.ts.map

package/lib/rules/regexEmptyCharacterClasses.js

@@ -0,0 +1,68 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { parseRegExpLiteral, visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexEmptyCharacterClasses.ts
+function characterClassIsEmpty(node) {
+	return !node.negate && !node.elements.length;
+}
+function findEmptyCharacterClasses(pattern, flags) {
+	const results = [];
+	let ast;
+	try {
+		ast = parseRegExpLiteral(new RegExp(pattern, flags));
+	} catch {
+		return results;
+	}
+	visitRegExpAST(ast, { onCharacterClassEnter(node) {
+		if (characterClassIsEmpty(node)) results.push(node);
+	} });
+	return results;
+}
+var regexEmptyCharacterClasses_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports character classes that match no characters.",
+		id: "regexEmptyCharacterClasses",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { empty: {
+		primary: "This character class matches no characters because it is empty.",
+		secondary: ["An empty character class `[]` never matches anything.", "This often indicates a mistake in the regular expression."],
+		suggestions: ["Add characters to the class if it's meant to capture any.", "Remove the class if it is unintended."]
+	} },
+	setup(context) {
+		function checkRegexLiteral(node, services) {
+			const { flags, pattern, start } = getRegExpLiteralDetails(node, services);
+			const emptyClasses = findEmptyCharacterClasses(pattern, flags);
+			for (const charClass of emptyClasses) context.report({
+				message: "empty",
+				range: {
+					begin: start + charClass.start - 1,
+					end: start + charClass.end - 1
+				}
+			});
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			const emptyClasses = findEmptyCharacterClasses(construction.pattern.replace(/\\\\/g, "\\"), construction.flags);
+			for (const charClass of emptyClasses) context.report({
+				message: "empty",
+				range: {
+					begin: construction.start + charClass.start,
+					end: construction.start + charClass.end
+				}
+			});
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexEmptyCharacterClasses_default as default };
+
+//# sourceMappingURL=regexEmptyCharacterClasses.js.map

package/lib/rules/regexEmptyGroups.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports empty groups in regular expressions.";
+    readonly id: "regexEmptyGroups";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "emptyGroup", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexEmptyGroups.d.ts.map

package/lib/rules/regexEmptyGroups.js

@@ -0,0 +1,66 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexEmptyGroups.ts
+function isEmptyGroup(group) {
+	return group.alternatives.every((alternative) => !alternative.elements.length);
+}
+var regexEmptyGroups_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports empty groups in regular expressions.",
+		id: "regexEmptyGroups",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { emptyGroup: {
+		primary: "Empty {{ kind }} `{{ raw }}` matches nothing.",
+		secondary: ["Empty groups match the empty string and have no effect on the regex."],
+		suggestions: ["Remove the empty group.", "Replace the empty group with a non-capturing group."]
+	} },
+	setup(context) {
+		function reportEmptyGroup(group, kind, start) {
+			if (isEmptyGroup(group)) context.report({
+				data: {
+					kind,
+					raw: group.raw
+				},
+				message: "emptyGroup",
+				range: {
+					begin: start + group.start,
+					end: start + group.end
+				}
+			});
+		}
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, {
+				onCapturingGroupEnter(group) {
+					reportEmptyGroup(group, "capturing group", patternStart);
+				},
+				onGroupEnter(group) {
+					reportEmptyGroup(group, "non-capturing group", patternStart);
+				}
+			});
+		}
+		function checkRegexLiteral(node, services) {
+			const details = getRegExpLiteralDetails(node, services);
+			checkPattern(details.pattern, details.start, details.flags);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (construction) checkPattern(construction.pattern, construction.start + 1, construction.flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexEmptyGroups_default as default };
+
+//# sourceMappingURL=regexEmptyGroups.js.map

package/lib/rules/regexEmptyLazyQuantifiers.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports lazy quantifiers at the end of regular expressions.";
+    readonly id: "regexEmptyLazyQuantifiers";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "uselessElement" | "uselessQuantifier" | "uselessRange", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexEmptyLazyQuantifiers.d.ts.map