@flint.fyi/ts 0.21.0 → 0.22.0

package/lib/rules/regexMisleadingQuantifiers.js

@@ -1,76 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { parseRegexpAst } from "./utils/parseRegexpAst.js";
-import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
-import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { visitRegExpAST } from "@eslint-community/regexpp";
-//#region src/rules/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 };

package/lib/rules/regexMisleadingUnicodeCharacters.d.ts

@@ -1,9 +0,0 @@
-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: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "combiningClass" | "emojiModifier" | "regionalIndicatorSymbol" | "surrogatePair" | "surrogatePairWithoutUFlag" | "zwj", undefined>;
-export default _default;

package/lib/rules/regexMisleadingUnicodeCharacters.js

@@ -1,201 +0,0 @@
-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 };

package/lib/rules/regexNamedBackreferences.d.ts

@@ -1,9 +0,0 @@
-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: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferNamed", undefined>;
-export default _default;

package/lib/rules/regexNamedBackreferences.js

@@ -1,46 +0,0 @@
-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 };

package/lib/rules/regexNamedCaptureGroups.d.ts

@@ -1,8 +0,0 @@
-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";
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferNamed", undefined>;
-export default _default;

package/lib/rules/regexNamedCaptureGroups.js

@@ -1,65 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { parseRegexpAst } from "./utils/parseRegexpAst.js";
-import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
-import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
-import { 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 };

package/lib/rules/regexNamedReplacements.d.ts

@@ -1,9 +0,0 @@
-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: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferNamed", undefined>;
-export default _default;

package/lib/rules/regexNamedReplacements.js

@@ -1,91 +0,0 @@
-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 };

package/lib/rules/regexNonStandardFlags.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports non-standard regular expression flags.";
-    readonly id: "regexNonStandardFlags";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unexpected", undefined>;
-export default _default;

package/lib/rules/regexNonStandardFlags.js

@@ -1,64 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
-import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/regexNonStandardFlags.ts
-const standardFlags = /* @__PURE__ */ 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 };

package/lib/rules/regexObscureRanges.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports obscure character ranges in regular expressions.";
-    readonly id: "regexObscureRanges";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "obscure", undefined>;
-export default _default;