@pobammer-ts/eslint-cease-nonsense-rules 1.6.0 → 1.7.0

package/dist/index.js

@@ -25,6 +25,7 @@ var __export = (target, all) => {
       set: (newValue) => all[name] = () => newValue
     });
 };
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // node_modules/eslint-visitor-keys/dist/eslint-visitor-keys.cjs
@@ -5663,7 +5664,7 @@ var require_ScopeBase = __commonJS((exports) => {
       }
     };
     #staticCloseRef = (ref6) => {
-      const resolve2 = () => {
+      const resolve3 = () => {
         const name = ref6.identifier.name;
         const variable = this.set.get(name);
         if (!variable) {
@@ -5681,7 +5682,7 @@ var require_ScopeBase = __commonJS((exports) => {
         ref6.resolved = variable;
         return true;
       };
-      if (!resolve2()) {
+      if (!resolve3()) {
         this.delegateToUpperScope(ref6);
       }
     };
@@ -6163,7 +6164,7 @@ var require_VisitorBase = __commonJS((exports) => {
   function isObject(obj) {
     return typeof obj === "object" && obj != null;
   }
-  function isNode3(node) {
+  function isNode2(node) {
     return isObject(node) && typeof node.type === "string";
   }
 
@@ -6190,11 +6191,11 @@ var require_VisitorBase = __commonJS((exports) => {
         }
         if (Array.isArray(child)) {
           for (const subChild of child) {
-            if (isNode3(subChild)) {
+            if (isNode2(subChild)) {
               this.visit(subChild);
             }
           }
-        } else if (isNode3(child)) {
+        } else if (isNode2(child)) {
           this.visit(child);
         }
       }
@@ -7399,7 +7400,7 @@ var require_analyze = __commonJS((exports) => {
   var visitor_keys_1 = require_dist();
   var referencer_1 = require_referencer();
   var ScopeManager_1 = require_ScopeManager();
-  var DEFAULT_OPTIONS3 = {
+  var DEFAULT_OPTIONS = {
     childVisitorKeys: visitor_keys_1.visitorKeys,
     emitDecoratorMetadata: false,
     globalReturn: false,
@@ -7411,14 +7412,14 @@ var require_analyze = __commonJS((exports) => {
   };
   function analyze(tree, providedOptions) {
     const options3 = {
-      childVisitorKeys: providedOptions?.childVisitorKeys ?? DEFAULT_OPTIONS3.childVisitorKeys,
+      childVisitorKeys: providedOptions?.childVisitorKeys ?? DEFAULT_OPTIONS.childVisitorKeys,
       emitDecoratorMetadata: false,
-      globalReturn: providedOptions?.globalReturn ?? DEFAULT_OPTIONS3.globalReturn,
-      impliedStrict: providedOptions?.impliedStrict ?? DEFAULT_OPTIONS3.impliedStrict,
-      jsxFragmentName: providedOptions?.jsxFragmentName ?? DEFAULT_OPTIONS3.jsxFragmentName,
-      jsxPragma: providedOptions?.jsxPragma === undefined ? DEFAULT_OPTIONS3.jsxPragma : providedOptions.jsxPragma,
+      globalReturn: providedOptions?.globalReturn ?? DEFAULT_OPTIONS.globalReturn,
+      impliedStrict: providedOptions?.impliedStrict ?? DEFAULT_OPTIONS.impliedStrict,
+      jsxFragmentName: providedOptions?.jsxFragmentName ?? DEFAULT_OPTIONS.jsxFragmentName,
+      jsxPragma: providedOptions?.jsxPragma === undefined ? DEFAULT_OPTIONS.jsxPragma : providedOptions.jsxPragma,
       lib: providedOptions?.lib ?? ["esnext"],
-      sourceType: providedOptions?.sourceType ?? DEFAULT_OPTIONS3.sourceType
+      sourceType: providedOptions?.sourceType ?? DEFAULT_OPTIONS.sourceType
     };
     options3.lib = options3.lib.map((l) => l.toLowerCase());
     const scopeManager = new ScopeManager_1.ScopeManager(options3);
@@ -15425,7 +15426,10 @@ function Compile(...args) {
 var isArrayConfig = Compile(build_default.Array(build_default.String()));
 var isObjectConfig = Compile(build_default.Record(build_default.String(), build_default.String()));
 var isOptionsObject = Compile(build_default.Object({
-  bannedInstances: build_default.Union([build_default.Array(build_default.String()), build_default.Record(build_default.String(), build_default.String())])
+  bannedInstances: build_default.Union([
+    build_default.Array(build_default.String()),
+    build_default.Record(build_default.String(), build_default.String())
+  ])
 }));
 function normalizeConfig(options3) {
   if (!isOptionsObject.Check(options3))
@@ -15434,13 +15438,13 @@ function normalizeConfig(options3) {
   if (isArrayConfig.Check(bannedInstances)) {
     const map = new Map;
     for (const className of bannedInstances)
-      map.set(className.toLowerCase(), { originalName: className, message: undefined });
+      map.set(className.toLowerCase(), { message: undefined, originalName: className });
     return { bannedClasses: map };
   }
   if (isObjectConfig.Check(bannedInstances)) {
     const map = new Map;
     for (const [className, message] of Object.entries(bannedInstances))
-      map.set(className.toLowerCase(), { originalName: className, message });
+      map.set(className.toLowerCase(), { message, originalName: className });
     return { bannedClasses: map };
   }
   return { bannedClasses: new Map };
@@ -15597,9 +15601,9 @@ function hasTypeAnnotationProperty(node) {
 }
 function hasTypeAnnotation(node) {
   if (node.type === TSESTree3.AST_NODE_TYPES.VariableDeclarator && node.id && typeof node.id === "object" && hasTypeAnnotationProperty(node.id))
-    return !!node.id.typeAnnotation;
+    return Boolean(node.id.typeAnnotation);
   if (SHOULD_NOT_NOT_RETURN_TYPE.has(node.type))
-    return !!node.returnType;
+    return Boolean(node.returnType);
   return false;
 }
 function getTypeName(node) {
@@ -15610,29 +15614,33 @@ function isIanitorValidator(node) {
 }
 function extractIanitorStaticVariable(typeAnnotation) {
   let currentType = typeAnnotation;
-  if (currentType.type === TSESTree3.AST_NODE_TYPES.TSTypeReference && currentType.typeName.type === TSESTree3.AST_NODE_TYPES.Identifier && currentType.typeName.name === "Readonly" && currentType.typeArguments?.params[0])
-    currentType = currentType.typeArguments.params[0];
+  if (currentType.type === TSESTree3.AST_NODE_TYPES.TSTypeReference && currentType.typeName.type === TSESTree3.AST_NODE_TYPES.Identifier && currentType.typeName.name === "Readonly" && currentType.typeArguments?.params[0]) {
+    [currentType] = currentType.typeArguments.params;
+  }
   if (currentType.type !== TSESTree3.AST_NODE_TYPES.TSTypeReference)
     return;
   const { typeName, typeArguments } = currentType;
   const firstParam = typeArguments?.params[0];
-  if (typeName.type === TSESTree3.AST_NODE_TYPES.TSQualifiedName && typeName.left.type === TSESTree3.AST_NODE_TYPES.Identifier && typeName.left.name === "Ianitor" && typeName.right.type === TSESTree3.AST_NODE_TYPES.Identifier && typeName.right.name === "Static" && firstParam?.type === TSESTree3.AST_NODE_TYPES.TSTypeQuery && firstParam.exprName.type === TSESTree3.AST_NODE_TYPES.Identifier)
+  if (typeName.type === TSESTree3.AST_NODE_TYPES.TSQualifiedName && typeName.left.type === TSESTree3.AST_NODE_TYPES.Identifier && typeName.left.name === "Ianitor" && typeName.right.type === TSESTree3.AST_NODE_TYPES.Identifier && typeName.right.name === "Static" && firstParam?.type === TSESTree3.AST_NODE_TYPES.TSTypeQuery && firstParam.exprName.type === TSESTree3.AST_NODE_TYPES.Identifier) {
     return firstParam.exprName.name;
+  }
   return;
 }
 function hasIanitorStaticType(typeAnnotation) {
   let currentType = typeAnnotation;
-  if (currentType.type === TSESTree3.AST_NODE_TYPES.TSTypeReference && currentType.typeName.type === TSESTree3.AST_NODE_TYPES.Identifier && currentType.typeName.name === "Readonly" && currentType.typeArguments?.params[0])
-    currentType = currentType.typeArguments.params[0];
+  if (currentType.type === TSESTree3.AST_NODE_TYPES.TSTypeReference && currentType.typeName.type === TSESTree3.AST_NODE_TYPES.Identifier && currentType.typeName.name === "Readonly" && currentType.typeArguments?.params[0]) {
+    [currentType] = currentType.typeArguments.params;
+  }
   if (currentType.type !== TSESTree3.AST_NODE_TYPES.TSTypeReference)
     return false;
   const { typeName, typeArguments } = currentType;
   return typeName.type === TSESTree3.AST_NODE_TYPES.TSQualifiedName && typeName.left.type === TSESTree3.AST_NODE_TYPES.Identifier && typeName.left.name === "Ianitor" && typeName.right.type === TSESTree3.AST_NODE_TYPES.Identifier && typeName.right.name === "Static" && typeArguments?.params[0]?.type === TSESTree3.AST_NODE_TYPES.TSTypeQuery;
 }
 function calculateIanitorComplexity(node) {
-  const callee = node.callee;
-  if (callee?.type !== TSESTree3.AST_NODE_TYPES.MemberExpression || callee.property?.type !== TSESTree3.AST_NODE_TYPES.Identifier)
+  const { callee } = node;
+  if (callee?.type !== TSESTree3.AST_NODE_TYPES.MemberExpression || callee.property?.type !== TSESTree3.AST_NODE_TYPES.Identifier) {
     return 0;
+  }
   const method = callee.property.name;
   switch (method) {
     case "interface":
@@ -15662,7 +15670,8 @@ function calculateIanitorComplexity(node) {
 var createRule = ESLintUtils.RuleCreator((name) => `https://github.com/howmanysmall/eslint-cease-nonsense-rules/blob/main/docs/rules/${name}.md`);
 var enforceIanitorCheckType = createRule({
   create(context) {
-    const config = { ...DEFAULT_CONFIGURATION, ...context.options[0] };
+    const [rawOptions] = context.options;
+    const config = { ...DEFAULT_CONFIGURATION, ...rawOptions };
     const cache = {
       nodeCache: new WeakMap,
       visitedNodes: new WeakSet
@@ -15789,15 +15798,14 @@ var enforceIanitorCheckType = createRule({
         }
         case TSESTree3.AST_NODE_TYPES.TSFunctionType:
         case TSESTree3.AST_NODE_TYPES.TSMethodSignature: {
-          const func = node;
           score = 2;
-          for (const param of func.params) {
+          for (const param of node.params) {
             const typeAnnotation = "typeAnnotation" in param ? param.typeAnnotation : undefined;
             if (typeAnnotation)
               score = addScore(score, calculateStructuralComplexity(typeAnnotation.typeAnnotation, nextDepth));
           }
-          if (func.returnType)
-            score = addScore(score, calculateStructuralComplexity(func.returnType.typeAnnotation, nextDepth));
+          if (node.returnType)
+            score = addScore(score, calculateStructuralComplexity(node.returnType.typeAnnotation, nextDepth));
           break;
         }
         default:
@@ -15811,8 +15819,7 @@ var enforceIanitorCheckType = createRule({
     const variableDeclaratorsToCheck = new Map;
     return {
       "Program:exit"() {
-        for (const [nodeKey, data] of variableDeclaratorsToCheck.entries()) {
-          const node = nodeKey;
+        for (const [node, data] of variableDeclaratorsToCheck.entries()) {
           if (node.id.type === TSESTree3.AST_NODE_TYPES.Identifier && ianitorStaticVariables.has(node.id.name))
             continue;
           context.report({
@@ -15890,6 +15897,283 @@ var enforceIanitorCheckType = createRule({
 });
 var enforce_ianitor_check_type_default = enforceIanitorCheckType;
 
+// src/utilities/format-utilities.ts
+import { readFileSync } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+
+// node_modules/arkregex/out/regex.js
+var regex2 = (src, flags) => new RegExp(src, flags);
+Object.assign(regex2, { as: regex2 });
+// src/oxfmt-sync.ts
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { MessageChannel, receiveMessageOnPort, Worker } from "node:worker_threads";
+var FORMAT_TIMEOUT = 30000;
+var workerState;
+function resolveWorkerPath() {
+  const jsPath = new URL("./oxfmt-worker.js", import.meta.url);
+  const jsFilePath = fileURLToPath(jsPath);
+  if (existsSync(jsFilePath))
+    return jsPath;
+  const tsPath = new URL("./oxfmt-worker.ts", import.meta.url);
+  const tsFilePath = fileURLToPath(tsPath);
+  if (existsSync(tsFilePath))
+    return tsPath;
+  throw new Error(`Oxfmt worker not found at ${jsFilePath} or ${tsFilePath}. Did you run 'bun run build'?`);
+}
+function getWorker() {
+  if (workerState !== undefined)
+    return workerState;
+  const controlBuffer = new SharedArrayBuffer(4);
+  const workerPath = resolveWorkerPath();
+  const { port1: responsePort, port2: requestPort } = new MessageChannel;
+  const worker = new Worker(workerPath, {
+    stderr: true,
+    stdout: true,
+    transferList: [requestPort],
+    workerData: { requestPort }
+  });
+  worker.unref();
+  workerState = { controlBuffer, responsePort, worker };
+  return workerState;
+}
+function formatSync(fileName, sourceText, options3 = {}) {
+  const { controlBuffer, responsePort } = getWorker();
+  const control = new Int32Array(controlBuffer);
+  Atomics.store(control, 0, 0);
+  const request = {
+    controlBuffer,
+    fileName,
+    options: options3,
+    sourceText
+  };
+  responsePort.postMessage(request);
+  const waitResult = Atomics.wait(control, 0, 0, FORMAT_TIMEOUT);
+  if (waitResult === "timed-out")
+    throw new Error(`Oxfmt timed out after ${FORMAT_TIMEOUT}ms`);
+  const received = receiveMessageOnPort(responsePort);
+  if (received === undefined)
+    throw new Error("No response received from oxfmt worker");
+  const response = received.message;
+  if (response.error !== undefined)
+    throw new Error(response.error);
+  if (response.code === undefined)
+    throw new Error("Oxfmt returned undefined code");
+  return response.code;
+}
+
+// src/utilities/format-utilities.ts
+var cachedConfig;
+function loadOxfmtConfig() {
+  if (cachedConfig !== undefined)
+    return cachedConfig;
+  try {
+    const configPath = resolve2(process.cwd(), ".oxfmtrc.json");
+    const configText = readFileSync(configPath, "utf8");
+    const parsed = JSON.parse(configText);
+    if (typeof parsed !== "object" || parsed === null) {
+      cachedConfig = {};
+      return cachedConfig;
+    }
+    const config = parsed;
+    const { $schema: _schema, ignorePatterns: _ignore, ...formatOptions } = config;
+    cachedConfig = formatOptions;
+    return cachedConfig;
+  } catch {
+    cachedConfig = {};
+    return cachedConfig;
+  }
+}
+function getExtension(filePath) {
+  if (filePath.endsWith(".tsx"))
+    return ".tsx";
+  if (filePath.endsWith(".ts"))
+    return ".ts";
+  if (filePath.endsWith(".jsx"))
+    return ".jsx";
+  if (filePath.endsWith(".js"))
+    return ".js";
+  if (filePath.endsWith(".mts"))
+    return ".mts";
+  if (filePath.endsWith(".mjs"))
+    return ".mjs";
+  if (filePath.endsWith(".cts"))
+    return ".cts";
+  if (filePath.endsWith(".cjs"))
+    return ".cjs";
+  return;
+}
+function formatWithOxfmtSync(source, filePath) {
+  const extension = getExtension(filePath);
+  if (extension === undefined)
+    throw new Error(`Unsupported file extension for ${filePath}`);
+  const config = loadOxfmtConfig();
+  return formatSync(filePath, source, config);
+}
+function generateDifferences(original, formatted) {
+  if (original === formatted)
+    return [];
+  return [
+    {
+      deleteText: original,
+      insertText: formatted,
+      offset: 0,
+      operation: "REPLACE"
+    }
+  ];
+}
+var MAX_LENGTH = 60;
+var SYMBOLS = {
+  " ": "·",
+  "\n": "␊",
+  "\r": "␍",
+  "\t": "→"
+};
+var WHITESPACE_REGEXP = regex2(`[\r
+	 ]`, "g");
+function toSymbol(character) {
+  return SYMBOLS[character] ?? character;
+}
+function showInvisibles(text) {
+  let result = text;
+  if (result.length > MAX_LENGTH)
+    result = `${result.slice(0, MAX_LENGTH)}…`;
+  return result.replaceAll(WHITESPACE_REGEXP, toSymbol);
+}
+
+// src/rules/fast-format.ts
+var INSERT = "INSERT";
+var DELETE = "DELETE";
+var REPLACE = "REPLACE";
+var DEFAULT_CACHE_CAPACITY = 32;
+function getLocFromIndex(sourceCode, index2) {
+  if (typeof sourceCode.getLocFromIndex === "function")
+    return sourceCode.getLocFromIndex(index2);
+  return { column: index2, line: 1 };
+}
+function createCacheKey(filename, source) {
+  return `${filename}::${source}`;
+}
+function createLruCache(limit) {
+  const entries = new Map;
+  const capacity = Math.max(limit, 1);
+  function clear() {
+    entries.clear();
+  }
+  function get(key) {
+    const value = entries.get(key);
+    if (value === undefined)
+      return;
+    entries.delete(key);
+    entries.set(key, value);
+    return value;
+  }
+  function set(key, value) {
+    entries.set(key, value);
+    if (entries.size > capacity) {
+      const oldestKey = entries.keys().next().value;
+      if (oldestKey !== undefined)
+        entries.delete(oldestKey);
+    }
+    return value;
+  }
+  return { clear, get, set };
+}
+function cacheFormattedResult(cache, filename, source, formatted) {
+  const entry = { formatted, kind: "formatted" };
+  const sourceKey = createCacheKey(filename, source);
+  cache.set(sourceKey, entry);
+  if (formatted !== source) {
+    const formattedKey = createCacheKey(filename, formatted);
+    cache.set(formattedKey, entry);
+  }
+  return entry;
+}
+function formatWithCaching(cache, filename, source, services) {
+  const cacheKey = createCacheKey(filename, source);
+  const cached = cache.get(cacheKey);
+  if (cached !== undefined)
+    return cached;
+  try {
+    const formatted = services.format(source, filename);
+    return cacheFormattedResult(cache, filename, source, formatted);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    return cache.set(cacheKey, { kind: "error", message: `Oxfmt error: ${message}` });
+  }
+}
+function createFormatCache(limit = DEFAULT_CACHE_CAPACITY) {
+  return createLruCache(limit);
+}
+var defaultServices = {
+  format: formatWithOxfmtSync,
+  generate: generateDifferences,
+  show: showInvisibles
+};
+var defaultCache = createFormatCache();
+function createFastFormatRule(options3 = {}) {
+  const cache = options3.cache ?? defaultCache;
+  const services = {
+    format: options3.services?.format ?? defaultServices.format,
+    generate: options3.services?.generate ?? defaultServices.generate,
+    show: options3.services?.show ?? defaultServices.show
+  };
+  return {
+    create(context) {
+      const { filename, sourceCode } = context;
+      if (getExtension(filename) === undefined)
+        return {};
+      return {
+        Program() {
+          const source = sourceCode.text;
+          const outcome = formatWithCaching(cache, filename, source, services);
+          if (outcome.kind === "error") {
+            context.report({
+              loc: { column: 0, line: 1 },
+              message: outcome.message
+            });
+            return;
+          }
+          if (source === outcome.formatted)
+            return;
+          const differences = services.generate(source, outcome.formatted);
+          for (const { operation, offset, deleteText, insertText } of differences) {
+            const range = [offset, offset + (deleteText?.length ?? 0)];
+            context.report({
+              data: {
+                deleteText: services.show(deleteText ?? ""),
+                insertText: services.show(insertText ?? "")
+              },
+              fix: (fixer) => fixer.replaceTextRange(range, insertText ?? ""),
+              loc: {
+                end: getLocFromIndex(sourceCode, range[1]),
+                start: getLocFromIndex(sourceCode, range[0])
+              },
+              messageId: operation
+            });
+          }
+        }
+      };
+    },
+    meta: {
+      docs: {
+        description: "Enforce oxfmt code formatting",
+        recommended: true
+      },
+      fixable: "code",
+      messages: {
+        [INSERT]: "Insert `{{ insertText }}`",
+        [DELETE]: "Delete `{{ deleteText }}`",
+        [REPLACE]: "Replace `{{ deleteText }}` with `{{ insertText }}`"
+      },
+      schema: [],
+      type: "layout"
+    }
+  };
+}
+var fastFormat = createFastFormatRule();
+var fast_format_default = fastFormat;
+
 // src/rules/no-async-constructor.ts
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
 var PROMISE_CHAIN_METHODS = new Set(["then", "catch", "finally"]);
@@ -16023,22 +16307,24 @@ function findConstructorViolations(constructorBody, asyncMethods) {
     if (!hasDynamicProperties(current))
       return;
     for (const key in current) {
-      const childValue = current[key];
-      if (childValue === undefined)
-        continue;
-      if (Array.isArray(childValue)) {
-        for (const item of childValue) {
-          if (!isNode(item))
-            continue;
-          parentMap.set(item, current);
-          traverse(item);
+      if (Object.hasOwn(current, key)) {
+        const childValue = current[key];
+        if (childValue === undefined)
+          continue;
+        if (Array.isArray(childValue)) {
+          for (const item of childValue) {
+            if (!isNode(item))
+              continue;
+            parentMap.set(item, current);
+            traverse(item);
+          }
+          continue;
         }
-        continue;
+        if (!isNode(childValue))
+          continue;
+        parentMap.set(childValue, current);
+        traverse(childValue);
       }
-      if (!isNode(childValue))
-        continue;
-      parentMap.set(childValue, current);
-      traverse(childValue);
     }
   }
   traverse(constructorBody);
@@ -16182,7 +16468,7 @@ import { createRequire as createRequire4 } from "node:module";
 import { createRequire as createRequire2 } from "node:module";
 var require2 = createRequire2(import.meta.url);
 var __dirname2 = new URL(".", import.meta.url).pathname;
-var { readFileSync } = require2("node:fs");
+var { readFileSync: readFileSync2 } = require2("node:fs");
 var nativeBinding = null;
 var loadErrors = [];
 var isMusl = () => {
@@ -16201,7 +16487,7 @@ var isMusl = () => {
 var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
 var isMuslFromFilesystem = () => {
   try {
-    return readFileSync("/usr/bin/ldd", "utf-8").includes("musl");
+    return readFileSync2("/usr/bin/ldd", "utf-8").includes("musl");
   } catch {
     return null;
   }
@@ -17106,8 +17392,8 @@ function createCamelCaseDetector(probability) {
 }
 
 // src/recognizers/contains-detector.ts
-var WHITESPACE_GLOBAL_REGEX = /\s+/g;
-var ESCAPE = /[-/\\^$*+?.()|[\]{}]/g;
+var WHITESPACE_GLOBAL_REGEX = regex2("\\s+", "g");
+var ESCAPE = regex2("[-/\\^$*+?.()|[\\]{}]", "g");
 function escapeForRegex(value) {
   return value.replaceAll(ESCAPE, String.raw`\$&`);
 }
@@ -17130,17 +17416,17 @@ function createContainsDetector(probability, patterns2) {
 }
 
 // src/recognizers/end-with-detector.ts
-var WHITESPACE_REGEX = /\s/;
+var WHITESPACE_REGEX = regex2("\\s");
 function createEndWithDetector(probability, endings) {
   const endingsSet = new Set(endings);
   return {
     probability,
     scan(line) {
       for (let index2 = line.length - 1;index2 >= 0; index2 -= 1) {
-        const char = line.charAt(index2);
-        if (endingsSet.has(char))
+        const character = line.charAt(index2);
+        if (endingsSet.has(character))
           return 1;
-        if (!WHITESPACE_REGEX.test(char) && char !== "*" && char !== "/")
+        if (!WHITESPACE_REGEX.test(character) && character !== "*" && character !== "/")
           return 0;
       }
       return 0;
@@ -17258,7 +17544,7 @@ function groupComments(comments, sourceCode) {
       if (size > 0) {
         groups[groupsSize++] = {
           comments: currentLineComments,
-          value: currentLineComments.map((c) => c.value).join(`
+          value: currentLineComments.map(({ value }) => value).join(`
 `)
         };
         currentLineComments = [];
@@ -17341,7 +17627,7 @@ function toParsedStatements(body) {
 function isExpressionExclusion(statement, codeText) {
   if (statement.type !== "ExpressionStatement")
     return false;
-  const expression = statement.expression;
+  const { expression } = statement;
   if (!expression)
     return false;
   if (expression.type === "Identifier")
@@ -17418,7 +17704,7 @@ var noCommentedCode = {
           if (containsCode(balanced, context.filename)) {
             const firstComment = group.comments.at(0);
             const lastComment = group.comments.at(-1);
-            if (!firstComment || !lastComment)
+            if (!(firstComment && lastComment))
               continue;
             context.report({
               loc: {
@@ -17455,95 +17741,633 @@ var noCommentedCode = {
 };
 var no_commented_code_default = noCommentedCode;
 
-// src/rules/no-instance-methods-without-this.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/types";
-var DEFAULT_OPTIONS = {
-  checkPrivate: true,
-  checkProtected: true,
-  checkPublic: true
-};
-function normalizeOptions(rawOptions) {
-  const mergedOptions = { ...DEFAULT_OPTIONS };
-  if (rawOptions?.checkPrivate !== undefined)
-    mergedOptions.checkPrivate = rawOptions.checkPrivate;
-  if (rawOptions?.checkProtected !== undefined)
-    mergedOptions.checkProtected = rawOptions.checkProtected;
-  if (rawOptions?.checkPublic !== undefined)
-    mergedOptions.checkPublic = rawOptions.checkPublic;
-  return mergedOptions;
-}
-function shouldCheckMethod(node, options3) {
-  if (node.static)
-    return false;
-  if (node.kind !== "method")
-    return false;
-  const accessibility = node.accessibility ?? "public";
-  if (accessibility === "private" && !options3.checkPrivate)
-    return false;
-  if (accessibility === "protected" && !options3.checkProtected)
-    return false;
-  if (accessibility === "public" && !options3.checkPublic)
-    return false;
-  return true;
+// src/rules/no-god-components.ts
+import { TSESTree as TSESTree5 } from "@typescript-eslint/types";
+var COMPONENT_NAME_PATTERN = /^[A-Z]/;
+var FUNCTION_BOUNDARIES = new Set([
+  TSESTree5.AST_NODE_TYPES.FunctionDeclaration,
+  TSESTree5.AST_NODE_TYPES.FunctionExpression,
+  TSESTree5.AST_NODE_TYPES.ArrowFunctionExpression
+]);
+var RUNTIME_TS_WRAPPERS = new Set([
+  "ParenthesizedExpression",
+  "TSAsExpression",
+  "TSSatisfiesExpression",
+  "TSTypeAssertion",
+  "TSNonNullExpression",
+  "TSInstantiationExpression",
+  "ChainExpression"
+]);
+function isComponentName(name) {
+  return COMPONENT_NAME_PATTERN.test(name);
 }
-function isNode2(value) {
-  return typeof value === "object" && value !== null && "type" in value;
+function isReactComponentHOC(callExpr) {
+  const { callee } = callExpr;
+  if (callee.type === TSESTree5.AST_NODE_TYPES.Identifier)
+    return callee.name === "forwardRef" || callee.name === "memo";
+  if (callee.type === TSESTree5.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree5.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === TSESTree5.AST_NODE_TYPES.Identifier)
+    return callee.property.name === "forwardRef" || callee.property.name === "memo";
+  return false;
 }
-function hasDynamicProperties2(_node) {
-  return true;
+function getComponentNameFromFunction(node) {
+  if (node.type === TSESTree5.AST_NODE_TYPES.FunctionDeclaration && node.id && isComponentName(node.id.name)) {
+    return node.id.name;
+  }
+  if (node.type === TSESTree5.AST_NODE_TYPES.FunctionExpression || node.type === TSESTree5.AST_NODE_TYPES.ArrowFunctionExpression) {
+    const { parent } = node;
+    if (parent === null || parent === undefined)
+      return;
+    if (parent.type === TSESTree5.AST_NODE_TYPES.VariableDeclarator && parent.id.type === TSESTree5.AST_NODE_TYPES.Identifier && isComponentName(parent.id.name)) {
+      return parent.id.name;
+    }
+    if (parent.type === TSESTree5.AST_NODE_TYPES.Property && parent.key.type === TSESTree5.AST_NODE_TYPES.Identifier && isComponentName(parent.key.name)) {
+      return parent.key.name;
+    }
+    if (parent.type === TSESTree5.AST_NODE_TYPES.MethodDefinition && parent.key.type === TSESTree5.AST_NODE_TYPES.Identifier && isComponentName(parent.key.name)) {
+      return parent.key.name;
+    }
+  }
+  return;
 }
-function traverseForThis(currentNode, visited2) {
-  if (visited2.has(currentNode))
-    return false;
-  visited2.add(currentNode);
-  if (currentNode.type === AST_NODE_TYPES2.ThisExpression || currentNode.type === AST_NODE_TYPES2.Super)
-    return true;
-  if (!hasDynamicProperties2(currentNode))
-    return false;
-  for (const key in currentNode) {
-    const childValue = currentNode[key];
-    if (childValue === null || childValue === undefined)
-      continue;
-    if (Array.isArray(childValue)) {
-      for (const item of childValue)
-        if (isNode2(item) && traverseForThis(item, visited2))
-          return true;
-      continue;
+function getComponentNameFromCallParent(callExpr) {
+  const { parent } = callExpr;
+  if (parent === null || parent === undefined)
+    return;
+  if (parent.type === TSESTree5.AST_NODE_TYPES.VariableDeclarator && parent.id.type === TSESTree5.AST_NODE_TYPES.Identifier && isComponentName(parent.id.name)) {
+    return parent.id.name;
+  }
+  if (parent.type === TSESTree5.AST_NODE_TYPES.AssignmentExpression && parent.left.type === TSESTree5.AST_NODE_TYPES.Identifier && isComponentName(parent.left.name)) {
+    return parent.left.name;
+  }
+  if (parent.type === TSESTree5.AST_NODE_TYPES.ExportDefaultDeclaration && callExpr.arguments.length > 0) {
+    const [firstArg] = callExpr.arguments;
+    if (firstArg && firstArg.type === TSESTree5.AST_NODE_TYPES.FunctionExpression && firstArg.id && isComponentName(firstArg.id.name)) {
+      return firstArg.id.name;
     }
-    if (isNode2(childValue) && traverseForThis(childValue, visited2))
-      return true;
   }
-  return false;
+  return;
 }
-function methodUsesThis(node) {
-  const value = node.value;
-  if (value === undefined || value.type !== AST_NODE_TYPES2.FunctionExpression)
+function getHookName(callExpression) {
+  const { callee } = callExpression;
+  if (callee.type === TSESTree5.AST_NODE_TYPES.Identifier)
+    return callee.name;
+  if (callee.type === TSESTree5.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree5.AST_NODE_TYPES.Identifier) {
+    return callee.property.name;
+  }
+  return;
+}
+function countDestructuredProps(node) {
+  const [firstParam] = node.params;
+  if (!firstParam)
+    return;
+  let pattern4;
+  if (firstParam.type === TSESTree5.AST_NODE_TYPES.ObjectPattern)
+    pattern4 = firstParam;
+  if (firstParam.type === TSESTree5.AST_NODE_TYPES.AssignmentPattern && firstParam.left.type === TSESTree5.AST_NODE_TYPES.ObjectPattern) {
+    pattern4 = firstParam.left;
+  }
+  if (!pattern4)
+    return;
+  let count = 0;
+  for (const { type: type3 } of pattern4.properties)
+    if (type3 === TSESTree5.AST_NODE_TYPES.Property)
+      count += 1;
+  return count;
+}
+function isTypeOnlyNullLiteral(node) {
+  const { parent } = node;
+  if (parent === null || parent === undefined)
     return false;
-  return traverseForThis(value, new WeakSet);
+  if (typeof parent.type === "string" && parent.type.startsWith("TS") && !RUNTIME_TS_WRAPPERS.has(parent.type))
+    return true;
+  if (parent.type === TSESTree5.AST_NODE_TYPES.TSLiteralType)
+    return true;
+  return false;
 }
-var noInstanceMethodsWithoutThis = {
-  create(context) {
-    const rawOptions = context.options[0];
-    const options3 = normalizeOptions(rawOptions);
-    return {
-      MethodDefinition(node) {
-        if (!shouldCheckMethod(node, options3))
-          return;
-        if (methodUsesThis(node))
-          return;
-        const methodName = node.key.type === AST_NODE_TYPES2.Identifier ? node.key.name : "unknown";
-        context.report({
-          data: { methodName },
-          messageId: "noInstanceMethodWithoutThis",
-          node
-        });
+function analyzeComponentBody(functionNode, sourceCode, stateHooks) {
+  let maxJsxDepth = 0;
+  let stateHookCount = 0;
+  const nullLiterals = new Array;
+  function visit(current, jsxDepth) {
+    if (FUNCTION_BOUNDARIES.has(current.type) && current !== functionNode)
+      return;
+    let nextDepth = jsxDepth;
+    if (current.type === TSESTree5.AST_NODE_TYPES.JSXElement || current.type === TSESTree5.AST_NODE_TYPES.JSXFragment) {
+      nextDepth = jsxDepth + 1;
+      if (nextDepth > maxJsxDepth)
+        maxJsxDepth = nextDepth;
+    }
+    if (current.type === TSESTree5.AST_NODE_TYPES.CallExpression) {
+      const hookName = getHookName(current);
+      if (typeof hookName === "string" && hookName.length > 0 && stateHooks.has(hookName))
+        stateHookCount += 1;
+    }
+    if (current.type === TSESTree5.AST_NODE_TYPES.Literal && current.value === null) {
+      const literalNode = current;
+      if (!isTypeOnlyNullLiteral(literalNode))
+        nullLiterals.push(literalNode);
+    }
+    function getVisitorKeysForNodeType(nodeType) {
+      const visitorKeysUnknown = sourceCode.visitorKeys;
+      if (visitorKeysUnknown === null || visitorKeysUnknown === undefined || typeof visitorKeysUnknown !== "object")
+        return [];
+      const visitorKeysRecord = visitorKeysUnknown;
+      const keysUnknown = visitorKeysRecord[nodeType];
+      if (!Array.isArray(keysUnknown))
+        return [];
+      const keys3 = new Array;
+      for (const key of keysUnknown)
+        if (typeof key === "string")
+          keys3.push(key);
+      return keys3;
+    }
+    const keys2 = getVisitorKeysForNodeType(current.type);
+    const currentRecord = current;
+    for (const key of keys2) {
+      const value = currentRecord[key];
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (typeof item === "object" && item !== null && "type" in item) {
+            visit(item, nextDepth);
+          }
+        }
+        continue;
       }
-    };
-  },
-  defaultOptions: [DEFAULT_OPTIONS],
-  meta: {
-    docs: {
-      description: "Detect instance methods that do not use 'this' and suggest converting them to standalone functions for better performance in roblox-ts.",
+      if (typeof value === "object" && value !== null && "type" in value) {
+        visit(value, nextDepth);
+      }
+    }
+  }
+  visit(functionNode.body, 0);
+  return { maxJsxDepth, nullLiterals, stateHookCount };
+}
+function parseOptions(options3) {
+  const defaults = {
+    enforceTargetLines: true,
+    ignoreComponents: [],
+    maxDestructuredProps: 5,
+    maxLines: 200,
+    maxStateHooks: 5,
+    maxTsxNesting: 3,
+    stateHooks: ["useState", "useReducer", "useBinding"],
+    targetLines: 120
+  };
+  if (typeof options3 !== "object" || options3 === null)
+    return defaults;
+  const cast = options3;
+  return {
+    enforceTargetLines: typeof cast.enforceTargetLines === "boolean" ? cast.enforceTargetLines : defaults.enforceTargetLines,
+    ignoreComponents: Array.isArray(cast.ignoreComponents) ? cast.ignoreComponents : defaults.ignoreComponents,
+    maxDestructuredProps: typeof cast.maxDestructuredProps === "number" ? cast.maxDestructuredProps : defaults.maxDestructuredProps,
+    maxLines: typeof cast.maxLines === "number" ? cast.maxLines : defaults.maxLines,
+    maxStateHooks: typeof cast.maxStateHooks === "number" ? cast.maxStateHooks : defaults.maxStateHooks,
+    maxTsxNesting: typeof cast.maxTsxNesting === "number" ? cast.maxTsxNesting : defaults.maxTsxNesting,
+    stateHooks: Array.isArray(cast.stateHooks) ? cast.stateHooks : defaults.stateHooks,
+    targetLines: typeof cast.targetLines === "number" ? cast.targetLines : defaults.targetLines
+  };
+}
+var noGodComponents = {
+  create(context) {
+    const configuration = parseOptions(context.options[0]);
+    const ignoreSet = new Set(configuration.ignoreComponents);
+    const stateHooks = new Set(configuration.stateHooks);
+    const checked = new WeakSet;
+    const { sourceCode } = context;
+    function checkComponent(node, name) {
+      if (ignoreSet.has(name))
+        return;
+      if (checked.has(node))
+        return;
+      checked.add(node);
+      const location = node.loc;
+      if (location !== null && location !== undefined) {
+        const lines = location.end.line - location.start.line + 1;
+        if (lines > configuration.maxLines) {
+          context.report({
+            data: { lines, max: configuration.maxLines, name, target: configuration.targetLines },
+            messageId: "exceedsMaxLines",
+            node
+          });
+        } else if (configuration.enforceTargetLines && lines > configuration.targetLines) {
+          context.report({
+            data: { lines, max: configuration.maxLines, name, target: configuration.targetLines },
+            messageId: "exceedsTargetLines",
+            node
+          });
+        }
+      }
+      const propsCount = countDestructuredProps(node);
+      if (typeof propsCount === "number" && propsCount > configuration.maxDestructuredProps) {
+        context.report({
+          data: { count: propsCount, max: configuration.maxDestructuredProps, name },
+          messageId: "tooManyProps",
+          node
+        });
+      }
+      const analysis = analyzeComponentBody(node, sourceCode, stateHooks);
+      if (analysis.maxJsxDepth > configuration.maxTsxNesting) {
+        context.report({
+          data: { depth: analysis.maxJsxDepth, max: configuration.maxTsxNesting, name },
+          messageId: "tsxNestingTooDeep",
+          node
+        });
+      }
+      if (analysis.stateHookCount > configuration.maxStateHooks) {
+        context.report({
+          data: {
+            count: analysis.stateHookCount,
+            hooks: configuration.stateHooks.join(", "),
+            max: configuration.maxStateHooks,
+            name
+          },
+          messageId: "tooManyStateHooks",
+          node
+        });
+      }
+      for (const literal2 of analysis.nullLiterals) {
+        context.report({
+          messageId: "nullLiteral",
+          node: literal2
+        });
+      }
+    }
+    function maybeCheckFunction(node) {
+      const name = getComponentNameFromFunction(node);
+      if (typeof name !== "string" || name.length === 0)
+        return;
+      checkComponent(node, name);
+    }
+    return {
+      ArrowFunctionExpression(node) {
+        maybeCheckFunction(node);
+      },
+      CallExpression(node) {
+        const callExpr = node;
+        if (!isReactComponentHOC(callExpr))
+          return;
+        const [firstArg] = callExpr.arguments;
+        if (!firstArg || firstArg.type !== TSESTree5.AST_NODE_TYPES.FunctionExpression && firstArg.type !== TSESTree5.AST_NODE_TYPES.ArrowFunctionExpression) {
+          return;
+        }
+        const nameFromParent = getComponentNameFromCallParent(callExpr);
+        const nameFromArg = getComponentNameFromFunction(firstArg);
+        const name = nameFromParent ?? nameFromArg;
+        if (typeof name !== "string" || name.length === 0)
+          return;
+        checkComponent(firstArg, name);
+      },
+      FunctionDeclaration(node) {
+        maybeCheckFunction(node);
+      },
+      FunctionExpression(node) {
+        maybeCheckFunction(node);
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce React component size and complexity limits inspired by the 'Refactor God Component' checklist.",
+      recommended: false
+    },
+    messages: {
+      exceedsMaxLines: "Component '{{name}}' is {{lines}} lines; max allowed is {{max}}. Split into smaller components/hooks.",
+      exceedsTargetLines: "Component '{{name}}' is {{lines}} lines; target is {{target}} (max {{max}}). Consider extracting hooks/components.",
+      nullLiteral: "Avoid `null` in components; use `undefined` instead.",
+      tooManyProps: "Component '{{name}}' destructures {{count}} props; max allowed is {{max}}. Group props or split the component.",
+      tooManyStateHooks: "Component '{{name}}' has {{count}} state hooks ({{hooks}}); max allowed is {{max}}. Extract cohesive state into a custom hook.",
+      tsxNestingTooDeep: "Component '{{name}}' has TSX nesting depth {{depth}}; max allowed is {{max}}. Extract child components."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          enforceTargetLines: {
+            default: true,
+            description: "Whether to report when exceeding targetLines (soft limit).",
+            type: "boolean"
+          },
+          ignoreComponents: {
+            description: "Component names to ignore.",
+            items: { type: "string" },
+            type: "array"
+          },
+          maxDestructuredProps: {
+            default: 5,
+            description: "Maximum number of destructured props in a component parameter.",
+            type: "number"
+          },
+          maxLines: {
+            default: 200,
+            description: "Hard maximum lines for a component.",
+            type: "number"
+          },
+          maxStateHooks: {
+            default: 5,
+            description: "Maximum number of stateful hook calls in a component.",
+            type: "number"
+          },
+          maxTsxNesting: {
+            default: 3,
+            description: "Maximum JSX/TSX nesting depth in a component.",
+            type: "number"
+          },
+          stateHooks: {
+            default: ["useState", "useReducer", "useBinding"],
+            description: "Hook names to count toward state complexity.",
+            items: { type: "string" },
+            type: "array"
+          },
+          targetLines: {
+            default: 120,
+            description: "Soft target lines for a component.",
+            type: "number"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  }
+};
+var no_god_components_default = noGodComponents;
+
+// src/rules/no-identity-map.ts
+var import_scope_manager = __toESM(require_dist2(), 1);
+import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
+var DEFAULT_BINDING_PATTERNS = ["binding"];
+function getParameterName(param) {
+  if (param.type === AST_NODE_TYPES2.Identifier)
+    return param.name;
+  if (param.type === AST_NODE_TYPES2.AssignmentPattern && param.left.type === AST_NODE_TYPES2.Identifier) {
+    return param.left.name;
+  }
+  return;
+}
+function isBlockReturningIdentity(body, paramName) {
+  if (body.body.length !== 1)
+    return false;
+  const [statement] = body.body;
+  if (statement?.type !== AST_NODE_TYPES2.ReturnStatement)
+    return false;
+  if (!statement.argument)
+    return false;
+  if (statement.argument.type !== AST_NODE_TYPES2.Identifier)
+    return false;
+  return statement.argument.name === paramName;
+}
+function isIdentityCallback(callback) {
+  if (callback.type === AST_NODE_TYPES2.ArrowFunctionExpression) {
+    if (callback.params.length !== 1)
+      return false;
+    const [param] = callback.params;
+    if (param === undefined)
+      return false;
+    const paramName = getParameterName(param);
+    if (paramName === undefined || paramName === "")
+      return false;
+    if (callback.body.type === AST_NODE_TYPES2.Identifier) {
+      return callback.body.name === paramName;
+    }
+    if (callback.body.type === AST_NODE_TYPES2.BlockStatement) {
+      return isBlockReturningIdentity(callback.body, paramName);
+    }
+    return false;
+  }
+  if (callback.type === AST_NODE_TYPES2.FunctionExpression) {
+    if (callback.params.length !== 1)
+      return false;
+    const [param] = callback.params;
+    if (param === undefined)
+      return false;
+    const paramName = getParameterName(param);
+    if (paramName === undefined || paramName === "")
+      return false;
+    return isBlockReturningIdentity(callback.body, paramName);
+  }
+  return false;
+}
+function findVariable(context, identifier3) {
+  let scope = context.sourceCode.getScope(identifier3);
+  while (scope) {
+    const variable = scope.set.get(identifier3.name);
+    if (variable)
+      return variable;
+    scope = scope.upper ?? undefined;
+  }
+  return;
+}
+function getHookName2(node) {
+  const { callee } = node;
+  if (callee.type === AST_NODE_TYPES2.Identifier) {
+    return callee.name;
+  }
+  if (callee.type === AST_NODE_TYPES2.MemberExpression && callee.property.type === AST_NODE_TYPES2.Identifier) {
+    return callee.property.name;
+  }
+  return;
+}
+function isJoinBindingsCall(node) {
+  const { callee } = node;
+  if (callee.type === AST_NODE_TYPES2.Identifier) {
+    return callee.name === "joinBindings";
+  }
+  if (callee.type === AST_NODE_TYPES2.MemberExpression && callee.property.type === AST_NODE_TYPES2.Identifier) {
+    return callee.property.name === "joinBindings";
+  }
+  return false;
+}
+function isBindingInitialization(variable) {
+  for (const def of variable.defs) {
+    if (def.type !== import_scope_manager.DefinitionType.Variable)
+      continue;
+    const { init } = def.node;
+    if (!init || init.type !== AST_NODE_TYPES2.CallExpression)
+      continue;
+    const hookName = getHookName2(init);
+    if (hookName === "useBinding")
+      return true;
+    if (isJoinBindingsCall(init))
+      return true;
+    if (init.callee.type === AST_NODE_TYPES2.MemberExpression && init.callee.property.type === AST_NODE_TYPES2.Identifier && init.callee.property.name === "map") {
+      return true;
+    }
+  }
+  return false;
+}
+function isLikelyBinding(context, callee, patterns2) {
+  const { object: object3 } = callee;
+  if (object3.type === AST_NODE_TYPES2.Identifier) {
+    const lowerName = object3.name.toLowerCase();
+    for (const pattern4 of patterns2) {
+      if (lowerName.includes(pattern4.toLowerCase()))
+        return true;
+    }
+    const variable = findVariable(context, object3);
+    if (variable && isBindingInitialization(variable))
+      return true;
+  }
+  if (object3.type === AST_NODE_TYPES2.CallExpression && object3.callee.type === AST_NODE_TYPES2.MemberExpression && object3.callee.property.type === AST_NODE_TYPES2.Identifier && object3.callee.property.name === "map") {
+    return true;
+  }
+  if (object3.type === AST_NODE_TYPES2.CallExpression && isJoinBindingsCall(object3)) {
+    return true;
+  }
+  return false;
+}
+var noIdentityMap = {
+  create(context) {
+    const [rawOptions] = context.options;
+    const patterns2 = rawOptions?.bindingPatterns ?? DEFAULT_BINDING_PATTERNS;
+    return {
+      CallExpression(node) {
+        const { callee } = node;
+        if (callee.type !== AST_NODE_TYPES2.MemberExpression)
+          return;
+        if (callee.computed)
+          return;
+        if (callee.property.type !== AST_NODE_TYPES2.Identifier)
+          return;
+        if (callee.property.name !== "map")
+          return;
+        if (node.arguments.length !== 1)
+          return;
+        const [callback] = node.arguments;
+        if (!callback || callback.type === AST_NODE_TYPES2.SpreadElement)
+          return;
+        if (!isIdentityCallback(callback))
+          return;
+        const isBinding = isLikelyBinding(context, callee, patterns2);
+        context.report({
+          fix(fixer) {
+            const objectText = context.sourceCode.getText(callee.object);
+            return fixer.replaceText(node, objectText);
+          },
+          messageId: isBinding ? "identityBindingMap" : "identityArrayMap",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [{}],
+  meta: {
+    docs: {
+      description: "Disallow pointless identity `.map()` calls that return the parameter unchanged"
+    },
+    fixable: "code",
+    messages: {
+      identityArrayMap: "Pointless identity `.map()` call on Array. Use `table.clone(array)` or `[...array]` instead.",
+      identityBindingMap: "Pointless identity `.map()` call on Binding. Use the original binding directly."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          bindingPatterns: {
+            default: [...DEFAULT_BINDING_PATTERNS],
+            description: "Variable name patterns to recognize as Bindings (case insensitive)",
+            items: { type: "string" },
+            type: "array"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "suggestion"
+  }
+};
+var no_identity_map_default = noIdentityMap;
+
+// src/rules/no-instance-methods-without-this.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/types";
+var DEFAULT_OPTIONS = {
+  checkPrivate: true,
+  checkProtected: true,
+  checkPublic: true
+};
+function normalizeOptions(rawOptions) {
+  const mergedOptions = { ...DEFAULT_OPTIONS };
+  if (rawOptions?.checkPrivate !== undefined)
+    mergedOptions.checkPrivate = rawOptions.checkPrivate;
+  if (rawOptions?.checkProtected !== undefined)
+    mergedOptions.checkProtected = rawOptions.checkProtected;
+  if (rawOptions?.checkPublic !== undefined)
+    mergedOptions.checkPublic = rawOptions.checkPublic;
+  return mergedOptions;
+}
+function shouldCheckMethod(node, options3) {
+  if (node.static)
+    return false;
+  if (node.kind !== "method")
+    return false;
+  const accessibility = node.accessibility ?? "public";
+  if (accessibility === "private" && !options3.checkPrivate)
+    return false;
+  if (accessibility === "protected" && !options3.checkProtected)
+    return false;
+  if (accessibility === "public" && !options3.checkPublic)
+    return false;
+  return true;
+}
+function isNode2(value) {
+  return typeof value === "object" && value !== null && "type" in value;
+}
+function hasDynamicProperties2(_node) {
+  return true;
+}
+function traverseForThis(currentNode, visited2) {
+  if (visited2.has(currentNode))
+    return false;
+  visited2.add(currentNode);
+  if (currentNode.type === AST_NODE_TYPES3.ThisExpression || currentNode.type === AST_NODE_TYPES3.Super)
+    return true;
+  if (!hasDynamicProperties2(currentNode))
+    return false;
+  for (const key in currentNode) {
+    if (!Object.hasOwn(currentNode, key))
+      continue;
+    const childValue = currentNode[key];
+    if (childValue === null || childValue === undefined)
+      continue;
+    if (Array.isArray(childValue)) {
+      for (const item of childValue)
+        if (isNode2(item) && traverseForThis(item, visited2))
+          return true;
+      continue;
+    }
+    if (isNode2(childValue) && traverseForThis(childValue, visited2))
+      return true;
+  }
+  return false;
+}
+function methodUsesThis(node) {
+  const { value } = node;
+  if (value === undefined || value.type !== AST_NODE_TYPES3.FunctionExpression)
+    return false;
+  return traverseForThis(value, new WeakSet);
+}
+var noInstanceMethodsWithoutThis = {
+  create(context) {
+    const [rawOptions] = context.options;
+    const options3 = normalizeOptions(rawOptions);
+    return {
+      MethodDefinition(node) {
+        if (!shouldCheckMethod(node, options3))
+          return;
+        if (methodUsesThis(node))
+          return;
+        const methodName = node.key.type === AST_NODE_TYPES3.Identifier ? node.key.name : "unknown";
+        context.report({
+          data: { methodName },
+          messageId: "noInstanceMethodWithoutThis",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [DEFAULT_OPTIONS],
+  meta: {
+    docs: {
+      description: "Detect instance methods that do not use 'this' and suggest converting them to standalone functions for better performance in roblox-ts.",
       recommended: true
     },
     messages: {
@@ -17604,7 +18428,7 @@ var noPrint = {
 var no_print_default = noPrint;
 
 // src/rules/no-shorthand-names.ts
-import { TSESTree as TSESTree5 } from "@typescript-eslint/types";
+import { TSESTree as TSESTree6 } from "@typescript-eslint/types";
 var isRuleOptions = Compile(build_default.Object({
   allowPropertyAccess: build_default.Optional(build_default.Array(build_default.String())),
   shorthands: build_default.Optional(build_default.Record(build_default.String(), build_default.String()))
@@ -17621,19 +18445,19 @@ var DEFAULT_OPTIONS2 = {
     plr: "player"
   }
 };
-var REGEX_PATTERN_MATCHER = /^\/(.+)\/([gimsuy]*)$/;
+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])/;
 function splitIdentifierIntoWords(identifier3) {
   return identifier3.split(WORD_BOUNDARY_REGEX);
 }
 function createMatcher(key, replacement) {
   if (key.startsWith("/")) {
-    const match = key.match(REGEX_PATTERN_MATCHER);
+    const match = REGEX_PATTERN_MATCHER.exec(key);
     if (match) {
       return {
         matcher: {
           original: key,
-          pattern: new RegExp(`^${match[1]}$`, match[2]),
+          pattern: new RegExp(`^${match.groups.first}$`, match.groups.second),
           replacement
         },
         type: "pattern"
@@ -17671,8 +18495,8 @@ function matchWord(word, matchers, exactMatchers) {
     const match = word.match(matcher.pattern);
     if (match) {
       let replaced = matcher.replacement;
-      for (let i = 1;i < match.length; i++) {
-        replaced = replaced.replaceAll(new RegExp(`\\$${i}`, "g"), match[i] ?? "");
+      for (let index2 = 1;index2 < match.length; index2 += 1) {
+        replaced = replaced.replaceAll(new RegExp(`\\$${index2}`, "g"), match[index2] ?? "");
       }
       return {
         replacement: replaced,
@@ -17684,7 +18508,7 @@ function matchWord(word, matchers, exactMatchers) {
 }
 function buildReplacementIdentifier(identifier3, options3) {
   const words = splitIdentifierIntoWords(identifier3);
-  const matches = [];
+  const matches = new Array;
   let hasMatch = false;
   const newWords = words.map((word) => {
     const match = matchWord(word, options3.matchers, options3.exactMatchers);
@@ -17701,18 +18525,18 @@ function buildReplacementIdentifier(identifier3, options3) {
 }
 function normalizeOptions2(rawOptions) {
   const mergedShorthands = { ...DEFAULT_OPTIONS2.shorthands };
-  if (rawOptions?.shorthands)
+  if (rawOptions?.shorthands) {
     for (const [key, value] of Object.entries(rawOptions.shorthands))
       mergedShorthands[key] = value;
-  const matchers = [];
+  }
+  const matchers = new Array;
   const exactMatchers = new Map;
   for (const [key, value] of Object.entries(mergedShorthands)) {
     const result = createMatcher(key, value);
-    if (result.type === "exact") {
+    if (result.type === "exact")
       exactMatchers.set(result.original, result.replacement);
-    } else {
+    else
       matchers.push(result.matcher);
-    }
   }
   const allowPropertyAccessSource = rawOptions?.allowPropertyAccess ?? DEFAULT_OPTIONS2.allowPropertyAccess;
   return {
@@ -17736,11 +18560,12 @@ var noShorthandNames = {
         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 === TSESTree5.AST_NODE_TYPES.MemberExpression && parent.property === node)
+        if (matches.length === 1 && match !== undefined && allowPropertyAccess.has(match.shorthand) && parent !== undefined && isRecord2(parent) && parent.type === TSESTree6.AST_NODE_TYPES.MemberExpression && parent.property === node) {
           return;
-        if (identifierName === "plr" && parent?.type === TSESTree5.AST_NODE_TYPES.VariableDeclarator && parent.id === node) {
+        }
+        if (identifierName === "plr" && parent?.type === TSESTree6.AST_NODE_TYPES.VariableDeclarator && parent.id === node) {
           const { init } = parent;
-          if (init && isRecord2(init) && init.type === TSESTree5.AST_NODE_TYPES.MemberExpression && init.object !== undefined && isRecord2(init.object) && init.object.type === TSESTree5.AST_NODE_TYPES.Identifier && init.object.name === "Players" && init.property !== undefined && isRecord2(init.property) && init.property.type === TSESTree5.AST_NODE_TYPES.Identifier && init.property.name === "LocalPlayer") {
+          if (init && isRecord2(init) && init.type === TSESTree6.AST_NODE_TYPES.MemberExpression && init.object !== undefined && isRecord2(init.object) && init.object.type === TSESTree6.AST_NODE_TYPES.Identifier && init.object.name === "Players" && init.property !== undefined && isRecord2(init.property) && init.property.type === TSESTree6.AST_NODE_TYPES.Identifier && init.property.name === "LocalPlayer") {
             context.report({
               data: { replacement: "localPlayer", shorthand: "plr" },
               messageId: "useReplacement",
@@ -17749,7 +18574,7 @@ var noShorthandNames = {
             return;
           }
         }
-        const shorthandList = matches.map((m) => m.shorthand).join(", ");
+        const shorthandList = matches.map(({ shorthand }) => shorthand).join(", ");
         context.report({
           data: { replacement: replaced, shorthand: shorthandList },
           messageId: "useReplacement",
@@ -17790,8 +18615,8 @@ var noShorthandNames = {
 var no_shorthand_names_default = noShorthandNames;
 
 // src/rules/no-useless-use-spring.ts
-var import_scope_manager = __toESM(require_dist2(), 1);
-import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
+var import_scope_manager2 = __toESM(require_dist2(), 1);
+import { AST_NODE_TYPES as AST_NODE_TYPES4 } from "@typescript-eslint/utils";
 var DEFAULT_STATIC_GLOBAL_FACTORIES = [
   "Axes",
   "BrickColor",
@@ -17827,34 +18652,34 @@ var STATIC_UNARY_OPERATORS = new Set(["-", "+", "!", "~", "typeof", "void", "del
 function unwrapExpression(expression) {
   let current = expression;
   while (true) {
-    if (current.type === AST_NODE_TYPES3.TSAsExpression) {
+    if (current.type === AST_NODE_TYPES4.TSAsExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === AST_NODE_TYPES3.TSTypeAssertion) {
+    if (current.type === AST_NODE_TYPES4.TSTypeAssertion) {
       current = current.expression;
       continue;
     }
-    if (current.type === AST_NODE_TYPES3.TSNonNullExpression) {
+    if (current.type === AST_NODE_TYPES4.TSNonNullExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === AST_NODE_TYPES3.TSSatisfiesExpression) {
+    if (current.type === AST_NODE_TYPES4.TSSatisfiesExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === AST_NODE_TYPES3.TSInstantiationExpression) {
+    if (current.type === AST_NODE_TYPES4.TSInstantiationExpression) {
       current = current.expression;
       continue;
     }
-    if (current.type === AST_NODE_TYPES3.ChainExpression) {
+    if (current.type === AST_NODE_TYPES4.ChainExpression) {
       current = current.expression;
       continue;
     }
     return current;
   }
 }
-function findVariable(context, identifier3) {
+function findVariable2(context, identifier3) {
   let scope = context.sourceCode.getScope(identifier3);
   while (scope) {
     const variable = scope.set.get(identifier3.name);
@@ -17865,29 +18690,29 @@ function findVariable(context, identifier3) {
   return;
 }
 function isModuleLevelScope(scope) {
-  return scope.type === import_scope_manager.ScopeType.module || scope.type === import_scope_manager.ScopeType.global;
+  return scope.type === import_scope_manager2.ScopeType.module || scope.type === import_scope_manager2.ScopeType.global;
 }
 function isImport(variable) {
   for (const definition of variable.defs)
-    if (definition.type === import_scope_manager.DefinitionType.ImportBinding)
+    if (definition.type === import_scope_manager2.DefinitionType.ImportBinding)
       return true;
   return false;
 }
 function getConstInitializer(definition) {
-  if (definition === undefined || definition.type !== import_scope_manager.DefinitionType.Variable)
+  if (definition === undefined || definition.type !== import_scope_manager2.DefinitionType.Variable)
     return;
   const declarator = definition.node;
-  if (declarator.type !== AST_NODE_TYPES3.VariableDeclarator)
+  if (declarator.type !== AST_NODE_TYPES4.VariableDeclarator)
     return;
   const declaration = definition.parent;
-  if (declaration?.type !== AST_NODE_TYPES3.VariableDeclaration)
+  if (declaration?.type !== AST_NODE_TYPES4.VariableDeclaration)
     return;
   if (declaration.kind !== "const")
     return;
   return declarator.init ?? undefined;
 }
 function isStaticIdentifier(context, identifier3, seen, options3) {
-  const variable = findVariable(context, identifier3);
+  const variable = findVariable2(context, identifier3);
   if (variable === undefined)
     return options3.staticGlobalFactories.has(identifier3.name);
   if (!isModuleLevelScope(variable.scope))
@@ -17904,34 +18729,34 @@ function isStaticIdentifier(context, identifier3, seen, options3) {
   return false;
 }
 function isStaticMemberProperty(property, seen, options3) {
-  if (property.type === AST_NODE_TYPES3.PrivateIdentifier)
+  if (property.type === AST_NODE_TYPES4.PrivateIdentifier)
     return false;
-  if (property.type === AST_NODE_TYPES3.Identifier)
+  if (property.type === AST_NODE_TYPES4.Identifier)
     return true;
   return isStaticExpressionInner(property, seen, options3);
 }
 function isStaticCallCallee(context, callee, seen, options3) {
   const unwrapped = unwrapExpression(callee);
-  if (unwrapped.type === AST_NODE_TYPES3.Identifier)
+  if (unwrapped.type === AST_NODE_TYPES4.Identifier)
     return isStaticIdentifier(context, unwrapped, seen, options3);
-  if (unwrapped.type === AST_NODE_TYPES3.MemberExpression) {
+  if (unwrapped.type === AST_NODE_TYPES4.MemberExpression) {
     if (!isStaticExpression(context, unwrapped.object, seen, options3))
       return false;
     if (unwrapped.computed)
       return isStaticMemberProperty(unwrapped.property, seen, options3);
-    return unwrapped.property.type === AST_NODE_TYPES3.Identifier;
+    return unwrapped.property.type === AST_NODE_TYPES4.Identifier;
   }
   return false;
 }
 function isStaticObjectExpression(context, objectExpr, seen, options3) {
   for (const property of objectExpr.properties) {
-    if (property.type !== AST_NODE_TYPES3.Property)
+    if (property.type !== AST_NODE_TYPES4.Property)
       return false;
     if (property.kind !== "init")
       return false;
     if (property.computed && !isStaticExpressionInner(property.key, seen, options3))
       return false;
-    const value = property.value;
+    const { value } = property;
     if (!isNonPatternExpression(value))
       return false;
     if (!isStaticExpression(context, value, seen, options3))
@@ -17940,20 +18765,20 @@ function isStaticObjectExpression(context, objectExpr, seen, options3) {
   return true;
 }
 function isNonPatternExpression(value) {
-  return value.type !== AST_NODE_TYPES3.PrivateIdentifier && value.type !== AST_NODE_TYPES3.AssignmentPattern && value.type !== AST_NODE_TYPES3.ArrayPattern && value.type !== AST_NODE_TYPES3.ObjectPattern && value.type !== AST_NODE_TYPES3.RestElement && value.type !== AST_NODE_TYPES3.TSEmptyBodyFunctionExpression;
+  return value.type !== AST_NODE_TYPES4.PrivateIdentifier && value.type !== AST_NODE_TYPES4.AssignmentPattern && value.type !== AST_NODE_TYPES4.ArrayPattern && value.type !== AST_NODE_TYPES4.ObjectPattern && value.type !== AST_NODE_TYPES4.RestElement && value.type !== AST_NODE_TYPES4.TSEmptyBodyFunctionExpression;
 }
 function isNonPrivateExpression(value) {
-  return value.type !== AST_NODE_TYPES3.PrivateIdentifier;
+  return value.type !== AST_NODE_TYPES4.PrivateIdentifier;
 }
 function objectHasFromAndTo(objectExpr) {
   let hasFrom = false;
   let hasTo = false;
   for (const property of objectExpr.properties) {
-    if (property.type !== AST_NODE_TYPES3.Property)
+    if (property.type !== AST_NODE_TYPES4.Property)
       continue;
     if (property.computed)
       continue;
-    if (property.key.type !== AST_NODE_TYPES3.Identifier)
+    if (property.key.type !== AST_NODE_TYPES4.Identifier)
       continue;
     if (property.key.name === "from")
       hasFrom = true;
@@ -17966,10 +18791,10 @@ function objectHasFromAndTo(objectExpr) {
 }
 function hasFromAndToProperties(context, expression) {
   const unwrapped = unwrapExpression(expression);
-  if (unwrapped.type === AST_NODE_TYPES3.ObjectExpression)
+  if (unwrapped.type === AST_NODE_TYPES4.ObjectExpression)
     return objectHasFromAndTo(unwrapped);
-  if (unwrapped.type === AST_NODE_TYPES3.Identifier) {
-    const variable = findVariable(context, unwrapped);
+  if (unwrapped.type === AST_NODE_TYPES4.Identifier) {
+    const variable = findVariable2(context, unwrapped);
     if (variable === undefined)
       return false;
     if (!isModuleLevelScope(variable.scope))
@@ -17981,7 +18806,7 @@ function hasFromAndToProperties(context, expression) {
       if (initializer === undefined)
         continue;
       const normalizedInitializer = unwrapExpression(initializer);
-      if (normalizedInitializer.type !== AST_NODE_TYPES3.ObjectExpression)
+      if (normalizedInitializer.type !== AST_NODE_TYPES4.ObjectExpression)
         continue;
       if (objectHasFromAndTo(normalizedInitializer))
         return true;
@@ -17991,10 +18816,10 @@ function hasFromAndToProperties(context, expression) {
 }
 function isStaticObjectLikeConfig(context, expression, seen, options3) {
   const unwrapped = unwrapExpression(expression);
-  if (unwrapped.type === AST_NODE_TYPES3.ObjectExpression)
+  if (unwrapped.type === AST_NODE_TYPES4.ObjectExpression)
     return isStaticObjectExpression(context, unwrapped, seen, options3);
-  if (unwrapped.type === AST_NODE_TYPES3.Identifier) {
-    const variable = findVariable(context, unwrapped);
+  if (unwrapped.type === AST_NODE_TYPES4.Identifier) {
+    const variable = findVariable2(context, unwrapped);
     if (variable === undefined)
       return false;
     if (!isModuleLevelScope(variable.scope))
@@ -18006,7 +18831,7 @@ function isStaticObjectLikeConfig(context, expression, seen, options3) {
       if (initializer === undefined)
         continue;
       const normalizedInitializer = unwrapExpression(initializer);
-      if (normalizedInitializer.type !== AST_NODE_TYPES3.ObjectExpression)
+      if (normalizedInitializer.type !== AST_NODE_TYPES4.ObjectExpression)
         continue;
       if (isStaticObjectExpression(context, normalizedInitializer, seen, options3))
         return true;
@@ -18018,7 +18843,7 @@ function isStaticArrayExpression(context, arrayExpr, seen, options3) {
   for (const element of arrayExpr.elements) {
     if (!element)
       continue;
-    if (element.type === AST_NODE_TYPES3.SpreadElement)
+    if (element.type === AST_NODE_TYPES4.SpreadElement)
       return false;
     if (!isStaticExpression(context, element, seen, options3))
       return false;
@@ -18034,520 +18859,179 @@ function isStaticExpression(context, expression, seen, options3) {
     return true;
   seen.add(unwrapped);
   switch (unwrapped.type) {
-    case AST_NODE_TYPES3.Literal:
+    case AST_NODE_TYPES4.Literal:
       return true;
-    case AST_NODE_TYPES3.TemplateLiteral:
+    case AST_NODE_TYPES4.TemplateLiteral:
       return unwrapped.expressions.length === 0;
-    case AST_NODE_TYPES3.UnaryExpression:
+    case AST_NODE_TYPES4.UnaryExpression:
       return STATIC_UNARY_OPERATORS.has(unwrapped.operator) && isStaticExpression(context, unwrapped.argument, seen, options3);
-    case AST_NODE_TYPES3.BinaryExpression:
-    case AST_NODE_TYPES3.LogicalExpression:
-      if (!isNonPrivateExpression(unwrapped.left) || !isNonPrivateExpression(unwrapped.right))
+    case AST_NODE_TYPES4.BinaryExpression:
+    case AST_NODE_TYPES4.LogicalExpression:
+      if (!(isNonPrivateExpression(unwrapped.left) && isNonPrivateExpression(unwrapped.right)))
         return false;
       return isStaticExpression(context, unwrapped.left, seen, options3) && isStaticExpression(context, unwrapped.right, seen, options3);
-    case AST_NODE_TYPES3.ConditionalExpression:
+    case AST_NODE_TYPES4.ConditionalExpression:
       return isStaticExpression(context, unwrapped.test, seen, options3) && isStaticExpression(context, unwrapped.consequent, seen, options3) && isStaticExpression(context, unwrapped.alternate, seen, options3);
-    case AST_NODE_TYPES3.ArrayExpression:
+    case AST_NODE_TYPES4.ArrayExpression:
       return context !== undefined && isStaticArrayExpression(context, unwrapped, seen, options3);
-    case AST_NODE_TYPES3.ObjectExpression:
+    case AST_NODE_TYPES4.ObjectExpression:
       return context !== undefined && isStaticObjectExpression(context, unwrapped, seen, options3);
-    case AST_NODE_TYPES3.Identifier:
+    case AST_NODE_TYPES4.Identifier:
       return context !== undefined && isStaticIdentifier(context, unwrapped, seen, options3);
-    case AST_NODE_TYPES3.MemberExpression:
+    case AST_NODE_TYPES4.MemberExpression:
       return isStaticExpression(context, unwrapped.object, seen, options3) && (!unwrapped.computed || isStaticMemberProperty(unwrapped.property, seen, options3));
-    case AST_NODE_TYPES3.ChainExpression:
+    case AST_NODE_TYPES4.ChainExpression:
       return isStaticExpression(context, unwrapped.expression, seen, options3);
-    case AST_NODE_TYPES3.CallExpression:
-      return context !== undefined && isStaticCallCallee(context, unwrapped.callee, seen, options3) && unwrapped.arguments.every((arg) => arg.type !== AST_NODE_TYPES3.SpreadElement && isStaticExpression(context, arg, seen, options3));
-    case AST_NODE_TYPES3.NewExpression:
-      return context !== undefined && isStaticCallCallee(context, unwrapped.callee, seen, options3) && (unwrapped.arguments ?? []).every((arg) => arg.type !== AST_NODE_TYPES3.SpreadElement && isStaticExpression(context, arg, seen, options3));
-    case AST_NODE_TYPES3.SequenceExpression:
+    case AST_NODE_TYPES4.CallExpression:
+      return context !== undefined && isStaticCallCallee(context, unwrapped.callee, seen, options3) && unwrapped.arguments.every((arg) => arg.type !== AST_NODE_TYPES4.SpreadElement && isStaticExpression(context, arg, seen, options3));
+    case AST_NODE_TYPES4.NewExpression:
+      return context !== undefined && isStaticCallCallee(context, unwrapped.callee, seen, options3) && (unwrapped.arguments ?? []).every((arg) => arg.type !== AST_NODE_TYPES4.SpreadElement && isStaticExpression(context, arg, seen, options3));
+    case AST_NODE_TYPES4.SequenceExpression:
       return unwrapped.expressions.length > 0 && unwrapped.expressions.every((expr) => isStaticExpression(context, expr, seen, options3));
-    case AST_NODE_TYPES3.AssignmentExpression:
+    case AST_NODE_TYPES4.AssignmentExpression:
       return isStaticExpression(context, unwrapped.right, seen, options3);
-    default:
-      return false;
-  }
-}
-function classifyDependencies(context, argument, seen, options3) {
-  if (argument === undefined)
-    return 0 /* MissingOrOmitted */;
-  if (argument.type === AST_NODE_TYPES3.SpreadElement)
-    return 3 /* DynamicOrUnknown */;
-  const expr = unwrapExpression(argument);
-  if (expr.type !== AST_NODE_TYPES3.ArrayExpression)
-    return 3 /* DynamicOrUnknown */;
-  if (expr.elements.length === 0)
-    return 1 /* EmptyArray */;
-  if (isStaticArrayExpression(context, expr, seen, options3))
-    return 2 /* StaticArray */;
-  return 3 /* DynamicOrUnknown */;
-}
-function depsAreNonUpdating(kind, options3) {
-  if (kind === 0 /* MissingOrOmitted */ || kind === 2 /* StaticArray */)
-    return true;
-  if (kind === 1 /* EmptyArray */)
-    return options3.treatEmptyDepsAsViolation;
-  return false;
-}
-function isSpringHookCall(node, options3) {
-  const { callee } = node;
-  if (callee.type === AST_NODE_TYPES3.Identifier)
-    return options3.springHooks.has(callee.name);
-  if (callee.type === AST_NODE_TYPES3.MemberExpression && !callee.computed) {
-    const { property } = callee;
-    if (property.type === AST_NODE_TYPES3.Identifier)
-      return options3.springHooks.has(property.name);
-  }
-  return false;
-}
-var noUselessUseSpring = {
-  create(context) {
-    const rawOptions = context.options[0];
-    const normalized = {
-      ...DEFAULT_OPTION_VALUES,
-      ...rawOptions,
-      springHooks: new Set(rawOptions?.springHooks ?? DEFAULT_OPTION_VALUES.springHooks),
-      staticGlobalFactories: new Set(rawOptions?.staticGlobalFactories ?? DEFAULT_OPTION_VALUES.staticGlobalFactories)
-    };
-    return {
-      CallExpression(node) {
-        if (!isSpringHookCall(node, normalized))
-          return;
-        if (node.arguments.length === 0)
-          return;
-        const configArgument = node.arguments[0];
-        if (!configArgument)
-          return;
-        if (configArgument.type === AST_NODE_TYPES3.SpreadElement)
-          return;
-        const seen = new Set;
-        if (!isStaticObjectLikeConfig(context, configArgument, seen, normalized))
-          return;
-        if (hasFromAndToProperties(context, configArgument))
-          return;
-        const depsKind = classifyDependencies(context, node.arguments[1], seen, normalized);
-        if (!depsAreNonUpdating(depsKind, normalized))
-          return;
-        context.report({
-          messageId: "uselessSpring",
-          node
-        });
-      }
-    };
-  },
-  defaultOptions: [DEFAULT_OPTION_VALUES],
-  meta: {
-    docs: {
-      description: "Disallow useSpring hooks whose config and dependencies are entirely static"
-    },
-    messages: {
-      uselessSpring: "useSpring call has only static inputs and non-updating dependencies; replace it with a constant or remove the hook."
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          springHooks: {
-            description: "Hook identifiers that should be treated as spring hooks",
-            items: { type: "string" },
-            type: "array"
-          },
-          staticGlobalFactories: {
-            default: [...DEFAULT_STATIC_GLOBAL_FACTORIES],
-            description: "Global factory identifiers that are treated as static constructors",
-            items: { type: "string" },
-            type: "array"
-          },
-          treatEmptyDepsAsViolation: {
-            default: true,
-            description: "Treat static config with an empty dependency array as a violation",
-            type: "boolean"
-          }
-        },
-        type: "object"
-      }
-    ],
-    type: "suggestion"
-  }
-};
-var no_useless_use_spring_default = noUselessUseSpring;
-
-// src/rules/no-warn.ts
-var noWarn = {
-  create(context) {
-    return {
-      'CallExpression[callee.type="Identifier"][callee.name="warn"]'(node) {
-        context.report({
-          messageId: "useLog",
-          node
-        });
-      }
-    };
-  },
-  meta: {
-    docs: {
-      description: "Ban warn() function calls. Use Log instead.",
-      recommended: false
-    },
-    messages: {
-      useLog: "Use Log instead of warn()"
-    },
-    schema: [],
-    type: "problem"
-  }
-};
-var no_warn_default = noWarn;
-
-// src/rules/no-god-components.ts
-import { TSESTree as TSESTree6 } from "@typescript-eslint/types";
-var COMPONENT_NAME_PATTERN = /^[A-Z]/;
-var FUNCTION_BOUNDARIES = new Set([
-  TSESTree6.AST_NODE_TYPES.FunctionDeclaration,
-  TSESTree6.AST_NODE_TYPES.FunctionExpression,
-  TSESTree6.AST_NODE_TYPES.ArrowFunctionExpression
-]);
-var RUNTIME_TS_WRAPPERS = new Set([
-  "ParenthesizedExpression",
-  "TSAsExpression",
-  "TSSatisfiesExpression",
-  "TSTypeAssertion",
-  "TSNonNullExpression",
-  "TSInstantiationExpression",
-  "ChainExpression"
-]);
-function isComponentName(name) {
-  return COMPONENT_NAME_PATTERN.test(name);
-}
-function isReactComponentHOC(callExpr) {
-  const { callee } = callExpr;
-  if (callee.type === TSESTree6.AST_NODE_TYPES.Identifier)
-    return callee.name === "forwardRef" || callee.name === "memo";
-  if (callee.type === TSESTree6.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree6.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === TSESTree6.AST_NODE_TYPES.Identifier)
-    return callee.property.name === "forwardRef" || callee.property.name === "memo";
-  return false;
-}
-function getComponentNameFromFunction(node) {
-  if (node.type === TSESTree6.AST_NODE_TYPES.FunctionDeclaration && node.id && isComponentName(node.id.name))
-    return node.id.name;
-  if (node.type === TSESTree6.AST_NODE_TYPES.FunctionExpression || node.type === TSESTree6.AST_NODE_TYPES.ArrowFunctionExpression) {
-    const { parent } = node;
-    if (parent === null || parent === undefined)
-      return;
-    if (parent.type === TSESTree6.AST_NODE_TYPES.VariableDeclarator && parent.id.type === TSESTree6.AST_NODE_TYPES.Identifier && isComponentName(parent.id.name))
-      return parent.id.name;
-    if (parent.type === TSESTree6.AST_NODE_TYPES.Property && parent.key.type === TSESTree6.AST_NODE_TYPES.Identifier && isComponentName(parent.key.name))
-      return parent.key.name;
-    if (parent.type === TSESTree6.AST_NODE_TYPES.MethodDefinition && parent.key.type === TSESTree6.AST_NODE_TYPES.Identifier && isComponentName(parent.key.name))
-      return parent.key.name;
-  }
-  return;
-}
-function getComponentNameFromCallParent(callExpr) {
-  const { parent } = callExpr;
-  if (parent === null || parent === undefined)
-    return;
-  if (parent.type === TSESTree6.AST_NODE_TYPES.VariableDeclarator && parent.id.type === TSESTree6.AST_NODE_TYPES.Identifier && isComponentName(parent.id.name))
-    return parent.id.name;
-  if (parent.type === TSESTree6.AST_NODE_TYPES.AssignmentExpression && parent.left.type === TSESTree6.AST_NODE_TYPES.Identifier && isComponentName(parent.left.name))
-    return parent.left.name;
-  if (parent.type === TSESTree6.AST_NODE_TYPES.ExportDefaultDeclaration && callExpr.arguments.length > 0) {
-    const firstArg = callExpr.arguments[0];
-    if (firstArg && firstArg.type === TSESTree6.AST_NODE_TYPES.FunctionExpression && firstArg.id && isComponentName(firstArg.id.name))
-      return firstArg.id.name;
-  }
-  return;
-}
-function getHookName(callExpression) {
-  const { callee } = callExpression;
-  if (callee.type === TSESTree6.AST_NODE_TYPES.Identifier)
-    return callee.name;
-  if (callee.type === TSESTree6.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree6.AST_NODE_TYPES.Identifier)
-    return callee.property.name;
-  return;
-}
-function countDestructuredProps(node) {
-  const firstParam = node.params[0];
-  if (!firstParam)
-    return;
-  let pattern4;
-  if (firstParam.type === TSESTree6.AST_NODE_TYPES.ObjectPattern)
-    pattern4 = firstParam;
-  if (firstParam.type === TSESTree6.AST_NODE_TYPES.AssignmentPattern && firstParam.left.type === TSESTree6.AST_NODE_TYPES.ObjectPattern)
-    pattern4 = firstParam.left;
-  if (!pattern4)
-    return;
-  let count = 0;
-  for (const prop of pattern4.properties) {
-    if (prop.type === TSESTree6.AST_NODE_TYPES.Property)
-      count += 1;
-  }
-  return count;
-}
-function isTypeOnlyNullLiteral(node) {
-  const parent = node.parent;
-  if (parent === null || parent === undefined)
-    return false;
-  if (typeof parent.type === "string" && parent.type.startsWith("TS") && !RUNTIME_TS_WRAPPERS.has(parent.type))
-    return true;
-  if (parent.type === TSESTree6.AST_NODE_TYPES.TSLiteralType)
-    return true;
-  return false;
-}
-function analyzeComponentBody(functionNode, sourceCode, stateHooks) {
-  let maxJsxDepth = 0;
-  let stateHookCount = 0;
-  const nullLiterals = new Array;
-  function visit(current, jsxDepth) {
-    if (FUNCTION_BOUNDARIES.has(current.type) && current !== functionNode)
-      return;
-    let nextDepth = jsxDepth;
-    if (current.type === TSESTree6.AST_NODE_TYPES.JSXElement || current.type === TSESTree6.AST_NODE_TYPES.JSXFragment) {
-      nextDepth = jsxDepth + 1;
-      if (nextDepth > maxJsxDepth)
-        maxJsxDepth = nextDepth;
-    }
-    if (current.type === TSESTree6.AST_NODE_TYPES.CallExpression) {
-      const hookName = getHookName(current);
-      if (typeof hookName === "string" && hookName.length > 0 && stateHooks.has(hookName))
-        stateHookCount += 1;
-    }
-    if (current.type === TSESTree6.AST_NODE_TYPES.Literal && current.value === null) {
-      const literalNode = current;
-      if (!isTypeOnlyNullLiteral(literalNode))
-        nullLiterals.push(literalNode);
-    }
-    function getVisitorKeysForNodeType(nodeType) {
-      const visitorKeysUnknown = sourceCode.visitorKeys;
-      if (visitorKeysUnknown === null || visitorKeysUnknown === undefined || typeof visitorKeysUnknown !== "object")
-        return [];
-      const visitorKeysRecord = visitorKeysUnknown;
-      const keysUnknown = visitorKeysRecord[nodeType];
-      if (!Array.isArray(keysUnknown))
-        return [];
-      const keys3 = new Array;
-      for (const key of keysUnknown)
-        if (typeof key === "string")
-          keys3.push(key);
-      return keys3;
-    }
-    const keys2 = getVisitorKeysForNodeType(current.type);
-    const currentRecord = current;
-    for (const key of keys2) {
-      const value = currentRecord[key];
-      if (Array.isArray(value)) {
-        for (const item of value) {
-          if (typeof item === "object" && item !== null && "type" in item) {
-            visit(item, nextDepth);
-          }
-        }
-        continue;
-      }
-      if (typeof value === "object" && value !== null && "type" in value) {
-        visit(value, nextDepth);
-      }
-    }
+    default:
+      return false;
   }
-  visit(functionNode.body, 0);
-  return { maxJsxDepth, nullLiterals, stateHookCount };
 }
-function parseOptions(options3) {
-  const defaults = {
-    enforceTargetLines: true,
-    ignoreComponents: [],
-    maxDestructuredProps: 5,
-    maxLines: 200,
-    maxStateHooks: 5,
-    maxTsxNesting: 3,
-    stateHooks: ["useState", "useReducer", "useBinding"],
-    targetLines: 120
-  };
-  if (typeof options3 !== "object" || options3 === null)
-    return defaults;
-  const cast = options3;
-  return {
-    enforceTargetLines: typeof cast.enforceTargetLines === "boolean" ? cast.enforceTargetLines : defaults.enforceTargetLines,
-    ignoreComponents: Array.isArray(cast.ignoreComponents) ? cast.ignoreComponents : defaults.ignoreComponents,
-    maxDestructuredProps: typeof cast.maxDestructuredProps === "number" ? cast.maxDestructuredProps : defaults.maxDestructuredProps,
-    maxLines: typeof cast.maxLines === "number" ? cast.maxLines : defaults.maxLines,
-    maxStateHooks: typeof cast.maxStateHooks === "number" ? cast.maxStateHooks : defaults.maxStateHooks,
-    maxTsxNesting: typeof cast.maxTsxNesting === "number" ? cast.maxTsxNesting : defaults.maxTsxNesting,
-    stateHooks: Array.isArray(cast.stateHooks) ? cast.stateHooks : defaults.stateHooks,
-    targetLines: typeof cast.targetLines === "number" ? cast.targetLines : defaults.targetLines
-  };
+function classifyDependencies(context, argument, seen, options3) {
+  if (argument === undefined)
+    return 0 /* MissingOrOmitted */;
+  if (argument.type === AST_NODE_TYPES4.SpreadElement)
+    return 3 /* DynamicOrUnknown */;
+  const expr = unwrapExpression(argument);
+  if (expr.type !== AST_NODE_TYPES4.ArrayExpression)
+    return 3 /* DynamicOrUnknown */;
+  if (expr.elements.length === 0)
+    return 1 /* EmptyArray */;
+  if (isStaticArrayExpression(context, expr, seen, options3))
+    return 2 /* StaticArray */;
+  return 3 /* DynamicOrUnknown */;
 }
-var noGodComponents = {
+function depsAreNonUpdating(kind, options3) {
+  if (kind === 0 /* MissingOrOmitted */ || kind === 2 /* StaticArray */)
+    return true;
+  if (kind === 1 /* EmptyArray */)
+    return options3.treatEmptyDepsAsViolation;
+  return false;
+}
+function isSpringHookCall(node, options3) {
+  const { callee } = node;
+  if (callee.type === AST_NODE_TYPES4.Identifier)
+    return options3.springHooks.has(callee.name);
+  if (callee.type === AST_NODE_TYPES4.MemberExpression && !callee.computed) {
+    const { property } = callee;
+    if (property.type === AST_NODE_TYPES4.Identifier)
+      return options3.springHooks.has(property.name);
+  }
+  return false;
+}
+var noUselessUseSpring = {
   create(context) {
-    const configuration = parseOptions(context.options[0]);
-    const ignoreSet = new Set(configuration.ignoreComponents);
-    const stateHooks = new Set(configuration.stateHooks);
-    const checked = new WeakSet;
-    const sourceCode = context.sourceCode;
-    function checkComponent(node, name) {
-      if (ignoreSet.has(name))
-        return;
-      if (checked.has(node))
-        return;
-      checked.add(node);
-      const location = node.loc;
-      if (location !== null && location !== undefined) {
-        const lines = location.end.line - location.start.line + 1;
-        if (lines > configuration.maxLines) {
-          context.report({
-            data: { lines, max: configuration.maxLines, name, target: configuration.targetLines },
-            messageId: "exceedsMaxLines",
-            node
-          });
-        } else if (configuration.enforceTargetLines && lines > configuration.targetLines) {
-          context.report({
-            data: { lines, max: configuration.maxLines, name, target: configuration.targetLines },
-            messageId: "exceedsTargetLines",
-            node
-          });
-        }
-      }
-      const propsCount = countDestructuredProps(node);
-      if (typeof propsCount === "number" && propsCount > configuration.maxDestructuredProps) {
-        context.report({
-          data: { count: propsCount, max: configuration.maxDestructuredProps, name },
-          messageId: "tooManyProps",
-          node
-        });
-      }
-      const analysis = analyzeComponentBody(node, sourceCode, stateHooks);
-      if (analysis.maxJsxDepth > configuration.maxTsxNesting) {
-        context.report({
-          data: { depth: analysis.maxJsxDepth, max: configuration.maxTsxNesting, name },
-          messageId: "tsxNestingTooDeep",
-          node
-        });
-      }
-      if (analysis.stateHookCount > configuration.maxStateHooks) {
-        context.report({
-          data: {
-            count: analysis.stateHookCount,
-            hooks: configuration.stateHooks.join(", "),
-            max: configuration.maxStateHooks,
-            name
-          },
-          messageId: "tooManyStateHooks",
-          node
-        });
-      }
-      for (const literal2 of analysis.nullLiterals) {
-        context.report({
-          messageId: "nullLiteral",
-          node: literal2
-        });
-      }
-    }
-    function maybeCheckFunction(node) {
-      const name = getComponentNameFromFunction(node);
-      if (typeof name !== "string" || name.length === 0)
-        return;
-      checkComponent(node, name);
-    }
+    const [rawOptions] = context.options;
+    const normalized = {
+      ...DEFAULT_OPTION_VALUES,
+      ...rawOptions,
+      springHooks: new Set(rawOptions?.springHooks ?? DEFAULT_OPTION_VALUES.springHooks),
+      staticGlobalFactories: new Set(rawOptions?.staticGlobalFactories ?? DEFAULT_OPTION_VALUES.staticGlobalFactories)
+    };
     return {
-      FunctionDeclaration(node) {
-        maybeCheckFunction(node);
-      },
-      FunctionExpression(node) {
-        maybeCheckFunction(node);
-      },
-      ArrowFunctionExpression(node) {
-        maybeCheckFunction(node);
-      },
       CallExpression(node) {
-        const callExpr = node;
-        if (!isReactComponentHOC(callExpr))
+        if (!isSpringHookCall(node, normalized))
           return;
-        const firstArg = callExpr.arguments[0];
-        if (!firstArg || firstArg.type !== TSESTree6.AST_NODE_TYPES.FunctionExpression && firstArg.type !== TSESTree6.AST_NODE_TYPES.ArrowFunctionExpression)
+        if (node.arguments.length === 0)
           return;
-        const nameFromParent = getComponentNameFromCallParent(callExpr);
-        const nameFromArg = getComponentNameFromFunction(firstArg);
-        const name = nameFromParent ?? nameFromArg;
-        if (typeof name !== "string" || name.length === 0)
+        const [configArgument] = node.arguments;
+        if (!configArgument)
           return;
-        checkComponent(firstArg, name);
+        if (configArgument.type === AST_NODE_TYPES4.SpreadElement)
+          return;
+        const seen = new Set;
+        if (!isStaticObjectLikeConfig(context, configArgument, seen, normalized))
+          return;
+        if (hasFromAndToProperties(context, configArgument))
+          return;
+        const depsKind = classifyDependencies(context, node.arguments[1], seen, normalized);
+        if (!depsAreNonUpdating(depsKind, normalized))
+          return;
+        context.report({
+          messageId: "uselessSpring",
+          node
+        });
       }
     };
   },
+  defaultOptions: [DEFAULT_OPTION_VALUES],
   meta: {
     docs: {
-      description: "Enforce React component size and complexity limits inspired by the 'Refactor God Component' checklist.",
-      recommended: false
+      description: "Disallow useSpring hooks whose config and dependencies are entirely static"
     },
     messages: {
-      exceedsTargetLines: "Component '{{name}}' is {{lines}} lines; target is {{target}} (max {{max}}). Consider extracting hooks/components.",
-      exceedsMaxLines: "Component '{{name}}' is {{lines}} lines; max allowed is {{max}}. Split into smaller components/hooks.",
-      tsxNestingTooDeep: "Component '{{name}}' has TSX nesting depth {{depth}}; max allowed is {{max}}. Extract child components.",
-      tooManyStateHooks: "Component '{{name}}' has {{count}} state hooks ({{hooks}}); max allowed is {{max}}. Extract cohesive state into a custom hook.",
-      tooManyProps: "Component '{{name}}' destructures {{count}} props; max allowed is {{max}}. Group props or split the component.",
-      nullLiteral: "Avoid `null` in components; use `undefined` instead."
+      uselessSpring: "useSpring call has only static inputs and non-updating dependencies; replace it with a constant or remove the hook."
     },
     schema: [
       {
         additionalProperties: false,
         properties: {
-          enforceTargetLines: {
-            default: true,
-            description: "Whether to report when exceeding targetLines (soft limit).",
-            type: "boolean"
-          },
-          ignoreComponents: {
-            description: "Component names to ignore.",
+          springHooks: {
+            description: "Hook identifiers that should be treated as spring hooks",
             items: { type: "string" },
             type: "array"
           },
-          maxDestructuredProps: {
-            default: 5,
-            description: "Maximum number of destructured props in a component parameter.",
-            type: "number"
-          },
-          maxLines: {
-            default: 200,
-            description: "Hard maximum lines for a component.",
-            type: "number"
-          },
-          maxStateHooks: {
-            default: 5,
-            description: "Maximum number of stateful hook calls in a component.",
-            type: "number"
-          },
-          maxTsxNesting: {
-            default: 3,
-            description: "Maximum JSX/TSX nesting depth in a component.",
-            type: "number"
-          },
-          stateHooks: {
-            default: ["useState", "useReducer", "useBinding"],
-            description: "Hook names to count toward state complexity.",
+          staticGlobalFactories: {
+            default: [...DEFAULT_STATIC_GLOBAL_FACTORIES],
+            description: "Global factory identifiers that are treated as static constructors",
             items: { type: "string" },
             type: "array"
           },
-          targetLines: {
-            default: 120,
-            description: "Soft target lines for a component.",
-            type: "number"
+          treatEmptyDepsAsViolation: {
+            default: true,
+            description: "Treat static config with an empty dependency array as a violation",
+            type: "boolean"
           }
         },
         type: "object"
       }
     ],
+    type: "suggestion"
+  }
+};
+var no_useless_use_spring_default = noUselessUseSpring;
+
+// src/rules/no-warn.ts
+var noWarn = {
+  create(context) {
+    return {
+      'CallExpression[callee.type="Identifier"][callee.name="warn"]'(node) {
+        context.report({
+          messageId: "useLog",
+          node
+        });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Ban warn() function calls. Use Log instead.",
+      recommended: false
+    },
+    messages: {
+      useLog: "Use Log instead of warn()"
+    },
+    schema: [],
     type: "problem"
   }
 };
-var no_god_components_default = noGodComponents;
+var no_warn_default = noWarn;
 
 // src/rules/prefer-sequence-overloads.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES4 } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES5 } from "@typescript-eslint/types";
 var sequenceDescriptors = [
   { keypointName: "ColorSequenceKeypoint", sequenceName: "ColorSequence" },
   { keypointName: "NumberSequenceKeypoint", sequenceName: "NumberSequence" }
 ];
 function isSequenceIdentifier(node) {
-  if (node.type !== AST_NODE_TYPES4.Identifier)
+  if (node.type !== AST_NODE_TYPES5.Identifier)
     return false;
   for (const { sequenceName } of sequenceDescriptors)
     if (sequenceName === node.name)
@@ -18561,16 +19045,16 @@ function findDescriptor(sequenceName) {
   return;
 }
 var isNumericLiteral = Compile(build_default.Object({
-  type: build_default.Literal(AST_NODE_TYPES4.Literal),
+  type: build_default.Literal(AST_NODE_TYPES5.Literal),
   value: build_default.Number()
 }));
 function isExpressionArgument(argument) {
-  return argument !== undefined && argument.type !== AST_NODE_TYPES4.SpreadElement;
+  return argument !== undefined && argument.type !== AST_NODE_TYPES5.SpreadElement;
 }
 function extractKeypoint(element, descriptor) {
-  if (element === undefined || element.type !== AST_NODE_TYPES4.NewExpression)
+  if (element === undefined || element.type !== AST_NODE_TYPES5.NewExpression)
     return;
-  if (element.callee.type !== AST_NODE_TYPES4.Identifier || element.callee.name !== descriptor.keypointName)
+  if (element.callee.type !== AST_NODE_TYPES5.Identifier || element.callee.name !== descriptor.keypointName)
     return;
   if (element.arguments.length !== 2)
     return;
@@ -18600,7 +19084,7 @@ var preferSequenceOverloads = {
         if (descriptor === undefined || node.arguments.length !== 1)
           return;
         const [argument] = node.arguments;
-        if (argument === undefined || argument.type !== AST_NODE_TYPES4.ArrayExpression || argument.elements.length !== 2)
+        if (argument === undefined || argument.type !== AST_NODE_TYPES5.ArrayExpression || argument.elements.length !== 2)
           return;
         const firstElement = argument.elements[0] ?? undefined;
         const secondElement = argument.elements[1] ?? undefined;
@@ -18683,7 +19167,7 @@ function reconstructText(node) {
     if (typeof operator !== "string" || !OPERATORS2.has(operator))
       return;
     const { left, right } = node;
-    if (!isRecord3(left) || !isRecord3(right))
+    if (!(isRecord3(left) && isRecord3(right)))
       return;
     const leftText = reconstructText(left);
     const rightText = reconstructText(right);
@@ -18744,7 +19228,7 @@ function collectArguments(_context2, parameters3) {
   const texts = [undefined, undefined, undefined, undefined];
   for (let index2 = 0;index2 < 4; index2++) {
     const parameter2 = parameters3[index2];
-    if (!isRecord3(parameter2) || !hasTypeProperty(parameter2))
+    if (!(isRecord3(parameter2) && hasTypeProperty(parameter2)))
       return;
     if (parameter2.type === TSESTree7.AST_NODE_TYPES.SpreadElement)
       return;
@@ -18842,12 +19326,14 @@ function parseOptions2(options3) {
     hooks: options3.hooks
   };
 }
-function getHookName2(callExpression) {
+function getHookName3(callExpression) {
   const { callee } = callExpression;
-  if (callee.type === TSESTree8.AST_NODE_TYPES.Identifier && typeof callee.name === "string" && callee.name.length > 0)
+  if (callee.type === TSESTree8.AST_NODE_TYPES.Identifier && typeof callee.name === "string" && callee.name.length > 0) {
     return callee.name;
-  if (callee.type === TSESTree8.AST_NODE_TYPES.MemberExpression && callee.property?.type === TSESTree8.AST_NODE_TYPES.Identifier && typeof callee.property.name === "string" && callee.property.name.length > 0)
+  }
+  if (callee.type === TSESTree8.AST_NODE_TYPES.MemberExpression && callee.property?.type === TSESTree8.AST_NODE_TYPES.Identifier && typeof callee.property.name === "string" && callee.property.name.length > 0) {
     return callee.property.name;
+  }
   return;
 }
 function resolveIdentifierToFunction(identifier3, context) {
@@ -18877,7 +19363,7 @@ function resolveIdentifierToFunction(identifier3, context) {
       if (typeof definition !== "object" || definition === null)
         continue;
       const castDefinition = definition;
-      const node = castDefinition.node;
+      const { node } = castDefinition;
       if (typeof node !== "object" || node === null)
         continue;
       const castNode = node;
@@ -18940,7 +19426,7 @@ function isCallbackHookResult(identifier3, context) {
       if (typeof definition !== "object" || definition === null)
         continue;
       const castDefinition = definition;
-      const node = castDefinition.node;
+      const { node } = castDefinition;
       if (typeof node !== "object" || node === null)
         continue;
       const castNode = node;
@@ -18951,7 +19437,7 @@ function isCallbackHookResult(identifier3, context) {
       const init = castNode.init;
       if (init.type !== TSESTree8.AST_NODE_TYPES.CallExpression)
         continue;
-      const calleeHookName = getHookName2(init);
+      const calleeHookName = getHookName3(init);
       if (calleeHookName === "useCallback" || calleeHookName === "useMemo")
         return true;
     }
@@ -18973,7 +19459,7 @@ var requireNamedEffectFunctions = {
     return {
       CallExpression(node) {
         const callExpression = node;
-        const hookName = getHookName2(callExpression);
+        const hookName = getHookName3(callExpression);
         if (typeof hookName !== "string" || !effectHooks.has(hookName))
           return;
         const firstArgument = callExpression.arguments?.[0];
@@ -19139,7 +19625,7 @@ var requireNamedEffectFunctions = {
 var require_named_effect_functions_default = requireNamedEffectFunctions;
 
 // src/rules/require-paired-calls.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES5 } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES6 } 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),
@@ -19157,20 +19643,20 @@ var isRuleOptions3 = Compile(build_default.Partial(build_default.Readonly(build_
   pairs: build_default.Readonly(build_default.Array(isPairConfiguration))
 }))));
 var LOOP_NODE_TYPES = new Set([
-  AST_NODE_TYPES5.DoWhileStatement,
-  AST_NODE_TYPES5.ForInStatement,
-  AST_NODE_TYPES5.ForOfStatement,
-  AST_NODE_TYPES5.ForStatement,
-  AST_NODE_TYPES5.WhileStatement
+  AST_NODE_TYPES6.DoWhileStatement,
+  AST_NODE_TYPES6.ForInStatement,
+  AST_NODE_TYPES6.ForOfStatement,
+  AST_NODE_TYPES6.ForStatement,
+  AST_NODE_TYPES6.WhileStatement
 ]);
 var DEFAULT_ROBLOX_YIELDING_FUNCTIONS = ["task.wait", "wait", "*.WaitForChild", "*.*Async"];
 function getCallName(node) {
   const { callee } = node;
-  if (callee.type === AST_NODE_TYPES5.Identifier)
+  if (callee.type === AST_NODE_TYPES6.Identifier)
     return callee.name;
-  if (callee.type === AST_NODE_TYPES5.MemberExpression) {
-    const object3 = callee.object.type === AST_NODE_TYPES5.Identifier ? callee.object.name : undefined;
-    const property = callee.property.type === AST_NODE_TYPES5.Identifier ? callee.property.name : undefined;
+  if (callee.type === AST_NODE_TYPES6.MemberExpression) {
+    const object3 = callee.object.type === AST_NODE_TYPES6.Identifier ? callee.object.name : undefined;
+    const property = callee.property.type === AST_NODE_TYPES6.Identifier ? callee.property.name : undefined;
     if (object3 !== undefined && property !== undefined)
       return `${object3}.${property}`;
   }
@@ -19206,12 +19692,12 @@ function isLoopLikeStatement(node) {
   return LOOP_NODE_TYPES.has(node.type);
 }
 function isSwitchStatement(node) {
-  return node?.type === AST_NODE_TYPES5.SwitchStatement;
+  return node?.type === AST_NODE_TYPES6.SwitchStatement;
 }
 function findLabeledStatementBody(label, startingNode) {
   let current = startingNode;
   while (current) {
-    if (current.type === AST_NODE_TYPES5.LabeledStatement && current.label.name === label.name)
+    if (current.type === AST_NODE_TYPES6.LabeledStatement && current.label.name === label.name)
       return current.body;
     current = current.parent ?? undefined;
   }
@@ -19248,7 +19734,7 @@ function cloneEntry(value) {
 }
 var rule = {
   create(context) {
-    const rawOptions = context.options[0];
+    const [rawOptions] = context.options;
     const baseOptions = isRuleOptions3.Check(rawOptions) ? rawOptions : {};
     const options3 = {
       allowConditionalClosers: baseOptions.allowConditionalClosers ?? false,
@@ -19414,7 +19900,7 @@ var rule = {
         const hasCompleteElse = ifNode.alternate !== undefined && ifNode.alternate !== null;
         for (const branchStack of branches) {
           for (const entry of branchStack) {
-            const wasInOriginal = originalStack.some((o) => o.index === entry.index);
+            const wasInOriginal = originalStack.some(({ index: index2 }) => index2 === entry.index);
             if (!wasInOriginal) {
               const validClosers = getValidClosers(entry.config);
               const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
@@ -19463,8 +19949,8 @@ var rule = {
     }
     function onIfConsequentExit(node) {
       const consequentNode = node;
-      const parent = consequentNode.parent;
-      if (parent?.type === AST_NODE_TYPES5.IfStatement) {
+      const { parent } = consequentNode;
+      if (parent?.type === AST_NODE_TYPES6.IfStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -19478,8 +19964,8 @@ var rule = {
     }
     function onIfAlternateExit(node) {
       const alternateNode = node;
-      const parent = alternateNode.parent;
-      if (parent?.type === AST_NODE_TYPES5.IfStatement) {
+      const { parent } = alternateNode;
+      if (parent?.type === AST_NODE_TYPES6.IfStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -19528,7 +20014,7 @@ var rule = {
     function onTryBlockExit(node) {
       const blockNode = node;
       const { parent } = blockNode;
-      if (parent?.type === AST_NODE_TYPES5.TryStatement) {
+      if (parent?.type === AST_NODE_TYPES6.TryStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -19547,7 +20033,7 @@ var rule = {
     function onCatchClauseExit(node) {
       const catchNode = node;
       const { parent } = catchNode;
-      if (parent?.type === AST_NODE_TYPES5.TryStatement) {
+      if (parent?.type === AST_NODE_TYPES6.TryStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -19610,7 +20096,7 @@ var rule = {
     function onSwitchCaseExit(node) {
       const caseNode = node;
       const { parent } = caseNode;
-      if (parent?.type === AST_NODE_TYPES5.SwitchStatement) {
+      if (parent?.type === AST_NODE_TYPES6.SwitchStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -19641,7 +20127,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_TYPES5.ReturnStatement ? "return" : "throw";
+        const statementType = statementNode.type === AST_NODE_TYPES6.ReturnStatement ? "return" : "throw";
         const lineNumber = statementNode.loc?.start.line ?? 0;
         context.report({
           data: {
@@ -19658,7 +20144,7 @@ var rule = {
       const statementNode = node;
       if (openerStack.length === 0)
         return;
-      const targetLoop = statementNode.type === AST_NODE_TYPES5.ContinueStatement ? resolveContinueTargetLoop(statementNode) : resolveBreakTargetLoop(statementNode);
+      const targetLoop = statementNode.type === AST_NODE_TYPES6.ContinueStatement ? resolveContinueTargetLoop(statementNode) : resolveBreakTargetLoop(statementNode);
       if (!targetLoop)
         return;
       for (const { node: openerNode, config, opener, loopAncestors } of openerStack) {
@@ -19666,7 +20152,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_TYPES5.BreakStatement ? "break" : "continue";
+        const statementType = statementNode.type === AST_NODE_TYPES6.BreakStatement ? "break" : "continue";
         const lineNumber = statementNode.loc?.start.line ?? 0;
         context.report({
           data: {
@@ -19804,7 +20290,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_TYPES5.AwaitExpression ? "await" : "yield";
+        const asyncType = asyncNode.type === AST_NODE_TYPES6.AwaitExpression ? "await" : "yield";
         context.report({
           data: { asyncType, closer, opener },
           messageId: "asyncViolation",
@@ -20021,10 +20507,12 @@ function isIterationOrMemoCallback(callExpr, iterationMethods, memoizationHooks)
     const methodName = callee.property.name;
     if (iterationMethods.has(methodName))
       return true;
-    if (methodName === "from" && callee.object.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.object.type === TSESTree9.AST_NODE_TYPES.Identifier && callee.object.object.name === "Array" && callExpr.arguments.length >= 2)
+    if (methodName === "from" && callee.object.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.object.type === TSESTree9.AST_NODE_TYPES.Identifier && callee.object.object.name === "Array" && callExpr.arguments.length >= 2) {
       return true;
-    if (methodName === "call" && callee.object.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.object.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.object.property.type === TSESTree9.AST_NODE_TYPES.Identifier && iterationMethods.has(callee.object.object.property.name))
+    }
+    if (methodName === "call" && callee.object.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.object.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.object.property.type === TSESTree9.AST_NODE_TYPES.Identifier && iterationMethods.has(callee.object.object.property.name)) {
       return true;
+    }
   }
   return false;
 }
@@ -20036,14 +20524,15 @@ function findEnclosingCallExpression(node) {
       for (const argument of parent.arguments) {
         if (argument === current)
           return parent;
-        if (argument.type === TSESTree9.AST_NODE_TYPES.SpreadElement && argument.argument === current)
+        if (argument.type === TSESTree9.AST_NODE_TYPES.SpreadElement && argument.argument === current) {
           return parent;
+        }
       }
       return;
     }
     if (ARGUMENT_WRAPPER_TYPES.has(parent.type)) {
       current = parent;
-      parent = parent.parent;
+      ({ parent } = parent);
       continue;
     }
     break;
@@ -20133,14 +20622,16 @@ function isTopLevelReturn(node) {
     return false;
   if (parent.type === TSESTree9.AST_NODE_TYPES.ReturnStatement) {
     let currentNode = ascendPastWrappers(parent.parent);
-    while (currentNode && CONTROL_FLOW_TYPES.has(currentNode.type))
+    while (currentNode && CONTROL_FLOW_TYPES.has(currentNode.type)) {
       currentNode = ascendPastWrappers(currentNode.parent);
+    }
     if (!currentNode)
       return false;
     if (IS_FUNCTION_EXPRESSION.has(currentNode.type)) {
       const functionParent = ascendPastWrappers(currentNode.parent);
-      if (functionParent?.type === TSESTree9.AST_NODE_TYPES.CallExpression)
+      if (functionParent?.type === TSESTree9.AST_NODE_TYPES.CallExpression) {
         return isReactComponentHOC2(functionParent);
+      }
       return true;
     }
     return currentNode.type === TSESTree9.AST_NODE_TYPES.FunctionDeclaration;
@@ -20158,7 +20649,7 @@ function isIgnoredCallExpression(node, ignoreList) {
   if (!parent)
     return false;
   if (parent.type === TSESTree9.AST_NODE_TYPES.JSXExpressionContainer) {
-    parent = parent.parent;
+    ({ parent } = parent);
     if (!parent)
       return false;
   }
@@ -20169,11 +20660,12 @@ function isIgnoredCallExpression(node, ignoreList) {
       const { callee } = parent;
       if (callee.type === TSESTree9.AST_NODE_TYPES.Identifier)
         return ignoreList.includes(callee.name);
-      if (callee.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree9.AST_NODE_TYPES.Identifier && callee.property.type === TSESTree9.AST_NODE_TYPES.Identifier)
+      if (callee.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree9.AST_NODE_TYPES.Identifier && callee.property.type === TSESTree9.AST_NODE_TYPES.Identifier) {
         return ignoreList.includes(`${callee.object.name}.${callee.property.name}`);
+      }
       return false;
     }
-    parent = parent.parent;
+    ({ parent } = parent);
   }
   return false;
 }
@@ -20181,12 +20673,13 @@ function isJSXPropValue(node) {
   let { parent } = node;
   if (!parent)
     return false;
-  while (parent && (parent.type === TSESTree9.AST_NODE_TYPES.ConditionalExpression || parent.type === TSESTree9.AST_NODE_TYPES.LogicalExpression))
-    parent = parent.parent;
+  while (parent && (parent.type === TSESTree9.AST_NODE_TYPES.ConditionalExpression || parent.type === TSESTree9.AST_NODE_TYPES.LogicalExpression)) {
+    ({ parent } = parent);
+  }
   if (!parent)
     return false;
   if (parent.type === TSESTree9.AST_NODE_TYPES.JSXExpressionContainer) {
-    parent = parent.parent;
+    ({ parent } = parent);
     if (!parent)
       return false;
   }
@@ -20202,7 +20695,7 @@ function isTernaryJSXChild(node) {
       foundTernary = true;
     current = current.parent;
   }
-  if (!foundTernary || !current)
+  if (!(foundTernary && current))
     return false;
   if (current.type !== TSESTree9.AST_NODE_TYPES.JSXExpressionContainer)
     return false;
@@ -20411,7 +20904,7 @@ var GLOBAL_BUILTINS = new Set([
   "Window",
   "Event"
 ]);
-function getHookName3(node) {
+function getHookName4(node) {
   const { callee } = node;
   if (callee.type === TSESTree10.AST_NODE_TYPES.Identifier)
     return callee.name;
@@ -20474,7 +20967,7 @@ function isStableArrayIndex(stableResult, node, identifierName) {
   if (!(stableResult instanceof Set) || node.type !== TSESTree10.AST_NODE_TYPES.VariableDeclarator || node.id.type !== TSESTree10.AST_NODE_TYPES.ArrayPattern) {
     return false;
   }
-  const elements = node.id.elements;
+  const { elements } = node.id;
   let index2 = 0;
   for (const element of elements) {
     if (element.type === TSESTree10.AST_NODE_TYPES.Identifier && element.name === identifierName) {
@@ -20488,7 +20981,7 @@ function isStableHookValue(init, node, identifierName, stableHooks) {
   const castInit = init;
   if (castInit.type !== TSESTree10.AST_NODE_TYPES.CallExpression)
     return false;
-  const hookName = getHookName3(castInit);
+  const hookName = getHookName4(castInit);
   if (!hookName)
     return false;
   const stableResult = stableHooks.get(hookName);
@@ -20507,7 +21000,7 @@ function isStableValue(variable, identifierName, stableHooks) {
     if (STABLE_VALUE_TYPES.has(type3))
       return true;
     if (type3 === "Variable" && node.type === TSESTree10.AST_NODE_TYPES.VariableDeclarator) {
-      const parent = node.parent;
+      const { parent } = node;
       if (!parent || parent.type !== TSESTree10.AST_NODE_TYPES.VariableDeclaration || parent.kind !== "const")
         continue;
       const init = node.init;
@@ -20554,10 +21047,10 @@ function findTopmostMemberExpression(node) {
     const isMemberParent = parent.type === TSESTree10.AST_NODE_TYPES.MemberExpression && parent.object === current;
     const isChainParent = parent.type === TSESTree10.AST_NODE_TYPES.ChainExpression;
     const isNonNullParent = parent.type === TSESTree10.AST_NODE_TYPES.TSNonNullExpression;
-    if (!isMemberParent && !isChainParent && !isNonNullParent)
+    if (!(isMemberParent || isChainParent || isNonNullParent))
       break;
     current = parent;
-    parent = parent.parent;
+    ({ parent } = parent);
   }
   return current;
 }
@@ -20575,21 +21068,21 @@ var TS_RUNTIME_EXPRESSIONS = new Set([
   TSESTree10.AST_NODE_TYPES.TSInstantiationExpression
 ]);
 function isComputedPropertyIdentifier(identifier3) {
-  const parent = identifier3.parent;
+  const { parent } = identifier3;
   return parent?.type === TSESTree10.AST_NODE_TYPES.Property && parent.computed && parent.key === identifier3;
 }
 function isInTypePosition(identifier3) {
   let parent = identifier3.parent;
   while (parent) {
     if (TS_RUNTIME_EXPRESSIONS.has(parent.type)) {
-      parent = parent.parent;
+      ({ parent } = parent);
       continue;
     }
     if (parent.type.startsWith("TS"))
       return true;
     if (IS_CEASE_BOUNDARY.has(parent.type))
       return false;
-    parent = parent.parent;
+    ({ parent } = parent);
   }
   return false;
 }
@@ -20613,7 +21106,7 @@ function isDeclaredInComponentBody(variable, closureNode) {
         return node === functionParent;
       });
     }
-    parent = parent.parent;
+    ({ parent } = parent);
   }
   return false;
 }
@@ -20789,7 +21282,7 @@ var useExhaustiveDependencies = {
     return {
       CallExpression(node) {
         const callNode = node;
-        const hookName = getHookName3(callNode);
+        const hookName = getHookName4(callNode);
         if (hookName === undefined || hookName === "")
           return;
         const hookConfig = hookConfigs.get(hookName);
@@ -21213,7 +21706,7 @@ var useHookAtTopLevel = {
         const current = getCurrentContext();
         if (!current)
           return;
-        if (!current.isComponentOrHook && !current.inNestedFunction)
+        if (!(current.isComponentOrHook || current.inNestedFunction))
           return;
         if (isInFinallyBlock(callNode))
           return;
@@ -21385,7 +21878,7 @@ var useHookAtTopLevel = {
 };
 var use_hook_at_top_level_default = useHookAtTopLevel;
 
-// src/configure-utilities.ts
+// src/utilities/configure-utilities.ts
 function createPairConfiguration(opener, closer, options3 = {}) {
   return { closer, opener, ...options3 };
 }
@@ -21487,10 +21980,12 @@ var rules = {
   "ban-instances": ban_instances_default,
   "ban-react-fc": ban_react_fc_default,
   "enforce-ianitor-check-type": enforce_ianitor_check_type_default,
+  "fast-format": fast_format_default,
   "no-async-constructor": no_async_constructor_default,
   "no-color3-constructor": no_color3_constructor_default,
   "no-commented-code": no_commented_code_default,
   "no-god-components": no_god_components_default,
+  "no-identity-map": no_identity_map_default,
   "no-instance-methods-without-this": no_instance_methods_without_this_default,
   "no-print": no_print_default,
   "no-shorthand-names": no_shorthand_names_default,
@@ -21506,17 +22001,17 @@ var rules = {
 };
 var recommended = {
   plugins: {
-    "cease-nonsense": {
-      rules
-    }
+    "cease-nonsense": { rules }
   },
   rules: {
     "cease-nonsense/ban-react-fc": "error",
     "cease-nonsense/enforce-ianitor-check-type": "error",
+    "cease-nonsense/fast-format": "error",
     "cease-nonsense/no-async-constructor": "error",
     "cease-nonsense/no-color3-constructor": "error",
-    "cease-nonsense/no-instance-methods-without-this": "error",
     "cease-nonsense/no-god-components": "error",
+    "cease-nonsense/no-identity-map": "error",
+    "cease-nonsense/no-instance-methods-without-this": "error",
     "cease-nonsense/no-print": "error",
     "cease-nonsense/no-shorthand-names": "error",
     "cease-nonsense/no-warn": "error",
@@ -21551,4 +22046,4 @@ export {
   createBanInstancesOptions
 };
 
-//# debugId=BE95AD3504B774A764756E2164756E21
+//# debugId=F65B81A39A5D507164756E2164756E21