@flint.fyi/ts 0.21.0 → 0.22.0

package/lib/rules/redundantTypeConstituents.js

@@ -1,275 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/redundantTypeConstituents.ts
-const literalToPrimitiveTypeFlags = {
-	[ts.TypeFlags.BigIntLiteral]: ts.TypeFlags.BigInt,
-	[ts.TypeFlags.BooleanLiteral]: ts.TypeFlags.Boolean,
-	[ts.TypeFlags.NumberLiteral]: ts.TypeFlags.Number,
-	[ts.TypeFlags.StringLiteral]: ts.TypeFlags.String,
-	[ts.TypeFlags.TemplateLiteral]: ts.TypeFlags.String
-};
-const literalTypeFlags = [
-	ts.TypeFlags.BigIntLiteral,
-	ts.TypeFlags.BooleanLiteral,
-	ts.TypeFlags.NumberLiteral,
-	ts.TypeFlags.StringLiteral,
-	ts.TypeFlags.TemplateLiteral
-];
-const primitiveTypeFlags = [
-	ts.TypeFlags.BigInt,
-	ts.TypeFlags.Boolean,
-	ts.TypeFlags.Number,
-	ts.TypeFlags.String
-];
-const primitiveTypeFlagNames = {
-	[ts.TypeFlags.BigInt]: "bigint",
-	[ts.TypeFlags.Boolean]: "boolean",
-	[ts.TypeFlags.Number]: "number",
-	[ts.TypeFlags.String]: "string"
-};
-function describeLiteralType(type) {
-	if (type.isStringLiteral()) return JSON.stringify(type.value);
-	if (tsutils.isBigIntLiteralType(type)) return `${type.value.negative ? "-" : ""}${type.value.base10Value}n`;
-	if (type.isLiteral()) return String(type.value);
-	if (tsutils.isIntrinsicErrorType(type) && type.aliasSymbol) return String(type.aliasSymbol.escapedName);
-	if (type.flags & ts.TypeFlags.Any) return "any";
-	if (type.flags & ts.TypeFlags.Never) return "never";
-	if (type.flags & ts.TypeFlags.Unknown) return "unknown";
-	if (tsutils.isTemplateLiteralType(type)) return "template literal type";
-	if (tsutils.isTrueLiteralType(type)) return "true";
-	if (tsutils.isFalseLiteralType(type)) return "false";
-	return "literal type";
-}
-function isDescendantOf(node, potentialAncestor) {
-	let current = node;
-	while (current) {
-		if (current === potentialAncestor) return true;
-		current = current.parent;
-	}
-	return false;
-}
-function isNodeInsideReturnType(node) {
-	let current = node.parent;
-	while (current) {
-		if (current.kind === ts.SyntaxKind.FunctionDeclaration || current.kind === ts.SyntaxKind.FunctionExpression || current.kind === ts.SyntaxKind.ArrowFunction || current.kind === ts.SyntaxKind.MethodDeclaration || current.kind === ts.SyntaxKind.MethodSignature || current.kind === ts.SyntaxKind.FunctionType || current.kind === ts.SyntaxKind.CallSignature || current.kind === ts.SyntaxKind.ConstructSignature || current.kind === ts.SyntaxKind.ConstructorType) return !!current.type && isDescendantOf(node, current.type);
-		current = current.parent;
-	}
-	return false;
-}
-function unionTypePartsUnlessBoolean(type) {
-	if (type.isUnion() && type.types.length === 2 && type.types[0] && type.types[1] && tsutils.isFalseLiteralType(type.types[0]) && tsutils.isTrueLiteralType(type.types[1])) return [type];
-	return tsutils.unionConstituents(type);
-}
-var redundantTypeConstituents_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports union and intersection type constituents that are redundant or override other types.",
-		id: "redundantTypeConstituents",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: {
-		errorTypeOverrides: {
-			primary: "{{ typeName }} is an 'error' type that acts as 'any' and overrides all other types in this {{ container }} type.",
-			secondary: ["Error types that resolve to 'any' make the entire union or intersection effectively 'any'.", "This typically indicates a type reference that TypeScript couldn't resolve."],
-			suggestions: ["Remove the redundant type constituent."]
-		},
-		literalOverridden: {
-			primary: "{{ literal }} is overridden by {{ primitive }} in this union type.",
-			secondary: ["When a primitive type like 'string' is in a union with a string literal, the literal is redundant.", "The primitive type already includes all possible literal values."],
-			suggestions: ["Remove the literal type."]
-		},
-		overridden: {
-			primary: "{{ typeName }} is overridden by other types in this {{ container }} type.",
-			secondary: ["This type constituent has no effect because it is subsumed by other types in the {{ container }}.", "Consider removing it to simplify the type."],
-			suggestions: ["Remove the redundant type."]
-		},
-		overrides: {
-			primary: "{{ typeName }} overrides all other types in this {{ container }} type.",
-			secondary: ["This type makes all other constituents in the {{ container }} redundant.", "Consider simplifying to just this type."],
-			suggestions: ["Simplify to just this type."]
-		},
-		primitiveOverridden: {
-			primary: "{{ primitive }} is overridden by {{ literal }} in this intersection type.",
-			secondary: ["When a primitive type intersects with its literal type, the result is the literal type.", "The primitive type is redundant in this intersection."],
-			suggestions: ["Remove the primitive type."]
-		}
-	},
-	setup(context) {
-		return { visitors: {
-			IntersectionType: (node, { sourceFile, typeChecker }) => {
-				const seenLiteralTypes = /* @__PURE__ */ new Map();
-				const seenPrimitiveTypes = /* @__PURE__ */ new Map();
-				const seenUnionTypes = /* @__PURE__ */ new Map();
-				for (const typeNode of node.types) {
-					const typeParts = unionTypePartsUnlessBoolean(typeChecker.getTypeAtLocation(typeNode));
-					for (const typePart of typeParts) {
-						const typeName = describeLiteralType(typePart);
-						if (typePart.flags === ts.TypeFlags.Any) {
-							context.report({
-								data: {
-									container: "intersection",
-									typeName
-								},
-								message: typeName !== "any" ? "errorTypeOverrides" : "overrides",
-								range: getTSNodeRange(typeNode, sourceFile)
-							});
-							continue;
-						}
-						if (typePart.flags === ts.TypeFlags.Never) {
-							context.report({
-								data: {
-									container: "intersection",
-									typeName
-								},
-								message: "overrides",
-								range: getTSNodeRange(typeNode, sourceFile)
-							});
-							continue;
-						}
-						if (typePart.flags === ts.TypeFlags.Unknown) {
-							context.report({
-								data: {
-									container: "intersection",
-									typeName
-								},
-								message: "overridden",
-								range: getTSNodeRange(typeNode, sourceFile)
-							});
-							continue;
-						}
-						for (const literalTypeFlag of literalTypeFlags) if (typePart.flags === literalTypeFlag) {
-							const primitiveFlag = literalToPrimitiveTypeFlags[literalTypeFlag];
-							if (primitiveFlag) {
-								const existing = seenLiteralTypes.get(primitiveFlag);
-								if (existing) existing.push(typeName);
-								else seenLiteralTypes.set(primitiveFlag, [typeName]);
-							}
-							break;
-						}
-						for (const primitiveTypeFlag of primitiveTypeFlags) if (typePart.flags === primitiveTypeFlag) {
-							const existing = seenPrimitiveTypes.get(primitiveTypeFlag);
-							if (existing) existing.push(typeNode);
-							else seenPrimitiveTypes.set(primitiveTypeFlag, [typeNode]);
-						}
-					}
-					if (typeParts.length >= 2) seenUnionTypes.set(typeNode, typeParts.map((typePart) => ({
-						typeFlags: typePart.flags,
-						typeName: describeLiteralType(typePart)
-					})));
-				}
-				if (seenUnionTypes.size) {
-					for (const [typeRef, typeValues] of seenUnionTypes) {
-						let primitiveFlag;
-						for (const { typeFlags } of typeValues) {
-							const mapped = literalToPrimitiveTypeFlags[typeFlags];
-							if (mapped && seenPrimitiveTypes.has(mapped)) primitiveFlag = mapped;
-							else {
-								primitiveFlag = void 0;
-								break;
-							}
-						}
-						if (primitiveFlag !== void 0) context.report({
-							data: {
-								literal: typeValues.map((v) => v.typeName).join(" | "),
-								primitive: primitiveTypeFlagNames[primitiveFlag] ?? ""
-							},
-							message: "primitiveOverridden",
-							range: getTSNodeRange(typeRef, sourceFile)
-						});
-					}
-					return;
-				}
-				for (const [primitiveTypeFlag, typeNodes] of seenPrimitiveTypes) {
-					const matchedLiteralTypes = seenLiteralTypes.get(primitiveTypeFlag);
-					if (matchedLiteralTypes) for (const typeNode of typeNodes) context.report({
-						data: {
-							literal: matchedLiteralTypes.join(" | "),
-							primitive: primitiveTypeFlagNames[primitiveTypeFlag] ?? ""
-						},
-						message: "primitiveOverridden",
-						range: getTSNodeRange(typeNode, sourceFile)
-					});
-				}
-			},
-			UnionType: (node, { sourceFile, typeChecker }) => {
-				const seenLiteralTypes = /* @__PURE__ */ new Map();
-				const seenPrimitiveTypes = /* @__PURE__ */ new Set();
-				for (const typeNode of node.types) {
-					const typeParts = unionTypePartsUnlessBoolean(typeChecker.getTypeAtLocation(typeNode));
-					for (const typePart of typeParts) {
-						const typeName = describeLiteralType(typePart);
-						if (typePart.flags === ts.TypeFlags.Any || typePart.flags === ts.TypeFlags.Unknown) {
-							context.report({
-								data: {
-									container: "union",
-									typeName
-								},
-								message: typePart.flags === ts.TypeFlags.Any && typeName !== "any" ? "errorTypeOverrides" : "overrides",
-								range: getTSNodeRange(typeNode, sourceFile)
-							});
-							continue;
-						}
-						if (typePart.flags === ts.TypeFlags.Never && !isNodeInsideReturnType(node)) {
-							context.report({
-								data: {
-									container: "union",
-									typeName: "never"
-								},
-								message: "overridden",
-								range: getTSNodeRange(typeNode, sourceFile)
-							});
-							continue;
-						}
-						for (const literalTypeFlag of literalTypeFlags) if (typePart.flags === literalTypeFlag) {
-							const primitiveFlag = literalToPrimitiveTypeFlags[literalTypeFlag];
-							if (primitiveFlag) {
-								const existing = seenLiteralTypes.get(primitiveFlag);
-								if (existing) existing.push({
-									literalValue: typeName,
-									typeNode
-								});
-								else seenLiteralTypes.set(primitiveFlag, [{
-									literalValue: typeName,
-									typeNode
-								}]);
-							}
-							break;
-						}
-						for (const primitiveTypeFlag of primitiveTypeFlags) if ((typePart.flags & primitiveTypeFlag) !== 0) seenPrimitiveTypes.add(primitiveTypeFlag);
-					}
-				}
-				const overriddenTypeNodes = /* @__PURE__ */ new Map();
-				for (const [primitiveTypeFlag, typeNodesWithText] of seenLiteralTypes) if (seenPrimitiveTypes.has(primitiveTypeFlag)) for (const { literalValue, typeNode } of typeNodesWithText) {
-					const existing = overriddenTypeNodes.get(typeNode);
-					if (existing) existing.push({
-						literalValue,
-						primitiveTypeFlag
-					});
-					else overriddenTypeNodes.set(typeNode, [{
-						literalValue,
-						primitiveTypeFlag
-					}]);
-				}
-				for (const [typeNode, typeFlagsWithText] of overriddenTypeNodes) {
-					const grouped = /* @__PURE__ */ new Map();
-					for (const { literalValue, primitiveTypeFlag } of typeFlagsWithText) {
-						const existing = grouped.get(primitiveTypeFlag);
-						if (existing) existing.push(literalValue);
-						else grouped.set(primitiveTypeFlag, [literalValue]);
-					}
-					for (const [primitiveTypeFlag, literals] of grouped) context.report({
-						data: {
-							literal: literals.join(" | "),
-							primitive: primitiveTypeFlagNames[primitiveTypeFlag] ?? ""
-						},
-						message: "literalOverridden",
-						range: getTSNodeRange(typeNode, sourceFile)
-					});
-				}
-			}
-		} };
-	}
-});
-//#endregion
-export { redundantTypeConstituents_default as default };

package/lib/rules/regexAllGlobalFlags.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports `matchAll()` and `replaceAll()` calls with regex arguments missing the global flag.";
-    readonly id: "regexAllGlobalFlags";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "missingGlobalFlag", undefined>;
-export default _default;

package/lib/rules/regexAllGlobalFlags.js

@@ -1,54 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/regexAllGlobalFlags.ts
-function getRegexFlags(node, sourceFile) {
-	switch (node.kind) {
-		case ts.SyntaxKind.CallExpression:
-		case ts.SyntaxKind.NewExpression:
-			if (ts.isIdentifier(node.expression) && node.expression.text === "RegExp" && node.arguments) {
-				if (node.arguments.length < 2) return "";
-				const flagsArg = node.arguments[1];
-				if (ts.isStringLiteral(flagsArg)) return flagsArg.text;
-			}
-			return;
-		case ts.SyntaxKind.RegularExpressionLiteral: {
-			const text = node.getText(sourceFile);
-			const lastSlash = text.lastIndexOf("/");
-			return lastSlash >= 0 ? text.slice(lastSlash + 1) : "";
-		}
-		default: return;
-	}
-}
-var regexAllGlobalFlags_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports `matchAll()` and `replaceAll()` calls with regex arguments missing the global flag.",
-		id: "regexAllGlobalFlags",
-		presets: ["logical"]
-	},
-	messages: { missingGlobalFlag: {
-		primary: "The regex argument to `{{ method }}()` requires the global (`g`) flag.",
-		secondary: ["String.prototype.{{ method }}() throws a TypeError at runtime if the regex argument lacks the global flag."],
-		suggestions: ["Add the global (g) flag to the regex."]
-	} },
-	setup(context) {
-		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
-			if (!ts.isPropertyAccessExpression(node.expression)) return;
-			const methodName = node.expression.name.text;
-			if (methodName !== "matchAll" && methodName !== "replaceAll") return;
-			const expectedArgCount = methodName === "matchAll" ? 1 : 2;
-			if (node.arguments.length < expectedArgCount) return;
-			const firstArg = node.arguments[0];
-			if (!(typeChecker.getTypeAtLocation(node.expression.expression).flags & ts.TypeFlags.StringLike)) return;
-			const flags = getRegexFlags(firstArg, sourceFile);
-			if (flags === void 0 || flags.includes("g")) return;
-			context.report({
-				data: { method: methodName },
-				message: "missingGlobalFlag",
-				range: getTSNodeRange(firstArg, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { regexAllGlobalFlags_default as default };

package/lib/rules/regexAmbiguousInvalidity.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports regex patterns that use ambiguous or invalid syntax from Annex B.";
-    readonly id: "regexAmbiguousInvalidity";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "incompleteBackreference" | "incompleteEscapeSequence" | "invalidControlEscape" | "invalidPropertyEscape" | "invalidRange" | "octalEscape" | "quantifiedAssertion" | "regexMessage" | "unescapedSourceCharacter" | "uselessEscape", undefined>;
-export default _default;

package/lib/rules/regexAmbiguousInvalidity.js

@@ -1,295 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-import { RegExpParser, RegExpValidator, visitRegExpAST } from "@eslint-community/regexpp";
-//#region src/rules/regexAmbiguousInvalidity.ts
-const validator = new RegExpValidator({
-	ecmaVersion: 2020,
-	strict: true
-});
-const CHARACTER_CLASS_SYNTAX_CHARACTERS = new Set("\\/()[]{}^$.|-+*?".split(""));
-const SYNTAX_CHARACTERS = new Set("\\/()[]{}^$.|+*?".split(""));
-function isControlEscape(raw) {
-	return /^\\c[A-Za-z]$/u.test(raw);
-}
-function isEscapeSequence(raw) {
-	return isOctalEscape(raw) || isControlEscape(raw) || isHexadecimalEscape(raw) || isUnicodeEscape(raw) || isUnicodeCodePointEscape(raw);
-}
-function isHexadecimalEscape(raw) {
-	return /^\\x[\dA-Fa-f]{2}$/u.test(raw);
-}
-function isOctalEscape(raw) {
-	return /^\\[0-7]{1,3}$/u.test(raw);
-}
-function isUnicodeCodePointEscape(raw) {
-	return /^\\u\{[\dA-Fa-f]{1,8}\}$/u.test(raw);
-}
-function isUnicodeEscape(raw) {
-	return /^\\u[\dA-Fa-f]{4}$/u.test(raw);
-}
-function parseFlags(flagsStr) {
-	return {
-		unicode: flagsStr.includes("u"),
-		unicodeSets: flagsStr.includes("v")
-	};
-}
-function validateRegExpPattern(pattern, flags) {
-	try {
-		validator.validatePattern(pattern, void 0, void 0, flags);
-		return null;
-	} catch (error) {
-		return error instanceof Error ? error.message : null;
-	}
-}
-function checkPatternWithRegexpp(pattern, flags) {
-	if (flags.unicode || flags.unicodeSets) return [];
-	const issues = [];
-	const parser = new RegExpParser();
-	let ast;
-	try {
-		ast = parser.parsePattern(pattern, void 0, void 0, flags);
-	} catch {
-		const message = validateRegExpPattern(pattern, flags);
-		if (message) issues.push({
-			data: { message },
-			end: pattern.length,
-			message: "regexMessage",
-			start: 0
-		});
-		return issues;
-	}
-	let reported = false;
-	let hasNamedBackreference = false;
-	visitRegExpAST(ast, {
-		onBackreferenceEnter(bNode) {
-			if (typeof bNode.ref === "string") hasNamedBackreference = true;
-		},
-		onCharacterClassEnter(ccNode) {
-			for (let i = 0; i < ccNode.elements.length; i++) {
-				const current = ccNode.elements[i];
-				if (current?.type === "CharacterSet") {
-					const next = ccNode.elements[i + 1];
-					const nextNext = ccNode.elements[i + 2];
-					if (next?.raw === "-" && nextNext) {
-						issues.push({
-							data: {},
-							end: current.end,
-							message: "invalidRange",
-							start: current.start
-						});
-						reported = true;
-						return;
-					}
-					const prev = ccNode.elements[i - 1];
-					const prevPrev = ccNode.elements[i - 2];
-					if (prev?.raw === "-" && prevPrev && prevPrev.type !== "CharacterClassRange") {
-						issues.push({
-							data: {},
-							end: current.end,
-							message: "invalidRange",
-							start: current.start
-						});
-						reported = true;
-						return;
-					}
-				}
-			}
-		},
-		onCharacterEnter(cNode) {
-			if (cNode.raw === "\\") {
-				issues.push({
-					data: {},
-					end: cNode.end,
-					message: "invalidControlEscape",
-					start: cNode.start
-				});
-				reported = true;
-				return;
-			}
-			if (cNode.raw === "\\u" || cNode.raw === "\\x") {
-				issues.push({
-					data: { expr: cNode.raw },
-					end: cNode.end,
-					message: "incompleteEscapeSequence",
-					start: cNode.start
-				});
-				reported = true;
-				return;
-			}
-			if (cNode.raw === "\\p" || cNode.raw === "\\P") {
-				issues.push({
-					data: { expr: cNode.raw },
-					end: cNode.end,
-					message: "invalidPropertyEscape",
-					start: cNode.start
-				});
-				reported = true;
-				return;
-			}
-			if (cNode.value !== 0 && isOctalEscape(cNode.raw)) {
-				issues.push({
-					data: {
-						escape: cNode.raw,
-						hex: `\\x${cNode.value.toString(16).padStart(2, "0")}`
-					},
-					end: cNode.end,
-					message: "octalEscape",
-					start: cNode.start
-				});
-				reported = true;
-				return;
-			}
-			const insideCharClass = cNode.parent.type === "CharacterClass" || cNode.parent.type === "CharacterClassRange";
-			if (!insideCharClass) {
-				if (cNode.raw === "\\k") {
-					issues.push({
-						data: { expr: cNode.raw },
-						end: cNode.end,
-						message: "incompleteBackreference",
-						start: cNode.start
-					});
-					reported = true;
-					return;
-				}
-				if (cNode.raw === "{" || cNode.raw === "}" || cNode.raw === "]") {
-					issues.push({
-						data: { character: cNode.raw },
-						end: cNode.end,
-						message: "unescapedSourceCharacter",
-						start: cNode.start
-					});
-					reported = true;
-					return;
-				}
-			}
-			if (isEscapeSequence(cNode.raw)) return;
-			if (cNode.raw.startsWith("\\")) {
-				const identity = cNode.raw.slice(1);
-				const syntaxChars = insideCharClass ? CHARACTER_CLASS_SYNTAX_CHARACTERS : SYNTAX_CHARACTERS;
-				if (cNode.value === identity.charCodeAt(0) && !syntaxChars.has(identity)) {
-					issues.push({
-						data: { escaped: identity },
-						end: cNode.end,
-						message: "uselessEscape",
-						start: cNode.start
-					});
-					reported = true;
-				}
-			}
-		},
-		onQuantifierEnter(quantifierNode) {
-			if (quantifierNode.element.type === "Assertion") {
-				issues.push({
-					data: {},
-					end: quantifierNode.end,
-					message: "quantifiedAssertion",
-					start: quantifierNode.start
-				});
-				reported = true;
-			}
-		}
-	});
-	if (hasNamedBackreference) return issues;
-	if (!reported) {
-		const message = validateRegExpPattern(pattern, flags);
-		if (message) issues.push({
-			data: { message },
-			end: pattern.length,
-			message: "regexMessage",
-			start: 0
-		});
-	}
-	return issues;
-}
-var regexAmbiguousInvalidity_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports regex patterns that use ambiguous or invalid syntax from Annex B.",
-		id: "regexAmbiguousInvalidity",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: {
-		incompleteBackreference: {
-			primary: "Incomplete backreference '{{ expr }}'.",
-			secondary: ["This regex uses syntax from ECMAScript Annex B which is ambiguous or deprecated.", "Either use a valid backreference or remove the useless escaping."],
-			suggestions: ["Complete the backreference or remove the escape."]
-		},
-		incompleteEscapeSequence: {
-			primary: "Incomplete escape sequence '{{ expr }}'.",
-			secondary: ["This regex uses syntax from ECMAScript Annex B which is ambiguous or deprecated.", "Either use a valid escape sequence or remove the useless escaping."],
-			suggestions: ["Complete the escape sequence or remove the escape."]
-		},
-		invalidControlEscape: {
-			primary: "Invalid or incomplete control escape sequence.",
-			secondary: ["This regex uses syntax from ECMAScript Annex B which is ambiguous or deprecated.", "Either use a valid control escape sequence or escape the standalone backslash."],
-			suggestions: ["Use a valid control escape like \\cA or escape the backslash."]
-		},
-		invalidPropertyEscape: {
-			primary: "Invalid property escape sequence '{{ expr }}'.",
-			secondary: ["This regex uses syntax from ECMAScript Annex B which is ambiguous or deprecated.", "Either use a valid property escape sequence or remove the useless escaping."],
-			suggestions: ["Use a valid Unicode property escape like \\p{L} with the 'u' flag."]
-		},
-		invalidRange: {
-			primary: "Invalid character class range. A character set cannot be the minimum or maximum of a character class range.",
-			secondary: ["This regex uses syntax from ECMAScript Annex B which is ambiguous or deprecated.", "Either escape the `-` or fix the character class range."],
-			suggestions: ["Escape the `-` character or reorder the character class."]
-		},
-		octalEscape: {
-			primary: "Invalid legacy octal escape sequence '{{ escape }}'. Use a hexadecimal escape instead.",
-			secondary: ["This regex uses syntax from ECMAScript Annex B which is ambiguous or deprecated.", "Octal escapes can be confused with backreferences."],
-			suggestions: ["Replace with hexadecimal escape '{{ hex }}'."]
-		},
-		quantifiedAssertion: {
-			primary: "Assertions are not allowed to be quantified directly.",
-			secondary: ["This regex uses syntax from ECMAScript Annex B which is ambiguous or deprecated.", "Wrap the assertion in a non-capturing group if you need to quantify it."],
-			suggestions: ["Wrap the assertion in a non-capturing group: (?:...)"]
-		},
-		regexMessage: {
-			primary: "{{ message }}.",
-			secondary: ["This regex uses syntax from ECMAScript Annex B which is ambiguous or deprecated.", "Consider using strict regex syntax for clarity and cross-platform compatibility."],
-			suggestions: ["Fix the regex syntax error."]
-		},
-		unescapedSourceCharacter: {
-			primary: "Unescaped source character '{{ character }}' should be escaped.",
-			secondary: ["This regex uses syntax from ECMAScript Annex B which is ambiguous or deprecated.", "Consider using strict regex syntax for clarity and cross-platform compatibility."],
-			suggestions: ["Escape the character with a backslash."]
-		},
-		uselessEscape: {
-			primary: "Useless escape '\\{{ escaped }}'.",
-			secondary: ["This regex uses syntax from ECMAScript Annex B which is ambiguous or deprecated.", "Identity escapes with non-syntax characters are forbidden in strict mode."],
-			suggestions: ["Remove the unnecessary backslash."]
-		}
-	},
-	setup(context) {
-		function reportIssues(issues, start) {
-			for (const issue of issues) context.report({
-				data: issue.data,
-				message: issue.message,
-				range: {
-					begin: start + issue.start + 1,
-					end: start + issue.end + 1
-				}
-			});
-		}
-		function checkCallOrNewExpression(node, { program, sourceFile, typeChecker }) {
-			if (!ts.isIdentifier(node.expression) || node.expression.text !== "RegExp" || !isGlobalDeclarationOfName(node.expression, "RegExp", typeChecker, program) || !node.arguments?.length) return;
-			const patternArg = node.arguments[0];
-			if (!ts.isStringLiteral(patternArg)) return;
-			const flagsArg = node.arguments[1];
-			const flags = parseFlags(flagsArg && ts.isStringLiteral(flagsArg) ? flagsArg.text : "");
-			reportIssues(checkPatternWithRegexpp(patternArg.text, flags), patternArg.getStart(sourceFile));
-		}
-		return { visitors: {
-			CallExpression: checkCallOrNewExpression,
-			NewExpression: checkCallOrNewExpression,
-			RegularExpressionLiteral: (node, { sourceFile }) => {
-				const text = node.getText(sourceFile);
-				const lastSlash = text.lastIndexOf("/");
-				if (lastSlash <= 0) return;
-				const flags = parseFlags(text.slice(lastSlash + 1));
-				reportIssues(checkPatternWithRegexpp(text.slice(1, lastSlash), flags), node.getStart(sourceFile));
-			}
-		} };
-	}
-});
-//#endregion
-export { regexAmbiguousInvalidity_default as default };

package/lib/rules/regexCharacterClassRanges.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports character class elements that can be simplified to ranges.";
-    readonly id: "regexCharacterClassRanges";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferRange", undefined>;
-export default _default;