@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/regexUnicodeProperties.js

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

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

package/lib/rules/regexUnnecessaryAssertions.js

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

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

package/lib/rules/regexUnnecessaryBackreferences.js

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

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

package/lib/rules/regexUnnecessaryCharacterClasses.js

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

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