@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/regexSuperLinearMoves.js

@@ -0,0 +1,142 @@
+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";
+//#region src/rules/regexSuperLinearMoves.ts
+function canMatchEmpty(element) {
+	switch (element.type) {
+		case "Assertion": return true;
+		case "CapturingGroup":
+		case "Group": return element.alternatives.some((alternative) => alternative.elements.every(canMatchEmpty));
+		case "Quantifier": return element.min === 0;
+		default: return false;
+	}
+}
+function canReject(element) {
+	switch (element.type) {
+		case "Assertion": return element.kind === "end" || element.kind === "word";
+		case "Backreference":
+		case "Character":
+		case "ExpressionCharacterClass": return true;
+		case "CapturingGroup":
+		case "Group": return element.alternatives.some((alternative) => alternative.elements.some(canReject));
+		case "CharacterClass": return !isMatchAll(element);
+		case "CharacterSet": return element.kind !== "any" || element.raw !== "[\\s\\S]";
+		case "Quantifier": return element.min !== 0 && canReject(element.element);
+		default: return false;
+	}
+}
+function findReachableQuantifiers(pattern) {
+	const quantifiers = [];
+	function walkAlternative(alternative) {
+		for (const element of alternative.elements) {
+			switch (element.type) {
+				case "CapturingGroup":
+				case "Group":
+					for (const innerAlternative of element.alternatives) walkAlternative(innerAlternative);
+					break;
+				case "Quantifier":
+					if (element.max === Infinity && element.min === 0) quantifiers.push(element);
+					break;
+			}
+			if (!canMatchEmpty(element)) return;
+		}
+	}
+	for (const alternative of pattern.alternatives) walkAlternative(alternative);
+	return quantifiers;
+}
+function generateAttackString(quantifier) {
+	let character;
+	switch (quantifier.element.type) {
+		case "Character":
+			character = String.fromCharCode(quantifier.element.value);
+			break;
+		case "CharacterClass": {
+			const first = quantifier.element.elements[0];
+			if (first.type === "Character") character = String.fromCharCode(first.value);
+			break;
+		}
+		case "CharacterSet":
+			switch (quantifier.element.kind) {
+				case "any":
+					character = "x";
+					break;
+				case "digit":
+					character = "0";
+					break;
+				case "space":
+					character = " ";
+					break;
+			}
+			break;
+	}
+	return (character ?? "a").repeat(20);
+}
+function getFollowingElements(quantifier) {
+	const index = quantifier.parent.elements.indexOf(quantifier);
+	const following = quantifier.parent.elements.slice(index + 1);
+	const grandparent = quantifier.parent.parent;
+	if (grandparent.type === "CapturingGroup" || grandparent.type === "Group") {
+		const groupParent = grandparent.parent;
+		if (groupParent.type === "Alternative") following.push(...groupParent.elements.slice(groupParent.elements.indexOf(grandparent) + 1));
+	}
+	return following;
+}
+function hasRejectingSuffix(quantifier) {
+	return getFollowingElements(quantifier).some(canReject);
+}
+function isAnchoredAtStart(pattern) {
+	return pattern.alternatives.every((alternative) => {
+		const first = alternative.elements[0];
+		return first.type === "Assertion" && first.kind === "start";
+	});
+}
+function isMatchAll(characterClass) {
+	return characterClass.negate && !characterClass.elements.length;
+}
+var regexSuperLinearMoves_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports quantifiers that can cause quadratic regex matching time.",
+		id: "regexSuperLinearMoves",
+		presets: ["logical"]
+	},
+	messages: { superLinear: {
+		primary: "This quantifier can cause quadratic regex matching time. An input like `{{ attack }}` could trigger slow matching.",
+		secondary: ["When a quantifier at the start of a pattern is followed by elements that can fail to match, the regex engine may try the pattern from each position in the input string.", "For an input of length n, this can result in O(n²) time complexity."],
+		suggestions: ["Anchor the pattern with `^` to prevent repeated matching attempts.", "Ensure the quantifier is preceded by a required consuming element."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst || isAnchoredAtStart(regexpAst)) return;
+			const quantifiers = findReachableQuantifiers(regexpAst).filter(hasRejectingSuffix);
+			for (const quantifier of quantifiers) context.report({
+				data: { attack: generateAttackString(quantifier) },
+				message: "superLinear",
+				range: {
+					begin: patternStart + quantifier.start,
+					end: patternStart + quantifier.end
+				}
+			});
+		}
+		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.pattern, construction.start + 1, construction.flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexSuperLinearMoves_default as default };
+
+//# sourceMappingURL=regexSuperLinearMoves.js.map

package/lib/rules/regexTestMethods.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports match() and exec() calls that should use RegExp.prototype.test() for boolean checks.";
+    readonly id: "regexTestMethods";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferTest", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexTestMethods.d.ts.map

package/lib/rules/regexTestMethods.js

@@ -0,0 +1,83 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
+import { isBuiltinSymbolLike } from "./utils/isBuiltinSymbolLike.js";
+import { isInBooleanContext } from "./utils/isInBooleanContext.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/regexTestMethods.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 (flagsArg && 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;
+	}
+}
+function needsParentheses(node) {
+	return !(ts.isIdentifier(node) || ts.isRegularExpressionLiteral(node) || ts.isParenthesizedExpression(node) || ts.isCallExpression(node) || ts.isNewExpression(node));
+}
+var regexTestMethods_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports match() and exec() calls that should use RegExp.prototype.test() for boolean checks.",
+		id: "regexTestMethods",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { preferTest: {
+		primary: "Prefer the faster `RegExp.test()` for boolean checks instead of the slower `RegExp.{{ method }}()`.",
+		secondary: ["`RegExp.prototype.test()` is more efficient and semantically clearer when only checking for existence.", "`RegExp.prototype.exec()` returns a full matches array, including capture groups, which is slower to execute."],
+		suggestions: ["Replace with `RegExp.prototype.test()` for boolean context checks."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression: (node, { program, sourceFile, typeChecker }) => {
+			if (!ts.isPropertyAccessExpression(node.expression) || node.arguments.length !== 1) return;
+			const methodName = node.expression.name.text;
+			if (methodName !== "match" && methodName !== "exec") return;
+			if (!isInBooleanContext(node)) return;
+			const argument = node.arguments[0];
+			const range = getTSNodeRange(node, sourceFile);
+			if (methodName === "exec") {
+				if (!isBuiltinSymbolLike(program, getConstrainedTypeAtLocation(node.expression.expression, typeChecker), "RegExp")) return;
+				const flags = getRegexFlags(node.expression.expression, sourceFile);
+				const hasGlobalFlag = flags === void 0 || flags.includes("g");
+				context.report({
+					data: { method: "exec" },
+					fix: hasGlobalFlag ? void 0 : {
+						range,
+						text: `${node.expression.expression.getText(sourceFile)}.test(${argument.getText(sourceFile)})`
+					},
+					message: "preferTest",
+					range
+				});
+				return;
+			}
+			if (!(getConstrainedTypeAtLocation(node.expression.expression, typeChecker).flags & ts.TypeFlags.StringLike)) return;
+			if (!isBuiltinSymbolLike(program, getConstrainedTypeAtLocation(argument, typeChecker), "RegExp")) return;
+			const flags = getRegexFlags(argument, sourceFile);
+			const hasGlobalFlag = flags === void 0 || flags.includes("g");
+			const regexText = needsParentheses(argument) ? `(${argument.getText(sourceFile)})` : argument.getText(sourceFile);
+			context.report({
+				data: { method: "match" },
+				fix: hasGlobalFlag ? void 0 : {
+					range,
+					text: `${regexText}.test(${node.expression.expression.getText(sourceFile)})`
+				},
+				message: "preferTest",
+				range
+			});
+		} } };
+	}
+});
+//#endregion
+export { regexTestMethods_default as default };
+
+//# sourceMappingURL=regexTestMethods.js.map

package/lib/rules/regexUnicodeCodepointEscapes.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports surrogate pair escapes in regular expressions that can be replaced with Unicode codepoint escapes.";
+    readonly id: "regexUnicodeCodepointEscapes";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "useSurrogatePair", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexUnicodeCodepointEscapes.d.ts.map

package/lib/rules/regexUnicodeCodepointEscapes.js

@@ -0,0 +1,107 @@
+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/regexUnicodeCodepointEscapes.ts
+function isSurrogatePairEscape(raw) {
+	return /^(?:\\u[\da-f]{4}){2}$/i.test(raw);
+}
+var regexUnicodeCodepointEscapes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports surrogate pair escapes in regular expressions that can be replaced with Unicode codepoint escapes.",
+		id: "regexUnicodeCodepointEscapes",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { useSurrogatePair: {
+		primary: "Prefer the more expressive Unicode codepoint escape `{{ replacement }}` instead of surrogate pair `{{ raw }}`.",
+		secondary: ["Unicode codepoint escapes are clearer and more maintainable than surrogate pairs."],
+		suggestions: ["Replace `{{ raw }}` with `{{ replacement }}`."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags) {
+			if (!flags.includes("u") && !flags.includes("v")) return;
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onCharacterEnter(charNode) {
+				if (charNode.value < 65536 || !isSurrogatePairEscape(charNode.raw)) return;
+				let hex = charNode.value.toString(16);
+				if (/[A-F]/.test(charNode.raw)) hex = hex.toUpperCase();
+				const replacement = `\\u{${hex}}`;
+				context.report({
+					data: {
+						raw: charNode.raw,
+						replacement
+					},
+					fix: {
+						range: {
+							begin: patternStart + charNode.start,
+							end: patternStart + charNode.end
+						},
+						text: replacement
+					},
+					message: "useSurrogatePair",
+					range: {
+						begin: patternStart + charNode.start,
+						end: patternStart + charNode.end
+					}
+				});
+			} });
+		}
+		function checkStringPattern(rawPattern, patternStart, flags) {
+			if (!flags.includes("u") && !flags.includes("v")) return;
+			const surrogatePairPattern = /\\\\u([\da-f]{4})\\\\u([\da-f]{4})/gi;
+			let match;
+			while ((match = surrogatePairPattern.exec(rawPattern)) !== null) {
+				const [fullMatch, highHex, lowHex] = match;
+				if (!highHex || !lowHex) continue;
+				const high = parseInt(highHex, 16);
+				if (high < 55296 || high > 56319) continue;
+				const low = parseInt(lowHex, 16);
+				if (low < 56320 || low > 57343) continue;
+				let hex = ((high - 55296) * 1024 + (low - 56320) + 65536).toString(16);
+				if (/[A-F]/.test(fullMatch)) hex = hex.toUpperCase();
+				const raw = `\\u${highHex}\\u${lowHex}`;
+				const displayReplacement = `\\u{${hex}}`;
+				const fixText = `\\${displayReplacement}`;
+				context.report({
+					data: {
+						raw,
+						replacement: displayReplacement
+					},
+					fix: {
+						range: {
+							begin: patternStart + match.index,
+							end: patternStart + match.index + match[0].length
+						},
+						text: fixText
+					},
+					message: "useSurrogatePair",
+					range: {
+						begin: patternStart + match.index,
+						end: patternStart + match.index + match[0].length
+					}
+				});
+			}
+		}
+		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;
+			checkStringPattern(construction.pattern, construction.start + 1, construction.flags);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnicodeCodepointEscapes_default as default };
+
+//# sourceMappingURL=regexUnicodeCodepointEscapes.js.map

package/lib/rules/regexUnicodeEscapes.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Enforces consistent Unicode escape style in regex patterns by preferring codepoint escapes.";
+    readonly id: "regexUnicodeEscapes";
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferCodepointEscape", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexUnicodeEscapes.d.ts.map

package/lib/rules/regexUnicodeEscapes.js

@@ -0,0 +1,97 @@
+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/regexUnicodeEscapes.ts
+function collectSurrogatePairIndices(characters) {
+	const surrogateIndices = /* @__PURE__ */ new Set();
+	for (let index = 0; index < characters.length - 1; index++) {
+		const current = characters[index];
+		const next = characters[index + 1];
+		if (isFourDigitUnicodeEscape(current.raw) && isFourDigitUnicodeEscape(next.raw) && isHighSurrogate(current.value) && isLowSurrogate(next.value) && current.end === next.start) {
+			surrogateIndices.add(index);
+			surrogateIndices.add(index + 1);
+		}
+	}
+	return surrogateIndices;
+}
+function isFourDigitUnicodeEscape(raw) {
+	return /^\\u[0-9a-f]{4}$/i.test(raw);
+}
+function isHighSurrogate(codePoint) {
+	return codePoint >= 55296 && codePoint <= 56319;
+}
+function isLowSurrogate(codePoint) {
+	return codePoint >= 56320 && codePoint <= 57343;
+}
+var regexUnicodeEscapes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Enforces consistent Unicode escape style in regex patterns by preferring codepoint escapes.",
+		id: "regexUnicodeEscapes"
+	},
+	messages: { preferCodepointEscape: {
+		primary: "Prefer the Unicode codepoint escape '{{ replacement }}' instead of 4-digit escape '{{ raw }}'.",
+		secondary: ["The \\u{...} format is more flexible, readable, and consistent with modern Unicode handling in JavaScript."],
+		suggestions: ["Replace `{{ raw }}` with `{{ replacement }}`."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags, canFix) {
+			if (!flags.includes("u") && !flags.includes("v")) return;
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			const characters = [];
+			visitRegExpAST(regexpAst, { onCharacterEnter(charNode) {
+				if (isFourDigitUnicodeEscape(charNode.raw)) characters.push({
+					end: charNode.end,
+					raw: charNode.raw,
+					start: charNode.start,
+					value: charNode.value
+				});
+			} });
+			const surrogateIndices = collectSurrogatePairIndices(characters);
+			for (let index = 0; index < characters.length; index++) {
+				if (surrogateIndices.has(index)) continue;
+				const charInfo = characters[index];
+				const replacement = `\\u{${charInfo.raw.slice(2)}}`;
+				context.report({
+					data: {
+						raw: charInfo.raw,
+						replacement
+					},
+					fix: canFix ? {
+						range: {
+							begin: patternStart + charInfo.start,
+							end: patternStart + charInfo.end
+						},
+						text: replacement
+					} : void 0,
+					message: "preferCodepointEscape",
+					range: {
+						begin: patternStart + charInfo.start,
+						end: patternStart + charInfo.end
+					}
+				});
+			}
+		}
+		function checkRegexLiteral(node, services) {
+			const details = getRegExpLiteralDetails(node, services);
+			checkPattern(details.pattern, details.start, details.flags, true);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			checkPattern(construction.raw, construction.start + 1, construction.flags, false);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnicodeEscapes_default as default };
+
+//# sourceMappingURL=regexUnicodeEscapes.js.map

package/lib/rules/regexUnicodeFlag.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Require regex patterns to have the unicode ('u') or unicodeSets ('v') flag for proper Unicode character handling.";
+    readonly id: "regexUnicodeFlag";
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "missing", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexUnicodeFlag.d.ts.map

package/lib/rules/regexUnicodeFlag.js

@@ -0,0 +1,97 @@
+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 * as ts$1 from "typescript";
+//#region src/rules/regexUnicodeFlag.ts
+function canAddUnicodeFlag(pattern, flags) {
+	return !hasUnicodeFlag(flags) && parseRegexpAst(pattern, flags + "u") !== void 0;
+}
+function hasUnicodeFlag(flags) {
+	return flags.includes("u") || flags.includes("v");
+}
+var regexUnicodeFlag_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Require regex patterns to have the unicode ('u') or unicodeSets ('v') flag for proper Unicode character handling.",
+		id: "regexUnicodeFlag"
+	},
+	messages: { missing: {
+		primary: "This regular expression is missing the Unicode ('u') flag for proper Unicode character handling.",
+		secondary: ["Without the unicode flag, regex patterns may fail to match Unicode characters correctly, especially surrogate pairs like emoji."],
+		suggestions: ["Add the `u` flag to enable unicode mode.", "Use the `v` flag for unicodeSets mode (ES2024)."]
+	} },
+	setup(context) {
+		function checkRegexLiteral(node, services) {
+			const details = getRegExpLiteralDetails(node, services);
+			if (hasUnicodeFlag(details.flags)) return;
+			const nodeEnd = node.getEnd();
+			context.report({
+				fix: canAddUnicodeFlag(details.pattern, details.flags) ? {
+					range: {
+						begin: details.start - 1,
+						end: nodeEnd
+					},
+					text: `${node.getText(services.sourceFile)}u`
+				} : void 0,
+				message: "missing",
+				range: {
+					begin: details.start - 1,
+					end: nodeEnd
+				}
+			});
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			const firstArgument = construction.args[0];
+			const secondArgument = construction.args[1];
+			const hasSecondArgument = secondArgument !== void 0;
+			const secondIsStringLiteral = secondArgument?.kind === ts$1.SyntaxKind.StringLiteral;
+			if (hasUnicodeFlag(construction.flags)) return;
+			const nodeStart = node.getStart(services.sourceFile);
+			const nodeEnd = node.getEnd();
+			let fix;
+			if (canAddUnicodeFlag(construction.raw, construction.flags)) {
+				if (secondIsStringLiteral) {
+					const secondStart = secondArgument.getStart(services.sourceFile);
+					const secondEnd = secondArgument.getEnd();
+					const quote = secondArgument.getText(services.sourceFile)[0];
+					fix = {
+						range: {
+							begin: secondStart,
+							end: secondEnd
+						},
+						text: `${quote}${construction.flags}u${quote}`
+					};
+				} else if (!hasSecondArgument) {
+					const firstEnd = firstArgument.getEnd();
+					fix = {
+						range: {
+							begin: firstEnd,
+							end: firstEnd
+						},
+						text: `, "u"`
+					};
+				}
+			}
+			context.report({
+				fix,
+				message: "missing",
+				range: {
+					begin: nodeStart,
+					end: nodeEnd
+				}
+			});
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexUnicodeFlag_default as default };
+
+//# sourceMappingURL=regexUnicodeFlag.js.map

package/lib/rules/regexUnicodeProperties.d.ts

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