@flint.fyi/ts 0.21.0 → 0.23.0

package/lib/rules/regexDollarEscapes.js

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

package/lib/rules/regexDuplicateCharacterClassCharacters.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports duplicate characters in regular expression character classes.";
-    readonly id: "regexDuplicateCharacterClassCharacters";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "duplicate" | "includedInRange", undefined>;
-export default _default;

package/lib/rules/regexDuplicateCharacterClassCharacters.js

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

package/lib/rules/regexEmptyAlternatives.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports empty alternatives in regular expressions that may indicate a mistake.";
-    readonly id: "regexEmptyAlternatives";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "emptyAlternative", undefined>;
-export default _default;

package/lib/rules/regexEmptyAlternatives.js

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

package/lib/rules/regexEmptyCapturingGroups.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports capturing groups that only capture empty strings.";
-    readonly id: "regexEmptyCapturingGroups";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "emptyCapture", undefined>;
-export default _default;

package/lib/rules/regexEmptyCapturingGroups.js

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

package/lib/rules/regexEmptyCharacterClasses.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports character classes that match no characters.";
-    readonly id: "regexEmptyCharacterClasses";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "empty", undefined>;
-export default _default;

package/lib/rules/regexEmptyCharacterClasses.js

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

package/lib/rules/regexEmptyGroups.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports empty groups in regular expressions.";
-    readonly id: "regexEmptyGroups";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "emptyGroup", undefined>;
-export default _default;

package/lib/rules/regexEmptyGroups.js

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

package/lib/rules/regexEmptyLazyQuantifiers.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports lazy quantifiers at the end of regular expressions.";
-    readonly id: "regexEmptyLazyQuantifiers";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "uselessElement" | "uselessQuantifier" | "uselessRange", undefined>;
-export default _default;