@flint.fyi/ts 0.15.0 → 0.18.0

package/lib/rules/regexLookaroundAssertions.js

@@ -0,0 +1,163 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexLookaroundAssertions.ts
+function buildFixedPattern(originalPattern, boundaryGroups) {
+	let result = originalPattern;
+	for (const { group, position } of [...boundaryGroups].reverse()) {
+		const replacement = `${position === "start" ? "(?<=" : "(?="}${groupToRaw(group)})`;
+		result = result.slice(0, group.start) + replacement + result.slice(group.end);
+	}
+	return result;
+}
+function buildFixedReplacement(originalText, boundaryGroups) {
+	let result = originalText;
+	for (let i = boundaryGroups.length; i >= 1; i--) result = result.replaceAll(`$${i}`, "");
+	return result;
+}
+function getBoundaryGroups(pattern, groups) {
+	if (!groups.length || groups.length > 2 || groups.some((group) => group.name != null)) return;
+	const alternatives = pattern.alternatives;
+	if (alternatives.length !== 1) return;
+	const elements = alternatives[0].elements;
+	if (elements.length < 2) return;
+	const result = [];
+	const firstElement = elements[0];
+	const lastElement = elements.at(-1);
+	if (groups.length === 1) {
+		const group = groups[0];
+		if (firstElement === group) result.push({
+			group,
+			position: "start"
+		});
+		else if (lastElement === group) result.push({
+			group,
+			position: "end"
+		});
+		else return;
+	} else {
+		const [first, second] = groups;
+		if (firstElement === first && lastElement === second) result.push({
+			group: first,
+			position: "start"
+		}, {
+			group: second,
+			position: "end"
+		});
+		else return;
+	}
+	return result;
+}
+function getCapturingGroups(pattern) {
+	const groups = [];
+	visitRegExpAST(pattern, { onCapturingGroupEnter(groupNode) {
+		groups.push(groupNode);
+	} });
+	return groups;
+}
+function getRegexPatternAndFlags(node) {
+	if (node.kind !== ts.SyntaxKind.RegularExpressionLiteral) return;
+	const match = /^\/(.+)\/([dgimsuyv]*)$/.exec(node.text);
+	if (!match) return;
+	return {
+		flags: match[2],
+		pattern: match[1]
+	};
+}
+function groupToRaw(group) {
+	return group.alternatives.flatMap((alternative) => alternative.elements.flatMap((element) => element.raw)).join("");
+}
+function hasBackreferences(pattern) {
+	let found = false;
+	visitRegExpAST(pattern, { onBackreferenceEnter() {
+		found = true;
+	} });
+	return found;
+}
+function hasSpecialDollarSyntax(text) {
+	return /\$[$&'`]|\$<[^>]+>/.test(text);
+}
+function hasVariableLengthContent(node) {
+	let found = false;
+	visitRegExpAST(node, { onQuantifierEnter(quantifier) {
+		if (quantifier.min !== quantifier.max) found = true;
+	} });
+	return found;
+}
+function parseReplacementReferences(text) {
+	const references = /* @__PURE__ */ new Map();
+	const pattern = /\$(\d+)/g;
+	let match;
+	while (match = pattern.exec(text)) {
+		const index = parseInt(match[1], 10);
+		if (index > 0) references.set(index, (references.get(index) ?? 0) + 1);
+	}
+	return references;
+}
+var regexLookaroundAssertions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports capturing groups at pattern boundaries that can be replaced with lookaround assertions.",
+		id: "regexLookaroundAssertions",
+		presets: ["stylisticStrict"]
+	},
+	messages: { preferLookaround: {
+		primary: "This capturing group can be optimized by switching to a lookaround assertion.",
+		secondary: ["Lookaround assertions avoid re-inserting captured content in the replacement string.", "Using them allows engines to more easily optimize regular expressions."],
+		suggestions: ["Convert to a lookahead or lookbehind assertion."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+			if (!ts.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "replace" && node.expression.name.text !== "replaceAll" || node.arguments.length < 2) return;
+			if (!(getConstrainedTypeAtLocation(node.expression.expression, typeChecker).flags & ts.TypeFlags.StringLike)) return;
+			const regexArgument = node.arguments[0];
+			const replacementArgument = node.arguments[1];
+			if (!ts.isStringLiteral(replacementArgument) || hasSpecialDollarSyntax(replacementArgument.text)) return;
+			const regexInfo = getRegexPatternAndFlags(regexArgument);
+			if (!regexInfo) return;
+			const regexpAst = parseRegexpAst(regexInfo.pattern, regexInfo.flags);
+			if (!regexpAst || hasBackreferences(regexpAst)) return;
+			const capturingGroups = getCapturingGroups(regexpAst);
+			if (!capturingGroups.length || capturingGroups.length > 2) return;
+			const boundaryGroups = getBoundaryGroups(regexpAst, capturingGroups);
+			if (!boundaryGroups) return;
+			const references = parseReplacementReferences(replacementArgument.text);
+			for (let i = 0; i < boundaryGroups.length; i++) if (references.get(i + 1) !== 1) return;
+			for (const { group, position } of boundaryGroups) if (position === "start" && hasVariableLengthContent(group)) return;
+			const regexRange = getTSNodeRange(regexArgument, sourceFile);
+			const replacementRange = getTSNodeRange(replacementArgument, sourceFile);
+			const fixedPattern = buildFixedPattern(regexInfo.pattern, boundaryGroups);
+			const fixedReplacement = buildFixedReplacement(replacementArgument.text, boundaryGroups);
+			const fix = [{
+				range: {
+					begin: regexRange.begin + 1,
+					end: regexRange.end - 1 - regexInfo.flags.length
+				},
+				text: fixedPattern
+			}, {
+				range: {
+					begin: replacementRange.begin + 1,
+					end: replacementRange.end - 1
+				},
+				text: fixedReplacement
+			}];
+			for (const { group } of boundaryGroups) {
+				const groupRange = {
+					begin: regexRange.begin + 1 + group.start,
+					end: regexRange.begin + 1 + group.end
+				};
+				context.report({
+					fix,
+					message: "preferLookaround",
+					range: groupRange
+				});
+			}
+		} } };
+	}
+});
+//#endregion
+export { regexLookaroundAssertions_default as default };
+
+//# sourceMappingURL=regexLookaroundAssertions.js.map

package/lib/rules/regexLookaroundQuantifierOptimizations.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports non-constant quantifiers in lookaround assertions that could be simplified.";
+    readonly id: "regexLookaroundQuantifierOptimizations";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "replace" | "remove", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexLookaroundQuantifierOptimizations.d.ts.map

package/lib/rules/regexLookaroundQuantifierOptimizations.js

@@ -0,0 +1,94 @@
+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/regexLookaroundQuantifierOptimizations.ts
+function* extractInvalidQuantifiers(alternatives, kind) {
+	for (const { elements } of alternatives) {
+		if (!elements.length) continue;
+		const last = elements[kind === "lookahead" ? elements.length - 1 : 0];
+		switch (last.type) {
+			case "Group":
+				yield* extractInvalidQuantifiers(last.alternatives, kind);
+				break;
+			case "Quantifier":
+				if (last.min !== last.max && !hasCapturingGroupDescendant(last.element)) yield last;
+				break;
+		}
+	}
+}
+function hasCapturingGroupDescendant(element) {
+	switch (element.type) {
+		case "CapturingGroup": return true;
+		case "Group":
+			for (const alternative of element.alternatives) for (const child of alternative.elements) if (hasCapturingGroupDescendant(child)) return true;
+			return false;
+		case "Quantifier": return hasCapturingGroupDescendant(element.element);
+		default: return false;
+	}
+}
+var regexLookaroundQuantifierOptimizations_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports non-constant quantifiers in lookaround assertions that could be simplified.",
+		id: "regexLookaroundQuantifierOptimizations",
+		presets: ["logical"]
+	},
+	messages: {
+		remove: {
+			primary: "Quantifier '{{ raw }}' at the {{ endOrStart }} of the {{ kind }} can be removed.",
+			secondary: ["Non-constant quantifiers at the end of lookaheads or start of lookbehinds only match their minimum because the lookaround only checks for a match, not how much is matched."],
+			suggestions: ["Remove the quantifier."]
+		},
+		replace: {
+			primary: "Quantifier '{{ raw }}' at the {{ endOrStart }} of the {{ kind }} can be replaced with '{{ replacer }}'.",
+			secondary: ["Non-constant quantifiers at the end of lookaheads or start of lookbehinds only match their minimum because the lookaround only checks for a match, not how much is matched."],
+			suggestions: ["Replace the quantifier with the constant minimum."]
+		}
+	},
+	setup(context) {
+		function checkPattern(pattern, start, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onAssertionEnter(assertionNode) {
+				if (assertionNode.kind !== "lookahead" && assertionNode.kind !== "lookbehind") return;
+				const endOrStart = assertionNode.kind === "lookahead" ? "end" : "start";
+				const kind = assertionNode.negate ? `negative ${assertionNode.kind}` : assertionNode.kind;
+				for (const quantifier of extractInvalidQuantifiers(assertionNode.alternatives, assertionNode.kind)) {
+					const replacer = quantifier.min === 0 ? "" : quantifier.min === 1 ? quantifier.element.raw : `${quantifier.element.raw}{${quantifier.min}}`;
+					context.report({
+						data: {
+							endOrStart,
+							kind,
+							raw: quantifier.raw,
+							replacer
+						},
+						message: quantifier.min === 0 ? "remove" : "replace",
+						range: {
+							begin: start + quantifier.start,
+							end: start + quantifier.end
+						}
+					});
+				}
+			} });
+		}
+		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 { regexLookaroundQuantifierOptimizations_default as default };
+
+//# sourceMappingURL=regexLookaroundQuantifierOptimizations.js.map

package/lib/rules/regexMatchNotation.d.ts

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

package/lib/rules/regexMatchNotation.js

@@ -0,0 +1,139 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexMatchNotation.ts
+const allowedNotation = String.raw`[\s\S]`;
+function isMatchAnyCharacterClass(node, flags) {
+	if (node.negate) return !node.elements.length;
+	const positiveElements = [];
+	const negativeElements = [];
+	for (const element of node.elements) if (element.type === "CharacterSet") switch (element.kind) {
+		case "digit":
+			if (element.negate) negativeElements.push({
+				kind: "digit",
+				type: "CharacterSet"
+			});
+			else positiveElements.push({
+				kind: "digit",
+				type: "CharacterSet"
+			});
+			break;
+		case "property": {
+			if (!flags.unicode && !flags.unicodeSets) break;
+			const key = `property:${element.key}:${element.value ?? ""}`;
+			if (element.negate) negativeElements.push({
+				kind: key,
+				negate: true,
+				type: "CharacterSet"
+			});
+			else positiveElements.push({
+				kind: key,
+				type: "CharacterSet"
+			});
+			break;
+		}
+		case "space":
+			if (element.negate) negativeElements.push({
+				kind: "space",
+				type: "CharacterSet"
+			});
+			else positiveElements.push({
+				kind: "space",
+				type: "CharacterSet"
+			});
+			break;
+		case "word":
+			if (element.negate) negativeElements.push({
+				kind: "word",
+				type: "CharacterSet"
+			});
+			else positiveElements.push({
+				kind: "word",
+				type: "CharacterSet"
+			});
+			break;
+		default: break;
+	}
+	else if (element.type === "CharacterClassRange" && element.min.value === 0 && (element.max.value === 65535 || element.max.value === 1114111 || flags.unicode && element.max.value >= 1114111)) return true;
+	for (const positive of positiveElements) if (negativeElements.find((negative) => negative.kind === positive.kind)) return true;
+	const hasSpace = positiveElements.some((e) => e.kind === "space");
+	const hasNonSpace = negativeElements.some((e) => e.kind === "space");
+	if (hasSpace && hasNonSpace) return true;
+	const hasDigit = positiveElements.some((e) => e.kind === "digit");
+	const hasNonDigit = negativeElements.some((e) => e.kind === "digit");
+	if (hasDigit && hasNonDigit) return true;
+	const hasWord = positiveElements.some((e) => e.kind === "word");
+	const hasNonWord = negativeElements.some((e) => e.kind === "word");
+	if (hasWord && hasNonWord) return true;
+	return false;
+}
+var regexMatchNotation_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports inconsistent notations for matching any character in regular expressions.",
+		id: "regexMatchNotation",
+		presets: ["stylisticStrict"]
+	},
+	messages: { unexpected: {
+		primary: "For consistency, prefer '{{ preferred }}' over '{{ raw }}' to match any character.",
+		secondary: ["Using a consistent notation for matching any character improves readability."],
+		suggestions: ["Replace with the standard notation."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			const flagsInfo = {
+				dotAll: flags.includes("s"),
+				unicode: flags.includes("u"),
+				unicodeSets: flags.includes("v")
+			};
+			visitRegExpAST(regexpAst, { onCharacterClassEnter(ccNode) {
+				if (isMatchAnyCharacterClass(ccNode, flagsInfo) && ccNode.raw !== allowedNotation) {
+					const preferred = flagsInfo.dotAll ? "." : allowedNotation;
+					context.report({
+						data: {
+							preferred,
+							raw: ccNode.raw
+						},
+						message: "unexpected",
+						range: {
+							begin: patternStart + ccNode.start,
+							end: patternStart + ccNode.end
+						}
+					});
+				}
+			} });
+		}
+		function checkRegexLiteral(node, { sourceFile }) {
+			const text = node.getText(sourceFile);
+			const match = /^\/(.*)\/([dgimsuyv]*)$/.exec(text);
+			if (!match) return;
+			const [, pattern, flags] = match;
+			if (!pattern) return;
+			checkPattern(pattern, node.getStart(sourceFile) + 1, flags ?? "");
+		}
+		function checkRegExpConstructor(node, { sourceFile }) {
+			if (node.expression.kind !== ts$1.SyntaxKind.Identifier || node.expression.text !== "RegExp") return;
+			const args = node.arguments;
+			if (!args?.length) return;
+			const firstArgument = args[0];
+			if (firstArgument?.kind !== ts$1.SyntaxKind.StringLiteral) return;
+			const patternStart = firstArgument.getStart(sourceFile) + 1;
+			let flags = "";
+			const secondArgument = args[1];
+			if (secondArgument?.kind === ts$1.SyntaxKind.StringLiteral) flags = secondArgument.text;
+			checkPattern(firstArgument.text, patternStart, flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexMatchNotation_default as default };
+
+//# sourceMappingURL=regexMatchNotation.js.map

package/lib/rules/regexMisleadingCapturingGroups.d.ts

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

package/lib/rules/regexMisleadingCapturingGroups.js

@@ -0,0 +1,229 @@
+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/regexMisleadingCapturingGroups.ts
+function collectFromElement(element, collector) {
+	const result = /* @__PURE__ */ new Set();
+	forEachInGroup(element, (element) => {
+		for (const item of collector(element)) result.add(item);
+	});
+	return result;
+}
+function elementContainsPositiveSet(element, kind) {
+	return forEachInGroup(element, (el) => el.type === "CharacterSet" && hasNegate(el) && el.kind === kind && !el.negate);
+}
+function findFollowingElement(capturingGroup) {
+	const info = getAlternativeIndex(capturingGroup);
+	return info?.elements[info.index + 1];
+}
+function findPrecedingQuantifier(capturingGroup) {
+	const info = getAlternativeIndex(capturingGroup);
+	if (!info || info.index <= 0) return;
+	const previous = info.elements[info.index - 1];
+	return previous?.type === "Quantifier" && previous.max > previous.min ? previous : void 0;
+}
+function forEachInGroup(element, callback) {
+	switch (element.type) {
+		case "CapturingGroup":
+		case "Group":
+			for (const alt of element.alternatives) for (const el of alt.elements) if (forEachInGroup(el, callback)) return true;
+			return false;
+		case "Quantifier": return forEachInGroup(element.element, callback);
+		default: return callback(element) === true;
+	}
+}
+function getAlternativeIndex(capturingGroup) {
+	const parent = capturingGroup.parent;
+	if (parent.type !== "Alternative") return;
+	const index = parent.elements.indexOf(capturingGroup);
+	return index === -1 ? void 0 : {
+		elements: parent.elements,
+		index
+	};
+}
+function getCharacterSetType(el) {
+	if (el.kind === "any") return "set:any";
+	if (!hasNegate(el)) return "";
+	return `set:${el.kind}${el.negate ? ":negated" : ""}`;
+}
+function getCharacterValues(elements) {
+	const result = [];
+	for (const el of elements) if (el.type === "Character") result.push(el.value);
+	return result;
+}
+function getClassExcludedChars(element) {
+	if (element.type !== "CharacterClass" || !element.negate) return /* @__PURE__ */ new Set();
+	return new Set(getCharacterValues(element.elements));
+}
+function getElementCharacters(element) {
+	return collectFromElement(element, (el) => {
+		if (el.type === "Character") return [el.value];
+		if (el.type === "CharacterClass") return getCharacterValues(el.elements);
+		return [];
+	});
+}
+function getEndQuantifier(capturingGroup) {
+	for (const alternative of capturingGroup.alternatives) {
+		if (!alternative.elements.length) continue;
+		const last = alternative.elements.at(-1);
+		if (last.type === "Quantifier" && last.max > last.min) return last;
+	}
+}
+function getFirstElementInGroup(element) {
+	let current = element;
+	while (current) {
+		if (current.type === "Quantifier") {
+			current = current.element;
+			continue;
+		}
+		if (current.type === "Group" || current.type === "CapturingGroup") {
+			const alternative = current.alternatives[0];
+			if (!alternative) return;
+			current = alternative.elements[0];
+			continue;
+		}
+		break;
+	}
+	return current;
+}
+function getMatchableCharacterTypes(element) {
+	return collectFromElement(element, (el) => {
+		if (el.type === "Character") return [`char:${el.value}`];
+		if (el.type === "CharacterSet") {
+			const type = getCharacterSetType(el);
+			return type ? [type] : [];
+		}
+		if (el.type === "CharacterClass") return el.elements.flatMap((child) => {
+			if (child.type === "Character") return [`char:${child.value}`];
+			if (child.type === "CharacterSet" && hasNegate(child)) return [`set:${child.kind}${child.negate ? ":negated" : ""}`];
+			if (child.type === "CharacterClassRange") return [`range:${child.min.value}-${child.max.value}`];
+			return [];
+		});
+		return [];
+	});
+}
+function getStartQuantifier(alternative, direction) {
+	const elements = alternative.elements;
+	if (!elements.length) return;
+	const first = direction === "ltr" ? elements[0] : elements.at(-1);
+	if (!first) return;
+	if (first.type === "Quantifier") return first;
+	if (first.type === "Group") for (const alt of first.alternatives) {
+		const quantifier = getStartQuantifier(alt, direction);
+		if (quantifier) return quantifier;
+	}
+}
+function hasNegate(node) {
+	return "negate" in node;
+}
+function hasOverlap(a, b) {
+	if (a.has("set:any") || b.has("set:any")) return true;
+	for (const type of a) if (b.has(type)) return true;
+	return false;
+}
+function isAllowedEndPattern(endQuantifier, followingElement) {
+	return isDotDelimiterPattern(endQuantifier, followingElement) || isNegatedSetFollowedByPositive(endQuantifier, followingElement) || isExcludedDelimiterPattern(endQuantifier, followingElement);
+}
+function isDotDelimiterPattern(endQuantifier, followingElement) {
+	return endQuantifier.element.type === "CharacterSet" && endQuantifier.element.kind === "any" && followingElement.type === "Character";
+}
+function isExcludedDelimiterPattern(endQuantifier, followingElement) {
+	if (endQuantifier.element.type !== "CharacterClass" || !endQuantifier.element.negate) return false;
+	const excluded = getClassExcludedChars(endQuantifier.element);
+	if (!excluded.size) return false;
+	const followingChars = getElementCharacters(followingElement);
+	for (const character of followingChars) if (excluded.has(character)) return true;
+	return false;
+}
+function isNegatedSetFollowedByPositive(endQuantifier, followingElement) {
+	return endQuantifier.element.type === "CharacterSet" && hasNegate(endQuantifier.element) && endQuantifier.element.negate && elementContainsPositiveSet(followingElement, endQuantifier.element.kind);
+}
+var regexMisleadingCapturingGroups_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports capturing groups that capture less text than their pattern suggests.",
+		id: "regexMisleadingCapturingGroups",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		misleadingEnd: {
+			primary: "Quantifier '{{ quantifierRaw }}' at the end of capturing group may capture less than expected due to backtracking.",
+			secondary: ["The quantifier at the end of this capturing group may give up characters during backtracking to satisfy a following pattern."],
+			suggestions: ["Use an atomic group.", "Rewrite the pattern."]
+		},
+		misleadingStart: {
+			primary: "Capturing group with '{{ captureRaw }}' will always capture {{ behavior }} because '{{ precedingRaw }}' consumes matching characters first.",
+			secondary: ["The quantifier in this capturing group can never match as much as expected because a preceding quantifier already consumed the characters."],
+			suggestions: ["Remove the quantifier in the capturing group.", "Simplify the quantifier in the capturing group."]
+		}
+	},
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onCapturingGroupEnter(cgNode) {
+				checkMisleadingStart(cgNode, patternStart);
+				checkMisleadingEnd(cgNode, patternStart);
+			} });
+		}
+		function checkMisleadingStart(capturingGroupNode, patternStart) {
+			const precedingQuantifier = findPrecedingQuantifier(capturingGroupNode);
+			const firstAlternative = capturingGroupNode.alternatives[0];
+			if (!precedingQuantifier || !firstAlternative) return;
+			const startQuantifier = getStartQuantifier(firstAlternative, "ltr");
+			if (!startQuantifier) return;
+			if (startQuantifier.element.type === "CharacterSet" && startQuantifier.element.kind === "any") return;
+			if (!hasOverlap(getMatchableCharacterTypes(precedingQuantifier.element), getMatchableCharacterTypes(startQuantifier.element))) return;
+			const behavior = startQuantifier.min === 0 ? "the empty string" : `only ${startQuantifier.min} character${startQuantifier.min > 1 ? "s" : ""}`;
+			context.report({
+				data: {
+					behavior,
+					captureRaw: startQuantifier.raw,
+					precedingRaw: precedingQuantifier.raw
+				},
+				message: "misleadingStart",
+				range: {
+					begin: patternStart + startQuantifier.start,
+					end: patternStart + startQuantifier.end
+				}
+			});
+		}
+		function checkMisleadingEnd(capturingGroupNode, patternStart) {
+			const endQuantifier = getEndQuantifier(capturingGroupNode);
+			if (!endQuantifier) return;
+			const followingElement = findFollowingElement(capturingGroupNode);
+			if (!followingElement || isAllowedEndPattern(endQuantifier, followingElement)) return;
+			const endTypes = getMatchableCharacterTypes(endQuantifier.element);
+			const firstFollowing = getFirstElementInGroup(followingElement);
+			if (!hasOverlap(endTypes, firstFollowing ? getMatchableCharacterTypes(firstFollowing) : /* @__PURE__ */ new Set())) return;
+			context.report({
+				data: { quantifierRaw: endQuantifier.raw },
+				message: "misleadingEnd",
+				range: {
+					begin: patternStart + endQuantifier.start,
+					end: patternStart + endQuantifier.end
+				}
+			});
+		}
+		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 { regexMisleadingCapturingGroups_default as default };
+
+//# sourceMappingURL=regexMisleadingCapturingGroups.js.map

package/lib/rules/regexMisleadingQuantifiers.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports quantifiers whose minimum implies they must match but whose element can match empty.";
+    readonly id: "regexMisleadingQuantifiers";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "confusing", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexMisleadingQuantifiers.d.ts.map