@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/regexUnnecessaryCharacterRanges.js

@@ -1,108 +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/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

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

package/lib/rules/regexUnnecessaryDisjunctions.js

@@ -1,118 +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/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

@@ -1,10 +0,0 @@
-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: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "namedNotFound" | "numericNotFound", undefined>;
-export default _default;
-//# sourceMappingURL=regexUnnecessaryDollarReplacements.d.ts.map

package/lib/rules/regexUnnecessaryDollarReplacements.js

@@ -1,144 +0,0 @@
-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

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

package/lib/rules/regexUnnecessaryEscapes.js

@@ -1,136 +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/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

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

package/lib/rules/regexUnnecessaryLookaroundAssertions.js

@@ -1,80 +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/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

@@ -1,10 +0,0 @@
-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: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryNesting", undefined>;
-export default _default;
-//# sourceMappingURL=regexUnnecessaryNestedAssertions.d.ts.map