@flint.fyi/ts 0.21.0 → 0.22.0

package/lib/rules/regexUnnecessaryNestedAssertions.js

@@ -1,196 +0,0 @@
-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 };

package/lib/rules/regexUnnecessaryNestedQuantifiers.d.ts

@@ -1,9 +0,0 @@
-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: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryNestedQuantifiers", undefined>;
-export default _default;

package/lib/rules/regexUnnecessaryNestedQuantifiers.js

@@ -1,91 +0,0 @@
-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 };

package/lib/rules/regexUnnecessaryNonCapturingGroups.d.ts

@@ -1,9 +0,0 @@
-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: readonly ["stylistic"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryGroup", undefined>;
-export default _default;

package/lib/rules/regexUnnecessaryNonCapturingGroups.js

@@ -1,102 +0,0 @@
-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 };

package/lib/rules/regexUnnecessaryNumericQuantifiers.d.ts

@@ -1,9 +0,0 @@
-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: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryNumericQuantifier", undefined>;
-export default _default;

package/lib/rules/regexUnnecessaryNumericQuantifiers.js

@@ -1,67 +0,0 @@
-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 };

package/lib/rules/regexUnnecessaryOptionalAssertions.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports assertions inside optional quantifiers that have no effect.";
-    readonly id: "regexUnnecessaryOptionalAssertions";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryOptionalAssertion", undefined>;
-export default _default;

package/lib/rules/regexUnnecessaryOptionalAssertions.js

@@ -1,135 +0,0 @@
-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 };

package/lib/rules/regexUnnecessaryReferentialBackreferences.d.ts

@@ -1,9 +0,0 @@
-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: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "potentiallyUselessBackref", undefined>;
-export default _default;