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

package/dist/index.js

@@ -18728,6 +18728,7 @@ var no_print_default = noPrint;
 import { TSESTree as TSESTree6 } from "@typescript-eslint/types";
 var isRuleOptions = Compile(build_default.Object({
   allowPropertyAccess: build_default.Optional(build_default.Array(build_default.String())),
+  ignoreShorthands: build_default.Optional(build_default.Array(build_default.String())),
   shorthands: build_default.Optional(build_default.Record(build_default.String(), build_default.String()))
 }));
 function isRecord2(value) {
@@ -18735,6 +18736,7 @@ function isRecord2(value) {
 }
 var DEFAULT_OPTIONS2 = {
   allowPropertyAccess: ["char"],
+  ignoreShorthands: [],
   shorthands: {
     args: "parameters",
     char: "character",
@@ -18744,32 +18746,78 @@ var DEFAULT_OPTIONS2 = {
 };
 var REGEX_PATTERN_MATCHER = regex2("^/(?<first>.+)/(?<second>[gimsuy]*)$");
 var WORD_BOUNDARY_REGEX = /(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|(?<=[a-zA-Z])(?=\d)|(?<=\d)(?=[a-zA-Z])/;
+var FUNT_PATTERN = regex2("[.+^${}()|[\\]\\\\]", "g");
+var SPLIT_CACHE = new Map;
+var MAX_SPLIT_CACHE_SIZE = 1024;
 function splitIdentifierIntoWords(identifier3) {
-  return identifier3.split(WORD_BOUNDARY_REGEX);
+  const cached = SPLIT_CACHE.get(identifier3);
+  if (cached !== undefined)
+    return cached;
+  const words = identifier3.split(WORD_BOUNDARY_REGEX);
+  if (SPLIT_CACHE.size >= MAX_SPLIT_CACHE_SIZE) {
+    const firstKey = SPLIT_CACHE.keys().next().value;
+    if (firstKey !== undefined)
+      SPLIT_CACHE.delete(firstKey);
+  }
+  SPLIT_CACHE.set(identifier3, words);
+  return words;
+}
+function countCaptureGroups(replacement) {
+  const matches = replacement.match(/\$(\d+)/g);
+  if (matches === null)
+    return 0;
+  let maxGroup = 0;
+  for (const dollarRef of matches) {
+    const groupNum = Number.parseInt(dollarRef.slice(1), 10);
+    if (groupNum > maxGroup)
+      maxGroup = groupNum;
+  }
+  return maxGroup;
+}
+var REPLACEMENT_PATTERN_CACHE = new Map;
+function getReplacementPattern(index2) {
+  let pattern4 = REPLACEMENT_PATTERN_CACHE.get(index2);
+  if (pattern4 === undefined) {
+    pattern4 = new RegExp(`\\$${index2}`, "g");
+    REPLACEMENT_PATTERN_CACHE.set(index2, pattern4);
+  }
+  return pattern4;
+}
+function buildReplacementPatterns(replacement) {
+  const count = countCaptureGroups(replacement);
+  if (count === 0)
+    return [];
+  const patterns2 = new Array(count);
+  for (let index2 = 1;index2 <= count; index2 += 1) {
+    patterns2[index2 - 1] = getReplacementPattern(index2);
+  }
+  return patterns2;
 }
 function createMatcher(key, replacement) {
   if (key.startsWith("/")) {
-    const match = REGEX_PATTERN_MATCHER.exec(key);
-    if (match) {
+    const match = key.match(REGEX_PATTERN_MATCHER);
+    if (match?.groups) {
       return {
         matcher: {
           original: key,
           pattern: new RegExp(`^${match.groups.first}$`, match.groups.second),
-          replacement
+          replacement,
+          replacementPatterns: buildReplacementPatterns(replacement)
         },
         type: "pattern"
       };
     }
   }
   if (key.includes("*") || key.includes("?")) {
-    const regexPattern = key.replaceAll(/[.+^${}()|[\]\\]/g, String.raw`\$&`).replaceAll("*", "(.*)").replaceAll("?", "(.)");
+    const regexPattern = key.replaceAll(FUNT_PATTERN, String.raw`\$&`).replaceAll("*", "(.*)").replaceAll("?", "(.)");
     let captureIndex = 0;
     const regexReplacement = replacement.replaceAll("*", () => `$${++captureIndex}`);
     return {
       matcher: {
         original: key,
         pattern: new RegExp(`^${regexPattern}$`),
-        replacement: regexReplacement
+        replacement: regexReplacement,
+        replacementPatterns: buildReplacementPatterns(regexReplacement)
       },
       type: "pattern"
     };
@@ -18784,6 +18832,7 @@ function matchWord(word, matchers, exactMatchers) {
   const exactReplacement = exactMatchers.get(word);
   if (exactReplacement !== undefined) {
     return {
+      matchedWord: word,
       replacement: exactReplacement,
       shorthand: word
     };
@@ -18792,10 +18841,13 @@ function matchWord(word, matchers, exactMatchers) {
     const match = word.match(matcher.pattern);
     if (match) {
       let replaced = matcher.replacement;
-      for (let index2 = 1;index2 < match.length; index2 += 1) {
-        replaced = replaced.replaceAll(new RegExp(`\\$${index2}`, "g"), match[index2] ?? "");
+      let captureIndex = 1;
+      for (const replacementPattern of matcher.replacementPatterns) {
+        replaced = replaced.replaceAll(replacementPattern, match[captureIndex] ?? "");
+        captureIndex += 1;
       }
       return {
+        matchedWord: word,
         replacement: replaced,
         shorthand: matcher.original
       };
@@ -18803,22 +18855,13 @@ function matchWord(word, matchers, exactMatchers) {
   }
   return;
 }
-function buildReplacementIdentifier(identifier3, options3) {
-  const words = splitIdentifierIntoWords(identifier3);
-  const matches = new Array;
-  let hasMatch = false;
-  const newWords = words.map((word) => {
-    const match = matchWord(word, options3.matchers, options3.exactMatchers);
-    if (match) {
-      hasMatch = true;
-      matches.push(match);
-      return match.replacement;
-    }
-    return word;
-  });
-  if (!hasMatch)
-    return;
-  return { matches, replaced: newWords.join("") };
+function isWordIgnored(word, ignoreMatchers, ignoreExact) {
+  if (ignoreExact.has(word))
+    return true;
+  for (const matcher of ignoreMatchers)
+    if (matcher.pattern.test(word))
+      return true;
+  return false;
 }
 function normalizeOptions2(rawOptions) {
   const mergedShorthands = { ...DEFAULT_OPTIONS2.shorthands };
@@ -18836,29 +18879,112 @@ function normalizeOptions2(rawOptions) {
       matchers.push(result.matcher);
   }
   const allowPropertyAccessSource = rawOptions?.allowPropertyAccess ?? DEFAULT_OPTIONS2.allowPropertyAccess;
+  const ignoreMatchers = new Array;
+  const ignoreExact = new Set;
+  for (const pattern4 of rawOptions?.ignoreShorthands ?? []) {
+    const result = createMatcher(pattern4, "");
+    if (result.type === "exact")
+      ignoreExact.add(result.original);
+    else
+      ignoreMatchers.push(result.matcher);
+  }
   return {
     allowPropertyAccess: new Set(allowPropertyAccessSource),
     exactMatchers,
+    ignoreExact,
+    ignoreMatchers,
     matchers,
     selector: "Identifier"
   };
 }
+var IMPORT_PARENT_TYPES = new Set(["ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier"]);
 var noShorthandNames = {
   create(context) {
     const validatedOptions = isRuleOptions.Check(context.options[0]) ? context.options[0] : undefined;
     const normalized = normalizeOptions2(validatedOptions);
-    const { allowPropertyAccess, selector } = normalized;
+    const { allowPropertyAccess, ignoreMatchers, ignoreExact, selector, matchers, exactMatchers } = normalized;
+    const identifierResultCache = new Map;
+    const ignoredWordCache = new Map;
+    function cachedIsWordIgnored(word) {
+      const cached = ignoredWordCache.get(word);
+      if (cached !== undefined)
+        return cached;
+      const result = isWordIgnored(word, ignoreMatchers, ignoreExact);
+      ignoredWordCache.set(word, result);
+      return result;
+    }
+    function getIdentifierResult(identifier3) {
+      if (identifierResultCache.has(identifier3))
+        return identifierResultCache.get(identifier3);
+      const words = splitIdentifierIntoWords(identifier3);
+      const matches = new Array;
+      let hasMatch = false;
+      for (const word of words) {
+        const match = matchWord(word, matchers, exactMatchers);
+        if (match) {
+          hasMatch = true;
+          matches.push(match);
+        }
+      }
+      if (!hasMatch) {
+        identifierResultCache.set(identifier3, undefined);
+        return;
+      }
+      let replaced = "";
+      let matchIndex = 0;
+      for (const word of words) {
+        const currentMatch = matches[matchIndex];
+        if (currentMatch !== undefined && currentMatch.matchedWord === word) {
+          replaced += currentMatch.replacement;
+          matchIndex += 1;
+        } else {
+          replaced += word;
+        }
+      }
+      const result = { matches, replaced };
+      identifierResultCache.set(identifier3, result);
+      return result;
+    }
     return {
       [selector](node) {
+        const { parent } = node;
+        if (parent !== undefined && isRecord2(parent)) {
+          const parentType = parent.type;
+          if (IMPORT_PARENT_TYPES.has(parentType))
+            return;
+        }
         const identifierName = node.name;
-        const result = buildReplacementIdentifier(identifierName, normalized);
+        const result = getIdentifierResult(identifierName);
         if (result === undefined)
           return;
         const { replaced, matches } = result;
-        const { parent } = node;
-        const [match] = matches;
-        if (matches.length === 1 && match !== undefined && allowPropertyAccess.has(match.shorthand) && parent !== undefined && isRecord2(parent) && parent.type === TSESTree6.AST_NODE_TYPES.MemberExpression && parent.property === node) {
+        if (cachedIsWordIgnored(identifierName))
           return;
+        let allIgnored = true;
+        for (const match of matches) {
+          if (!cachedIsWordIgnored(match.matchedWord)) {
+            allIgnored = false;
+            break;
+          }
+        }
+        if (allIgnored)
+          return;
+        if (parent !== undefined && isRecord2(parent)) {
+          const parentType = parent.type;
+          const isPropertyAccess = parentType === "MemberExpression" && parent.property === node || parentType === "TSQualifiedName" && parent.right === node;
+          if (isPropertyAccess) {
+            if (allowPropertyAccess.has(identifierName))
+              return;
+            let allWordsAllowed = true;
+            for (const match of matches) {
+              if (!allowPropertyAccess.has(match.matchedWord)) {
+                allWordsAllowed = false;
+                break;
+              }
+            }
+            if (allWordsAllowed)
+              return;
+          }
         }
         if (identifierName === "plr" && parent?.type === TSESTree6.AST_NODE_TYPES.VariableDeclarator && parent.id === node) {
           const { init } = parent;
@@ -18893,7 +19019,12 @@ var noShorthandNames = {
         additionalProperties: false,
         properties: {
           allowPropertyAccess: {
-            description: "Shorthand names that are allowed as property access",
+            description: "Shorthand names allowed as property access or qualified names",
+            items: { type: "string" },
+            type: "array"
+          },
+          ignoreShorthands: {
+            description: "Shorthand patterns to ignore completely (supports exact, glob, regex)",
             items: { type: "string" },
             type: "array"
           },
@@ -19636,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)
@@ -19657,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;
@@ -19696,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;
@@ -20042,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);
 }
@@ -20075,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;
@@ -20108,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;
         }
       }
@@ -20137,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;
         }
       },
@@ -20192,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 }));
@@ -20203,7 +20734,7 @@ function parseOptions2(options3) {
       hooks: DEFAULT_HOOKS
     };
   }
-  if (!isRuleOptions2.Check(options3)) {
+  if (!isRuleOptions3.Check(options3)) {
     return {
       environment: "roblox-ts",
       hooks: DEFAULT_HOOKS
@@ -20513,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),
@@ -20524,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}`;
   }
@@ -20580,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;
   }
@@ -20620,10 +21151,21 @@ function resolveContinueTargetLoop(statement) {
 function cloneEntry(value) {
   return { ...value, loopAncestors: [...value.loopAncestors] };
 }
+var messages = {
+  asyncViolation: "Cannot use {{asyncType}} between '{{opener}}' and '{{closer}}' (requireSync: true)",
+  conditionalOpener: "Conditional opener '{{opener}}' at {{location}} may not have matching closer on all paths",
+  maxNestingExceeded: "Maximum nesting depth of {{max}} exceeded for paired calls",
+  multipleOpeners: "Multiple consecutive calls to '{{opener}}' without matching closers (allowMultipleOpeners: false)",
+  robloxYieldViolation: "Yielding function '{{yieldingFunction}}' auto-closes all profiles - subsequent '{{closer}}' will error",
+  unexpectedCloser: "Unexpected call to '{{closer}}' - expected one of: {{expected}}",
+  unpairedCloser: "Unexpected call to '{{closer}}' - no matching opener on stack",
+  unpairedOpener: "Unpaired call to '{{opener}}' - missing '{{closer}}' on {{paths}}",
+  wrongOrder: "Closer '{{closer}}' called out of order - expected to close '{{expected}}' but '{{actual}}' is still open"
+};
 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,
@@ -20656,12 +21198,14 @@ var rule = {
       if (closerToOpenersCache.has(closer))
         return closerToOpenersCache.get(closer) ?? [];
       const names = new Array;
+      let size = 0;
       for (const pair of options3.pairs) {
         if (!getValidClosers(pair).includes(closer))
           continue;
-        for (const openerName of getAllOpeners(pair))
+        for (const openerName of getAllOpeners(pair)) {
           if (!names.includes(openerName))
-            names.push(openerName);
+            names[size++] = openerName;
+        }
       }
       closerToOpenersCache.set(closer, names);
       return names;
@@ -20670,6 +21214,7 @@ var rule = {
       if (openerToClosersCache.has(opener))
         return openerToClosersCache.get(opener) ?? [];
       const closers = new Array;
+      let size = 0;
       for (const pair of options3.pairs) {
         const allOpeners = getAllOpeners(pair);
         if (!allOpeners.includes(opener))
@@ -20677,7 +21222,7 @@ var rule = {
         const validClosers = getValidClosers(pair);
         for (const closer of validClosers)
           if (!closers.includes(closer))
-            closers.push(closer);
+            closers[size++] = closer;
       }
       openerToClosersCache.set(opener, closers);
       return closers;
@@ -20713,24 +21258,19 @@ var rule = {
     function saveSnapshot(node) {
       stackSnapshots.set(node, cloneStack());
     }
-    function findPairConfig(functionName, isOpener) {
-      return options3.pairs.find((pair) => {
-        if (isOpener)
-          return getAllOpeners(pair).includes(functionName);
-        const validClosers = getValidClosers(pair);
-        return validClosers.includes(functionName);
-      });
+    function findPairConfiguration(functionName, isOpener) {
+      return options3.pairs.find((pair) => (isOpener ? getAllOpeners(pair) : getValidClosers(pair)).includes(functionName));
     }
     function isRobloxYieldingFunction(functionName, configuration) {
       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) {
@@ -20838,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);
@@ -20853,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);
@@ -20902,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);
@@ -20921,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);
@@ -20984,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);
@@ -21015,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: {
@@ -21032,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) {
@@ -21040,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: {
@@ -21058,12 +21598,12 @@ var rule = {
       const callName = getCallName(callNode);
       if (callName === undefined || callName === "")
         return;
-      const openerConfig = findPairConfig(callName, true);
+      const openerConfig = findPairConfiguration(callName, true);
       if (openerConfig) {
         handleOpener(callNode, callName, openerConfig);
         return;
       }
-      if (findPairConfig(callName, false)) {
+      if (findPairConfiguration(callName, false)) {
         handleCloser(callNode, callName);
         return;
       }
@@ -21115,31 +21655,31 @@ var rule = {
             messageId: "unpairedCloser",
             node
           });
+          return;
+        }
+        const topEntry = openerStack.at(-1);
+        if (topEntry) {
+          const expectedClosers = getExpectedClosersForOpener(topEntry.opener);
+          const closerDescription = formatOpenerList(expectedClosers);
+          context.report({
+            data: {
+              closer,
+              expected: closerDescription
+            },
+            messageId: "unexpectedCloser",
+            node
+          });
         } else {
-          const topEntry = openerStack.at(-1);
-          if (topEntry) {
-            const expectedClosers = getExpectedClosersForOpener(topEntry.opener);
-            const closerDescription = formatOpenerList(expectedClosers);
-            context.report({
-              data: {
-                closer,
-                expected: closerDescription
-              },
-              messageId: "unexpectedCloser",
-              node
-            });
-          } else {
-            const openerCandidates = getConfiguredOpenersForCloser(closer);
-            const openerDescription = formatOpenerList(openerCandidates);
-            context.report({
-              data: {
-                closer,
-                opener: openerDescription
-              },
-              messageId: "unpairedCloser",
-              node
-            });
-          }
+          const openerCandidates = getConfiguredOpenersForCloser(closer);
+          const openerDescription = formatOpenerList(openerCandidates);
+          context.report({
+            data: {
+              closer,
+              opener: openerDescription
+            },
+            messageId: "unpairedCloser",
+            node
+          });
         }
         return;
       }
@@ -21178,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",
@@ -21200,10 +21740,9 @@ var rule = {
       ForInStatement: onLoopEnter,
       "ForInStatement:exit": onLoopExit,
       ForOfStatement: (node) => {
-        const forOfNode = node;
-        if (forOfNode.await)
-          onAsyncYield(forOfNode);
-        onLoopEnter(forOfNode);
+        if (node.await)
+          onAsyncYield(node);
+        onLoopEnter(node);
       },
       "ForOfStatement:exit": onLoopExit,
       ForStatement: onLoopEnter,
@@ -21232,6 +21771,7 @@ var rule = {
       YieldExpression: onAsyncYield
     };
   },
+  defaultOptions: [],
   meta: {
     docs: {
       description: "Enforces balanced opener/closer function calls across all execution paths",
@@ -21239,17 +21779,7 @@ var rule = {
       url: "https://github.com/howmanysmall/eslint-idiot-lint/tree/main/docs/rules/require-paired-calls.md"
     },
     fixable: "code",
-    messages: {
-      asyncViolation: "Cannot use {{asyncType}} between '{{opener}}' and '{{closer}}' (requireSync: true)",
-      conditionalOpener: "Conditional opener '{{opener}}' at {{location}} may not have matching closer on all paths",
-      maxNestingExceeded: "Maximum nesting depth of {{max}} exceeded for paired calls",
-      multipleOpeners: "Multiple consecutive calls to '{{opener}}' without matching closers (allowMultipleOpeners: false)",
-      robloxYieldViolation: "Yielding function '{{yieldingFunction}}' auto-closes all profiles - subsequent '{{closer}}' will error",
-      unexpectedCloser: "Unexpected call to '{{closer}}' - expected one of: {{expected}}",
-      unpairedCloser: "Unexpected call to '{{closer}}' - no matching opener on stack",
-      unpairedOpener: "Unpaired call to '{{opener}}' - missing '{{closer}}' on {{paths}}",
-      wrongOrder: "Closer '{{closer}}' called out of order - expected to close '{{expected}}' but '{{actual}}' is still open"
-    },
+    messages,
     schema: [
       {
         additionalProperties: false,
@@ -21719,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("."));
@@ -21999,8 +22529,9 @@ function isStableValue(variable, identifierName, stableHooks) {
       return true;
     if (type3 === "Variable" && node.type === TSESTree10.AST_NODE_TYPES.VariableDeclarator) {
       const { parent } = node;
-      if (!parent || parent.type !== TSESTree10.AST_NODE_TYPES.VariableDeclaration || parent.kind !== "const")
+      if (!parent || parent.type !== TSESTree10.AST_NODE_TYPES.VariableDeclaration || parent.kind !== "const") {
         continue;
+      }
       const init = node.init;
       if (init && isStableHookValue(init, node, identifierName, stableHooks))
         return true;
@@ -22575,8 +23106,9 @@ function isHookCall(node) {
   const { callee } = node;
   if (callee.type === TSESTree11.AST_NODE_TYPES.Identifier)
     return isReactHook(callee.name);
-  if (callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree11.AST_NODE_TYPES.Identifier)
+  if (callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree11.AST_NODE_TYPES.Identifier) {
     return isReactHook(callee.property.name);
+  }
   return false;
 }
 var FUNCTION_BOUNDARIES2 = new Set([
@@ -22610,9 +23142,7 @@ function isRecursiveCall(node, functionName) {
   if (!functionName)
     return false;
   const { callee } = node;
-  if (callee.type === "Identifier")
-    return callee.name === functionName;
-  return false;
+  return callee.type === "Identifier" && callee.name === functionName;
 }
 var useHookAtTopLevel = {
   create(context) {
@@ -22913,7 +23443,7 @@ function createNoInstanceMethodsOptions(options3 = {}) {
   };
 }
 function createNoShorthandOptions(options3 = {}) {
-  return { allowPropertyAccess: [], shorthands: {}, ...options3 };
+  return { allowPropertyAccess: [], ignoreShorthands: [], shorthands: {}, ...options3 };
 }
 function createEffectFunctionOptions(options3 = {}) {
   return { environment: "standard", hooks: [], ...options3 };
@@ -22976,6 +23506,9 @@ function createNoUselessUseSpringOptions(options3 = {}) {
     ...options3
   };
 }
+function createPreferPatternReplacementsOptions(patterns2 = []) {
+  return { patterns: patterns2 };
+}
 
 // src/index.ts
 var rules = {
@@ -22997,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,
@@ -23038,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,
@@ -23055,4 +23591,4 @@ export {
   createBanInstancesOptions
 };
 
-//# debugId=C1BEC810E1B754DD64756E2164756E21
+//# debugId=928BD58DAA13C57A64756E2164756E21