@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/regexUnnecessaryOptionalAssertions.js

@@ -0,0 +1,137 @@
+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/regexUnnecessaryOptionalAssertions.ts
+function canConsumeCharacters(element) {
+	switch (element.type) {
+		case "Assertion": return false;
+		case "CapturingGroup":
+		case "Group": return element.alternatives.some((alternative) => alternative.elements.some(canConsumeCharacters));
+		case "Quantifier": return element.max !== 0 && canConsumeCharacters(element.element);
+		default: return true;
+	}
+}
+function getUnnecessaryAssertions(quantifierElement, assertions) {
+	return assertions.filter((assertion) => isOptionalAssertion(quantifierElement, assertion));
+}
+function isOptionalAssertion(quantifierElement, assertion) {
+	let current = assertion;
+	while (current !== quantifierElement) {
+		const parent = current.parent;
+		if (!parent) return false;
+		switch (parent.type) {
+			case "Alternative":
+				for (const sibling of parent.elements) {
+					if (sibling === current) continue;
+					if (canConsumeCharacters(sibling)) return false;
+				}
+				break;
+			case "CapturingGroup":
+			case "Group":
+				if (parent !== quantifierElement) {
+					const containingAlternative = parent.alternatives.find((alternative) => alternative === current || alternative.elements.some(function containsNode(element) {
+						if (element === current) return true;
+						if (element.type === "Group" || element.type === "CapturingGroup") return element.alternatives.some((a) => a.elements.some(containsNode));
+						if (element.type === "Quantifier") return containsNode(element.element);
+						return false;
+					}));
+					if (containingAlternative) {
+						for (const element of containingAlternative.elements) if (element !== current && canConsumeCharacters(element)) return false;
+					}
+				}
+				break;
+			case "Quantifier":
+				if (parent !== quantifierElement && parent.max > 1 && canConsumeCharacters(parent.element)) return false;
+				break;
+		}
+		current = parent;
+	}
+	return true;
+}
+var regexUnnecessaryOptionalAssertions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports assertions inside optional quantifiers that have no effect.",
+		id: "regexUnnecessaryOptionalAssertions",
+		presets: ["logical"]
+	},
+	messages: { unnecessaryOptionalAssertion: {
+		primary: "The assertion `{{ raw }}` inside optional quantifier `{{ quantifier }}` is unnecessary.",
+		secondary: ["This assertion is inside a quantifier with minimum 0, and all paths to the assertion consume no characters.", "The regex engine can skip the entire quantified element, making this assertion useless."],
+		suggestions: ["Add character-consuming elements in the same path as the assertion.", "Remove the assertion if it's not needed."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			const zeroMinQuantifierStack = [];
+			const collectedAssertions = [];
+			visitRegExpAST(regexpAst, {
+				onAssertionEnter(assertion) {
+					if (zeroMinQuantifierStack.length) collectedAssertions.push(assertion);
+				},
+				onQuantifierEnter(quantifier) {
+					if (quantifier.min === 0) zeroMinQuantifierStack.push(quantifier);
+				},
+				onQuantifierLeave(quantifier) {
+					if (quantifier.min === 0) {
+						if (zeroMinQuantifierStack.pop() === quantifier && collectedAssertions.length) {
+							const assertionsInThisQuantifier = collectedAssertions.filter((assertion) => isDescendantOf(assertion, quantifier));
+							const unnecessary = getUnnecessaryAssertions(quantifier.element, assertionsInThisQuantifier);
+							for (const assertion of unnecessary) context.report({
+								data: {
+									quantifier: quantifier.raw,
+									raw: assertion.raw
+								},
+								fix: {
+									range: {
+										begin: patternStart + assertion.start,
+										end: patternStart + assertion.end
+									},
+									text: ""
+								},
+								message: "unnecessaryOptionalAssertion",
+								range: {
+									begin: patternStart + assertion.start,
+									end: patternStart + assertion.end
+								}
+							});
+							for (const assertion of assertionsInThisQuantifier) {
+								const index = collectedAssertions.indexOf(assertion);
+								if (index !== -1) collectedAssertions.splice(index, 1);
+							}
+						}
+					}
+				}
+			});
+		}
+		function isDescendantOf(node, ancestor) {
+			let current = node;
+			while (current) {
+				if (current === ancestor) return true;
+				current = current.parent;
+			}
+			return false;
+		}
+		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) return;
+			checkPattern(construction.pattern, construction.start + 1, construction.flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnnecessaryOptionalAssertions_default as default };
+
+//# sourceMappingURL=regexUnnecessaryOptionalAssertions.js.map

package/lib/rules/regexUnnecessaryReferentialBackreferences.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports backreferences that may reference a capturing group that was not matched.";
+    readonly id: "regexUnnecessaryReferentialBackreferences";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "potentiallyUselessBackref", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexUnnecessaryReferentialBackreferences.d.ts.map

package/lib/rules/regexUnnecessaryReferentialBackreferences.js

@@ -0,0 +1,123 @@
+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/regexUnnecessaryReferentialBackreferences.ts
+function containsNode(ancestor, target) {
+	if (ancestor === target) return true;
+	switch (ancestor.type) {
+		case "Alternative": return ancestor.elements.some((element) => containsNode(element, target));
+		case "Assertion":
+			if (ancestor.kind === "lookahead" || ancestor.kind === "lookbehind") return ancestor.alternatives.some((alternative) => containsNode(alternative, target));
+			return false;
+		case "CapturingGroup":
+		case "Group":
+		case "Pattern": return ancestor.alternatives.some((alternative) => containsNode(alternative, target));
+		case "Quantifier": return containsNode(ancestor.element, target);
+		default: return false;
+	}
+}
+function getAncestors(node) {
+	const ancestors = [];
+	let current = node.parent;
+	while (current) {
+		ancestors.push(current);
+		current = current.parent;
+	}
+	return ancestors;
+}
+function groupCanOnlyMatchEmpty(group) {
+	return group.alternatives.every((alternative) => alternative.elements.every((element) => {
+		if (element.type === "Quantifier" && element.min === 0) return true;
+		if (element.type === "Group" || element.type === "CapturingGroup") return groupCanOnlyMatchEmpty(element);
+		if (element.type === "Assertion") return true;
+		return false;
+	}));
+}
+function isBackreferenceAfterGroup(group, backreference) {
+	const groupAncestors = getAncestors(group);
+	const backrefAncestors = getAncestors(backreference);
+	const commonAncestor = groupAncestors.find((ancestor) => backrefAncestors.includes(ancestor));
+	if (commonAncestor?.type !== "Alternative") return false;
+	return commonAncestor.elements.findIndex((element) => containsNode(element, group) || element === group) < commonAncestor.elements.findIndex((element) => containsNode(element, backreference) || element === backreference);
+}
+function isInsideLookahead(group) {
+	for (const ancestor of getAncestors(group)) if (ancestor.type === "Assertion" && ancestor.kind === "lookahead") return true;
+	return false;
+}
+function mayBeUndefinedAtBackref(group) {
+	const groupAncestors = getAncestors(group);
+	for (const ancestor of groupAncestors) {
+		if (ancestor.type === "Quantifier" && ancestor.min === 0) return true;
+		if (ancestor.type === "Alternative") {
+			const parent = ancestor.parent;
+			if (parent.type === "Group" || parent.type === "CapturingGroup" || parent.type === "Pattern") {
+				if (parent.alternatives.filter((alternative) => containsNode(alternative, group)).length < parent.alternatives.length) return true;
+			}
+		}
+		if (ancestor.type === "Quantifier" && ancestor.max > 1) {
+			const quantifiedElement = ancestor.element;
+			if (quantifiedElement.type === "Group" || quantifiedElement.type === "CapturingGroup") {
+				if (quantifiedElement === group) continue;
+				if (quantifiedElement.alternatives.filter((alternative) => containsNode(alternative, group)).length < quantifiedElement.alternatives.length) return true;
+			}
+		}
+	}
+	return false;
+}
+var regexUnnecessaryReferentialBackreferences_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports backreferences that may reference a capturing group that was not matched.",
+		id: "regexUnnecessaryReferentialBackreferences",
+		presets: ["logical"]
+	},
+	messages: { potentiallyUselessBackref: {
+		primary: "Ensure capturing group is always matched before backreference `{{ raw }}`.",
+		secondary: ["This backreference may always be empty because the referenced capturing group might not participate in the match.", "The group may be in an optional quantifier, inside an alternation where some branches don't include it, or reset in a loop."],
+		suggestions: ["Make sure the capturing group is always matched before the backreference.", "Consider restructuring the regex to ensure the group participates in the match."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onBackreferenceEnter(backreference) {
+				const { resolved } = backreference;
+				const groups = Array.isArray(resolved) ? resolved : [resolved];
+				for (const group of groups) {
+					if (groupCanOnlyMatchEmpty(group) || isInsideLookahead(group) || !isBackreferenceAfterGroup(group, backreference)) continue;
+					if (mayBeUndefinedAtBackref(group)) {
+						context.report({
+							data: { raw: backreference.raw },
+							message: "potentiallyUselessBackref",
+							range: {
+								begin: patternStart + backreference.start,
+								end: patternStart + backreference.end
+							}
+						});
+						return;
+					}
+				}
+			} });
+		}
+		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) return;
+			checkPattern(construction.raw, construction.start + 1, construction.flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnnecessaryReferentialBackreferences_default as default };
+
+//# sourceMappingURL=regexUnnecessaryReferentialBackreferences.js.map

package/lib/rules/regexUnnecessarySetOperands.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports unnecessary operands in regular expression character class set operations.";
+    readonly id: "regexUnnecessarySetOperands";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "intersectionDisjoint" | "intersectionSubset" | "subtractionDisjoint" | "subtractionSubset", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexUnnecessarySetOperands.d.ts.map

package/lib/rules/regexUnnecessarySetOperands.js

@@ -0,0 +1,136 @@
+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 { RegExpParser, visitRegExpAST } from "@eslint-community/regexpp";
+import { toUnicodeSet } from "regexp-ast-analysis";
+//#region src/rules/regexUnnecessarySetOperands.ts
+var regexUnnecessarySetOperands_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports unnecessary operands in regular expression character class set operations.",
+		id: "regexUnnecessarySetOperands",
+		presets: ["logical"]
+	},
+	messages: {
+		intersectionDisjoint: {
+			primary: "This operation can be simplified: '{{ left }}' and '{{ right }}' are disjoint, so the result is always empty.",
+			secondary: ["When two sets have no common elements, their intersection is empty.", "This likely indicates a mistake in the regular expression."],
+			suggestions: ["Review the operands to ensure they share common elements.", "Remove the expression if the empty result is intentional."]
+		},
+		intersectionSubset: {
+			primary: "This operation can be simplified: '{{ subset }}' is a subset of '{{ superset }}', so the superset operand is redundant.",
+			secondary: ["When one operand is a subset of another in an intersection, the superset is redundant.", "The result is equivalent to just the subset operand."],
+			suggestions: ["Remove the redundant superset operand."]
+		},
+		subtractionDisjoint: {
+			primary: "This operation can be simplified: '{{ left }}' and '{{ right }}' are disjoint, so the subtraction has no effect.",
+			secondary: ["Subtracting a set that shares no elements with the left operand does nothing.", "The right operand can be safely removed."],
+			suggestions: ["Remove the unnecessary right operand.", "Review the operands to ensure the subtraction is meaningful."]
+		},
+		subtractionSubset: {
+			primary: "This operation can be simplified: '{{ left }}' is a subset of '{{ right }}', so the result is always empty.",
+			secondary: ["When you subtract a set that contains all elements of the left operand, the result is empty.", "This likely indicates a mistake in the regular expression."],
+			suggestions: ["Review the operands to ensure this is intentional.", "Consider using a different pattern if the empty result is unintended."]
+		}
+	},
+	setup(context) {
+		const unicodeSetsFlags = {
+			unicode: false,
+			unicodeSets: true
+		};
+		function unwrapBrackets(raw) {
+			if (raw.startsWith("[") && raw.endsWith("]")) return raw.slice(1, -1);
+			return raw;
+		}
+		function report(node, patternStart, canFix, message, data, fixText) {
+			const range = {
+				begin: patternStart + node.start,
+				end: patternStart + node.end
+			};
+			context.report({
+				data,
+				fix: canFix && fixText ? {
+					range,
+					text: fixText
+				} : void 0,
+				message,
+				range
+			});
+		}
+		function checkIntersection(node, patternStart, canFix) {
+			const leftSet = toUnicodeSet(node.left, unicodeSetsFlags);
+			const rightSet = toUnicodeSet(node.right, unicodeSetsFlags);
+			if (leftSet.isDisjointWith(rightSet)) {
+				report(node, patternStart, canFix, "intersectionDisjoint", {
+					left: node.left.raw,
+					right: node.right.raw
+				}, "^^");
+				return;
+			}
+			if (leftSet.isSubsetOf(rightSet)) {
+				report(node, patternStart, canFix, "intersectionSubset", {
+					subset: node.left.raw,
+					superset: node.right.raw
+				}, unwrapBrackets(node.left.raw));
+				return;
+			}
+			if (rightSet.isSubsetOf(leftSet)) report(node, patternStart, canFix, "intersectionSubset", {
+				subset: node.right.raw,
+				superset: node.left.raw
+			}, unwrapBrackets(node.right.raw));
+		}
+		function checkSubtraction(node, patternStart, canFix) {
+			const leftSet = toUnicodeSet(node.left, unicodeSetsFlags);
+			const rightSet = toUnicodeSet(node.right, unicodeSetsFlags);
+			if (leftSet.isDisjointWith(rightSet)) {
+				report(node, patternStart, canFix, "subtractionDisjoint", {
+					left: node.left.raw,
+					right: node.right.raw
+				}, unwrapBrackets(node.left.raw));
+				return;
+			}
+			if (leftSet.isSubsetOf(rightSet)) report(node, patternStart, canFix, "subtractionSubset", {
+				left: node.left.raw,
+				right: node.right.raw
+			}, "^^");
+		}
+		function checkPattern(pattern, patternStart, canFix) {
+			let regexpAst;
+			try {
+				regexpAst = new RegExpParser().parsePattern(pattern, void 0, void 0, {
+					unicode: false,
+					unicodeSets: true
+				});
+			} catch {
+				return;
+			}
+			visitRegExpAST(regexpAst, {
+				onClassIntersectionEnter(node) {
+					checkIntersection(node, patternStart, canFix);
+				},
+				onClassSubtractionEnter(node) {
+					checkSubtraction(node, patternStart, canFix);
+				}
+			});
+		}
+		function checkRegexLiteral(node, services) {
+			const details = getRegExpLiteralDetails(node, services);
+			if (!details.flags.includes("v")) return;
+			checkPattern(details.pattern, details.start, true);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction?.flags.includes("v")) return;
+			checkPattern(construction.raw, construction.start + 1, false);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnnecessarySetOperands_default as default };
+
+//# sourceMappingURL=regexUnnecessarySetOperands.js.map

package/lib/rules/regexUnusedCapturingGroups.d.ts

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

package/lib/rules/regexUnusedCapturingGroups.js

@@ -0,0 +1,69 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexUnusedCapturingGroups.ts
+function findUnusedCapturingGroups(pattern, flags) {
+	const results = [];
+	const ast = parseRegexpAst(pattern, flags);
+	if (!ast) return results;
+	visitRegExpAST(ast, { onCapturingGroupEnter(node) {
+		if (!node.references.length) results.push(node);
+	} });
+	return results;
+}
+var regexUnusedCapturingGroups_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports capturing groups in regular expressions that are never referenced.",
+		id: "regexUnusedCapturingGroups",
+		presets: ["logical"]
+	},
+	messages: { unusedCapture: {
+		primary: "Capturing group `{{ raw }}` is never referenced.",
+		secondary: ["Capturing groups that are never backreferenced can be misleading by unintentionally indicating that the group should be captured.", "Non-capturing groups are generally preferred for clarity when the group does not need to be captured."],
+		suggestions: ["Convert to a non-capturing group if the capture is not needed.", "Add a backreference if the capture is needed."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, flags, start) {
+			const unusedGroups = findUnusedCapturingGroups(pattern, flags);
+			for (const group of unusedGroups) {
+				const range = {
+					begin: start + 1 + group.start,
+					end: start + 1 + group.end
+				};
+				const nonCapturing = `(?:${group.alternatives.map((alt) => alt.raw).join("|")})`;
+				context.report({
+					data: { raw: group.raw },
+					message: "unusedCapture",
+					range,
+					suggestions: [{
+						id: "useNonCapturing",
+						range,
+						text: nonCapturing
+					}]
+				});
+			}
+		}
+		function checkRegexLiteral(node, services) {
+			const details = getRegExpLiteralDetails(node, services);
+			const range = getTSNodeRange(node, services.sourceFile);
+			checkPattern(details.pattern, details.flags, range.begin);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			checkPattern(construction.raw, construction.flags, construction.start);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnusedCapturingGroups_default as default };
+
+//# sourceMappingURL=regexUnusedCapturingGroups.js.map

package/lib/rules/regexUnusedFlags.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports regular expression flags that have no effect on the pattern.";
+    readonly id: "regexUnusedFlags";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unusedDotAll" | "unusedIgnoreCase" | "unusedMultiline", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexUnusedFlags.d.ts.map

package/lib/rules/regexUnusedFlags.js

@@ -0,0 +1,116 @@
+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 * as ts$1 from "typescript";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexUnusedFlags.ts
+function analyzePattern(pattern) {
+	const usage = {
+		hasAnchor: false,
+		hasDot: false,
+		hasLetter: false
+	};
+	visitRegExpAST(pattern, {
+		onAssertionEnter(node) {
+			if (node.kind === "start" || node.kind === "end") usage.hasAnchor = true;
+		},
+		onCharacterClassRangeEnter(node) {
+			if (rangeContainsLetter(node.min.value, node.max.value)) usage.hasLetter = true;
+		},
+		onCharacterEnter(node) {
+			if (isAsciiLetter(node.value)) usage.hasLetter = true;
+		},
+		onCharacterSetEnter(node) {
+			if (node.kind === "any") usage.hasDot = true;
+		}
+	});
+	return usage;
+}
+function findUnusedFlags(pattern, flags) {
+	const regexpAst = parseRegexpAst(pattern, flags);
+	if (!regexpAst) return [];
+	const usage = analyzePattern(regexpAst);
+	const unusedFlags = [];
+	if (flags.includes("i") && !usage.hasLetter) unusedFlags.push("i");
+	if (flags.includes("m") && !usage.hasAnchor) unusedFlags.push("m");
+	if (flags.includes("s") && !usage.hasDot) unusedFlags.push("s");
+	return unusedFlags;
+}
+function isAsciiLetter(codePoint) {
+	return codePoint >= 65 && codePoint <= 90 || codePoint >= 97 && codePoint <= 122;
+}
+function rangeContainsLetter(min, max) {
+	return min <= 90 && max >= 65 || min <= 122 && max >= 97;
+}
+var regexUnusedFlags_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports regular expression flags that have no effect on the pattern.",
+		id: "regexUnusedFlags",
+		presets: ["logical"]
+	},
+	messages: {
+		unusedDotAll: {
+			primary: "The `s` flag has no effect because the pattern contains no dots.",
+			secondary: ["The dotAll flag only affects the . metacharacter."],
+			suggestions: ["Remove the 's' flag."]
+		},
+		unusedIgnoreCase: {
+			primary: "The `i` flag has no effect because the pattern contains no letters.",
+			secondary: ["The ignoreCase flag only affects matching of ASCII letters (A-Za-z)."],
+			suggestions: ["Remove the 'i' flag."]
+		},
+		unusedMultiline: {
+			primary: "The `m` flag has no effect because the pattern contains no line anchors.",
+			secondary: ["The multiline flag only affects the ^ and $ anchors."],
+			suggestions: ["Remove the 'm' flag."]
+		}
+	},
+	setup(context) {
+		function reportUnusedFlags(unusedFlags, flags, flagsStart) {
+			for (const flag of unusedFlags) {
+				const flagIndex = flags.indexOf(flag);
+				const message = flag === "i" ? "unusedIgnoreCase" : flag === "m" ? "unusedMultiline" : "unusedDotAll";
+				const range = {
+					begin: flagsStart + flagIndex,
+					end: flagsStart + flagIndex + 1
+				};
+				context.report({
+					fix: {
+						range,
+						text: ""
+					},
+					message,
+					range
+				});
+			}
+		}
+		function checkRegexLiteral(node, services) {
+			const details = getRegExpLiteralDetails(node, services);
+			const unusedFlags = findUnusedFlags(details.pattern, details.flags);
+			if (!unusedFlags.length) return;
+			const flagsStart = details.start + node.text.length - details.flags.length - 1;
+			reportUnusedFlags(unusedFlags, details.flags, flagsStart);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction || construction.args.length < 2) return;
+			const unusedFlags = findUnusedFlags(construction.raw, construction.flags);
+			if (!unusedFlags.length) return;
+			const secondArgument = construction.args[1];
+			if (secondArgument.kind !== ts$1.SyntaxKind.StringLiteral) return;
+			const flagsStart = secondArgument.getStart(services.sourceFile) + 1;
+			reportUnusedFlags(unusedFlags, construction.flags, flagsStart);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnusedFlags_default as default };
+
+//# sourceMappingURL=regexUnusedFlags.js.map

package/lib/rules/regexUnusedLazyQuantifiers.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports lazy quantifiers that have no effect because the quantifier is constant.";
+    readonly id: "regexUnusedLazyQuantifiers";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "uselessLazy", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexUnusedLazyQuantifiers.d.ts.map