@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/regexMisleadingQuantifiers.js

@@ -0,0 +1,78 @@
+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/regexMisleadingQuantifiers.ts
+function formatQuantifier(min, max, greedy) {
+	let result;
+	if (min === 0 && max === 1) result = "?";
+	else if (min === 0 && max === Infinity) result = "*";
+	else if (min === 1 && max === Infinity) result = "+";
+	else if (min === max) result = `{${min}}`;
+	else if (max === Infinity) result = `{${min},}`;
+	else result = `{${min},${max}}`;
+	return greedy ? result : `${result}?`;
+}
+function isPotentiallyEmpty(element) {
+	switch (element.type) {
+		case "Assertion":
+		case "Backreference": return true;
+		case "CapturingGroup":
+		case "Group": return element.alternatives.some((alt) => alt.elements.every((el) => isPotentiallyEmpty(el)));
+		case "Quantifier": return element.min === 0 || isPotentiallyEmpty(element.element);
+		default: return false;
+	}
+}
+var regexMisleadingQuantifiers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports quantifiers whose minimum implies they must match but whose element can match empty.",
+		id: "regexMisleadingQuantifiers",
+		presets: ["logical"]
+	},
+	messages: { confusing: {
+		primary: "Quantifier minimum is {{ min }} but the element can match empty. Consider using '{{ proposal }}' instead.",
+		secondary: ["This quantifier suggests it must match at least {{ min }} time(s), but the quantified element can match the empty string, so the effective minimum is 0."],
+		suggestions: ["Replace the quantifier with one that reflects the actual minimum."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onQuantifierEnter(qNode) {
+				if (qNode.min <= 0 || !isPotentiallyEmpty(qNode.element)) return;
+				const proposal = formatQuantifier(0, qNode.max, qNode.greedy);
+				context.report({
+					data: {
+						min: qNode.min,
+						proposal
+					},
+					message: "confusing",
+					range: {
+						begin: patternStart + qNode.start,
+						end: patternStart + qNode.end
+					}
+				});
+			} });
+		}
+		function checkRegexLiteral(node, { sourceFile }) {
+			const details = getRegExpLiteralDetails(node, { sourceFile });
+			checkPattern(details.pattern, details.start, details.flags);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			checkPattern(construction.pattern, construction.start + 1, construction.flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexMisleadingQuantifiers_default as default };
+
+//# sourceMappingURL=regexMisleadingQuantifiers.js.map

package/lib/rules/regexMisleadingUnicodeCharacters.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports characters in regex character classes that appear as single visual characters but are made of multiple code points.";
+    readonly id: "regexMisleadingUnicodeCharacters";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "combiningClass" | "emojiModifier" | "regionalIndicatorSymbol" | "surrogatePair" | "surrogatePairWithoutUFlag" | "zwj", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexMisleadingUnicodeCharacters.d.ts.map

package/lib/rules/regexMisleadingUnicodeCharacters.js

@@ -0,0 +1,203 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexMisleadingUnicodeCharacters.ts
+function findAllMatches(characters, hasUnicodeFlag) {
+	const matches = [];
+	if (hasUnicodeFlag) for (const nodes of findSurrogatePairs(characters)) matches.push({
+		kind: "surrogatePair",
+		nodes
+	});
+	else for (const nodes of findSurrogatePairsWithoutUFlag(characters)) matches.push({
+		kind: "surrogatePairWithoutUFlag",
+		nodes
+	});
+	for (const nodes of findCombiningClass(characters)) matches.push({
+		kind: "combiningClass",
+		nodes
+	});
+	for (const nodes of findEmojiModifiers(characters)) matches.push({
+		kind: "emojiModifier",
+		nodes
+	});
+	for (const nodes of findRegionalIndicatorSymbols(characters)) matches.push({
+		kind: "regionalIndicatorSymbol",
+		nodes
+	});
+	for (const nodes of findZeroWidthJoins(characters)) matches.push({
+		kind: "zwj",
+		nodes
+	});
+	return matches;
+}
+function* findCombiningClass(characters) {
+	for (const [index, char] of characters.entries()) {
+		const previous = characters[index - 1];
+		if (previous && isCombiningCharacter(char.value) && !isCombiningCharacter(previous.value)) yield [previous, char];
+	}
+}
+function* findEmojiModifiers(characters) {
+	for (const [index, char] of characters.entries()) {
+		const previous = characters[index - 1];
+		if (previous && isEmojiModifier(char.value) && !isEmojiModifier(previous.value)) yield [previous, char];
+	}
+}
+function* findRegionalIndicatorSymbols(characters) {
+	for (const [index, char] of characters.entries()) {
+		const previous = characters[index - 1];
+		if (previous && isRegionalIndicatorSymbol(char.value) && isRegionalIndicatorSymbol(previous.value)) yield [previous, char];
+	}
+}
+function* findSurrogatePairs(characters) {
+	for (const [index, char] of characters.entries()) {
+		const previous = characters[index - 1];
+		if (previous && isSurrogatePair(previous.value, char.value) && (isUnicodeCodePointEscape(previous) || isUnicodeCodePointEscape(char))) yield [previous, char];
+	}
+}
+function* findSurrogatePairsWithoutUFlag(characters) {
+	for (const [index, char] of characters.entries()) {
+		const previous = characters[index - 1];
+		if (previous && isSurrogatePair(previous.value, char.value) && !isUnicodeCodePointEscape(previous) && !isUnicodeCodePointEscape(char)) yield [previous, char];
+	}
+}
+function* findZeroWidthJoins(characters) {
+	let sequence;
+	for (const [index, char] of characters.entries()) {
+		const previous = characters[index - 1];
+		const next = characters[index + 1];
+		if (previous && next && char.value === 8205 && previous.value !== 8205 && next.value !== 8205) if (sequence) if (sequence.at(-1) === previous) sequence.push(char, next);
+		else {
+			yield sequence;
+			sequence = characters.slice(index - 1, index + 2);
+		}
+		else sequence = characters.slice(index - 1, index + 2);
+	}
+	if (sequence) yield sequence;
+}
+function getMessageId(kind) {
+	switch (kind) {
+		case "combiningClass": return "combiningClass";
+		case "emojiModifier": return "emojiModifier";
+		case "regionalIndicatorSymbol": return "regionalIndicatorSymbol";
+		case "surrogatePair": return "surrogatePair";
+		case "surrogatePairWithoutUFlag": return "surrogatePairWithoutUFlag";
+		case "zwj": return "zwj";
+	}
+}
+function isCombiningCharacter(codePoint) {
+	return /^[\p{Mc}\p{Me}\p{Mn}]$/u.test(String.fromCodePoint(codePoint));
+}
+function isEmojiModifier(code) {
+	return code >= 127995 && code <= 127999;
+}
+function isRegionalIndicatorSymbol(code) {
+	return code >= 127462 && code <= 127487;
+}
+function isSurrogatePair(lead, tail) {
+	return lead >= 55296 && lead < 56320 && tail >= 56320 && tail < 57344;
+}
+function isUnicodeCodePointEscape(char) {
+	return /^\\u\{[\da-f]+\}$/iu.test(char.raw);
+}
+function* iterateCharacterSequence(nodes) {
+	let sequence = [];
+	for (const node of nodes) switch (node.type) {
+		case "Character":
+			sequence.push(node);
+			break;
+		case "CharacterClass":
+		case "CharacterSet":
+		case "ClassStringDisjunction":
+		case "ExpressionCharacterClass":
+			if (sequence.length) {
+				yield sequence;
+				sequence = [];
+			}
+			break;
+		case "CharacterClassRange":
+			sequence.push(node.min);
+			yield sequence;
+			sequence = [node.max];
+			break;
+	}
+	if (sequence.length) yield sequence;
+}
+var regexMisleadingUnicodeCharacters_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports characters in regex character classes that appear as single visual characters but are made of multiple code points.",
+		id: "regexMisleadingUnicodeCharacters",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		combiningClass: {
+			primary: "Misleading combined character in character class.",
+			secondary: ["The base character and combining mark are matched separately, not as a single unit."],
+			suggestions: ["Match the composed character outside of a character class.", "Use Unicode normalization for the regular expression."]
+		},
+		emojiModifier: {
+			primary: "Misleading emoji with skin tone modifier in character class.",
+			secondary: ["The emoji and its modifier are matched separately, not as a single unit."],
+			suggestions: ["Match the emoji sequence outside of a character class."]
+		},
+		regionalIndicatorSymbol: {
+			primary: "Misleading regional indicator symbols (flag) in character class.",
+			secondary: ["The two regional indicator symbols are matched separately, not as a single flag."],
+			suggestions: ["Match the flag sequence outside of a character class."]
+		},
+		surrogatePair: {
+			primary: "Misleading surrogate pair in character class.",
+			secondary: ["The surrogate code points are represented with different escape types."],
+			suggestions: ["Use consistent escape sequences for both halves of the pair."]
+		},
+		surrogatePairWithoutUFlag: {
+			primary: "Misleading surrogate pair in character class without the `u` or `v` flag.",
+			secondary: ["Without the unicode flag, each half of the surrogate pair is matched separately."],
+			suggestions: ["Add the `u` flag to the regex."]
+		},
+		zwj: {
+			primary: "Misleading zero-width joiner sequence in character class.",
+			secondary: ["Characters joined with ZWJ are matched separately, not as a single unit.", "Consider matching the sequence outside of a character class."],
+			suggestions: ["Match the ZWJ sequence outside of a character class."]
+		}
+	},
+	setup(context) {
+		return { visitors: { RegularExpressionLiteral: (node, services) => {
+			const details = getRegExpLiteralDetails(node, services);
+			const regexpAst = parseRegexpAst(details.pattern, details.flags);
+			if (!regexpAst) return;
+			const hasUnicodeFlag = details.flags.includes("u") || details.flags.includes("v");
+			const range = getTSNodeRange(node, services.sourceFile);
+			visitRegExpAST(regexpAst, { onCharacterClassEnter(characterClassNode) {
+				for (const characters of iterateCharacterSequence(characterClassNode.elements)) {
+					const matches = findAllMatches(characters, hasUnicodeFlag);
+					for (const { kind, nodes: characters } of matches) {
+						const first = characters[0];
+						const last = characters.at(-1);
+						const messageId = getMessageId(kind);
+						context.report({
+							message: messageId,
+							range: {
+								begin: range.begin + 1 + first.start,
+								end: range.begin + 1 + last.end
+							},
+							...kind === "surrogatePairWithoutUFlag" && { suggestions: [{
+								id: "addUnicodeFlag",
+								range: {
+									begin: range.end,
+									end: range.end
+								},
+								text: "u"
+							}] }
+						});
+					}
+				}
+			} });
+		} } };
+	}
+});
+//#endregion
+export { regexMisleadingUnicodeCharacters_default as default };
+
+//# sourceMappingURL=regexMisleadingUnicodeCharacters.js.map

package/lib/rules/regexNamedBackreferences.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports backreferences that do not use the name of their referenced capturing group.";
+    readonly id: "regexNamedBackreferences";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferNamed", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexNamedBackreferences.d.ts.map

package/lib/rules/regexNamedBackreferences.js

@@ -0,0 +1,48 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexNamedBackreferences.ts
+var regexNamedBackreferences_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports backreferences that do not use the name of their referenced capturing group.",
+		id: "regexNamedBackreferences",
+		presets: ["stylisticStrict"]
+	},
+	messages: { preferNamed: {
+		primary: "Prefer named backreference `\\k<{{ name }}>` over numeric backreference `{{ found }}`.",
+		secondary: ["Named backreferences are more readable and maintainable than numeric ones.", "If the capturing group has a name, the backreference should use that name."],
+		suggestions: ["Replace `{{ found }}` with `\\k<{{ name }}>`"]
+	} },
+	setup(context) {
+		return { visitors: { RegularExpressionLiteral: (node, { sourceFile }) => {
+			const details = getRegExpLiteralDetails(node, { sourceFile });
+			const regexpAst = parseRegexpAst(details.pattern, details.flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onBackreferenceEnter(backNode) {
+				if (Array.isArray(backNode.resolved) || !backNode.resolved.name || backNode.raw.startsWith("\\k<")) return;
+				const range = {
+					begin: details.start + backNode.start,
+					end: details.start + backNode.end
+				};
+				context.report({
+					data: {
+						found: backNode.raw,
+						name: backNode.resolved.name
+					},
+					fix: {
+						range,
+						text: `\\k<${backNode.resolved.name}>`
+					},
+					message: "preferNamed",
+					range
+				});
+			} });
+		} } };
+	}
+});
+//#endregion
+export { regexNamedBackreferences_default as default };
+
+//# sourceMappingURL=regexNamedBackreferences.js.map

package/lib/rules/regexNamedCaptureGroups.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports capturing groups in regular expressions that do not have a name.";
+    readonly id: "regexNamedCaptureGroups";
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferNamed", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexNamedCaptureGroups.d.ts.map

package/lib/rules/regexNamedCaptureGroups.js

@@ -0,0 +1,67 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexNamedCaptureGroups.ts
+var regexNamedCaptureGroups_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports capturing groups in regular expressions that do not have a name.",
+		id: "regexNamedCaptureGroups"
+	},
+	messages: { preferNamed: {
+		primary: "Anonymous capture group `{{ group }}` should be converted to a named or non-capturing group for clarity.",
+		secondary: ["Named capture groups make regex patterns more readable and maintainable.", "If the capture is not needed, use a non-capturing group `(?:...)` instead."],
+		suggestions: ["Add a name to the capture group.", "Convert to a non-capturing group."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, flags, start) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onCapturingGroupEnter(groupNode) {
+				if (groupNode.name) return;
+				const suggestionRange = {
+					begin: start + 1 + groupNode.start + 1,
+					end: start + 1 + groupNode.start + 1
+				};
+				context.report({
+					data: { group: groupNode.raw },
+					message: "preferNamed",
+					range: {
+						begin: start + 1 + groupNode.start,
+						end: start + 1 + groupNode.end
+					},
+					suggestions: [{
+						id: "addGroupName",
+						range: suggestionRange,
+						text: "?<name>"
+					}, {
+						id: "convertToNonCapturing",
+						range: suggestionRange,
+						text: "?:"
+					}]
+				});
+			} });
+		}
+		function checkRegexLiteral(node, services) {
+			const details = getRegExpLiteralDetails(node, services);
+			const range = getTSNodeRange(node, services.sourceFile);
+			checkPattern(details.pattern, details.flags, range.begin);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			checkPattern(construction.raw, construction.flags, construction.start);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexNamedCaptureGroups_default as default };
+
+//# sourceMappingURL=regexNamedCaptureGroups.js.map

package/lib/rules/regexNamedReplacements.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports indexed references in replacement strings that should use named references.";
+    readonly id: "regexNamedReplacements";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferNamed", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexNamedReplacements.d.ts.map

package/lib/rules/regexNamedReplacements.js

@@ -0,0 +1,93 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexNamedReplacements.ts
+function getCapturingGroups(regexpAst) {
+	const groups = [];
+	visitRegExpAST(regexpAst, { onCapturingGroupEnter(groupNode) {
+		groups.push(groupNode);
+	} });
+	return groups;
+}
+function getRegexPatternAndFlags(node) {
+	if (node.kind !== ts.SyntaxKind.RegularExpressionLiteral) return;
+	const match = /^\/(.+)\/([dgimsuyv]*)$/.exec(node.text);
+	if (!match) return;
+	return {
+		flags: match[2],
+		pattern: match[1]
+	};
+}
+function parseReplacementReferences(replacementText) {
+	const references = [];
+	const pattern = /\$(\d+)/g;
+	let match;
+	while (match = pattern.exec(replacementText)) {
+		const index = parseInt(match[1], 10);
+		if (index > 0) references.push({
+			end: match.index + match[0].length,
+			index,
+			raw: match[0],
+			start: match.index
+		});
+	}
+	return references;
+}
+var regexNamedReplacements_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports indexed references in replacement strings that should use named references.",
+		id: "regexNamedReplacements",
+		presets: ["stylisticStrict"]
+	},
+	messages: { preferNamed: {
+		primary: "Prefer the explicit named replacement `$<{{ name }}>` over the position-specific indexed replacement `{{ found }}`.",
+		secondary: ["Named replacements are more readable and maintainable than indexed ones.", "If the capturing group has a name, the replacement should use that name."],
+		suggestions: ["Replace `{{ found }}` with `$<{{ name }}>`"]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+			if (!ts.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "replace" && node.expression.name.text !== "replaceAll" || node.arguments.length < 2 || !(getConstrainedTypeAtLocation(node.expression.expression, typeChecker).flags & ts.TypeFlags.StringLike)) return;
+			if (!(getConstrainedTypeAtLocation(node.expression.expression, typeChecker).flags & ts.TypeFlags.StringLike)) return;
+			const regexArg = node.arguments[0];
+			const replacementArg = node.arguments[1];
+			if (!ts.isStringLiteral(replacementArg)) return;
+			const regexInfo = getRegexPatternAndFlags(regexArg);
+			if (!regexInfo) return;
+			const regexpAst = parseRegexpAst(regexInfo.pattern, regexInfo.flags);
+			if (!regexpAst) return;
+			const capturingGroups = getCapturingGroups(regexpAst);
+			if (!capturingGroups.length) return;
+			const references = parseReplacementReferences(replacementArg.text);
+			const replacementRange = getTSNodeRange(replacementArg, sourceFile);
+			for (const reference of references) {
+				const group = capturingGroups[reference.index - 1];
+				if (!group?.name) continue;
+				context.report({
+					data: {
+						found: reference.raw,
+						name: group.name
+					},
+					fix: {
+						range: {
+							begin: replacementRange.begin + 1 + reference.start,
+							end: replacementRange.begin + 1 + reference.end
+						},
+						text: `$<${group.name}>`
+					},
+					message: "preferNamed",
+					range: {
+						begin: replacementRange.begin + 1 + reference.start,
+						end: replacementRange.begin + 1 + reference.end
+					}
+				});
+			}
+		} } };
+	}
+});
+//#endregion
+export { regexNamedReplacements_default as default };
+
+//# sourceMappingURL=regexNamedReplacements.js.map

package/lib/rules/regexNonStandardFlags.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports non-standard regular expression flags.";
+    readonly id: "regexNonStandardFlags";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unexpected", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexNonStandardFlags.d.ts.map

package/lib/rules/regexNonStandardFlags.js

@@ -0,0 +1,66 @@
+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 * as ts$1 from "typescript";
+//#region src/rules/regexNonStandardFlags.ts
+const standardFlags = new Set([
+	"d",
+	"g",
+	"i",
+	"m",
+	"s",
+	"u",
+	"v",
+	"y"
+]);
+var regexNonStandardFlags_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports non-standard regular expression flags.",
+		id: "regexNonStandardFlags",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { unexpected: {
+		primary: "Non-standard flag '{{ flag }}' is not part of the ECMAScript standard.",
+		secondary: ["Non-standard flags may not be supported in all JavaScript environments and should be avoided in production code."],
+		suggestions: ["Remove the non-standard flag."]
+	} },
+	setup(context) {
+		function checkFlags(flags, flagsStart) {
+			for (let i = 0; i < flags.length; i += 1) {
+				const flag = flags[i];
+				if (!standardFlags.has(flag)) context.report({
+					data: { flag },
+					message: "unexpected",
+					range: {
+						begin: flagsStart + i,
+						end: flagsStart + i + 1
+					}
+				});
+			}
+		}
+		function checkRegexLiteral(node, services) {
+			const details = getRegExpLiteralDetails(node, services);
+			checkFlags(details.flags, details.start + node.text.length - details.flags.length - 1);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			const args = construction.args;
+			if (args.length < 2) return;
+			const secondArgument = args[1];
+			if (secondArgument.kind !== ts$1.SyntaxKind.StringLiteral) return;
+			const flagsStart = secondArgument.getStart(services.sourceFile) + 1;
+			checkFlags(construction.flags, flagsStart);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexNonStandardFlags_default as default };
+
+//# sourceMappingURL=regexNonStandardFlags.js.map

package/lib/rules/regexObscureRanges.d.ts

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