@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/regexUnnecessaryNestedAssertions.js

@@ -0,0 +1,198 @@
+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/regexUnnecessaryNestedAssertions.ts
+const lookaheadOpeners = ["(?=", "(?!"];
+const lookbehindOpeners = ["(?<=", "(?<!"];
+const allLookaroundOpeners = [...lookaheadOpeners, ...lookbehindOpeners];
+function findCharacterClassEnd(pattern, startIndex) {
+	let index = startIndex + 1;
+	while (index < pattern.length) {
+		if (pattern[index] === "\\") {
+			index += 2;
+			continue;
+		}
+		if (pattern[index] === "]") return index;
+		index++;
+	}
+	return -1;
+}
+function findMatchingParen(pattern, startIndex) {
+	let depth = 1;
+	let index = startIndex;
+	while (index < pattern.length && depth > 0) {
+		if (pattern[index] === "\\") {
+			index += 2;
+			continue;
+		}
+		if (pattern[index] === "[") {
+			const closeIndex = findCharacterClassEnd(pattern, index);
+			if (closeIndex === -1) return -1;
+			index = closeIndex + 1;
+			continue;
+		}
+		if (pattern[index] === "(") depth++;
+		else if (pattern[index] === ")") depth--;
+		if (depth > 0) index++;
+	}
+	return depth === 0 ? index : -1;
+}
+function findTriviallyNestedAssertions(pattern, doubleEscaped) {
+	const findings = [];
+	const anchorPattern = doubleEscaped ? /^(?:\^|\$|\\\\b)$/i : /^(?:\^|\$|\\b)$/i;
+	let index = 0;
+	while (index < pattern.length) {
+		if (pattern[index] === "[") {
+			const closeIndex = findCharacterClassEnd(pattern, index);
+			if (closeIndex === -1) break;
+			index = closeIndex + 1;
+			continue;
+		}
+		if (pattern[index] === "\\" || doubleEscaped && pattern.slice(index, index + 2) === "\\\\") {
+			index += doubleEscaped && pattern.slice(index, index + 2) === "\\\\" ? 2 : 2;
+			continue;
+		}
+		const opener = allLookaroundOpeners.find((lookaround) => pattern.slice(index, index + lookaround.length) === lookaround);
+		if (!opener) {
+			index++;
+			continue;
+		}
+		const outerStart = index;
+		const contentStart = index + opener.length;
+		const closeIndex = findMatchingParen(pattern, contentStart);
+		if (closeIndex === -1) {
+			index++;
+			continue;
+		}
+		const outerEnd = closeIndex + 1;
+		if (hasQuantifierAfter(pattern, outerEnd)) {
+			index++;
+			continue;
+		}
+		const content = pattern.slice(contentStart, closeIndex);
+		if (hasTopLevelAlternation(content, doubleEscaped)) {
+			index++;
+			continue;
+		}
+		if (anchorPattern.test(content)) {
+			findings.push({
+				end: outerEnd,
+				innerRaw: content,
+				outerRaw: pattern.slice(outerStart, outerEnd),
+				start: outerStart
+			});
+			index = outerEnd;
+			continue;
+		}
+		const innerOpener = allLookaroundOpeners.find((lookaround) => content.startsWith(lookaround));
+		if (innerOpener) {
+			if (lookaheadOpeners.includes(opener) === lookaheadOpeners.includes(innerOpener)) {
+				const innerContentStart = innerOpener.length;
+				const innerCloseIndex = findMatchingParen(content, innerContentStart);
+				if (innerCloseIndex !== -1 && innerCloseIndex === content.length - 1 && !hasQuantifierAfter(content, innerCloseIndex + 1)) findings.push({
+					end: outerEnd,
+					innerRaw: content,
+					outerRaw: pattern.slice(outerStart, outerEnd),
+					start: outerStart
+				});
+			}
+		}
+		index = outerEnd;
+	}
+	return findings;
+}
+function hasQuantifierAfter(pattern, index) {
+	const nextChar = pattern[index];
+	return nextChar === "*" || nextChar === "+" || nextChar === "?" || nextChar === "{";
+}
+function hasTopLevelAlternation(content, doubleEscaped) {
+	let depth = 0;
+	let index = 0;
+	while (index < content.length) {
+		const char = content[index];
+		if (char === "\\") {
+			index += doubleEscaped && content[index + 1] === "\\" ? 3 : 2;
+			continue;
+		}
+		if (char === "[") {
+			const closeIndex = findCharacterClassEnd(content, index);
+			if (closeIndex === -1) return false;
+			index = closeIndex + 1;
+			continue;
+		}
+		if (char === "(") depth++;
+		else if (char === ")") depth--;
+		else if (char === "|" && depth === 0) return true;
+		index++;
+	}
+	return false;
+}
+var regexUnnecessaryNestedAssertions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports trivially nested assertions in regular expressions that can be simplified.",
+		id: "regexUnnecessaryNestedAssertions",
+		presets: ["logical"]
+	},
+	messages: { unnecessaryNesting: {
+		primary: "The lookaround '{{ outer }}' trivially wraps the assertion '{{ inner }}' and can be simplified.",
+		secondary: ["Use the inner assertion directly instead of wrapping it in a lookaround."],
+		suggestions: ["Replace the lookaround with the inner assertion."]
+	} },
+	setup(context) {
+		function checkRegexLiteral(node, services) {
+			const { pattern, start } = getRegExpLiteralDetails(node, services);
+			const findings = findTriviallyNestedAssertions(pattern, false);
+			for (const finding of findings) context.report({
+				data: {
+					inner: finding.innerRaw,
+					outer: finding.outerRaw
+				},
+				fix: {
+					range: {
+						begin: start + finding.start,
+						end: start + finding.end
+					},
+					text: finding.innerRaw
+				},
+				message: "unnecessaryNesting",
+				range: {
+					begin: start + finding.start,
+					end: start + finding.end
+				}
+			});
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			const findings = findTriviallyNestedAssertions(construction.pattern, true);
+			for (const finding of findings) context.report({
+				data: {
+					inner: finding.innerRaw,
+					outer: finding.outerRaw
+				},
+				fix: {
+					range: {
+						begin: construction.start + 1 + finding.start,
+						end: construction.start + 1 + finding.end
+					},
+					text: finding.innerRaw
+				},
+				message: "unnecessaryNesting",
+				range: {
+					begin: construction.start + 1 + finding.start,
+					end: construction.start + 1 + finding.end
+				}
+			});
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnnecessaryNestedAssertions_default as default };
+
+//# sourceMappingURL=regexUnnecessaryNestedAssertions.js.map

package/lib/rules/regexUnnecessaryNestedQuantifiers.d.ts

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

package/lib/rules/regexUnnecessaryNestedQuantifiers.js

@@ -0,0 +1,93 @@
+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/regexUnnecessaryNestedQuantifiers.ts
+function combineQuantifiers(inner, outer) {
+	if (inner === "+" && outer === "+") return "+";
+	if (inner === "+" && outer === "*") return "*";
+	if (inner === "?" && outer === "+") return "*";
+	if (inner === "?" && outer === "*") return "*";
+	if (inner === "*" && outer === "+") return "*";
+	if (inner === "*" && outer === "*") return "*";
+}
+function formatQuantifier(quantifier, greedy) {
+	return greedy ? quantifier : `${quantifier}?`;
+}
+function getSimpleQuantifier(min, max) {
+	if (min === 0 && max === 1) return "?";
+	if (min === 0 && max === Infinity) return "*";
+	if (min === 1 && max === Infinity) return "+";
+}
+var regexUnnecessaryNestedQuantifiers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports trivially nested quantifiers in regular expressions that can be simplified.",
+		id: "regexUnnecessaryNestedQuantifiers",
+		presets: ["logical"]
+	},
+	messages: { unnecessaryNestedQuantifiers: {
+		primary: "The nested quantifiers `{{ original }}` can be simplified to `{{ replacement }}`.",
+		secondary: ["A quantifier wrapping a non-capturing group with a single quantified element can be simplified to a single quantifier."],
+		suggestions: ["Replace with `{{ replacement }}`."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onQuantifierEnter(outerQuantifier) {
+				const outerSimple = getSimpleQuantifier(outerQuantifier.min, outerQuantifier.max);
+				if (!outerSimple) return;
+				const group = outerQuantifier.element;
+				if (group.type !== "Group" || group.alternatives.length !== 1) return;
+				const alternative = group.alternatives[0];
+				if (alternative.elements.length !== 1) return;
+				const innerElement = alternative.elements[0];
+				if (innerElement.type !== "Quantifier") return;
+				const innerSimple = getSimpleQuantifier(innerElement.min, innerElement.max);
+				if (!innerSimple || innerElement.greedy !== outerQuantifier.greedy) return;
+				const combined = combineQuantifiers(innerSimple, outerSimple);
+				if (!combined) return;
+				const atom = innerElement.element;
+				const replacement = `${pattern.slice(atom.start, atom.end)}${formatQuantifier(combined, outerQuantifier.greedy)}`;
+				context.report({
+					data: {
+						original: outerQuantifier.raw,
+						replacement
+					},
+					fix: {
+						range: {
+							begin: patternStart + outerQuantifier.start,
+							end: patternStart + outerQuantifier.end
+						},
+						text: replacement
+					},
+					message: "unnecessaryNestedQuantifiers",
+					range: {
+						begin: patternStart + outerQuantifier.start,
+						end: patternStart + outerQuantifier.end
+					}
+				});
+			} });
+		}
+		function checkRegexLiteral(node, { sourceFile }) {
+			const details = getRegExpLiteralDetails(node, { sourceFile });
+			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 { regexUnnecessaryNestedQuantifiers_default as default };
+
+//# sourceMappingURL=regexUnnecessaryNestedQuantifiers.js.map

package/lib/rules/regexUnnecessaryNonCapturingGroups.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports non-capturing groups that can be removed without changing the meaning of the regex.";
+    readonly id: "regexUnnecessaryNonCapturingGroups";
+    readonly presets: ["stylistic"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessaryGroup", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexUnnecessaryNonCapturingGroups.d.ts.map

package/lib/rules/regexUnnecessaryNonCapturingGroups.js

@@ -0,0 +1,104 @@
+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/regexUnnecessaryNonCapturingGroups.ts
+function canUnwrap(group, pattern) {
+	const alternative = group.alternatives[0];
+	const groupContent = alternative.raw;
+	if (!alternative.elements.length) return true;
+	const parent = group.parent;
+	let textBefore;
+	let textAfter;
+	if (parent.type === "Alternative") {
+		textBefore = pattern.slice(parent.start, group.start);
+		textAfter = pattern.slice(group.end, parent.end);
+	} else {
+		const alt = parent.parent;
+		textBefore = pattern.slice(alt.start, group.start);
+		textAfter = pattern.slice(group.end, alt.end);
+	}
+	return !mightCreateNewElement(textBefore, groupContent) && !mightCreateNewElement(groupContent, textAfter);
+}
+function isUnnecessaryGroup(group, pattern) {
+	const firstAlternative = group.alternatives[0];
+	if (group.alternatives.length === 1) {
+		if (!firstAlternative.elements.length) return false;
+		if (group.parent.type === "Quantifier") {
+			if (firstAlternative.elements.length !== 1) return false;
+			const singleElement = firstAlternative.elements[0];
+			if (singleElement.type === "Quantifier" || singleElement.type === "Assertion") return false;
+			return canUnwrap(group, pattern);
+		}
+		return canUnwrap(group, pattern);
+	}
+	if (group.parent.type === "Quantifier" || group.parent.elements.length !== 1) return false;
+	return canUnwrap(group, pattern);
+}
+function mightCreateNewElement(before, after) {
+	if (before.endsWith("\\c") && /^[a-z]/i.test(after)) return true;
+	if (/(?:^|[^\\])(?:\\{2})*\\(?:x[\dA-Fa-f]?|u[\dA-Fa-f]{0,3})$/.test(before) && /^[\da-f]/i.test(after)) return true;
+	if (/(?:^|[^\\])(?:\\{2})*\\u$/.test(before) && /^\{[\da-f]*(?:\}[\s\S]*)?$/i.test(after) || /(?:^|[^\\])(?:\\{2})*\\u\{[\da-f]*$/.test(before) && /^(?:[\da-f]+\}?|\})/i.test(after)) return true;
+	if (/(?:^|[^\\])(?:\\{2})*\\0[0-7]?$/.test(before) && /^[0-7]/.test(after) || /(?:^|[^\\])(?:\\{2})*\\[1-7]$/.test(before) && /^[0-7]/.test(after)) return true;
+	if (/(?:^|[^\\])(?:\\{2})*\\[1-9]\d*$/.test(before) && /^\d/.test(after) || /(?:^|[^\\])(?:\\{2})*\\k$/.test(before) && after.startsWith("<") || /(?:^|[^\\])(?:\\{2})*\\k<[^<>]*$/.test(before)) return true;
+	if (/(?:^|[^\\])(?:\\{2})*\\p$/i.test(before) && /^\{[\w=]*(?:\}[\s\S]*)?$/.test(after) || /(?:^|[^\\])(?:\\{2})*\\p\{[\w=]*$/i.test(before) && /^[\w=]+(?:\}[\s\S]*)?$|^\}/.test(after)) return true;
+	if (/(?:^|[^\\])(?:\\{2})*\{\d*$/.test(before) && /^[\d,}]/.test(after) || /(?:^|[^\\])(?:\\{2})*\{\d+,$/.test(before) && /^(?:\d+(?:\}|$)|\})/.test(after) || /(?:^|[^\\])(?:\\{2})*\{\d+,\d*$/.test(before) && after.startsWith("}")) return true;
+	return false;
+}
+var regexUnnecessaryNonCapturingGroups_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports non-capturing groups that can be removed without changing the meaning of the regex.",
+		id: "regexUnnecessaryNonCapturingGroups",
+		presets: ["stylistic"]
+	},
+	messages: { unnecessaryGroup: {
+		primary: "This non-capturing group can be removed without changing the regular expression's behavior.",
+		secondary: ["Non-capturing groups are generally only necessary when changing search behavior based on the full group.", "This non-capturing group has no such logic, and so can be removed without changing the regex behavior."],
+		suggestions: ["Remove the group delimiters to inline the group."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onGroupEnter(group) {
+				if (isUnnecessaryGroup(group, pattern)) {
+					const groupContent = group.raw.slice(3, -1);
+					context.report({
+						fix: {
+							range: {
+								begin: patternStart + group.start,
+								end: patternStart + group.end
+							},
+							text: groupContent
+						},
+						message: "unnecessaryGroup",
+						range: {
+							begin: patternStart + group.start,
+							end: patternStart + group.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.pattern, construction.start + 1, construction.flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnnecessaryNonCapturingGroups_default as default };
+
+//# sourceMappingURL=regexUnnecessaryNonCapturingGroups.js.map

package/lib/rules/regexUnnecessaryNumericQuantifiers.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports numeric quantifiers like '{n,n}' that can be simplified to '{n}'.";
+    readonly id: "regexUnnecessaryNumericQuantifiers";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessaryNumericQuantifier", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexUnnecessaryNumericQuantifiers.d.ts.map

package/lib/rules/regexUnnecessaryNumericQuantifiers.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 { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexUnnecessaryNumericQuantifiers.ts
+function getQuantifierSuffix(quantifier) {
+	const startOffset = quantifier.element.end - quantifier.start;
+	return quantifier.raw.slice(startOffset);
+}
+function isUnnecessaryNumericRangeQuantifier(quantifierSuffix) {
+	const base = quantifierSuffix.endsWith("?") ? quantifierSuffix.slice(0, -1) : quantifierSuffix;
+	return /^\{\d+,\d+\}$/.test(base);
+}
+var regexUnnecessaryNumericQuantifiers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports numeric quantifiers like '{n,n}' that can be simplified to '{n}'.",
+		id: "regexUnnecessaryNumericQuantifiers",
+		presets: ["logical"]
+	},
+	messages: { unnecessaryNumericQuantifier: {
+		primary: "This numeric quantifier `{{ raw }}` can be simplified to `{{ simplified }}`.",
+		secondary: ["Numeric quantifiers with the same minimum and maximum can be written more concisely.", "Using the simpler form results in an easier-to-read regular expression."],
+		suggestions: ["Replace `{{ raw }}` with `{{ simplified }}`."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onQuantifierEnter(quantifier) {
+				if (quantifier.min !== quantifier.max) return;
+				const quantifierSuffix = getQuantifierSuffix(quantifier);
+				if (!isUnnecessaryNumericRangeQuantifier(quantifierSuffix)) return;
+				const simplified = `{${quantifier.min}}${quantifier.greedy ? "" : "?"}`;
+				const quantifierStart = patternStart + quantifier.element.end;
+				context.report({
+					data: {
+						raw: quantifierSuffix,
+						simplified
+					},
+					message: "unnecessaryNumericQuantifier",
+					range: {
+						begin: quantifierStart,
+						end: patternStart + 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) return;
+			checkPattern(construction.pattern, construction.start + 1, construction.flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnnecessaryNumericQuantifiers_default as default };
+
+//# sourceMappingURL=regexUnnecessaryNumericQuantifiers.js.map

package/lib/rules/regexUnnecessaryOptionalAssertions.d.ts

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

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