@flint.fyi/ts 0.15.0 → 0.18.0

package/lib/rules/regexUnicodeProperties.js

@@ -0,0 +1,133 @@
+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/regexUnicodeProperties.ts
+function isPropertyCharacterSetWithValue(characterSet) {
+	return characterSet.kind === "property" && !!characterSet.value;
+}
+const scriptShortToLong = {
+	Arab: "Arabic",
+	Armn: "Armenian",
+	Beng: "Bengali",
+	Cyrl: "Cyrillic",
+	Deva: "Devanagari",
+	Geor: "Georgian",
+	Grek: "Greek",
+	Gujr: "Gujarati",
+	Guru: "Gurmukhi",
+	Hang: "Hangul",
+	Hani: "Han",
+	Hebr: "Hebrew",
+	Hira: "Hiragana",
+	Kana: "Katakana",
+	Knda: "Kannada",
+	Latn: "Latin",
+	Mlym: "Malayalam",
+	Mymr: "Myanmar",
+	Orya: "Oriya",
+	Sinh: "Sinhala",
+	Taml: "Tamil",
+	Telu: "Telugu",
+	Thai: "Thai",
+	Tibt: "Tibetan",
+	Zinh: "Inherited",
+	Zyyy: "Common",
+	Zzzz: "Unknown"
+};
+function getExplicitKey(raw) {
+	const match = /^\\p\{([^=]+)=/i.exec(raw);
+	return match ? match[1] : null;
+}
+function hasCategoryKey(explicitKey) {
+	const lower = explicitKey.toLowerCase().replace(/_/g, "");
+	return lower === "gc" || lower === "generalcategory";
+}
+var regexUnicodeProperties_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports inconsistent Unicode property names in regular expressions.",
+		id: "regexUnicodeProperties",
+		presets: ["stylistic"]
+	},
+	messages: {
+		preferLongScript: {
+			primary: "Use long Script property name '{{ longName }}' instead of '{{ shortName }}'.",
+			secondary: ["Long Script names are more readable and explicit."],
+			suggestions: ["Replace '{{ shortName }}' with '{{ longName }}'."]
+		},
+		unnecessaryPrefix: {
+			primary: "The '{{ key }}=' prefix is unnecessary for this Unicode property.",
+			secondary: ["Unicode properties may be expressed in several different ways.", "Including the fully-written out category prefix is a more verbose way that is not necessary."],
+			suggestions: ["Replace '{{ original }}' with '{{ replacement }}'."]
+		}
+	},
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags, isStringPattern) {
+			if (!flags.includes("u") && !flags.includes("v")) return;
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			function reportOn(characterSet, data, replacement, message) {
+				const sourceEnd = isStringPattern ? characterSet.end + 1 : characterSet.end;
+				context.report({
+					data,
+					fix: {
+						range: {
+							begin: patternStart + characterSet.start,
+							end: patternStart + sourceEnd
+						},
+						text: isStringPattern ? replacement.replace(/\\/g, "\\\\") : replacement
+					},
+					message,
+					range: {
+						begin: patternStart + characterSet.start,
+						end: patternStart + characterSet.end
+					}
+				});
+			}
+			function reportOnCategoryKey(characterSet, explicitKey) {
+				const replacement = `${characterSet.negate ? "\\P{" : "\\p{"}${characterSet.value}}`;
+				reportOn(characterSet, {
+					key: explicitKey,
+					original: characterSet.raw,
+					replacement
+				}, replacement, "unnecessaryPrefix");
+			}
+			function reportOnScriptKey(characterSet, explicitKey) {
+				const longName = scriptShortToLong[characterSet.value];
+				if (!longName) return;
+				const replacement = `${characterSet.negate ? "\\P{" : "\\p{"}${explicitKey}=${longName}}`;
+				reportOn(characterSet, {
+					longName,
+					shortName: characterSet.value
+				}, replacement, "preferLongScript");
+			}
+			visitRegExpAST(regexpAst, { onCharacterSetEnter(characterSet) {
+				if (!isPropertyCharacterSetWithValue(characterSet)) return;
+				const explicitKey = getExplicitKey(characterSet.raw);
+				if (!explicitKey) return;
+				if (hasCategoryKey(explicitKey)) reportOnCategoryKey(characterSet, explicitKey);
+				else reportOnScriptKey(characterSet, explicitKey);
+			} });
+		}
+		function checkRegexLiteral(node, services) {
+			const details = getRegExpLiteralDetails(node, services);
+			checkPattern(details.pattern, details.start, details.flags, false);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			checkPattern(construction.raw, construction.start + 1, construction.flags, true);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnicodeProperties_default as default };
+
+//# sourceMappingURL=regexUnicodeProperties.js.map

package/lib/rules/regexUnnecessaryAssertions.d.ts

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

package/lib/rules/regexUnnecessaryAssertions.js

@@ -0,0 +1,223 @@
+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/regexUnnecessaryAssertions.ts
+function findUnnecessaryAssertions(pattern, doubleEscaped, flags) {
+	const findings = [];
+	const hasMultiline = flags.includes("m");
+	const wordBoundaryRegex = doubleEscaped ? /\\\\b/g : /\\b/g;
+	const negatedWordBoundaryRegex = doubleEscaped ? /\\\\B/g : /\\B/g;
+	let match;
+	while ((match = wordBoundaryRegex.exec(pattern)) !== null) {
+		const assertionStart = match.index;
+		const assertionEnd = match.index + match[0].length;
+		if (isInsideCharacterClass(pattern, assertionStart)) continue;
+		const characterBefore = getCharBeforeAssertion(pattern, assertionStart, doubleEscaped);
+		const characterAfter = getCharAfterAssertion(pattern, assertionEnd, doubleEscaped);
+		if (characterBefore === void 0 || characterAfter === void 0) continue;
+		const beforeIsWord = isWordCharacter(characterBefore);
+		const afterIsWord = isWordCharacter(characterAfter);
+		if (beforeIsWord === void 0 || afterIsWord === void 0) continue;
+		if (beforeIsWord === afterIsWord) findings.push({
+			assertionRaw: match[0],
+			end: assertionEnd,
+			start: assertionStart,
+			type: "wordBoundary",
+			wordType: beforeIsWord ? "word" : "non-word"
+		});
+	}
+	while ((match = negatedWordBoundaryRegex.exec(pattern)) !== null) {
+		const assertionStart = match.index;
+		const assertionEnd = match.index + match[0].length;
+		if (isInsideCharacterClass(pattern, assertionStart)) continue;
+		const characterBefore = getCharBeforeAssertion(pattern, assertionStart, doubleEscaped);
+		const characterAfter = getCharAfterAssertion(pattern, assertionEnd, doubleEscaped);
+		if (characterBefore === void 0 || characterAfter === void 0) continue;
+		const beforeIsWord = isWordCharacter(characterBefore);
+		const afterIsWord = isWordCharacter(characterAfter);
+		if (beforeIsWord === void 0 || afterIsWord === void 0) continue;
+		if (beforeIsWord !== afterIsWord) findings.push({
+			assertionRaw: match[0],
+			end: assertionEnd,
+			start: assertionStart,
+			type: "negatedWordBoundary"
+		});
+	}
+	if (!hasMultiline) {
+		const startAnchorRegex = doubleEscaped ? /(?<!\\)\^/g : /(?<!\\)\^/g;
+		const endAnchorRegex = doubleEscaped ? /(?<!\\)\$/g : /(?<!\\)\$/g;
+		while ((match = startAnchorRegex.exec(pattern)) !== null) {
+			const position = match.index;
+			if (isInsideCharacterClass(pattern, position)) continue;
+			if (doubleEscaped && position > 0 && pattern[position - 1] === "\\") continue;
+			if (position > 0) findings.push({
+				assertionRaw: "^",
+				end: position + 1,
+				start: position,
+				type: "startAnchor"
+			});
+		}
+		while ((match = endAnchorRegex.exec(pattern)) !== null) {
+			const position = match.index;
+			if (isInsideCharacterClass(pattern, position)) continue;
+			if (doubleEscaped && position > 0 && pattern[position - 1] === "\\") continue;
+			if (position < pattern.length - 1) findings.push({
+				assertionRaw: "$",
+				end: position + 1,
+				start: position,
+				type: "endAnchor"
+			});
+		}
+	}
+	return findings;
+}
+function getCharacterFromEscape(escape) {
+	switch (escape) {
+		case "\\\\d":
+		case "\\d": return "0";
+		case "\\\\D":
+		case "\\D": return " ";
+		case "\\\\s":
+		case "\\s": return " ";
+		case "\\\\S":
+		case "\\S": return "a";
+		case "\\\\w":
+		case "\\w": return "a";
+		case "\\\\W":
+		case "\\W": return " ";
+		default: return;
+	}
+}
+function getCharAfterAssertion(pattern, assertionEnd, doubleEscaped) {
+	if (assertionEnd >= pattern.length) return;
+	const remaining = pattern.slice(assertionEnd);
+	if (doubleEscaped && remaining.startsWith("\\\\")) {
+		const charResult = getCharacterFromEscape(remaining.slice(0, 3));
+		if (charResult) return charResult;
+		if (remaining.length >= 3 && remaining[2]) return remaining[2];
+		return;
+	}
+	if (!doubleEscaped && remaining.startsWith("\\")) {
+		const twoCharEscape = remaining.slice(0, 2);
+		const charResult = getCharacterFromEscape(twoCharEscape);
+		if (charResult) return charResult;
+		if (twoCharEscape === "\\b" || twoCharEscape === "\\B" || remaining.length < 1 || !remaining[1]) return;
+		return remaining[1];
+	}
+	return remaining[0];
+}
+function getCharBeforeAssertion(pattern, assertionStart, doubleEscaped) {
+	if (assertionStart <= 0) return;
+	if (doubleEscaped) {
+		if (assertionStart >= 3 && pattern[assertionStart - 3] === "\\") {
+			const charResult = getCharacterFromEscape(pattern.slice(assertionStart - 3, assertionStart));
+			if (charResult) return charResult;
+			return pattern[assertionStart - 1];
+		}
+		return pattern[assertionStart - 1];
+	}
+	if (assertionStart >= 2 && pattern[assertionStart - 2] === "\\") {
+		const charResult = getCharacterFromEscape(pattern.slice(assertionStart - 2, assertionStart));
+		if (charResult) return charResult;
+		return pattern[assertionStart - 1];
+	}
+	return pattern[assertionStart - 1];
+}
+function isInsideCharacterClass(pattern, position) {
+	let inClass = false;
+	let escaped = false;
+	for (let index = 0; index < position; index++) {
+		const char = pattern[index];
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (char === "[" && !inClass) {
+			inClass = true;
+			continue;
+		}
+		if (char === "]" && inClass) inClass = false;
+	}
+	return inClass;
+}
+function isWordCharacter(character) {
+	return character ? /^\w$/.test(character) : void 0;
+}
+var regexUnnecessaryAssertions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports assertions in regular expressions that always reject.",
+		id: "regexUnnecessaryAssertions",
+		presets: ["logical"]
+	},
+	messages: {
+		endAnchor: {
+			primary: "The end anchor `$` always rejects because it is not at the end of the pattern.",
+			secondary: ["Without the `m` (multiline) flag, `$` can only match at the very end of the input string.", "Characters after `$` mean the pattern can never match."],
+			suggestions: [
+				"Remove the `$` anchor.",
+				"Move the `$` to the end of the pattern.",
+				"Add the `m` flag if you want `$` to match at line endings."
+			]
+		},
+		negatedWordBoundary: {
+			primary: "The negated word boundary `\\B` always rejects because there is a word/non-word transition.",
+			secondary: ["`\\B` asserts that the position is NOT at a word boundary.", "However, the surrounding characters already create a word/non-word transition, which is a word boundary."],
+			suggestions: ["Remove the `\\B` assertion.", "Use `\\b` if you intended to match a word boundary."]
+		},
+		startAnchor: {
+			primary: "The start anchor `^` always rejects because it is not at the start of the pattern.",
+			secondary: ["Without the `m` (multiline) flag, `^` can only match at the very beginning of the input string.", "Characters before `^` mean the pattern can never match."],
+			suggestions: [
+				"Remove the `^` anchor.",
+				"Move the `^` to the start of the pattern.",
+				"Add the `m` flag if you want `^` to match at line beginnings."
+			]
+		},
+		wordBoundary: {
+			primary: "The word boundary `\\b` always rejects because both sides are {{ type }} characters.",
+			secondary: ["`\\b` asserts that the position is at a word boundary (between a word and non-word character).", "Since both adjacent characters are {{ type }} characters, there is no boundary here."],
+			suggestions: ["Remove the `\\b` assertion.", "Use `\\B` if you intended to match inside a word."]
+		}
+	},
+	setup(context) {
+		function checkRegexLiteral(node, services) {
+			const { flags, pattern, start } = getRegExpLiteralDetails(node, services);
+			const findings = findUnnecessaryAssertions(pattern, false, flags);
+			for (const finding of findings) context.report({
+				data: { type: finding.wordType ?? "" },
+				message: finding.type,
+				range: {
+					begin: start + finding.start,
+					end: start + finding.end
+				}
+			});
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			const findings = findUnnecessaryAssertions(construction.pattern, true, construction.flags);
+			for (const finding of findings) context.report({
+				data: { type: finding.wordType ?? "" },
+				message: finding.type,
+				range: {
+					begin: construction.start + 1 + finding.start,
+					end: construction.start + 1 + finding.end
+				}
+			});
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnnecessaryAssertions_default as default };
+
+//# sourceMappingURL=regexUnnecessaryAssertions.js.map

package/lib/rules/regexUnnecessaryBackreferences.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports backreferences in regular expressions that will always match empty or fail.";
+    readonly id: "regexUnnecessaryBackreferences";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "nested" | "disjunctive" | "intoNegativeLookaround" | "forward" | "backward", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexUnnecessaryBackreferences.d.ts.map

package/lib/rules/regexUnnecessaryBackreferences.js

@@ -0,0 +1,125 @@
+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/regexUnnecessaryBackreferences.ts
+function getPathToRoot(node) {
+	const path = [];
+	for (let current = node; current; current = current.parent) path.push(current);
+	return path;
+}
+function getUselessProblem(backreference, group) {
+	const backrefPath = getPathToRoot(backreference);
+	if (backrefPath.includes(group)) return "nested";
+	const groupPath = getPathToRoot(group);
+	const backrefPathSet = new Set(backrefPath);
+	let commonAncestor;
+	let groupCut = [];
+	for (let i = 0; i < groupPath.length; i++) {
+		const node = groupPath[i];
+		if (node && backrefPathSet.has(node)) {
+			commonAncestor = node;
+			groupCut = groupPath.slice(0, i);
+			break;
+		}
+	}
+	if (commonAncestor) {
+		const backrefCut = backrefPath.slice(0, backrefPath.indexOf(commonAncestor));
+		if (backrefCut.length && !!groupCut.length) {
+			const backrefChild = backrefCut.at(-1);
+			const groupChild = groupCut.at(-1);
+			if (backrefChild.type === "Alternative" && groupChild.type === "Alternative" && backrefChild !== groupChild) return "disjunctive";
+		}
+	}
+	if (groupCut.some(isNegativeLookaround)) return "intoNegativeLookaround";
+	if ((backrefPath.some(isLookbehind) ? "rtl" : "ltr") === "ltr") {
+		if (backreference.end <= group.start) return "forward";
+	} else if (group.end <= backreference.start) return "backward";
+}
+function isLookbehind(node) {
+	return node.type === "Assertion" && node.kind === "lookbehind";
+}
+function isNegativeLookaround(node) {
+	return node.type === "Assertion" && (node.kind === "lookahead" || node.kind === "lookbehind") && node.negate;
+}
+var regexUnnecessaryBackreferences_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports backreferences in regular expressions that will always match empty or fail.",
+		id: "regexUnnecessaryBackreferences",
+		presets: ["logical"]
+	},
+	messages: {
+		backward: {
+			primary: "Backreference '{{ backreference }}' will be ignored because it appears after the group '{{ group }}' in a lookbehind.",
+			secondary: ["In lookbehind assertions, matching proceeds right-to-left, so this backreference is evaluated before the group."],
+			suggestions: ["Remove the ignored backreference.", "Modify the backreference and/or group to not conflict with each other."]
+		},
+		disjunctive: {
+			primary: "Backreference '{{ backreference }}' will be ignored because it and the group '{{ group }}' are in different alternatives.",
+			secondary: ["When this backreference is evaluated, the referenced group has not participated in the match."],
+			suggestions: ["Remove the ignored backreference.", "Modify the backreference and/or group to not conflict with each other."]
+		},
+		forward: {
+			primary: "Backreference '{{ backreference }}' will be ignored because it appears before the group '{{ group }}' is defined.",
+			secondary: ["A forward reference to a group that hasn't been matched yet will always match empty."],
+			suggestions: ["Remove the ignored backreference.", "Modify the backreference and/or group to not conflict with each other."]
+		},
+		intoNegativeLookaround: {
+			primary: "Backreference '{{ backreference }}' will be ignored because the group '{{ group }}' is in a negative lookaround.",
+			secondary: ["When a negative lookaround succeeds, the groups inside it have not matched anything."],
+			suggestions: ["Remove the ignored backreference.", "Modify the backreference and/or group to not conflict with each other."]
+		},
+		nested: {
+			primary: "Backreference '{{ backreference }}' will be ignored because it is inside the group it references.",
+			secondary: ["A backreference inside its own group will always match empty since the group hasn't finished capturing yet."],
+			suggestions: ["Remove the ignored backreference.", "Modify the backreference and/or group to not conflict with each other."]
+		}
+	},
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onBackreferenceEnter(backreference) {
+				const resolved = backreference.resolved;
+				const groups = Array.isArray(resolved) ? resolved : [resolved];
+				for (const group of groups) {
+					const problem = getUselessProblem(backreference, group);
+					if (problem) {
+						context.report({
+							data: {
+								backreference: backreference.raw,
+								group: group.raw
+							},
+							message: problem,
+							range: {
+								begin: patternStart + backreference.start,
+								end: patternStart + backreference.end
+							}
+						});
+						break;
+					}
+				}
+			} });
+		}
+		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.raw, construction.start + 1, construction.flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnnecessaryBackreferences_default as default };
+
+//# sourceMappingURL=regexUnnecessaryBackreferences.js.map

package/lib/rules/regexUnnecessaryCharacterClasses.d.ts

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

package/lib/rules/regexUnnecessaryCharacterClasses.js

@@ -0,0 +1,74 @@
+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/regexUnnecessaryCharacterClasses.ts
+function canUnwrapSingleElement(characterClass) {
+	if (characterClass.negate || characterClass.elements.length !== 1) return false;
+	const element = characterClass.elements[0];
+	switch (element.type) {
+		case "Character": return element.raw !== "=" && element.raw !== "\\b" && !/^\\[1-9]\d*$/.test(element.raw);
+		case "CharacterClassRange": return false;
+		default: return true;
+	}
+}
+function findUnnecessaryCharacterClasses(pattern, flags) {
+	const results = [];
+	let ast;
+	try {
+		ast = parseRegExpLiteral(new RegExp(pattern, flags));
+	} catch {
+		return results;
+	}
+	visitRegExpAST(ast, { onCharacterClassEnter(node) {
+		if (canUnwrapSingleElement(node)) results.push(node);
+	} });
+	return results;
+}
+var regexUnnecessaryCharacterClasses_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports character classes that wrap a single element that does not require brackets.",
+		id: "regexUnnecessaryCharacterClasses",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { unnecessary: {
+		primary: "This character class wraps a single element that does not require brackets.",
+		secondary: ["Brackets are used to encapsulate multiple classes of characters.", "Single-element character classes can be simplified by removing the brackets."],
+		suggestions: ["Remove the surrounding brackets from this character class."]
+	} },
+	setup(context) {
+		function checkRegexLiteral(node, services) {
+			const { flags, pattern, start } = getRegExpLiteralDetails(node, services);
+			const unnecessaryClasses = findUnnecessaryCharacterClasses(pattern, flags);
+			for (const characterClass of unnecessaryClasses) context.report({
+				message: "unnecessary",
+				range: {
+					begin: start + characterClass.start - 1,
+					end: start + characterClass.end - 1
+				}
+			});
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			const unnecessaryClasses = findUnnecessaryCharacterClasses(construction.pattern.replace(/\\\\/g, "\\"), construction.flags);
+			for (const characterClass of unnecessaryClasses) context.report({
+				message: "unnecessary",
+				range: {
+					begin: construction.start + characterClass.start,
+					end: construction.start + characterClass.end
+				}
+			});
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnnecessaryCharacterClasses_default as default };
+
+//# sourceMappingURL=regexUnnecessaryCharacterClasses.js.map

package/lib/rules/regexUnnecessaryCharacterRanges.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports character class ranges that span only one or two characters.";
+    readonly id: "regexUnnecessaryCharacterRanges";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "adjacent" | "identity", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexUnnecessaryCharacterRanges.d.ts.map