@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/regexUnnecessaryCharacterRanges.js

@@ -0,0 +1,108 @@
+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/regexUnnecessaryCharacterRanges.ts
+function findUnnecessaryRanges(pattern, flags) {
+	const results = [];
+	let ast;
+	try {
+		ast = parseRegExpLiteral(new RegExp(pattern, flags));
+	} catch {
+		return results;
+	}
+	visitRegExpAST(ast, { onCharacterClassRangeEnter(node) {
+		const rangeType = getUnnecessaryRangeType(node);
+		if (rangeType) results.push({
+			node,
+			type: rangeType
+		});
+	} });
+	return results;
+}
+function getRangeReplacement(range) {
+	if (range.type === "identity") return range.node.min.raw;
+	return range.node.min.raw + range.node.max.raw;
+}
+function getUnnecessaryRangeType(node) {
+	const min = node.min.value;
+	const max = node.max.value;
+	if (min === max) return "identity";
+	if (min + 1 === max) return "adjacent";
+}
+var regexUnnecessaryCharacterRanges_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports character class ranges that span only one or two characters.",
+		id: "regexUnnecessaryCharacterRanges",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		adjacent: {
+			primary: "This two-character range can be simplified to omit the hyphen.",
+			secondary: ["A range like `[a-b]` can be written as `[ab]` without the hyphen."],
+			suggestions: ["Replace the range with the two characters directly."]
+		},
+		identity: {
+			primary: "This single-character range can be simplified to just the character.",
+			secondary: ["A range like `[a-a]` can be simplified to just `[a]`."],
+			suggestions: ["Remove the hyphen and duplicate character."]
+		}
+	},
+	setup(context) {
+		function checkRegexLiteral(node, services) {
+			const { flags, pattern, start } = getRegExpLiteralDetails(node, services);
+			const unnecessaryRanges = findUnnecessaryRanges(pattern, flags);
+			for (const range of unnecessaryRanges) {
+				const beginPos = start + range.node.start - 1;
+				const endPos = start + range.node.end - 1;
+				context.report({
+					fix: {
+						range: {
+							begin: beginPos,
+							end: endPos
+						},
+						text: getRangeReplacement(range)
+					},
+					message: range.type,
+					range: {
+						begin: beginPos,
+						end: endPos
+					}
+				});
+			}
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			const unnecessaryRanges = findUnnecessaryRanges(construction.pattern.replace(/\\\\/g, "\\"), construction.flags);
+			for (const range of unnecessaryRanges) {
+				const beginPos = construction.start + range.node.start;
+				const endPos = construction.start + range.node.end;
+				context.report({
+					fix: {
+						range: {
+							begin: beginPos,
+							end: endPos
+						},
+						text: getRangeReplacement(range)
+					},
+					message: range.type,
+					range: {
+						begin: beginPos,
+						end: endPos
+					}
+				});
+			}
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnnecessaryCharacterRanges_default as default };
+
+//# sourceMappingURL=regexUnnecessaryCharacterRanges.js.map

package/lib/rules/regexUnnecessaryDisjunctions.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports single-character alternatives in string disjunctions.";
+    readonly id: "regexUnnecessaryDisjunctions";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessary", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexUnnecessaryDisjunctions.d.ts.map

package/lib/rules/regexUnnecessaryDisjunctions.js

@@ -0,0 +1,118 @@
+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/regexUnnecessaryDisjunctions.ts
+function computeFixedPattern(pattern, infos) {
+	const disjunctionMap = /* @__PURE__ */ new Map();
+	for (const info of infos) {
+		const existing = disjunctionMap.get(info.disjunction);
+		if (existing) existing.push(info.alternative);
+		else disjunctionMap.set(info.disjunction, [info.alternative]);
+	}
+	const replacements = [];
+	for (const [disjunction, singleCharAlts] of disjunctionMap) {
+		const singleCharSet = new Set(singleCharAlts);
+		const remainingAlts = disjunction.alternatives.filter((alt) => !singleCharSet.has(alt));
+		const extractedChars = singleCharAlts.map((alt) => alt.raw);
+		let replacement;
+		if (!remainingAlts.length) replacement = extractedChars.join("");
+		else {
+			const remainingDisjunction = `\\q{${remainingAlts.map((alt) => alt.raw).join("|")}}`;
+			replacement = extractedChars.join("") + remainingDisjunction;
+		}
+		replacements.push({
+			end: disjunction.end - 1,
+			start: disjunction.start - 1,
+			text: replacement
+		});
+	}
+	replacements.sort((a, b) => b.start - a.start);
+	let result = pattern;
+	for (const rep of replacements) result = result.slice(0, rep.start) + rep.text + result.slice(rep.end);
+	return result;
+}
+function findUnnecessaryStringAlternatives(pattern, flags) {
+	const results = [];
+	if (!flags.includes("v")) return results;
+	let ast;
+	try {
+		ast = parseRegExpLiteral(new RegExp(pattern, flags));
+	} catch {
+		return results;
+	}
+	visitRegExpAST(ast, { onStringAlternativeEnter(node) {
+		if (node.elements.length === 1) results.push({
+			alternative: node,
+			disjunction: node.parent
+		});
+	} });
+	return results;
+}
+var regexUnnecessaryDisjunctions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports single-character alternatives in string disjunctions.",
+		id: "regexUnnecessaryDisjunctions",
+		presets: ["logical"]
+	},
+	messages: { unnecessary: {
+		primary: "This single-character disjunction alternative can be inlined into the surrounding character class.",
+		secondary: ["Single-character alternatives in `\\q{...}` are equivalent to using the character directly.", "Their parent character class can be simplified by replacing the alternative with the character."],
+		suggestions: ["Extract the character from the `\\q{...}` into the surrounding character class."]
+	} },
+	setup(context) {
+		function checkRegexLiteral(node, services) {
+			const { flags, pattern, start } = getRegExpLiteralDetails(node, services);
+			const unnecessaryAlternatives = findUnnecessaryStringAlternatives(pattern, flags);
+			if (!unnecessaryAlternatives.length) return;
+			const fixedPattern = computeFixedPattern(pattern, unnecessaryAlternatives);
+			const nodeRange = {
+				begin: start - 1,
+				end: start + pattern.length + flags.length + 1
+			};
+			for (const info of unnecessaryAlternatives) context.report({
+				fix: {
+					range: nodeRange,
+					text: `/${fixedPattern}/${flags}`
+				},
+				message: "unnecessary",
+				range: {
+					begin: start + info.alternative.start - 1,
+					end: start + info.alternative.end - 1
+				}
+			});
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			const patternEscaped = construction.pattern.replace(/\\\\/g, "\\");
+			const unnecessaryAlternatives = findUnnecessaryStringAlternatives(patternEscaped, construction.flags);
+			if (!unnecessaryAlternatives.length) return;
+			const fixedPatternEscaped = computeFixedPattern(patternEscaped, unnecessaryAlternatives).replace(/\\/g, "\\\\");
+			for (const info of unnecessaryAlternatives) context.report({
+				fix: {
+					range: {
+						begin: construction.start + 1,
+						end: construction.start + 1 + construction.pattern.length
+					},
+					text: fixedPatternEscaped
+				},
+				message: "unnecessary",
+				range: {
+					begin: construction.start + info.alternative.start,
+					end: construction.start + info.alternative.end
+				}
+			});
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnnecessaryDisjunctions_default as default };
+
+//# sourceMappingURL=regexUnnecessaryDisjunctions.js.map

package/lib/rules/regexUnnecessaryDollarReplacements.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports replacement string references to capturing groups that do not exist in the pattern.";
+    readonly id: "regexUnnecessaryDollarReplacements";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "namedNotFound" | "numericNotFound", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexUnnecessaryDollarReplacements.d.ts.map

package/lib/rules/regexUnnecessaryDollarReplacements.js

@@ -0,0 +1,144 @@
+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/regexUnnecessaryDollarReplacements.ts
+function getGroupInfo(regexpAst) {
+	let count = 0;
+	const names = /* @__PURE__ */ new Set();
+	visitRegExpAST(regexpAst, { onCapturingGroupEnter(group) {
+		count++;
+		if (group.name) names.add(group.name);
+	} });
+	return {
+		count,
+		names
+	};
+}
+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 parseReplacementTokens(text) {
+	const tokens = [];
+	for (let i = 0; i < text.length; i++) {
+		if (text[i] !== "$") continue;
+		const next = text[i + 1];
+		if (!next) continue;
+		if (next === "$" || next === "&" || next === "`" || next === "'") {
+			i++;
+			continue;
+		}
+		if (next === "<") {
+			const close = text.indexOf(">", i + 2);
+			if (close === -1) continue;
+			const name = text.slice(i + 2, close);
+			tokens.push({
+				end: close + 1,
+				kind: "named",
+				raw: text.slice(i, close + 1),
+				reference: name,
+				start: i
+			});
+			i = close;
+			continue;
+		}
+		if (next >= "1" && next <= "9") {
+			const secondDigit = text[i + 2];
+			if (secondDigit && secondDigit >= "0" && secondDigit <= "9") {
+				tokens.push({
+					end: i + 3,
+					kind: "numeric",
+					raw: text.slice(i, i + 3),
+					reference: parseInt(next + secondDigit, 10),
+					start: i
+				});
+				i += 2;
+			} else {
+				tokens.push({
+					end: i + 2,
+					kind: "numeric",
+					raw: text.slice(i, i + 2),
+					reference: parseInt(next, 10),
+					start: i
+				});
+				i++;
+			}
+		}
+	}
+	return tokens;
+}
+var regexUnnecessaryDollarReplacements_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports replacement string references to capturing groups that do not exist in the pattern.",
+		id: "regexUnnecessaryDollarReplacements",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		namedNotFound: {
+			primary: "This replacement `{{ found }}` refers to a named capturing group that does not exist.",
+			secondary: ["There is no capturing group named `{{ reference }}` in the pattern."],
+			suggestions: ["Correct the capturing group name.", "Escape the dollar sign with `$$`."]
+		},
+		numericNotFound: {
+			primary: "This replacement `{{ found }}` refers to a capturing group that does not exist.",
+			secondary: ["The pattern only has {{ count }} capturing group(s), but `{{ found }}` references group {{ reference }}."],
+			suggestions: ["Correct the capturing group index.", "Escape the dollar sign with `$$`."]
+		}
+	},
+	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)) return;
+			const regexInfo = getRegexPatternAndFlags(regexArgument);
+			if (!regexInfo) return;
+			const regexpAst = parseRegexpAst(regexInfo.pattern, regexInfo.flags);
+			if (!regexpAst) return;
+			const groupInfo = getGroupInfo(regexpAst);
+			const tokens = parseReplacementTokens(replacementArgument.text);
+			const replacementRange = getTSNodeRange(replacementArgument, sourceFile);
+			for (const token of tokens) if (token.kind === "numeric") {
+				const reference = token.reference;
+				if (reference > groupInfo.count) context.report({
+					data: {
+						count: groupInfo.count,
+						found: token.raw,
+						reference
+					},
+					message: "numericNotFound",
+					range: {
+						begin: replacementRange.begin + 1 + token.start,
+						end: replacementRange.begin + 1 + token.end
+					}
+				});
+			} else {
+				const reference = token.reference;
+				if (!groupInfo.names.has(reference)) context.report({
+					data: {
+						found: token.raw,
+						reference
+					},
+					message: "namedNotFound",
+					range: {
+						begin: replacementRange.begin + 1 + token.start,
+						end: replacementRange.begin + 1 + token.end
+					}
+				});
+			}
+		} } };
+	}
+});
+//#endregion
+export { regexUnnecessaryDollarReplacements_default as default };
+
+//# sourceMappingURL=regexUnnecessaryDollarReplacements.js.map

package/lib/rules/regexUnnecessaryEscapes.d.ts

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

package/lib/rules/regexUnnecessaryEscapes.js

@@ -0,0 +1,136 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { parseRegExpLiteral, visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexUnnecessaryEscapes.ts
+const allowedRoots = new Set([
+	"$",
+	"(",
+	")",
+	"*",
+	"+",
+	".",
+	"/",
+	"?",
+	"[",
+	"\\",
+	"]",
+	"^",
+	"{",
+	"|",
+	"}"
+]);
+const allowedClasses = new Set(["\\", "]"]);
+function adjustPositionForEscapes(escaped, unescapedPosition) {
+	let escapedIndex = 0;
+	let unescapedIndex = 0;
+	while (unescapedIndex < unescapedPosition && escapedIndex < escaped.length) {
+		if (escaped[escapedIndex] === "\\" && escaped[escapedIndex + 1] === "\\") escapedIndex += 2;
+		else escapedIndex += 1;
+		unescapedIndex += 1;
+	}
+	return escapedIndex;
+}
+function findUnnecessaryEscapes(pattern, flags) {
+	const findings = [];
+	let ast;
+	try {
+		ast = parseRegExpLiteral(new RegExp(pattern, flags));
+	} catch {
+		return findings;
+	}
+	let currentClass;
+	visitRegExpAST(ast, {
+		onCharacterClassEnter(classNode) {
+			currentClass = classNode;
+		},
+		onCharacterClassLeave() {
+			currentClass = void 0;
+		},
+		onCharacterEnter(charNode) {
+			if (!charNode.raw.startsWith("\\")) return;
+			const literal = String.fromCodePoint(charNode.value);
+			if (charNode.raw.slice(1) !== literal) return;
+			if (!currentClass) {
+				if (!allowedRoots.has(literal)) findings.push({
+					character: literal,
+					end: charNode.end,
+					start: charNode.start
+				});
+				return;
+			}
+			if (allowedClasses.has(literal)) return;
+			if (literal === "^") {
+				if (currentClass.negate || charNode.start !== currentClass.start + 1) findings.push({
+					character: literal,
+					end: charNode.end,
+					start: charNode.start
+				});
+				return;
+			}
+			if (literal === "-") {
+				if (charNode.start === currentClass.elements[0].start || charNode.start === currentClass.elements.at(-1).start) findings.push({
+					character: literal,
+					end: charNode.end,
+					start: charNode.start
+				});
+				return;
+			}
+			findings.push({
+				character: literal,
+				end: charNode.end,
+				start: charNode.start
+			});
+		}
+	});
+	return findings;
+}
+var regexUnnecessaryEscapes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports unnecessary escape sequences in regular expressions.",
+		id: "regexUnnecessaryEscapes",
+		presets: ["stylistic"]
+	},
+	messages: { unnecessary: {
+		primary: "This escape sequence `\\{{ character }}` is unnecessary.",
+		secondary: ["The character `{{ character }}` does not require escaping in this context.", "Removing the escaping backslash will not change the regular expression."],
+		suggestions: ["Remove the backslash to simplify the pattern."]
+	} },
+	setup(context) {
+		function checkPattern(flags, pattern, start) {
+			const findings = findUnnecessaryEscapes(pattern, flags);
+			for (const finding of findings) {
+				const adjustedStart = adjustPositionForEscapes(pattern, finding.start - 1);
+				const adjustedEnd = adjustPositionForEscapes(pattern, finding.end - 1);
+				context.report({
+					data: { character: finding.character },
+					message: "unnecessary",
+					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 { regexUnnecessaryEscapes_default as default };
+
+//# sourceMappingURL=regexUnnecessaryEscapes.js.map

package/lib/rules/regexUnnecessaryLookaroundAssertions.d.ts

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

package/lib/rules/regexUnnecessaryLookaroundAssertions.js

@@ -0,0 +1,80 @@
+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/regexUnnecessaryLookaroundAssertions.ts
+var regexUnnecessaryLookaroundAssertions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports unnecessary nested lookaround assertions in regular expressions.",
+		id: "regexUnnecessaryLookaroundAssertions",
+		presets: ["logical"]
+	},
+	messages: {
+		lookahead: {
+			primary: "This lookahead assertion is unnecessary because it is at the end of another lookahead.",
+			secondary: [],
+			suggestions: ["Inline the nested pattern into the parent assertion."]
+		},
+		lookbehind: {
+			primary: "This lookbehind assertion is unnecessary because it is at the start of another lookbehind.",
+			secondary: [],
+			suggestions: ["Inline the nested pattern into the parent assertion."]
+		}
+	},
+	setup(context) {
+		function reportElement(element, kind, patternStart) {
+			if (element.type === "Assertion" && element.kind === kind && !element.negate) {
+				const innerContent = element.raw.slice(kind === "lookahead" ? 3 : 4, -1);
+				context.report({
+					fix: {
+						range: {
+							begin: patternStart + element.start,
+							end: patternStart + element.end
+						},
+						text: innerContent
+					},
+					message: kind,
+					range: {
+						begin: patternStart + element.start,
+						end: patternStart + element.end
+					}
+				});
+			}
+		}
+		function checkPattern(pattern, patternStart, flagsText) {
+			const regexpAst = parseRegexpAst(pattern, flagsText);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onAssertionEnter(assertion) {
+				if (assertion.kind !== "lookahead" && assertion.kind !== "lookbehind") return;
+				for (const alternative of assertion.alternatives) {
+					if (!alternative.elements.length) continue;
+					if (assertion.kind === "lookahead") reportElement(alternative.elements.at(-1), "lookahead", patternStart);
+					else {
+						const firstElement = alternative.elements[0];
+						reportElement(firstElement, "lookbehind", patternStart);
+					}
+				}
+			} });
+		}
+		function checkRegexLiteral(node, services) {
+			const { flags, pattern, start } = getRegExpLiteralDetails(node, services);
+			checkPattern(pattern, start, flags);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			checkPattern(construction.pattern.replace(/\\\\/g, "\\"), construction.start + 1, construction.flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnnecessaryLookaroundAssertions_default as default };
+
+//# sourceMappingURL=regexUnnecessaryLookaroundAssertions.js.map

package/lib/rules/regexUnnecessaryNestedAssertions.d.ts

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