@flint.fyi/ts 0.15.0 → 0.18.0

package/lib/rules/redundantTypeConstituents.js

@@ -0,0 +1,277 @@
+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 };
+
+//# sourceMappingURL=redundantTypeConstituents.js.map

package/lib/rules/regexAllGlobalFlags.d.ts

@@ -0,0 +1,10 @@
+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: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "missingGlobalFlag", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexAllGlobalFlags.d.ts.map

package/lib/rules/regexAllGlobalFlags.js

@@ -0,0 +1,56 @@
+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 };
+
+//# sourceMappingURL=regexAllGlobalFlags.js.map

package/lib/rules/regexAmbiguousInvalidity.d.ts

@@ -0,0 +1,10 @@
+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: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "incompleteBackreference" | "incompleteEscapeSequence" | "invalidControlEscape" | "invalidPropertyEscape" | "invalidRange" | "octalEscape" | "quantifiedAssertion" | "regexMessage" | "unescapedSourceCharacter" | "uselessEscape", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexAmbiguousInvalidity.d.ts.map

package/lib/rules/regexAmbiguousInvalidity.js

@@ -0,0 +1,297 @@
+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, { sourceFile, typeChecker }) {
+			if (!ts.isIdentifier(node.expression) || node.expression.text !== "RegExp" || !isGlobalDeclarationOfName(node.expression, "RegExp", typeChecker) || !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 };
+
+//# sourceMappingURL=regexAmbiguousInvalidity.js.map

package/lib/rules/regexCharacterClassRanges.d.ts

@@ -0,0 +1,10 @@
+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: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferRange", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexCharacterClassRanges.d.ts.map