@pobammer-ts/eslint-cease-nonsense-rules 1.10.0 → 1.11.0

package/dist/index.js

@@ -19767,14 +19767,414 @@ var preferPascalCaseEnums = {
 };
 var prefer_pascal_case_enums_default = preferPascalCaseEnums;
 
-// src/rules/prefer-sequence-overloads.ts
+// src/utilities/pattern-replacement/pattern-matcher.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES10 } from "@typescript-eslint/types";
+
+// src/utilities/pattern-replacement/constant-folder.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES9 } from "@typescript-eslint/types";
+function normalizeZero(num) {
+  return Object.is(num, -0) ? 0 : num;
+}
+function unwrap(node) {
+  switch (node.type) {
+    case AST_NODE_TYPES9.TSAsExpression:
+    case AST_NODE_TYPES9.TSNonNullExpression:
+      return unwrap(node.expression);
+    default:
+      return node;
+  }
+}
+function evaluateConstant(node) {
+  const expression = unwrap(node);
+  if (expression.type === AST_NODE_TYPES9.Literal && typeof expression.value === "number") {
+    return normalizeZero(expression.value);
+  }
+  if (expression.type === AST_NODE_TYPES9.UnaryExpression) {
+    const argument = evaluateConstant(expression.argument);
+    if (argument === undefined)
+      return;
+    switch (expression.operator) {
+      case "-":
+        return normalizeZero(-argument);
+      case "+":
+        return normalizeZero(Number(argument));
+      default:
+        return;
+    }
+  }
+  if (expression.type === AST_NODE_TYPES9.BinaryExpression) {
+    if (expression.left.type === AST_NODE_TYPES9.PrivateIdentifier)
+      return;
+    const left = evaluateConstant(expression.left);
+    const right = evaluateConstant(expression.right);
+    if (left === undefined || right === undefined)
+      return;
+    let result;
+    switch (expression.operator) {
+      case "+":
+        result = left + right;
+        break;
+      case "-":
+        result = left - right;
+        break;
+      case "*":
+        result = left * right;
+        break;
+      case "/":
+        result = left / right;
+        break;
+      default:
+        return;
+    }
+    return Number.isFinite(result) ? normalizeZero(result) : undefined;
+  }
+  return;
+}
+
+// src/utilities/pattern-replacement/pattern-matcher.ts
+function buildPatternIndex(patterns2) {
+  const index2 = new Map;
+  for (const pattern4 of patterns2) {
+    const key = pattern4.type === "constructor" ? `constructor:${pattern4.typeName}` : `staticMethod:${pattern4.typeName}:${pattern4.methodName}`;
+    const existing = index2.get(key);
+    if (existing)
+      existing.push(pattern4);
+    else
+      index2.set(key, [pattern4]);
+  }
+  return index2;
+}
+function resolveCallee(node) {
+  const callee = unwrap(node.callee);
+  if (node.type === AST_NODE_TYPES10.NewExpression && callee.type === AST_NODE_TYPES10.Identifier) {
+    return { kind: "constructor", typeName: callee.name };
+  }
+  if (node.type === AST_NODE_TYPES10.CallExpression) {
+    const member = callee.type === AST_NODE_TYPES10.ChainExpression ? unwrap(callee.expression) : callee;
+    if (member.type === AST_NODE_TYPES10.MemberExpression && !member.computed) {
+      const object3 = unwrap(member.object);
+      if (object3.type === AST_NODE_TYPES10.Identifier && member.property.type === AST_NODE_TYPES10.Identifier) {
+        return {
+          kind: "staticMethod",
+          methodName: member.property.name,
+          typeName: object3.name
+        };
+      }
+    }
+  }
+  return { kind: "unknown" };
+}
+function captureParameter(node, sourceCode) {
+  const expression = unwrap(node);
+  const sourceText = sourceCode.getText(expression);
+  const constValue = evaluateConstant(expression);
+  let expressionKey;
+  let isComplex = false;
+  if (expression.type === AST_NODE_TYPES10.Literal && typeof expression.value === "number") {
+    expressionKey = `literal:${normalizeZero(expression.value)}`;
+  } else if (expression.type === AST_NODE_TYPES10.Identifier) {
+    if (expression.name === "undefined")
+      expressionKey = "undefined";
+    else
+      expressionKey = `id:${expression.name}`;
+  } else if (constValue === undefined) {
+    expressionKey = `complex:${sourceText}`;
+    isComplex = true;
+  } else
+    expressionKey = `const:${constValue}`;
+  if (constValue === undefined)
+    return { expressionKey, isComplex, node: expression, sourceText };
+  return { constValue, expressionKey, isComplex, node: expression, sourceText };
+}
+function matchParameters(patterns2, parameters3, sourceCode) {
+  const captures = new Map;
+  const optionalStart = patterns2.findIndex((parsedArg) => parsedArg.kind === "optional");
+  const minimumParameters = optionalStart === -1 ? patterns2.length : optionalStart;
+  if (parameters3.length < minimumParameters || parameters3.length > patterns2.length)
+    return;
+  for (let index2 = 0;index2 < patterns2.length; index2 += 1) {
+    const pattern4 = patterns2[index2];
+    if (pattern4 === undefined)
+      continue;
+    const parameter2 = parameters3[index2];
+    const unwrappedParameter = parameter2 === undefined ? undefined : unwrap(parameter2);
+    const isMissing = parameter2 === undefined || unwrappedParameter?.type === AST_NODE_TYPES10.Identifier && unwrappedParameter.name === "undefined";
+    if (pattern4.kind === "literal") {
+      if (isMissing)
+        return;
+      const captured = captureParameter(parameter2, sourceCode);
+      if (captured.constValue !== pattern4.value)
+        return;
+    } else if (pattern4.kind === "optional") {
+      if (isMissing)
+        continue;
+      const captured = captureParameter(parameter2, sourceCode);
+      if (captured.constValue !== pattern4.value)
+        return;
+    } else if (pattern4.kind === "capture") {
+      if (isMissing)
+        return;
+      const captured = captureParameter(parameter2, sourceCode);
+      const captureName = pattern4.name;
+      const existing = captures.get(captureName);
+      if (existing !== undefined && existing.expressionKey !== captured.expressionKey)
+        return;
+      captures.set(captureName, captured);
+    } else if (pattern4.kind === "wildcard" && isMissing)
+      return;
+  }
+  return captures;
+}
+var CONDITION_PATTERN = regex2("^(?<operator>[!<>=]+)\\s*(?<target>.+)$");
+function parseCondition(condition) {
+  const match = CONDITION_PATTERN.exec(condition);
+  return match ? [match.groups.operator, match.groups.target] : ["==", "0"];
+}
+function evaluateConditions(conditions, captures) {
+  for (const [name, condition] of conditions) {
+    const captured = captures.get(name);
+    if (captured?.constValue === undefined)
+      return false;
+    const value = captured.constValue;
+    const [operator, targetStr] = parseCondition(condition);
+    const target2 = Number.parseFloat(targetStr);
+    if (!Number.isFinite(target2))
+      return false;
+    let passes;
+    switch (operator) {
+      case "!=":
+        passes = value !== target2;
+        break;
+      case "==":
+        passes = value === target2;
+        break;
+      case ">":
+        passes = value > target2;
+        break;
+      case "<":
+        passes = value < target2;
+        break;
+      case ">=":
+        passes = value >= target2;
+        break;
+      case "<=":
+        passes = value <= target2;
+        break;
+      default:
+        passes = false;
+    }
+    if (!passes)
+      return false;
+  }
+  return true;
+}
+function canSafelySubstitute(captures) {
+  for (const [, captured] of captures)
+    if (captured.isComplex)
+      return false;
+  return true;
+}
+// src/utilities/pattern-replacement/pattern-parser.ts
+var CONSTRUCTOR_PATTERN = regex2("^new\\s+(?<typeName>\\w+)\\((?<argumentsString>.*)\\)$");
+var STATIC_METHOD_PATTERN = regex2("^(?<typeName>\\w+)\\.(?<methodName>\\w+)\\((?<argumentsString>.*)\\)$");
+var STATIC_ACCESS_PATTERN = regex2("^(?<typeName>\\w+)\\.(?<property>\\w+)$");
+var CALL_PATTERN = regex2("^(?<name>\\w+)\\((?<argumentsString>.*)\\)$");
+function parseParameters(parametersString) {
+  const trimmed = parametersString.trim();
+  if (trimmed === "")
+    return [];
+  const parameters3 = trimmed.split(",").map((parameter2) => parameter2.trim());
+  const result = new Array;
+  let size = 0;
+  for (const parameter2 of parameters3) {
+    if (parameter2 === "_")
+      result[size++] = { kind: "wildcard" };
+    else if (parameter2.startsWith("$"))
+      result[size++] = { kind: "capture", name: parameter2.slice(1) };
+    else if (parameter2.endsWith("?")) {
+      const value = Number.parseFloat(parameter2.slice(0, -1));
+      result[size++] = { kind: "optional", value };
+    } else {
+      const value = Number.parseFloat(parameter2);
+      result[size++] = { kind: "literal", value };
+    }
+  }
+  return result;
+}
+function parseReplacement(replacement) {
+  const staticMatch = STATIC_ACCESS_PATTERN.exec(replacement);
+  if (staticMatch && !replacement.includes("("))
+    return { ...staticMatch.groups, kind: "staticAccess" };
+  const callMatch = CALL_PATTERN.exec(replacement);
+  if (callMatch) {
+    const { name, argumentsString } = callMatch.groups;
+    const parameters3 = argumentsString.trim() === "" ? [] : argumentsString.split(",").map((value) => value.trim());
+    return { kind: "call", name, parameters: parameters3 };
+  }
+  return { kind: "identifier", name: replacement };
+}
+function parsePattern(match, replacement, when) {
+  const conditions = new Map;
+  if (when)
+    for (const [key, value] of Object.entries(when))
+      conditions.set(key, value);
+  const constructorMatch = CONSTRUCTOR_PATTERN.exec(match);
+  if (constructorMatch) {
+    const { typeName, argumentsString } = constructorMatch.groups;
+    return {
+      conditions,
+      original: match,
+      parameters: parseParameters(argumentsString),
+      replacement: parseReplacement(replacement),
+      type: "constructor",
+      typeName
+    };
+  }
+  const staticMethodMatch = STATIC_METHOD_PATTERN.exec(match);
+  if (staticMethodMatch) {
+    const { typeName, methodName, argumentsString } = staticMethodMatch.groups;
+    return {
+      conditions,
+      methodName,
+      original: match,
+      parameters: parseParameters(argumentsString),
+      replacement: parseReplacement(replacement),
+      type: "staticMethod",
+      typeName
+    };
+  }
+  throw new Error(`Invalid pattern: ${match}`);
+}
+// src/utilities/pattern-replacement/pattern-types.ts
+function pattern4(configuration) {
+  return configuration;
+}
+// src/utilities/pattern-replacement/replacement-generator.ts
+function getReplacementIdentifier(replacement) {
+  switch (replacement.kind) {
+    case "identifier":
+      return replacement.name;
+    case "call":
+      return replacement.name;
+    case "staticAccess":
+      return;
+  }
+}
+function generateReplacement(replacement, captures) {
+  const { kind } = replacement;
+  switch (kind) {
+    case "identifier":
+      return replacement.name;
+    case "staticAccess":
+      return `${replacement.typeName}.${replacement.property}`;
+    case "call": {
+      const parameters3 = replacement.parameters.map((argument) => {
+        if (argument.startsWith("$")) {
+          const captureName = argument.slice(1);
+          const captured = captures.get(captureName);
+          if (captured === undefined)
+            throw new Error(`Missing capture: ${captureName}`);
+          return captured.sourceText;
+        }
+        return argument;
+      });
+      return `${replacement.name}(${parameters3.join(", ")})`;
+    }
+    default:
+      throw new Error(`Unknown replacement kind: ${kind}`);
+  }
+}
+// src/rules/prefer-pattern-replacements.ts
+var isRuleOptions2 = Compile(build_default.Object({
+  patterns: build_default.Array(build_default.Object({}, { additionalProperties: true }))
+}));
+function parsePatterns(patterns2) {
+  return patterns2.map((pattern5) => parsePattern(pattern5.match, pattern5.replacement, pattern5.when));
+}
+var preferPatternReplacements = {
+  create(context) {
+    const validatedOptions = isRuleOptions2.Check(context.options[0]) ? context.options[0] : undefined;
+    if (!validatedOptions || validatedOptions.patterns.length === 0)
+      return {};
+    const parsedPatterns = parsePatterns(validatedOptions.patterns);
+    const patternIndex = buildPatternIndex(parsedPatterns);
+    const { sourceCode } = context;
+    function hasNameConflict(node, identifierName) {
+      let scope = sourceCode.getScope(node);
+      while (scope) {
+        if (scope.set.has(identifierName))
+          return true;
+        scope = scope.upper ?? undefined;
+      }
+      return false;
+    }
+    function checkNode(node) {
+      const resolved = resolveCallee(node);
+      if (resolved.kind === "unknown")
+        return;
+      const key = resolved.kind === "constructor" ? `constructor:${resolved.typeName}` : `staticMethod:${resolved.typeName}:${resolved.methodName}`;
+      const candidates2 = patternIndex.get(key);
+      if (!candidates2 || candidates2.length === 0)
+        return;
+      for (const pattern5 of candidates2) {
+        const captures = matchParameters(pattern5.parameters, node.arguments, sourceCode);
+        if (!(captures && evaluateConditions(pattern5.conditions, captures) && canSafelySubstitute(captures))) {
+          continue;
+        }
+        const replacementId = getReplacementIdentifier(pattern5.replacement);
+        if (replacementId && hasNameConflict(node, replacementId))
+          continue;
+        const originalText = sourceCode.getText(node);
+        const replacementText = generateReplacement(pattern5.replacement, captures);
+        context.report({
+          data: { original: originalText, replacement: replacementText },
+          fix: (fixer) => fixer.replaceText(node, replacementText),
+          messageId: "preferReplacement",
+          node
+        });
+        return;
+      }
+    }
+    return {
+      CallExpression: checkNode,
+      NewExpression: checkNode
+    };
+  },
+  defaultOptions: [{ patterns: [] }],
+  meta: {
+    docs: {
+      description: "Enforce using configured replacements for common constructor/method patterns",
+      recommended: false
+    },
+    fixable: "code",
+    messages: {
+      preferReplacement: "Prefer '{{replacement}}' over '{{original}}'"
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          patterns: {
+            items: { type: "object" },
+            type: "array"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "suggestion"
+  }
+};
+var prefer_pattern_replacements_default = preferPatternReplacements;
+
+// src/rules/prefer-sequence-overloads.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES11 } from "@typescript-eslint/types";
 var sequenceDescriptors = [
   { keypointName: "ColorSequenceKeypoint", sequenceName: "ColorSequence" },
   { keypointName: "NumberSequenceKeypoint", sequenceName: "NumberSequence" }
 ];
 function isSequenceIdentifier(node) {
-  if (node.type !== AST_NODE_TYPES9.Identifier)
+  if (node.type !== AST_NODE_TYPES11.Identifier)
     return false;
   for (const { sequenceName } of sequenceDescriptors)
     if (sequenceName === node.name)
@@ -19788,16 +20188,16 @@ function findDescriptor(sequenceName) {
   return;
 }
 var isNumericLiteral = Compile(build_default.Object({
-  type: build_default.Literal(AST_NODE_TYPES9.Literal),
+  type: build_default.Literal(AST_NODE_TYPES11.Literal),
   value: build_default.Number()
 }));
 function isExpressionArgument(argument) {
-  return argument !== undefined && argument.type !== AST_NODE_TYPES9.SpreadElement;
+  return argument !== undefined && argument.type !== AST_NODE_TYPES11.SpreadElement;
 }
 function extractKeypoint(element, descriptor) {
-  if (element === undefined || element.type !== AST_NODE_TYPES9.NewExpression)
+  if (element === undefined || element.type !== AST_NODE_TYPES11.NewExpression)
     return;
-  if (element.callee.type !== AST_NODE_TYPES9.Identifier || element.callee.name !== descriptor.keypointName)
+  if (element.callee.type !== AST_NODE_TYPES11.Identifier || element.callee.name !== descriptor.keypointName)
     return;
   if (element.arguments.length !== 2)
     return;
@@ -19827,7 +20227,7 @@ var preferSequenceOverloads = {
         if (descriptor === undefined || node.arguments.length !== 1)
           return;
         const [argument] = node.arguments;
-        if (argument === undefined || argument.type !== AST_NODE_TYPES9.ArrayExpression || argument.elements.length !== 2)
+        if (argument === undefined || argument.type !== AST_NODE_TYPES11.ArrayExpression || argument.elements.length !== 2)
           return;
         const firstElement = argument.elements[0] ?? undefined;
         const secondElement = argument.elements[1] ?? undefined;
@@ -20173,16 +20573,16 @@ var preferUDim2Shorthand = {
 var prefer_udim2_shorthand_default = preferUDim2Shorthand;
 
 // src/rules/react-hooks-strict-return.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES10 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES12 } from "@typescript-eslint/utils";
 var MAX_RETURN_ELEMENTS = 2;
 var HOOK_PATTERN = /^use[A-Z0-9].*$/;
 function isHookNode(node) {
   let name;
-  if (node.type === AST_NODE_TYPES10.VariableDeclarator && node.id.type === AST_NODE_TYPES10.Identifier) {
+  if (node.type === AST_NODE_TYPES12.VariableDeclarator && node.id.type === AST_NODE_TYPES12.Identifier) {
     ({ name } = node.id);
-  } else if (node.type === AST_NODE_TYPES10.FunctionDeclaration && node.id)
+  } else if (node.type === AST_NODE_TYPES12.FunctionDeclaration && node.id)
     ({ name } = node.id);
-  else if (node.type === AST_NODE_TYPES10.FunctionExpression && node.id)
+  else if (node.type === AST_NODE_TYPES12.FunctionExpression && node.id)
     ({ name } = node.id);
   return name !== undefined && HOOK_PATTERN.test(name);
 }
@@ -20206,27 +20606,27 @@ function getArrayElementsFromVariable(scope, name) {
     if (!identifier3.parent)
       continue;
     const { parent } = identifier3;
-    if (parent.type !== AST_NODE_TYPES10.VariableDeclarator)
+    if (parent.type !== AST_NODE_TYPES12.VariableDeclarator)
       continue;
-    if (!parent.init || parent.init.type !== AST_NODE_TYPES10.ArrayExpression)
+    if (!parent.init || parent.init.type !== AST_NODE_TYPES12.ArrayExpression)
       continue;
     elements.push(...parent.init.elements);
   }
   return elements;
 }
 function countReturnElements(argument, scope) {
-  if (argument.type === AST_NODE_TYPES10.Identifier)
+  if (argument.type === AST_NODE_TYPES12.Identifier)
     return getArrayElementsFromVariable(scope, argument.name).length;
-  if (argument.type !== AST_NODE_TYPES10.ArrayExpression)
+  if (argument.type !== AST_NODE_TYPES12.ArrayExpression)
     return 0;
   let count = 0;
   for (const element of argument.elements) {
     if (element === null)
       count += 1;
-    else if (element.type === AST_NODE_TYPES10.SpreadElement) {
-      if (element.argument.type === AST_NODE_TYPES10.Identifier) {
+    else if (element.type === AST_NODE_TYPES12.SpreadElement) {
+      if (element.argument.type === AST_NODE_TYPES12.Identifier) {
         count += getArrayElementsFromVariable(scope, element.argument.name).length;
-      } else if (element.argument.type === AST_NODE_TYPES10.ArrayExpression) {
+      } else if (element.argument.type === AST_NODE_TYPES12.ArrayExpression) {
         count += element.argument.elements.length;
       } else
         count += 1;
@@ -20239,14 +20639,14 @@ function exceedsMaxReturnProperties(node, scope) {
   const { argument } = node;
   if (argument === null)
     return false;
-  if (argument.type === AST_NODE_TYPES10.ObjectExpression)
+  if (argument.type === AST_NODE_TYPES12.ObjectExpression)
     return false;
-  if (argument.type === AST_NODE_TYPES10.Identifier) {
+  if (argument.type === AST_NODE_TYPES12.Identifier) {
     const variable = getVariableByName(scope, argument.name);
     if (variable) {
       for (const { identifier: identifier3 } of variable.references) {
         const { parent } = identifier3;
-        if (parent?.type === AST_NODE_TYPES10.VariableDeclarator && parent.init?.type === AST_NODE_TYPES10.ObjectExpression) {
+        if (parent?.type === AST_NODE_TYPES12.VariableDeclarator && parent.init?.type === AST_NODE_TYPES12.ObjectExpression) {
           return false;
         }
       }
@@ -20268,13 +20668,13 @@ var reactHooksStrictReturn = {
     return {
       ArrowFunctionExpression(node) {
         const { parent } = node;
-        if (parent?.type === AST_NODE_TYPES10.VariableDeclarator && parent.id.type === AST_NODE_TYPES10.Identifier && HOOK_PATTERN.test(parent.id.name)) {
+        if (parent?.type === AST_NODE_TYPES12.VariableDeclarator && parent.id.type === AST_NODE_TYPES12.Identifier && HOOK_PATTERN.test(parent.id.name)) {
           hookDepth += 1;
         }
       },
       "ArrowFunctionExpression:exit"(node) {
         const { parent } = node;
-        if (parent?.type === AST_NODE_TYPES10.VariableDeclarator && parent.id.type === AST_NODE_TYPES10.Identifier && HOOK_PATTERN.test(parent.id.name)) {
+        if (parent?.type === AST_NODE_TYPES12.VariableDeclarator && parent.id.type === AST_NODE_TYPES12.Identifier && HOOK_PATTERN.test(parent.id.name)) {
           hookDepth -= 1;
         }
       },
@@ -20323,7 +20723,7 @@ var isHookConfiguration = build_default.Object({
   allowAsync: build_default.Boolean(),
   name: build_default.String()
 });
-var isRuleOptions2 = Compile(build_default.Object({
+var isRuleOptions3 = Compile(build_default.Object({
   environment: isEnvironmentMode,
   hooks: build_default.Array(isHookConfiguration)
 }, { additionalProperties: true }));
@@ -20334,7 +20734,7 @@ function parseOptions2(options3) {
       hooks: DEFAULT_HOOKS
     };
   }
-  if (!isRuleOptions2.Check(options3)) {
+  if (!isRuleOptions3.Check(options3)) {
     return {
       environment: "roblox-ts",
       hooks: DEFAULT_HOOKS
@@ -20644,7 +21044,7 @@ var requireNamedEffectFunctions = {
 var require_named_effect_functions_default = requireNamedEffectFunctions;
 
 // src/rules/require-paired-calls.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES11 } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES13 } from "@typescript-eslint/types";
 var isStringArray = Compile(build_default.Readonly(build_default.Array(build_default.String())));
 var isPairConfiguration = Compile(build_default.Readonly(build_default.Object({
   alternatives: build_default.Optional(isStringArray),
@@ -20655,27 +21055,27 @@ var isPairConfiguration = Compile(build_default.Readonly(build_default.Object({
   requireSync: build_default.Optional(build_default.Boolean()),
   yieldingFunctions: build_default.Optional(isStringArray)
 })));
-var isRuleOptions3 = Compile(build_default.Partial(build_default.Readonly(build_default.Object({
+var isRuleOptions4 = Compile(build_default.Partial(build_default.Readonly(build_default.Object({
   allowConditionalClosers: build_default.Optional(build_default.Boolean()),
   allowMultipleOpeners: build_default.Optional(build_default.Boolean()),
   maxNestingDepth: build_default.Optional(build_default.Number()),
   pairs: build_default.Readonly(build_default.Array(isPairConfiguration))
 }))));
 var LOOP_NODE_TYPES = new Set([
-  AST_NODE_TYPES11.DoWhileStatement,
-  AST_NODE_TYPES11.ForInStatement,
-  AST_NODE_TYPES11.ForOfStatement,
-  AST_NODE_TYPES11.ForStatement,
-  AST_NODE_TYPES11.WhileStatement
+  AST_NODE_TYPES13.DoWhileStatement,
+  AST_NODE_TYPES13.ForInStatement,
+  AST_NODE_TYPES13.ForOfStatement,
+  AST_NODE_TYPES13.ForStatement,
+  AST_NODE_TYPES13.WhileStatement
 ]);
 var DEFAULT_ROBLOX_YIELDING_FUNCTIONS = ["task.wait", "wait", "*.WaitForChild", "*.*Async"];
 function getCallName(node) {
   const { callee } = node;
-  if (callee.type === AST_NODE_TYPES11.Identifier)
+  if (callee.type === AST_NODE_TYPES13.Identifier)
     return callee.name;
-  if (callee.type === AST_NODE_TYPES11.MemberExpression) {
-    const object3 = callee.object.type === AST_NODE_TYPES11.Identifier ? callee.object.name : undefined;
-    const property = callee.property.type === AST_NODE_TYPES11.Identifier ? callee.property.name : undefined;
+  if (callee.type === AST_NODE_TYPES13.MemberExpression) {
+    const object3 = callee.object.type === AST_NODE_TYPES13.Identifier ? callee.object.name : undefined;
+    const property = callee.property.type === AST_NODE_TYPES13.Identifier ? callee.property.name : undefined;
     if (object3 !== undefined && property !== undefined)
       return `${object3}.${property}`;
   }
@@ -20711,12 +21111,12 @@ function isLoopLikeStatement(node) {
   return LOOP_NODE_TYPES.has(node.type);
 }
 function isSwitchStatement(node) {
-  return node?.type === AST_NODE_TYPES11.SwitchStatement;
+  return node?.type === AST_NODE_TYPES13.SwitchStatement;
 }
 function findLabeledStatementBody(label, startingNode) {
   let current = startingNode;
   while (current) {
-    if (current.type === AST_NODE_TYPES11.LabeledStatement && current.label.name === label.name)
+    if (current.type === AST_NODE_TYPES13.LabeledStatement && current.label.name === label.name)
       return current.body;
     current = current.parent ?? undefined;
   }
@@ -20765,7 +21165,7 @@ var messages = {
 var rule = {
   create(context) {
     const [rawOptions] = context.options;
-    const baseOptions = isRuleOptions3.Check(rawOptions) ? rawOptions : {};
+    const baseOptions = isRuleOptions4.Check(rawOptions) ? rawOptions : {};
     const options3 = {
       allowConditionalClosers: baseOptions.allowConditionalClosers ?? false,
       allowMultipleOpeners: baseOptions.allowMultipleOpeners ?? true,
@@ -20865,12 +21265,12 @@ var rule = {
       if (configuration.platform !== "roblox")
         return false;
       const yieldingFunctions = configuration.yieldingFunctions ?? DEFAULT_ROBLOX_YIELDING_FUNCTIONS;
-      return yieldingFunctions.some((pattern4) => {
-        if (pattern4.startsWith("*.")) {
-          const methodName = pattern4.slice(2);
+      return yieldingFunctions.some((pattern5) => {
+        if (pattern5.startsWith("*.")) {
+          const methodName = pattern5.slice(2);
           return functionName.endsWith(`.${methodName}`);
         }
-        return functionName === pattern4;
+        return functionName === pattern5;
       });
     }
     function onFunctionEnter(node) {
@@ -20978,7 +21378,7 @@ var rule = {
     function onIfConsequentExit(node) {
       const consequentNode = node;
       const { parent } = consequentNode;
-      if (parent?.type === AST_NODE_TYPES11.IfStatement) {
+      if (parent?.type === AST_NODE_TYPES13.IfStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -20993,7 +21393,7 @@ var rule = {
     function onIfAlternateExit(node) {
       const alternateNode = node;
       const { parent } = alternateNode;
-      if (parent?.type === AST_NODE_TYPES11.IfStatement) {
+      if (parent?.type === AST_NODE_TYPES13.IfStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -21042,7 +21442,7 @@ var rule = {
     function onTryBlockExit(node) {
       const blockNode = node;
       const { parent } = blockNode;
-      if (parent?.type === AST_NODE_TYPES11.TryStatement) {
+      if (parent?.type === AST_NODE_TYPES13.TryStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -21061,7 +21461,7 @@ var rule = {
     function onCatchClauseExit(node) {
       const catchNode = node;
       const { parent } = catchNode;
-      if (parent?.type === AST_NODE_TYPES11.TryStatement) {
+      if (parent?.type === AST_NODE_TYPES13.TryStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -21124,7 +21524,7 @@ var rule = {
     function onSwitchCaseExit(node) {
       const caseNode = node;
       const { parent } = caseNode;
-      if (parent?.type === AST_NODE_TYPES11.SwitchStatement) {
+      if (parent?.type === AST_NODE_TYPES13.SwitchStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -21155,7 +21555,7 @@ var rule = {
       for (const { opener, config, node: node2 } of openerStack) {
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const statementType = statementNode.type === AST_NODE_TYPES11.ReturnStatement ? "return" : "throw";
+        const statementType = statementNode.type === AST_NODE_TYPES13.ReturnStatement ? "return" : "throw";
         const lineNumber = statementNode.loc?.start.line ?? 0;
         context.report({
           data: {
@@ -21172,7 +21572,7 @@ var rule = {
       const statementNode = node;
       if (openerStack.length === 0)
         return;
-      const targetLoop = statementNode.type === AST_NODE_TYPES11.ContinueStatement ? resolveContinueTargetLoop(statementNode) : resolveBreakTargetLoop(statementNode);
+      const targetLoop = statementNode.type === AST_NODE_TYPES13.ContinueStatement ? resolveContinueTargetLoop(statementNode) : resolveBreakTargetLoop(statementNode);
       if (!targetLoop)
         return;
       for (const { node: openerNode, config, opener, loopAncestors } of openerStack) {
@@ -21180,7 +21580,7 @@ var rule = {
           continue;
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const statementType = statementNode.type === AST_NODE_TYPES11.BreakStatement ? "break" : "continue";
+        const statementType = statementNode.type === AST_NODE_TYPES13.BreakStatement ? "break" : "continue";
         const lineNumber = statementNode.loc?.start.line ?? 0;
         context.report({
           data: {
@@ -21318,7 +21718,7 @@ var rule = {
           continue;
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const asyncType = asyncNode.type === AST_NODE_TYPES11.AwaitExpression ? "await" : "yield";
+        const asyncType = asyncNode.type === AST_NODE_TYPES13.AwaitExpression ? "await" : "yield";
         context.report({
           data: { asyncType, closer, opener },
           messageId: "asyncViolation",
@@ -21849,8 +22249,8 @@ function resolveRelativeImport(importSource, sourceFile) {
 }
 
 // src/rules/strict-component-boundaries.ts
-function toRegExp(pattern4) {
-  return new RegExp(pattern4, "i");
+function toRegExp(pattern5) {
+  return new RegExp(pattern5, "i");
 }
 function pathSegmentsFromSource(source) {
   return source.split("/").filter((part) => !part.startsWith("."));
@@ -23106,6 +23506,9 @@ function createNoUselessUseSpringOptions(options3 = {}) {
     ...options3
   };
 }
+function createPreferPatternReplacementsOptions(patterns2 = []) {
+  return { patterns: patterns2 };
+}
 
 // src/index.ts
 var rules = {
@@ -23127,6 +23530,7 @@ var rules = {
   "prefer-early-return": prefer_early_return_default,
   "prefer-module-scope-constants": prefer_module_scope_constants_default,
   "prefer-pascal-case-enums": prefer_pascal_case_enums_default,
+  "prefer-pattern-replacements": prefer_pattern_replacements_default,
   "prefer-sequence-overloads": prefer_sequence_overloads_default,
   "prefer-singular-enums": prefer_singular_enums_default,
   "prefer-udim2-shorthand": prefer_udim2_shorthand_default,
@@ -23168,12 +23572,14 @@ var plugin = {
 };
 var src_default = plugin;
 export {
+  pattern4 as pattern,
   defaultRobloxProfilePair,
   src_default as default,
   createUseHookAtTopLevelOptions,
   createUseExhaustiveDependenciesOptions,
   createRequirePairedCallsOptions,
   createReactKeysOptions,
+  createPreferPatternReplacementsOptions,
   createPairConfiguration,
   createNoUselessUseSpringOptions,
   createNoShorthandOptions,
@@ -23185,4 +23591,4 @@ export {
   createBanInstancesOptions
 };
 
-//# debugId=CB943D9A894DADAF64756E2164756E21
+//# debugId=928BD58DAA13C57A64756E2164756E21