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

package/dist/index.js

@@ -7726,7 +7726,7 @@ var require_Referencer = __commonJS((exports) => {
       this.visitForIn(node);
     }
     ForStatement(node) {
-      if (node.init && node.init.type === types_1.AST_NODE_TYPES.VariableDeclaration && node.init.kind !== "var") {
+      if (node.init?.type === types_1.AST_NODE_TYPES.VariableDeclaration && node.init.kind !== "var") {
         this.scopeManager.nestForScope(node);
       }
       this.visitChildren(node);
@@ -8233,7 +8233,6 @@ function Assign(left, right) {
 var exports_emit = {};
 __export(exports_emit, {
   Ternary: () => Ternary,
-  StringGraphemeCount: () => StringGraphemeCount2,
   Statements: () => Statements,
   Return: () => Return,
   ReduceOr: () => ReduceOr,
@@ -8252,6 +8251,8 @@ __export(exports_emit, {
   IsObject: () => IsObject2,
   IsNumber: () => IsNumber2,
   IsNull: () => IsNull2,
+  IsMinLength: () => IsMinLength3,
+  IsMaxLength: () => IsMaxLength3,
   IsLessThan: () => IsLessThan2,
   IsLessEqualThan: () => IsLessEqualThan2,
   IsIterator: () => IsIterator2,
@@ -8283,7 +8284,6 @@ var exports_guard = {};
 __export(exports_guard, {
   Values: () => Values,
   Symbols: () => Symbols,
-  StringGraphemeCount: () => StringGraphemeCount,
   Keys: () => Keys,
   IsValueLike: () => IsValueLike,
   IsUndefined: () => IsUndefined,
@@ -8294,6 +8294,8 @@ __export(exports_guard, {
   IsNumber: () => IsNumber,
   IsNull: () => IsNull,
   IsMultipleOf: () => IsMultipleOf,
+  IsMinLength: () => IsMinLength2,
+  IsMaxLength: () => IsMaxLength2,
   IsLessThan: () => IsLessThan,
   IsLessEqualThan: () => IsLessEqualThan,
   IsIterator: () => IsIterator,
@@ -8310,11 +8312,114 @@ __export(exports_guard, {
   IsAsyncIterator: () => IsAsyncIterator,
   IsArray: () => IsArray,
   HasPropertyKey: () => HasPropertyKey,
+  GraphemeCount: () => GraphemeCount2,
   EveryAll: () => EveryAll,
   Every: () => Every,
   EntriesRegExp: () => EntriesRegExp,
   Entries: () => Entries
 });
+
+// node_modules/typebox/build/guard/string.mjs
+function IsBetween(value, min, max) {
+  return value >= min && value <= max;
+}
+function IsRegionalIndicator(value) {
+  return IsBetween(value, 127462, 127487);
+}
+function IsVariationSelector(value) {
+  return IsBetween(value, 65024, 65039);
+}
+function IsCombiningMark(value) {
+  return IsBetween(value, 768, 879) || IsBetween(value, 6832, 6911) || IsBetween(value, 7616, 7679) || IsBetween(value, 65056, 65071);
+}
+function CodePointLength(value) {
+  return value > 65535 ? 2 : 1;
+}
+function ConsumeModifiers(value, index) {
+  while (index < value.length) {
+    const point = value.codePointAt(index);
+    if (IsCombiningMark(point) || IsVariationSelector(point)) {
+      index += CodePointLength(point);
+    } else {
+      break;
+    }
+  }
+  return index;
+}
+function NextGraphemeClusterIndex(value, clusterStart) {
+  const startCP = value.codePointAt(clusterStart);
+  let clusterEnd = clusterStart + CodePointLength(startCP);
+  clusterEnd = ConsumeModifiers(value, clusterEnd);
+  while (clusterEnd < value.length - 1 && value[clusterEnd] === "‍") {
+    const nextCP = value.codePointAt(clusterEnd + 1);
+    clusterEnd += 1 + CodePointLength(nextCP);
+    clusterEnd = ConsumeModifiers(value, clusterEnd);
+  }
+  if (IsRegionalIndicator(startCP) && clusterEnd < value.length && IsRegionalIndicator(value.codePointAt(clusterEnd))) {
+    clusterEnd += CodePointLength(value.codePointAt(clusterEnd));
+  }
+  return clusterEnd;
+}
+function IsGraphemeCodePoint(value) {
+  return IsBetween(value, 55296, 56319) || IsBetween(value, 768, 879) || value === 8205;
+}
+function GraphemeCount(value) {
+  let count = 0;
+  let index = 0;
+  while (index < value.length) {
+    index = NextGraphemeClusterIndex(value, index);
+    count++;
+  }
+  return count;
+}
+function IsMinLength(value, minLength) {
+  let count = 0;
+  let index = 0;
+  while (index < value.length) {
+    index = NextGraphemeClusterIndex(value, index);
+    count++;
+    if (count >= minLength)
+      return true;
+  }
+  return false;
+}
+function IsMaxLength(value, maxLength) {
+  let count = 0;
+  let index = 0;
+  while (index < value.length) {
+    index = NextGraphemeClusterIndex(value, index);
+    count++;
+    if (count > maxLength)
+      return false;
+  }
+  return true;
+}
+function IsMinLengthFast(value, minLength) {
+  let index = 0;
+  while (index < value.length) {
+    if (IsGraphemeCodePoint(value.charCodeAt(index))) {
+      return IsMinLength(value, minLength);
+    }
+    index++;
+    if (index >= minLength)
+      return true;
+  }
+  return false;
+}
+function IsMaxLengthFast(value, maxLength) {
+  let index = 0;
+  while (index < value.length) {
+    if (IsGraphemeCodePoint(value.charCodeAt(index))) {
+      return IsMaxLength(value, maxLength);
+    }
+    index++;
+    if (index > maxLength)
+      return false;
+  }
+  return true;
+}
+
+// node_modules/typebox/build/guard/guard.mjs
 function IsArray(value) {
   return Array.isArray(value);
 }
@@ -8405,8 +8510,14 @@ function IsClassInstance(value) {
 function IsValueLike(value) {
   return IsBigInt(value) || IsBoolean(value) || IsNull(value) || IsNumber(value) || IsString(value) || IsUndefined(value);
 }
-function StringGraphemeCount(value) {
-  return Array.from(value).length;
+function GraphemeCount2(value) {
+  return GraphemeCount(value);
+}
+function IsMaxLength2(value, length) {
+  return IsMaxLengthFast(value, length);
+}
+function IsMinLength2(value, length) {
+  return IsMinLengthFast(value, length);
 }
 function Every(value, offset, callback) {
   for (let index = offset;index < value.length; index++) {
@@ -8529,8 +8640,11 @@ function IsLessEqualThan2(left, right) {
 function IsGreaterEqualThan2(left, right) {
   return `${left} >= ${right}`;
 }
-function StringGraphemeCount2(value) {
-  return `Guard.StringGraphemeCount(${value})`;
+function IsMinLength3(value, length) {
+  return `Guard.IsMinLength(${value}, ${length})`;
+}
+function IsMaxLength3(value, length) {
+  return `Guard.IsMaxLength(${value}, ${length})`;
 }
 function Every2(value, offset, params, expression) {
   return IsEqual(offset, "0") ? `${value}.every((${params[0]}, ${params[1]}) => ${expression})` : `((value, callback) => { for(let index = ${offset}; index < value.length; index++) if (!callback(value[index], index)) return false; return true })(${value}, (${params[0]}, ${params[1]}) => ${expression})`;
@@ -10794,6 +10908,10 @@ function EvaluateUnion(types) {
 function EvaluateType(type) {
   return IsIntersect(type) ? EvaluateIntersect(type.allOf) : IsUnion(type) ? EvaluateUnion(type.anyOf) : type;
 }
+function EvaluateUnionFast(types) {
+  const result = exports_guard.IsEqual(types.length, 1) ? types[0] : exports_guard.IsEqual(types.length, 0) ? Never() : Union(types);
+  return result;
+}
 
 // node_modules/typebox/build/type/engine/evaluate/broaden.mjs
 function BroadFilter(type, types) {
@@ -11559,10 +11677,10 @@ function IndexElementsWithIndexer(types, indexer) {
 function FromTupleWithIndexer(types, indexer) {
   const formattedArrayIndexer = FormatArrayIndexer(indexer);
   const elements = IndexElementsWithIndexer(types, formattedArrayIndexer);
-  return EvaluateUnion(elements);
+  return EvaluateUnionFast(elements);
 }
 function FromTupleWithoutIndexer(types) {
-  return EvaluateUnion(types);
+  return EvaluateUnionFast(types);
 }
 function FromTuple(types, indexer) {
   return IsNumber4(indexer) || IsInteger3(indexer) ? FromTupleWithoutIndexer(types) : FromTupleWithIndexer(types, indexer);
@@ -11731,7 +11849,7 @@ function FromPropertyKeys(keys) {
 function FromObject5(properties2) {
   const propertyKeys = exports_guard.Keys(properties2);
   const variants = FromPropertyKeys(propertyKeys);
-  const result = EvaluateUnion(variants);
+  const result = EvaluateUnionFast(variants);
   return result;
 }
 
@@ -11743,7 +11861,7 @@ function FromRecord(type) {
 // node_modules/typebox/build/type/engine/keyof/from-tuple.mjs
 function FromTuple3(types) {
   const result = types.map((_, index) => Literal(index));
-  return EvaluateUnion(result);
+  return EvaluateUnionFast(result);
 }
 
 // node_modules/typebox/build/type/engine/keyof/instantiate.mjs
@@ -12674,7 +12792,7 @@ function IsMaxItems(schema2) {
   return exports_guard.HasPropertyKey(schema2, "maxItems") && exports_guard.IsNumber(schema2.maxItems);
 }
 // node_modules/typebox/build/schema/types/maxLength.mjs
-function IsMaxLength(schema2) {
+function IsMaxLength4(schema2) {
   return exports_guard.HasPropertyKey(schema2, "maxLength") && exports_guard.IsNumber(schema2.maxLength);
 }
 // node_modules/typebox/build/schema/types/maxProperties.mjs
@@ -12694,7 +12812,7 @@ function IsMinItems(schema2) {
   return exports_guard.HasPropertyKey(schema2, "minItems") && exports_guard.IsNumber(schema2.minItems);
 }
 // node_modules/typebox/build/schema/types/minLength.mjs
-function IsMinLength(schema2) {
+function IsMinLength4(schema2) {
   return exports_guard.HasPropertyKey(schema2, "minLength") && exports_guard.IsNumber(schema2.minLength);
 }
 // node_modules/typebox/build/schema/types/minProperties.mjs
@@ -13818,10 +13936,10 @@ function ErrorMaxItems(stack, context, schemaPath, instancePath, schema4, value)
 
 // node_modules/typebox/build/schema/engine/maxLength.mjs
 function BuildMaxLength(stack, context, schema4, value) {
-  return exports_emit.IsLessEqualThan(exports_emit.StringGraphemeCount(value), exports_emit.Constant(schema4.maxLength));
+  return exports_emit.IsMaxLength(value, exports_emit.Constant(schema4.maxLength));
 }
 function CheckMaxLength(stack, context, schema4, value) {
-  return exports_guard.IsLessEqualThan(exports_guard.StringGraphemeCount(value), schema4.maxLength);
+  return exports_guard.IsMaxLength(value, schema4.maxLength);
 }
 function ErrorMaxLength(stack, context, schemaPath, instancePath, schema4, value) {
   return CheckMaxLength(stack, context, schema4, value) || context.AddError({
@@ -13908,10 +14026,10 @@ function ErrorMinItems(stack, context, schemaPath, instancePath, schema4, value)
 
 // node_modules/typebox/build/schema/engine/minLength.mjs
 function BuildMinLength(stack, context, schema4, value) {
-  return exports_emit.IsGreaterEqualThan(exports_emit.StringGraphemeCount(value), exports_emit.Constant(schema4.minLength));
+  return exports_emit.IsMinLength(value, exports_emit.Constant(schema4.minLength));
 }
 function CheckMinLength(stack, context, schema4, value) {
-  return exports_guard.IsGreaterEqualThan(exports_guard.StringGraphemeCount(value), schema4.minLength);
+  return exports_guard.IsMinLength(value, schema4.minLength);
 }
 function ErrorMinLength(stack, context, schemaPath, instancePath, schema4, value) {
   return CheckMinLength(stack, context, schema4, value) || context.AddError({
@@ -14403,7 +14521,7 @@ function HasStringType(schema4) {
   return HasTypeName(schema4, "string");
 }
 function HasStringKeywords(schema4) {
-  return IsSchemaObject(schema4) && (IsMinLength(schema4) || IsMaxLength(schema4) || IsFormat(schema4) || IsPattern(schema4));
+  return IsSchemaObject(schema4) && (IsMinLength4(schema4) || IsMaxLength4(schema4) || IsFormat(schema4) || IsPattern(schema4));
 }
 function HasNumberType(schema4) {
   return HasTypeName(schema4, "number") || HasTypeName(schema4, "bigint");
@@ -14472,9 +14590,9 @@ function BuildSchema(stack, context, schema4, value) {
     const constraints = [];
     if (IsFormat(schema4))
       constraints.push(BuildFormat(stack, context, schema4, value));
-    if (IsMaxLength(schema4))
+    if (IsMaxLength4(schema4))
       constraints.push(BuildMaxLength(stack, context, schema4, value));
-    if (IsMinLength(schema4))
+    if (IsMinLength4(schema4))
       constraints.push(BuildMinLength(stack, context, schema4, value));
     if (IsPattern(schema4))
       constraints.push(BuildPattern(stack, context, schema4, value));
@@ -14530,13 +14648,13 @@ function BuildSchema(stack, context, schema4, value) {
 }
 function CheckSchema(stack, context, schema4, value) {
   stack.Push(schema4);
-  const result = IsBooleanSchema(schema4) ? CheckBooleanSchema(stack, context, schema4, value) : (!IsType(schema4) || CheckType(stack, context, schema4, value)) && (!(exports_guard.IsObject(value) && !exports_guard.IsArray(value)) || (!IsRequired(schema4) || CheckRequired(stack, context, schema4, value)) && (!IsAdditionalProperties(schema4) || CheckAdditionalProperties(stack, context, schema4, value)) && (!IsDependencies(schema4) || CheckDependencies(stack, context, schema4, value)) && (!IsDependentRequired(schema4) || CheckDependentRequired(stack, context, schema4, value)) && (!IsDependentSchemas(schema4) || CheckDependentSchemas(stack, context, schema4, value)) && (!IsPatternProperties(schema4) || CheckPatternProperties(stack, context, schema4, value)) && (!IsProperties(schema4) || CheckProperties(stack, context, schema4, value)) && (!IsPropertyNames(schema4) || CheckPropertyNames(stack, context, schema4, value)) && (!IsMinProperties(schema4) || CheckMinProperties(stack, context, schema4, value)) && (!IsMaxProperties(schema4) || CheckMaxProperties(stack, context, schema4, value))) && (!exports_guard.IsArray(value) || (!IsAdditionalItems(schema4) || CheckAdditionalItems(stack, context, schema4, value)) && (!IsContains(schema4) || CheckContains(stack, context, schema4, value)) && (!IsItems(schema4) || CheckItems(stack, context, schema4, value)) && (!IsMaxContains(schema4) || CheckMaxContains(stack, context, schema4, value)) && (!IsMaxItems(schema4) || CheckMaxItems(stack, context, schema4, value)) && (!IsMinContains(schema4) || CheckMinContains(stack, context, schema4, value)) && (!IsMinItems(schema4) || CheckMinItems(stack, context, schema4, value)) && (!IsPrefixItems(schema4) || CheckPrefixItems(stack, context, schema4, value)) && (!IsUniqueItems(schema4) || CheckUniqueItems(stack, context, schema4, value))) && (!exports_guard.IsString(value) || (!IsFormat(schema4) || CheckFormat(stack, context, schema4, value)) && (!IsMaxLength(schema4) || CheckMaxLength(stack, context, schema4, value)) && (!IsMinLength(schema4) || CheckMinLength(stack, context, schema4, value)) && (!IsPattern(schema4) || CheckPattern(stack, context, schema4, value))) && (!(exports_guard.IsNumber(value) || exports_guard.IsBigInt(value)) || (!IsExclusiveMaximum(schema4) || CheckExclusiveMaximum(stack, context, schema4, value)) && (!IsExclusiveMinimum(schema4) || CheckExclusiveMinimum(stack, context, schema4, value)) && (!IsMaximum(schema4) || CheckMaximum(stack, context, schema4, value)) && (!IsMinimum(schema4) || CheckMinimum(stack, context, schema4, value)) && (!IsMultipleOf2(schema4) || CheckMultipleOf(stack, context, schema4, value))) && (!IsRecursiveRef(schema4) || CheckRecursiveRef(stack, context, schema4, value)) && (!IsRef2(schema4) || CheckRef(stack, context, schema4, value)) && (!IsGuard2(schema4) || CheckGuard(stack, context, schema4, value)) && (!IsConst(schema4) || CheckConst(stack, context, schema4, value)) && (!IsEnum2(schema4) || CheckEnum(stack, context, schema4, value)) && (!IsIf(schema4) || CheckIf(stack, context, schema4, value)) && (!IsNot(schema4) || CheckNot(stack, context, schema4, value)) && (!IsAllOf(schema4) || CheckAllOf(stack, context, schema4, value)) && (!IsAnyOf(schema4) || CheckAnyOf(stack, context, schema4, value)) && (!IsOneOf(schema4) || CheckOneOf(stack, context, schema4, value)) && (!IsUnevaluatedItems(schema4) || (!exports_guard.IsArray(value) || CheckUnevaluatedItems(stack, context, schema4, value))) && (!IsUnevaluatedProperties(schema4) || (!exports_guard.IsObject(value) || CheckUnevaluatedProperties(stack, context, schema4, value))) && (!IsRefine2(schema4) || CheckRefine(stack, context, schema4, value));
+  const result = IsBooleanSchema(schema4) ? CheckBooleanSchema(stack, context, schema4, value) : (!IsType(schema4) || CheckType(stack, context, schema4, value)) && (!(exports_guard.IsObject(value) && !exports_guard.IsArray(value)) || (!IsRequired(schema4) || CheckRequired(stack, context, schema4, value)) && (!IsAdditionalProperties(schema4) || CheckAdditionalProperties(stack, context, schema4, value)) && (!IsDependencies(schema4) || CheckDependencies(stack, context, schema4, value)) && (!IsDependentRequired(schema4) || CheckDependentRequired(stack, context, schema4, value)) && (!IsDependentSchemas(schema4) || CheckDependentSchemas(stack, context, schema4, value)) && (!IsPatternProperties(schema4) || CheckPatternProperties(stack, context, schema4, value)) && (!IsProperties(schema4) || CheckProperties(stack, context, schema4, value)) && (!IsPropertyNames(schema4) || CheckPropertyNames(stack, context, schema4, value)) && (!IsMinProperties(schema4) || CheckMinProperties(stack, context, schema4, value)) && (!IsMaxProperties(schema4) || CheckMaxProperties(stack, context, schema4, value))) && (!exports_guard.IsArray(value) || (!IsAdditionalItems(schema4) || CheckAdditionalItems(stack, context, schema4, value)) && (!IsContains(schema4) || CheckContains(stack, context, schema4, value)) && (!IsItems(schema4) || CheckItems(stack, context, schema4, value)) && (!IsMaxContains(schema4) || CheckMaxContains(stack, context, schema4, value)) && (!IsMaxItems(schema4) || CheckMaxItems(stack, context, schema4, value)) && (!IsMinContains(schema4) || CheckMinContains(stack, context, schema4, value)) && (!IsMinItems(schema4) || CheckMinItems(stack, context, schema4, value)) && (!IsPrefixItems(schema4) || CheckPrefixItems(stack, context, schema4, value)) && (!IsUniqueItems(schema4) || CheckUniqueItems(stack, context, schema4, value))) && (!exports_guard.IsString(value) || (!IsFormat(schema4) || CheckFormat(stack, context, schema4, value)) && (!IsMaxLength4(schema4) || CheckMaxLength(stack, context, schema4, value)) && (!IsMinLength4(schema4) || CheckMinLength(stack, context, schema4, value)) && (!IsPattern(schema4) || CheckPattern(stack, context, schema4, value))) && (!(exports_guard.IsNumber(value) || exports_guard.IsBigInt(value)) || (!IsExclusiveMaximum(schema4) || CheckExclusiveMaximum(stack, context, schema4, value)) && (!IsExclusiveMinimum(schema4) || CheckExclusiveMinimum(stack, context, schema4, value)) && (!IsMaximum(schema4) || CheckMaximum(stack, context, schema4, value)) && (!IsMinimum(schema4) || CheckMinimum(stack, context, schema4, value)) && (!IsMultipleOf2(schema4) || CheckMultipleOf(stack, context, schema4, value))) && (!IsRecursiveRef(schema4) || CheckRecursiveRef(stack, context, schema4, value)) && (!IsRef2(schema4) || CheckRef(stack, context, schema4, value)) && (!IsGuard2(schema4) || CheckGuard(stack, context, schema4, value)) && (!IsConst(schema4) || CheckConst(stack, context, schema4, value)) && (!IsEnum2(schema4) || CheckEnum(stack, context, schema4, value)) && (!IsIf(schema4) || CheckIf(stack, context, schema4, value)) && (!IsNot(schema4) || CheckNot(stack, context, schema4, value)) && (!IsAllOf(schema4) || CheckAllOf(stack, context, schema4, value)) && (!IsAnyOf(schema4) || CheckAnyOf(stack, context, schema4, value)) && (!IsOneOf(schema4) || CheckOneOf(stack, context, schema4, value)) && (!IsUnevaluatedItems(schema4) || (!exports_guard.IsArray(value) || CheckUnevaluatedItems(stack, context, schema4, value))) && (!IsUnevaluatedProperties(schema4) || (!exports_guard.IsObject(value) || CheckUnevaluatedProperties(stack, context, schema4, value))) && (!IsRefine2(schema4) || CheckRefine(stack, context, schema4, value));
   stack.Pop(schema4);
   return result;
 }
 function ErrorSchema(stack, context, schemaPath, instancePath, schema4, value) {
   stack.Push(schema4);
-  const result = IsBooleanSchema(schema4) ? ErrorBooleanSchema(stack, context, schemaPath, instancePath, schema4, value) : !!(+(!IsType(schema4) || ErrorType(stack, context, schemaPath, instancePath, schema4, value)) & +(!(exports_guard.IsObject(value) && !exports_guard.IsArray(value)) || !!(+(!IsRequired(schema4) || ErrorRequired(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsAdditionalProperties(schema4) || ErrorAdditionalProperties(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsDependencies(schema4) || ErrorDependencies(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsDependentRequired(schema4) || ErrorDependentRequired(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsDependentSchemas(schema4) || ErrorDependentSchemas(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsPatternProperties(schema4) || ErrorPatternProperties(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsProperties(schema4) || ErrorProperties(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsPropertyNames(schema4) || ErrorPropertyNames(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMinProperties(schema4) || ErrorMinProperties(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMaxProperties(schema4) || ErrorMaxProperties(stack, context, schemaPath, instancePath, schema4, value)))) & +(!exports_guard.IsArray(value) || !!(+(!IsAdditionalItems(schema4) || ErrorAdditionalItems(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsContains(schema4) || ErrorContains(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsItems(schema4) || ErrorItems(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMaxContains(schema4) || ErrorMaxContains(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMaxItems(schema4) || ErrorMaxItems(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMinContains(schema4) || ErrorMinContains(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMinItems(schema4) || ErrorMinItems(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsPrefixItems(schema4) || ErrorPrefixItems(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsUniqueItems(schema4) || ErrorUniqueItems(stack, context, schemaPath, instancePath, schema4, value)))) & +(!exports_guard.IsString(value) || !!(+(!IsFormat(schema4) || ErrorFormat(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMaxLength(schema4) || ErrorMaxLength(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMinLength(schema4) || ErrorMinLength(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsPattern(schema4) || ErrorPattern(stack, context, schemaPath, instancePath, schema4, value)))) & +(!(exports_guard.IsNumber(value) || exports_guard.IsBigInt(value)) || !!(+(!IsExclusiveMaximum(schema4) || ErrorExclusiveMaximum(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsExclusiveMinimum(schema4) || ErrorExclusiveMinimum(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMaximum(schema4) || ErrorMaximum(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMinimum(schema4) || ErrorMinimum(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMultipleOf2(schema4) || ErrorMultipleOf(stack, context, schemaPath, instancePath, schema4, value)))) & +(!IsRecursiveRef(schema4) || ErrorRecursiveRef(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsRef2(schema4) || ErrorRef(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsGuard2(schema4) || ErrorGuard(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsConst(schema4) || ErrorConst(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsEnum2(schema4) || ErrorEnum(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsIf(schema4) || ErrorIf(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsNot(schema4) || ErrorNot(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsAllOf(schema4) || ErrorAllOf(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsAnyOf(schema4) || ErrorAnyOf(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsOneOf(schema4) || ErrorOneOf(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsUnevaluatedItems(schema4) || (!exports_guard.IsArray(value) || ErrorUnevaluatedItems(stack, context, schemaPath, instancePath, schema4, value))) & +(!IsUnevaluatedProperties(schema4) || (!exports_guard.IsObject(value) || ErrorUnevaluatedProperties(stack, context, schemaPath, instancePath, schema4, value)))) && (!IsRefine2(schema4) || ErrorRefine(stack, context, schemaPath, instancePath, schema4, value));
+  const result = IsBooleanSchema(schema4) ? ErrorBooleanSchema(stack, context, schemaPath, instancePath, schema4, value) : !!(+(!IsType(schema4) || ErrorType(stack, context, schemaPath, instancePath, schema4, value)) & +(!(exports_guard.IsObject(value) && !exports_guard.IsArray(value)) || !!(+(!IsRequired(schema4) || ErrorRequired(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsAdditionalProperties(schema4) || ErrorAdditionalProperties(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsDependencies(schema4) || ErrorDependencies(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsDependentRequired(schema4) || ErrorDependentRequired(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsDependentSchemas(schema4) || ErrorDependentSchemas(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsPatternProperties(schema4) || ErrorPatternProperties(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsProperties(schema4) || ErrorProperties(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsPropertyNames(schema4) || ErrorPropertyNames(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMinProperties(schema4) || ErrorMinProperties(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMaxProperties(schema4) || ErrorMaxProperties(stack, context, schemaPath, instancePath, schema4, value)))) & +(!exports_guard.IsArray(value) || !!(+(!IsAdditionalItems(schema4) || ErrorAdditionalItems(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsContains(schema4) || ErrorContains(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsItems(schema4) || ErrorItems(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMaxContains(schema4) || ErrorMaxContains(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMaxItems(schema4) || ErrorMaxItems(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMinContains(schema4) || ErrorMinContains(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMinItems(schema4) || ErrorMinItems(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsPrefixItems(schema4) || ErrorPrefixItems(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsUniqueItems(schema4) || ErrorUniqueItems(stack, context, schemaPath, instancePath, schema4, value)))) & +(!exports_guard.IsString(value) || !!(+(!IsFormat(schema4) || ErrorFormat(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMaxLength4(schema4) || ErrorMaxLength(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMinLength4(schema4) || ErrorMinLength(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsPattern(schema4) || ErrorPattern(stack, context, schemaPath, instancePath, schema4, value)))) & +(!(exports_guard.IsNumber(value) || exports_guard.IsBigInt(value)) || !!(+(!IsExclusiveMaximum(schema4) || ErrorExclusiveMaximum(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsExclusiveMinimum(schema4) || ErrorExclusiveMinimum(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMaximum(schema4) || ErrorMaximum(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMinimum(schema4) || ErrorMinimum(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsMultipleOf2(schema4) || ErrorMultipleOf(stack, context, schemaPath, instancePath, schema4, value)))) & +(!IsRecursiveRef(schema4) || ErrorRecursiveRef(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsRef2(schema4) || ErrorRef(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsGuard2(schema4) || ErrorGuard(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsConst(schema4) || ErrorConst(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsEnum2(schema4) || ErrorEnum(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsIf(schema4) || ErrorIf(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsNot(schema4) || ErrorNot(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsAllOf(schema4) || ErrorAllOf(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsAnyOf(schema4) || ErrorAnyOf(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsOneOf(schema4) || ErrorOneOf(stack, context, schemaPath, instancePath, schema4, value)) & +(!IsUnevaluatedItems(schema4) || (!exports_guard.IsArray(value) || ErrorUnevaluatedItems(stack, context, schemaPath, instancePath, schema4, value))) & +(!IsUnevaluatedProperties(schema4) || (!exports_guard.IsObject(value) || ErrorUnevaluatedProperties(stack, context, schemaPath, instancePath, schema4, value)))) && (!IsRefine2(schema4) || ErrorRefine(stack, context, schemaPath, instancePath, schema4, value));
   stack.Pop(schema4);
   return result;
 }
@@ -15974,7 +16092,7 @@ function FromString9(context, type3) {
   const needsDefault = (IsPattern(type3) || IsFormat(type3)) && !IsDefault(type3);
   if (needsDefault)
     throw Error("Strings with format or pattern constraints must specify default");
-  const minLength3 = IsMinLength(type3) ? type3.minLength : 0;
+  const minLength3 = IsMinLength4(type3) ? type3.minLength : 0;
   return "".padEnd(minLength3);
 }
 
@@ -16145,6 +16263,10 @@ function Compile(...args) {
   });
   return new Validator(context, type3);
 }
+// src/utilities/create-rule.ts
+import { ESLintUtils } from "@typescript-eslint/utils";
+var createRule = ESLintUtils.RuleCreator((name) => `https://github.com/howmanysmall/eslint-cease-nonsense-rules/blob/main/docs/rules/${name}.md`);
+
 // src/rules/ban-instances.ts
 var isArrayConfig = Compile(build_default.Array(build_default.String()));
 var isObjectConfig = Compile(build_default.Record(build_default.String(), build_default.String()));
@@ -16170,11 +16292,7 @@ function normalizeConfig(options3) {
   }
   return { bannedClasses };
 }
-var docs = {
-  description: "Ban specified Roblox Instance classes in new Instance() calls and JSX elements.",
-  recommended: false
-};
-var banInstances = {
+var ban_instances_default = createRule({
   create(context) {
     const config = normalizeConfig(context.options[0]);
     if (config.bannedClasses.size === 0)
@@ -16228,9 +16346,11 @@ var banInstances = {
   },
   defaultOptions: [{ bannedInstances: [] }],
   meta: {
-    docs,
+    docs: {
+      description: "Ban specified Roblox Instance classes in new Instance() calls and JSX elements."
+    },
     messages: {
-      bannedInstance: "Instance class '{{className}}' is banned.",
+      bannedInstance: "Instance class '{{className}}' is banned by project configuration. This class may cause performance issues, is deprecated, or has a better alternative. Check project guidelines for the recommended replacement.",
       bannedInstanceCustom: "{{customMessage}}"
     },
     schema: [
@@ -16256,14 +16376,14 @@ var banInstances = {
       }
     ],
     type: "problem"
-  }
-};
-var ban_instances_default = banInstances;
+  },
+  name: "ban-instances"
+});
 
 // src/rules/ban-react-fc.ts
 import { TSESTree as TSESTree2 } from "@typescript-eslint/types";
 var BANNED_FC_NAMES = new Set(["FC", "FunctionComponent", "VFC", "VoidFunctionComponent"]);
-var banReactFC = {
+var ban_react_fc_default = createRule({
   create(context) {
     return {
       VariableDeclarator(node) {
@@ -16292,21 +16412,20 @@ var banReactFC = {
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Ban React.FC and similar component type annotations. Use explicit function declarations instead.",
-      recommended: true
+      description: "Ban React.FC and similar component type annotations. Use explicit function declarations instead."
     },
     messages: {
       banReactFC: "Avoid React.FC/FunctionComponent/VFC/VoidFunctionComponent types. They break debug information and profiling. Use explicit function declarations instead: `function Component(props: Props) { ... }`"
     },
     schema: [],
     type: "problem"
-  }
-};
-var ban_react_fc_default = banReactFC;
+  },
+  name: "ban-react-fc"
+});
 
 // src/rules/enforce-ianitor-check-type.ts
 import { TSESTree as TSESTree3 } from "@typescript-eslint/types";
-import { ESLintUtils } from "@typescript-eslint/utils";
+import { ESLintUtils as ESLintUtils2 } from "@typescript-eslint/utils";
 var DEFAULT_CONFIGURATION = {
   baseThreshold: 10,
   errorThreshold: 25,
@@ -16383,8 +16502,8 @@ function calculateIanitorComplexity(node) {
       return 1;
   }
 }
-var createRule = ESLintUtils.RuleCreator((name) => `https://github.com/howmanysmall/eslint-cease-nonsense-rules/blob/main/docs/rules/${name}.md`);
-var enforceIanitorCheckType = createRule({
+var createRule2 = ESLintUtils2.RuleCreator((name) => `https://github.com/howmanysmall/eslint-cease-nonsense-rules/blob/main/docs/rules/${name}.md`);
+var enforceIanitorCheckType = createRule2({
   create(context) {
     const [rawOptions] = context.options;
     const config = { ...DEFAULT_CONFIGURATION, ...rawOptions };
@@ -17560,7 +17679,7 @@ function reportViolation(context, violation) {
     node: violation.node
   });
 }
-var noAsyncConstructor = {
+var no_async_constructor_default = createRule({
   create(context) {
     return {
       "MethodDefinition[kind='constructor']"(node) {
@@ -17583,8 +17702,7 @@ var noAsyncConstructor = {
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Disallow asynchronous operations inside class constructors. Constructors return immediately, " + "so async work causes race conditions, unhandled rejections, and incomplete object states.",
-      recommended: true
+      description: "Disallow asynchronous operations inside class constructors. Constructors return immediately, " + "so async work causes race conditions, unhandled rejections, and incomplete object states."
     },
     messages: {
       asyncIifeInConstructor: "Refactor this asynchronous operation outside of the constructor. " + "Async IIFEs create unhandled promises and incomplete object state.",
@@ -17595,9 +17713,9 @@ var noAsyncConstructor = {
     },
     schema: [],
     type: "problem"
-  }
-};
-var no_async_constructor_default = noAsyncConstructor;
+  },
+  name: "no-async-constructor"
+});
 
 // src/rules/no-color3-constructor.ts
 import { TSESTree as TSESTree4 } from "@typescript-eslint/types";
@@ -17622,7 +17740,7 @@ function collectNumericComponents(parameters3) {
   }
   return { allZero, components };
 }
-var noColor3Constructor = {
+var no_color3_constructor_default = createRule({
   create(context) {
     return {
       NewExpression(node) {
@@ -17658,10 +17776,10 @@ var noColor3Constructor = {
       }
     };
   },
+  defaultOptions: [],
   meta: {
     docs: {
-      description: "Ban new Color3(...) except new Color3() or new Color3(0, 0, 0). Use Color3.fromRGB() instead.",
-      recommended: true
+      description: "Ban new Color3(...) except new Color3() or new Color3(0, 0, 0). Use Color3.fromRGB() instead."
     },
     fixable: "code",
     messages: {
@@ -17670,9 +17788,9 @@ var noColor3Constructor = {
     },
     schema: [],
     type: "problem"
-  }
-};
-var no_color3_constructor_default = noColor3Constructor;
+  },
+  name: "no-color3-constructor"
+});
 
 // src/rules/no-commented-code.ts
 import path from "node:path";
@@ -18026,27 +18144,27 @@ var noCommentedCode = {
           if (trimmedValue === "}")
             continue;
           const balanced = injectMissingBraces(trimmedValue);
-          if (containsCode(balanced, context.filename)) {
-            const firstComment = group.comments.at(0);
-            const lastComment = group.comments.at(-1);
-            if (!(firstComment && lastComment))
-              continue;
-            context.report({
-              loc: {
-                end: lastComment.loc.end,
-                start: firstComment.loc.start
-              },
-              messageId: "commentedCode",
-              suggest: [
-                {
-                  desc: "Remove this commented out code",
-                  fix(fixer) {
-                    return fixer.removeRange([firstComment.range[0], lastComment.range[1]]);
-                  }
+          if (!containsCode(balanced, context.filename))
+            return;
+          const firstComment = group.comments.at(0);
+          const lastComment = group.comments.at(-1);
+          if (!(firstComment && lastComment))
+            continue;
+          context.report({
+            loc: {
+              end: lastComment.loc.end,
+              start: firstComment.loc.start
+            },
+            messageId: "commentedCode",
+            suggest: [
+              {
+                desc: "Remove this commented out code",
+                fix(fixer) {
+                  return fixer.removeRange([firstComment.range[0], lastComment.range[1]]);
                 }
-              ]
-            });
-          }
+              }
+            ]
+          });
         }
       }
     };
@@ -18058,7 +18176,7 @@ var noCommentedCode = {
     },
     hasSuggestions: true,
     messages: {
-      commentedCode: "Remove this commented out code."
+      commentedCode: "Commented-out code creates confusion about intent and clutters the codebase. Version control preserves history, making dead code comments unnecessary. Delete the commented code entirely. If needed later, retrieve it from git history."
     },
     schema: [],
     type: "suggestion"
@@ -18512,7 +18630,7 @@ function isLikelyBinding(context, callee, patterns2) {
   }
   return object3.type === AST_NODE_TYPES2.CallExpression && isJoinBindingsCall(object3);
 }
-var noIdentityMap = {
+var no_identity_map_default = createRule({
   create(context) {
     const [{ bindingPatterns = DEFAULT_BINDING_PATTERNS } = {}] = context.options;
     return {
@@ -18570,9 +18688,9 @@ var noIdentityMap = {
       }
     ],
     type: "suggestion"
-  }
-};
-var no_identity_map_default = noIdentityMap;
+  },
+  name: "no-identity-map"
+});
 
 // src/rules/no-instance-methods-without-this.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/types";
@@ -18642,7 +18760,7 @@ function methodUsesThis(node) {
     return false;
   return traverseForThis(value, new WeakSet);
 }
-var noInstanceMethodsWithoutThis = {
+var no_instance_methods_without_this_default = createRule({
   create(context) {
     const [rawOptions] = context.options;
     const options3 = normalizeOptions(rawOptions);
@@ -18664,8 +18782,7 @@ var noInstanceMethodsWithoutThis = {
   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
+      description: "Detect instance methods that do not use 'this' and suggest converting them to standalone functions for better performance in roblox-ts."
     },
     messages: {
       noInstanceMethodWithoutThis: "Method '{{methodName}}' does not use 'this' and creates unnecessary metatable overhead in roblox-ts. Convert it to a standalone function for better performance."
@@ -18694,12 +18811,12 @@ var noInstanceMethodsWithoutThis = {
       }
     ],
     type: "problem"
-  }
-};
-var no_instance_methods_without_this_default = noInstanceMethodsWithoutThis;
+  },
+  name: "no-instance-methods-without-this"
+});
 
 // src/rules/no-print.ts
-var noPrint = {
+var no_print_default = createRule({
   create(context) {
     return {
       'CallExpression[callee.type="Identifier"][callee.name="print"]'(node) {
@@ -18710,19 +18827,19 @@ var noPrint = {
       }
     };
   },
+  defaultOptions: [],
   meta: {
     docs: {
-      description: "Ban print() function calls. Use Log instead.",
-      recommended: false
+      description: "Ban print() function calls. Use Log instead."
     },
     messages: {
-      useLog: "Use Log instead of print()"
+      useLog: "print() is a raw output function lacking log levels, timestamps, and filtering. Production systems require structured logging for debugging and monitoring. Replace print(...) with something from the logging package."
     },
     schema: [],
     type: "problem"
-  }
-};
-var no_print_default = noPrint;
+  },
+  name: "no-print"
+});
 
 // src/rules/no-shorthand-names.ts
 import { TSESTree as TSESTree6 } from "@typescript-eslint/types";
@@ -19012,7 +19129,7 @@ var noShorthandNames = {
       recommended: true
     },
     messages: {
-      useReplacement: "Use '{{replacement}}' instead of '{{shorthand}}' shorthand"
+      useReplacement: "'{{shorthand}}' is a shorthand abbreviation that reduces code readability. Abbreviated names force readers to mentally expand them and can mean different things in different contexts. Rename to '{{replacement}}' for clarity and self-documenting code."
     },
     schema: [
       {
@@ -19311,11 +19428,11 @@ function isStaticExpression(context, expression, seen, options3) {
     case AST_NODE_TYPES4.ChainExpression:
       return isStaticExpression(context, unwrapped.expression, seen, options3);
     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));
+      return context !== undefined && isStaticCallCallee(context, unwrapped.callee, seen, options3) && unwrapped.arguments.every((argument) => argument.type !== AST_NODE_TYPES4.SpreadElement && isStaticExpression(context, argument, 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));
+      return context !== undefined && isStaticCallCallee(context, unwrapped.callee, seen, options3) && (unwrapped.arguments ?? []).every((argument) => argument.type !== AST_NODE_TYPES4.SpreadElement && isStaticExpression(context, argument, seen, options3));
     case AST_NODE_TYPES4.SequenceExpression:
-      return unwrapped.expressions.length > 0 && unwrapped.expressions.every((expr) => isStaticExpression(context, expr, seen, options3));
+      return unwrapped.expressions.length > 0 && unwrapped.expressions.every((expression2) => isStaticExpression(context, expression2, seen, options3));
     case AST_NODE_TYPES4.AssignmentExpression:
       return isStaticExpression(context, unwrapped.right, seen, options3);
     default:
@@ -19354,7 +19471,7 @@ function isSpringHookCall(node, options3) {
   }
   return false;
 }
-var noUselessUseSpring = {
+var no_useless_use_spring_default = createRule({
   create(context) {
     const [rawOptions] = context.options;
     const normalized = {
@@ -19422,12 +19539,12 @@ var noUselessUseSpring = {
       }
     ],
     type: "suggestion"
-  }
-};
-var no_useless_use_spring_default = noUselessUseSpring;
+  },
+  name: "no-useless-use-spring"
+});
 
 // src/rules/no-warn.ts
-var noWarn = {
+var no_warn_default = createRule({
   create(context) {
     return {
       'CallExpression[callee.type="Identifier"][callee.name="warn"]'(node) {
@@ -19438,19 +19555,19 @@ var noWarn = {
       }
     };
   },
+  defaultOptions: [],
   meta: {
     docs: {
-      description: "Ban warn() function calls. Use Log instead.",
-      recommended: false
+      description: "Ban warn() function calls. Use Log instead."
     },
     messages: {
-      useLog: "Use Log instead of warn()"
+      useLog: "warn() is a raw output function lacking log levels, timestamps, and filtering. Production systems require structured logging for debugging and monitoring. Replace warn(...) with something from the logging package."
     },
     schema: [],
     type: "problem"
-  }
-};
-var no_warn_default = noWarn;
+  },
+  name: "no-warn"
+});
 
 // src/rules/prefer-class-properties.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES5 } from "@typescript-eslint/utils";
@@ -19496,7 +19613,7 @@ function isStaticMemberExpression(node) {
 function isConstructor(node) {
   return node.type === AST_NODE_TYPES5.MethodDefinition && node.kind === "constructor" && node.key.type === AST_NODE_TYPES5.Identifier && node.key.name === "constructor";
 }
-var preferClassProperties = {
+var prefer_class_properties_default = createRule({
   create(context) {
     const option = context.options[0] ?? "always";
     if (option === "never") {
@@ -19553,14 +19670,14 @@ var preferClassProperties = {
       description: "Prefer class properties to assignment of literals in constructors."
     },
     messages: {
-      unexpectedAssignment: "Unexpected assignment of literal instance member.",
-      unexpectedClassProperty: "Unexpected class property."
+      unexpectedAssignment: "Constructor assigns a literal value to this.property. Literals are static and known at class definition time. Move to a class property declaration: propertyName = value; at class level. This clarifies intent and reduces constructor complexity.",
+      unexpectedClassProperty: "Class property declarations are disabled by rule configuration (mode: 'never'). Move initialization into the constructor: this.propertyName = value; inside constructor()."
     },
     schema: [{ enum: ["always", "never"], type: "string" }],
     type: "suggestion"
-  }
-};
-var prefer_class_properties_default = preferClassProperties;
+  },
+  name: "prefer-class-properties"
+});
 
 // src/rules/prefer-early-return.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES6 } from "@typescript-eslint/utils";
@@ -19580,7 +19697,7 @@ function canSimplifyConditionalBody(body, maxStatements) {
   }
   return isOffendingConsequent(statement.consequent, maxStatements);
 }
-var preferEarlyReturn = {
+var prefer_early_return_default = createRule({
   create(context) {
     const options3 = context.options[0] ?? {};
     const maxStatements = options3.maximumStatements ?? DEFAULT_MAXIMUM_STATEMENTS;
@@ -19605,7 +19722,7 @@ var preferEarlyReturn = {
       description: "Prefer early returns over full-body conditional wrapping in function declarations."
     },
     messages: {
-      preferEarlyReturn: "Prefer an early return to a conditionally-wrapped function body"
+      preferEarlyReturn: "Function body is wrapped in a single conditional without an else branch. This increases nesting depth and cognitive load. Invert the condition and return early: if (!condition) return; then place the main logic at the top level."
     },
     schema: [
       {
@@ -19617,9 +19734,9 @@ var preferEarlyReturn = {
       }
     ],
     type: "suggestion"
-  }
-};
-var prefer_early_return_default = preferEarlyReturn;
+  },
+  name: "prefer-early-return"
+});
 
 // src/rules/prefer-module-scope-constants.ts
 var import_scope_manager3 = __toESM(require_dist2(), 1);
@@ -19636,7 +19753,7 @@ function isTopScope(scope) {
   }
   return false;
 }
-var preferModuleScopeConstants = {
+var prefer_module_scope_constants_default = createRule({
   create(context) {
     let inConstDeclaration = false;
     return {
@@ -19678,9 +19795,9 @@ var preferModuleScopeConstants = {
     },
     schema: [],
     type: "suggestion"
-  }
-};
-var prefer_module_scope_constants_default = preferModuleScopeConstants;
+  },
+  name: "prefer-module-scope-constants"
+});
 
 // src/rules/prefer-pascal-case-enums.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES8 } from "@typescript-eslint/utils";
@@ -19729,7 +19846,7 @@ function getIdentifierName(node) {
     return;
   return STARTS_WITH_DIGIT.test(node.value) ? undefined : node.value;
 }
-var preferPascalCaseEnums = {
+var prefer_pascal_case_enums_default = createRule({
   create(context) {
     function report(node, identifier3) {
       context.report({
@@ -19759,13 +19876,13 @@ var preferPascalCaseEnums = {
       description: "Enforce Pascal case when naming enums."
     },
     messages: {
-      notPascalCase: "Enum '{{ identifier }}' should use Pascal case."
+      notPascalCase: "Enum '{{ identifier }}' uses non-standard casing. TypeScript convention requires PascalCase for enum names and members to distinguish them from variables (camelCase) and constants (UPPER_CASE). Rename to PascalCase: capitalize first letter of each word, no underscores."
     },
     schema: [],
     type: "suggestion"
-  }
-};
-var prefer_pascal_case_enums_default = preferPascalCaseEnums;
+  },
+  name: "prefer-pascal-case-enums"
+});
 
 // src/utilities/pattern-replacement/pattern-matcher.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES10 } from "@typescript-eslint/types";
@@ -20091,7 +20208,7 @@ var isRuleOptions2 = Compile(build_default.Object({
 function parsePatterns(patterns2) {
   return patterns2.map((pattern5) => parsePattern(pattern5.match, pattern5.replacement, pattern5.when));
 }
-var preferPatternReplacements = {
+var prefer_pattern_replacements_default = createRule({
   create(context) {
     const validatedOptions = isRuleOptions2.Check(context.options[0]) ? context.options[0] : undefined;
     if (!validatedOptions || validatedOptions.patterns.length === 0)
@@ -20116,14 +20233,20 @@ var preferPatternReplacements = {
       const candidates2 = patternIndex.get(key);
       if (!candidates2 || candidates2.length === 0)
         return;
+      const skippedConflicts = [];
       for (const pattern5 of candidates2) {
         const captures = matchParameters(pattern5.parameters, node.arguments, sourceCode);
         if (!(captures && evaluateConditions(pattern5.conditions, captures) && canSafelySubstitute(captures))) {
           continue;
         }
         const replacementId = getReplacementIdentifier(pattern5.replacement);
-        if (replacementId && hasNameConflict(node, replacementId))
+        if (replacementId && hasNameConflict(node, replacementId)) {
+          skippedConflicts.push({
+            conflict: replacementId,
+            replacement: generateReplacement(pattern5.replacement, captures)
+          });
           continue;
+        }
         const originalText = sourceCode.getText(node);
         const replacementText = generateReplacement(pattern5.replacement, captures);
         context.report({
@@ -20132,8 +20255,22 @@ var preferPatternReplacements = {
           messageId: "preferReplacement",
           node
         });
+        for (const { replacement, conflict } of skippedConflicts) {
+          context.report({
+            data: { conflict, replacement },
+            messageId: "skippedDueToConflict",
+            node
+          });
+        }
         return;
       }
+      for (const { replacement, conflict } of skippedConflicts) {
+        context.report({
+          data: { conflict, replacement },
+          messageId: "skippedDueToConflict",
+          node
+        });
+      }
     }
     return {
       CallExpression: checkNode,
@@ -20143,12 +20280,12 @@ var preferPatternReplacements = {
   defaultOptions: [{ patterns: [] }],
   meta: {
     docs: {
-      description: "Enforce using configured replacements for common constructor/method patterns",
-      recommended: false
+      description: "Enforce using configured replacements for common constructor/method patterns"
     },
     fixable: "code",
     messages: {
-      preferReplacement: "Prefer '{{replacement}}' over '{{original}}'"
+      preferReplacement: "Prefer '{{replacement}}' over '{{original}}'",
+      skippedDueToConflict: "Pattern '{{replacement}}' was skipped because '{{conflict}}' is already in scope."
     },
     schema: [
       {
@@ -20163,9 +20300,9 @@ var preferPatternReplacements = {
       }
     ],
     type: "suggestion"
-  }
-};
-var prefer_pattern_replacements_default = preferPatternReplacements;
+  },
+  name: "prefer-pattern-replacements"
+});
 
 // src/rules/prefer-sequence-overloads.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES11 } from "@typescript-eslint/types";
@@ -20211,11 +20348,7 @@ function extractKeypoint(element, descriptor) {
     value: valueArgument
   };
 }
-var docs2 = {
-  description: "Prefer the optimized ColorSequence and NumberSequence constructor overloads over passing ColorSequenceKeypoint or NumberSequenceKeypoint arrays when only using endpoints 0 and 1.",
-  recommended: true
-};
-var preferSequenceOverloads = {
+var prefer_sequence_overloads_default = createRule({
   create(context) {
     const { sourceCode } = context;
     return {
@@ -20261,7 +20394,9 @@ var preferSequenceOverloads = {
   },
   defaultOptions: [],
   meta: {
-    docs: docs2,
+    docs: {
+      description: "Prefer using single or two-point overloads for Roblox Sequence methods instead of all three overloads."
+    },
     fixable: "code",
     messages: {
       preferSingleOverload: "Use the single-argument {{sequenceName}} constructor overload instead of redundant keypoints when both endpoints share the same value.",
@@ -20269,9 +20404,9 @@ var preferSequenceOverloads = {
     },
     schema: [],
     type: "problem"
-  }
-};
-var prefer_sequence_overloads_default = preferSequenceOverloads;
+  },
+  name: "prefer-sequence-overloads"
+});
 
 // src/rules/prefer-singular-enums.ts
 var IRREGULAR_PLURALS = new Set([
@@ -20385,7 +20520,7 @@ function isPlural(name) {
   const last = getLastAlphaToken(name);
   return last ? isPluralWord(last.lower, last.original) : false;
 }
-var preferSingularEnums = {
+var prefer_singular_enums_default = createRule({
   create(context) {
     return {
       TSEnumDeclaration(node) {
@@ -20406,13 +20541,13 @@ var preferSingularEnums = {
       description: "Prefer singular TypeScript enums."
     },
     messages: {
-      notSingular: "Enum '{{ name }}' should be singular."
+      notSingular: "Enum '{{ name }}' uses plural naming. Enums define a type of which only ONE value is selected at a time, so singular naming is semantically correct. Use 'Status' not 'Statuses', 'Color' not 'Colors'. Rename the enum to its singular form."
     },
     schema: [],
     type: "suggestion"
-  }
-};
-var prefer_singular_enums_default = preferSingularEnums;
+  },
+  name: "prefer-singular-enums"
+});
 
 // src/rules/prefer-udim2-shorthand.ts
 import { TSESTree as TSESTree7 } from "@typescript-eslint/utils";
@@ -20654,7 +20789,7 @@ function exceedsMaxReturnProperties(node, scope) {
   }
   return countReturnElements(argument, scope) > MAX_RETURN_ELEMENTS;
 }
-var reactHooksStrictReturn = {
+var react_hooks_strict_return_default = createRule({
   create(context) {
     let hookDepth = 0;
     function enterHook(node) {
@@ -20703,13 +20838,13 @@ var reactHooksStrictReturn = {
       description: "Restrict the number of returned items from React hooks."
     },
     messages: {
-      hooksStrictReturn: "React hooks must return a tuple of two or fewer values or a single object."
+      hooksStrictReturn: "Hook returns more than 2 tuple elements. Destructuring large tuples causes positional errors and breaks when adding values. Return an object with named properties instead: `return { value, setValue, isLoading };`"
     },
     schema: [],
     type: "suggestion"
-  }
-};
-var react_hooks_strict_return_default = reactHooksStrictReturn;
+  },
+  name: "react-hooks-strict-return"
+});
 
 // src/rules/require-named-effect-functions.ts
 import { TSESTree as TSESTree8 } from "@typescript-eslint/types";
@@ -20955,8 +21090,7 @@ var requireNamedEffectFunctions = {
           return;
         }
         if (argumentNode.type === TSESTree8.AST_NODE_TYPES.FunctionExpression) {
-          const functionExpressionNode = argumentNode;
-          const functionHasId = Boolean(functionExpressionNode.id);
+          const functionHasId = Boolean(argumentNode.id);
           if (functionHasId && argumentNode.async) {
             context.report({
               data: { hook: hookName },
@@ -20992,17 +21126,17 @@ var requireNamedEffectFunctions = {
       recommended: false
     },
     messages: {
-      anonymousFunction: "Use a named function instead of an anonymous function for better debuggability",
-      arrowFunction: "Use a named function instead of an arrow function for better debuggability",
-      asyncAnonymousFunction: "Async anonymous functions are not allowed in {{ hook }}. Use an async function declaration instead",
-      asyncArrowFunction: "Async arrow functions are not allowed in {{ hook }}. Use an async function declaration instead",
-      asyncFunctionDeclaration: "Async function declarations are not allowed in {{ hook }}. Set allowAsync: true for this hook to enable",
-      asyncFunctionExpression: "Async function expressions are not allowed in {{ hook }}. Use an async function declaration instead",
-      functionExpression: "Use a named function reference instead of a function expression for better debuggability",
-      identifierReferencesArrow: "{{ hook }} called with identifier that references an arrow function. Use a named function declaration instead",
-      identifierReferencesAsyncArrow: "{{ hook }} called with identifier that references an async arrow function. Set allowAsync: true for this hook to enable",
-      identifierReferencesAsyncFunction: "{{ hook }} called with identifier that references an async function. Set allowAsync: true for this hook to enable",
-      identifierReferencesCallback: "{{ hook }} called with identifier that references a useCallback/useMemo result. Use a named function declaration instead"
+      anonymousFunction: "Anonymous function passed to {{hook}}. debug.info returns empty string for anonymous functions, making stack traces useless for debugging. Extract to: function effectName() { ... } then pass effectName.",
+      arrowFunction: "Arrow function passed to {{hook}}. Arrow functions have no debug name and create new instances each render. Extract to: function effectName() { ... } then pass effectName.",
+      asyncAnonymousFunction: "Async anonymous function in {{hook}}. Two issues: (1) no debug name makes stack traces useless, (2) async effects require cancellation logic for unmount. Extract to: async function effectName() { ... } with cleanup.",
+      asyncArrowFunction: "Async arrow function in {{hook}}. Two issues: (1) arrow functions have no debug name, (2) async effects require cancellation logic. Extract to: async function effectName() { ... } with cleanup.",
+      asyncFunctionDeclaration: "Async function declaration passed to {{hook}}. Async effects require cancellation logic to handle component unmount. Implement cleanup or set allowAsync: true if cancellation is handled.",
+      asyncFunctionExpression: "Async function expression in {{hook}}. Async effects require cancellation logic for unmount. Extract to a named async function declaration with cleanup, then pass the reference.",
+      functionExpression: "Function expression passed to {{hook}}. Function expressions create new instances each render, breaking referential equality. Extract to: function effectName() { ... } at module or component top-level.",
+      identifierReferencesArrow: "{{hook}} receives identifier pointing to arrow function. Arrow functions have no debug name and lack referential stability. Convert to: function effectName() { ... } then pass effectName.",
+      identifierReferencesAsyncArrow: "{{hook}} receives identifier pointing to async arrow function. Two issues: (1) no debug name, (2) async effects require cancellation logic. Convert to: async function effectName() { ... } with cleanup.",
+      identifierReferencesAsyncFunction: "{{hook}} receives identifier pointing to async function. Async effects require cancellation logic for unmount. Implement cleanup or set allowAsync: true if cancellation is handled.",
+      identifierReferencesCallback: "{{hook}} receives identifier from useCallback/useMemo. These hooks return new references when dependencies change, causing unexpected effect re-runs. Use a stable function declaration: function effectName() { ... }"
     },
     schema: [
       {
@@ -21895,40 +22029,44 @@ function ascendPastWrappers(node) {
   return current;
 }
 function hasKeyAttribute(node) {
-  for (const attribute of node.openingElement.attributes)
+  for (const attribute of node.openingElement.attributes) {
     if (attribute.type === TSESTree9.AST_NODE_TYPES.JSXAttribute && attribute.name.name === "key")
       return true;
+  }
   return false;
 }
-function isReactComponentHOC2(callExpr) {
+function isHigherOrderComponent(callExpr) {
   const { callee } = callExpr;
-  if (callee.type === TSESTree9.AST_NODE_TYPES.Identifier)
+  if (callee.type === TSESTree9.AST_NODE_TYPES.Identifier) {
     return callee.name === "forwardRef" || callee.name === "memo";
-  if (callee.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree9.AST_NODE_TYPES.Identifier && callee.object.name === "React" && 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.object.name === "React" && callee.property.type === TSESTree9.AST_NODE_TYPES.Identifier) {
     return callee.property.name === "forwardRef" || callee.property.name === "memo";
+  }
   return false;
 }
 function getEnclosingFunctionLike(node) {
   let current = node.parent;
   while (current) {
-    if (current.type === TSESTree9.AST_NODE_TYPES.ArrowFunctionExpression || current.type === TSESTree9.AST_NODE_TYPES.FunctionExpression || current.type === TSESTree9.AST_NODE_TYPES.FunctionDeclaration)
+    if (current.type === TSESTree9.AST_NODE_TYPES.ArrowFunctionExpression || current.type === TSESTree9.AST_NODE_TYPES.FunctionExpression || current.type === TSESTree9.AST_NODE_TYPES.FunctionDeclaration) {
       return current;
+    }
     current = current.parent;
   }
   return;
 }
-function isIterationOrMemoCallback(callExpr, iterationMethods, memoizationHooks) {
-  const { callee } = callExpr;
+function isIterationOrMemoCallback(callExpression, iterationMethods, memoizationHooks) {
+  const { callee } = callExpression;
   if (callee.type === TSESTree9.AST_NODE_TYPES.Identifier && memoizationHooks.has(callee.name))
     return true;
   if (callee.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree9.AST_NODE_TYPES.Identifier) {
-    const methodName = callee.property.name;
-    if (iterationMethods.has(methodName))
+    const { name } = callee.property;
+    if (iterationMethods.has(name))
       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 (name === "from" && callee.object.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.object.type === TSESTree9.AST_NODE_TYPES.Identifier && callee.object.object.name === "Array" && callExpression.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 (name === "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;
     }
   }
@@ -21980,23 +22118,24 @@ function referenceActsAsCallback(reference, iterationMethods, memoizationHooks)
   const callExpression = findEnclosingCallExpression(reference.identifier);
   if (!callExpression)
     return false;
-  if (isReactComponentHOC2(callExpression))
+  if (isHigherOrderComponent(callExpression))
     return false;
   return isIterationOrMemoCallback(callExpression, iterationMethods, memoizationHooks);
 }
 function isFunctionUsedAsCallback(context, functionLike, iterationMethods, memoizationHooks) {
   const inlineCall = findEnclosingCallExpression(functionLike);
   if (inlineCall) {
-    if (isReactComponentHOC2(inlineCall))
+    if (isHigherOrderComponent(inlineCall))
       return false;
     return isIterationOrMemoCallback(inlineCall, iterationMethods, memoizationHooks);
   }
   const variable = getVariableForFunction(context, functionLike);
   if (!variable)
     return false;
-  for (const reference of variable.references)
+  for (const reference of variable.references) {
     if (referenceActsAsCallback(reference, iterationMethods, memoizationHooks))
       return true;
+  }
   return false;
 }
 var SHOULD_ASCEND_TYPES = new Set([
@@ -22048,7 +22187,7 @@ function isTopLevelReturn(node) {
     if (IS_FUNCTION_EXPRESSION.has(currentNode.type)) {
       const functionParent = ascendPastWrappers(currentNode.parent);
       if (functionParent?.type === TSESTree9.AST_NODE_TYPES.CallExpression) {
-        return isReactComponentHOC2(functionParent);
+        return isHigherOrderComponent(functionParent);
       }
       return true;
     }
@@ -22056,8 +22195,9 @@ function isTopLevelReturn(node) {
   }
   if (parent.type === TSESTree9.AST_NODE_TYPES.ArrowFunctionExpression) {
     const functionParent = ascendPastWrappers(parent.parent);
-    if (functionParent?.type === TSESTree9.AST_NODE_TYPES.CallExpression)
-      return isReactComponentHOC2(functionParent);
+    if (functionParent?.type === TSESTree9.AST_NODE_TYPES.CallExpression) {
+      return isHigherOrderComponent(functionParent);
+    }
     return true;
   }
   return false;
@@ -22122,11 +22262,7 @@ function isTernaryJSXChild(node) {
     return false;
   return containerParent.type === TSESTree9.AST_NODE_TYPES.JSXElement || containerParent.type === TSESTree9.AST_NODE_TYPES.JSXFragment;
 }
-var docs3 = {
-  description: "Enforce key props on all React elements except top-level returns",
-  recommended: true
-};
-var requireReactComponentKeys = {
+var require_react_component_keys_default = createRule({
   create(context) {
     const options3 = {
       ...DEFAULT_OPTIONS3,
@@ -22178,10 +22314,12 @@ var requireReactComponentKeys = {
   },
   defaultOptions: [DEFAULT_OPTIONS3],
   meta: {
-    docs: docs3,
+    docs: {
+      description: "Require keys on React components when used in lists or iteration."
+    },
     messages: {
-      missingKey: "All React elements except top-level returns require a key prop",
-      rootComponentWithKey: "Root component returns should not have key props"
+      missingKey: "JSX element in list/callback lacks key prop. React Luau warns about missing keys in _G.__DEV__ mode. Add a unique `key` prop using a stable identifier (not array index).",
+      rootComponentWithKey: "Root return has unnecessary key prop. The key gets overwritten by the parent anyway. Remove the `key` prop."
     },
     schema: [
       {
@@ -22226,9 +22364,220 @@ var requireReactComponentKeys = {
       }
     ],
     type: "problem"
-  }
+  },
+  name: "require-react-component-keys"
+});
+
+// src/rules/require-react-display-names.ts
+import { TSESTree as TSESTree10 } from "@typescript-eslint/types";
+var DEFAULT_OPTIONS4 = {
+  environment: "roblox-ts"
 };
-var require_react_component_keys_default = requireReactComponentKeys;
+var REACT_SOURCES_ROBLOX = new Set(["@rbxts/react", "@rbxts/roact"]);
+var REACT_SOURCES_STANDARD = new Set(["react", "react-dom"]);
+function getReactSources(environment2) {
+  return environment2 === "roblox-ts" ? REACT_SOURCES_ROBLOX : REACT_SOURCES_STANDARD;
+}
+function isReactImport(node, reactSources) {
+  return reactSources.has(node.source.value);
+}
+function isMemoCall(node, memoIdentifiers, reactNamespaces) {
+  const { callee } = node;
+  if (callee.type === TSESTree10.AST_NODE_TYPES.Identifier)
+    return memoIdentifiers.has(callee.name);
+  if (callee.type === TSESTree10.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree10.AST_NODE_TYPES.Identifier && callee.property.type === TSESTree10.AST_NODE_TYPES.Identifier) {
+    return reactNamespaces.has(callee.object.name) && callee.property.name === "memo";
+  }
+  return false;
+}
+function isCreateContextCall(node, createContextIdentifiers, reactNamespaces) {
+  const { callee } = node;
+  if (callee.type === TSESTree10.AST_NODE_TYPES.Identifier)
+    return createContextIdentifiers.has(callee.name);
+  if (callee.type === TSESTree10.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree10.AST_NODE_TYPES.Identifier && callee.property.type === TSESTree10.AST_NODE_TYPES.Identifier) {
+    return reactNamespaces.has(callee.object.name) && callee.property.name === "createContext";
+  }
+  return false;
+}
+function getVariableName(node) {
+  if (node.id.type === TSESTree10.AST_NODE_TYPES.Identifier)
+    return node.id.name;
+  return;
+}
+function isNodeInExport(node) {
+  let current = node;
+  while (current) {
+    const { type: type3 } = current;
+    if (type3 === TSESTree10.AST_NODE_TYPES.ExportNamedDeclaration)
+      return true;
+    if (type3 === TSESTree10.AST_NODE_TYPES.ExportDefaultDeclaration)
+      return true;
+    current = current.parent;
+  }
+  return false;
+}
+function isReferenceExported(reference) {
+  return isNodeInExport(reference.identifier);
+}
+var require_react_display_names_default = createRule({
+  create(context) {
+    const options3 = {
+      ...DEFAULT_OPTIONS4,
+      ...context.options[0]
+    };
+    const reactSources = getReactSources(options3.environment);
+    const memoIdentifiers = new Set;
+    const createContextIdentifiers = new Set;
+    const reactNamespaces = new Set;
+    const trackedVariables = new Map;
+    const displayNameAssignments = new Set;
+    return {
+      "AssignmentExpression[left.type='MemberExpression'][left.property.name='displayName']"(node) {
+        const left = node.left;
+        if (left.object.type === TSESTree10.AST_NODE_TYPES.Identifier) {
+          displayNameAssignments.add(left.object.name);
+        }
+      },
+      ExportDefaultDeclaration(node) {
+        const { declaration } = node;
+        if (declaration.type === TSESTree10.AST_NODE_TYPES.CallExpression) {
+          if (isMemoCall(declaration, memoIdentifiers, reactNamespaces)) {
+            context.report({
+              messageId: "directMemoExport",
+              node
+            });
+            return;
+          }
+          if (isCreateContextCall(declaration, createContextIdentifiers, reactNamespaces)) {
+            context.report({
+              messageId: "directContextExport",
+              node
+            });
+            return;
+          }
+        }
+        if (declaration.type === TSESTree10.AST_NODE_TYPES.Identifier) {
+          const tracked = trackedVariables.get(declaration.name);
+          if (tracked) {
+            trackedVariables.set(declaration.name, {
+              ...tracked,
+              isDefaultExported: true
+            });
+          }
+        }
+      },
+      ExportNamedDeclaration(node) {
+        if (!node.specifiers)
+          return;
+        for (const specifier of node.specifiers) {
+          if (specifier.type !== TSESTree10.AST_NODE_TYPES.ExportSpecifier)
+            continue;
+          const localName = specifier.local.type === TSESTree10.AST_NODE_TYPES.Identifier ? specifier.local.name : specifier.local.value;
+          const exportedName = specifier.exported.type === TSESTree10.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
+          if (exportedName === "default") {
+            const tracked = trackedVariables.get(localName);
+            if (tracked) {
+              trackedVariables.set(localName, {
+                ...tracked,
+                isDefaultExported: true
+              });
+            }
+          }
+        }
+      },
+      ImportDeclaration(node) {
+        if (!isReactImport(node, reactSources))
+          return;
+        for (const specifier of node.specifiers) {
+          if (specifier.type === TSESTree10.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === TSESTree10.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+            reactNamespaces.add(specifier.local.name);
+          } else if (specifier.type === TSESTree10.AST_NODE_TYPES.ImportSpecifier) {
+            const importedName = specifier.imported.type === TSESTree10.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+            if (importedName === "memo")
+              memoIdentifiers.add(specifier.local.name);
+            else if (importedName === "createContext")
+              createContextIdentifiers.add(specifier.local.name);
+          }
+        }
+      },
+      "Program:exit"() {
+        for (const [name, tracked] of trackedVariables) {
+          const hasDisplayName = displayNameAssignments.has(name);
+          if (hasDisplayName)
+            continue;
+          const declaredVariables = context.sourceCode.getDeclaredVariables(tracked.node);
+          const variable = declaredVariables.find((declared) => declared.name === name);
+          let isExported = tracked.isDefaultExported;
+          if (variable)
+            isExported ||= variable.references.some(isReferenceExported);
+          const declarationParent = tracked.node.parent;
+          if (declarationParent?.parent?.type === TSESTree10.AST_NODE_TYPES.ExportNamedDeclaration) {
+            isExported = true;
+          }
+          if (isExported) {
+            context.report({
+              data: { name },
+              messageId: tracked.kind === "memo" ? "missingMemoDisplayName" : "missingContextDisplayName",
+              node: tracked.node
+            });
+          }
+        }
+      },
+      VariableDeclarator(node) {
+        if (!node.init || node.init.type !== TSESTree10.AST_NODE_TYPES.CallExpression)
+          return;
+        const name = getVariableName(node);
+        if (!name)
+          return;
+        if (isMemoCall(node.init, memoIdentifiers, reactNamespaces)) {
+          trackedVariables.set(name, {
+            hasDisplayName: false,
+            isDefaultExported: false,
+            kind: "memo",
+            name,
+            node
+          });
+        } else if (isCreateContextCall(node.init, createContextIdentifiers, reactNamespaces)) {
+          trackedVariables.set(name, {
+            hasDisplayName: false,
+            isDefaultExported: false,
+            kind: "context",
+            name,
+            node
+          });
+        }
+      }
+    };
+  },
+  defaultOptions: [DEFAULT_OPTIONS4],
+  meta: {
+    docs: {
+      description: "Require displayName property on exported React.memo components and React.createContext contexts for better debugging."
+    },
+    messages: {
+      directContextExport: "Do not export createContext result directly. Assign to a variable, set displayName, then export.",
+      directMemoExport: "Do not export memo result directly. Assign to a variable, set displayName, then export both named and default.",
+      missingContextDisplayName: "Exported Context '{{name}}' is missing displayName. Add `{{name}}.displayName = \"{{name}}\";` before exporting.",
+      missingMemoDisplayName: "Exported memoized component '{{name}}' is missing displayName. Add `{{name}}.displayName = \"{{name}}\";` before exporting."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          environment: {
+            default: "roblox-ts",
+            description: "The React environment: 'roblox-ts' uses @rbxts/react, 'standard' uses react.",
+            enum: ["roblox-ts", "standard"],
+            type: "string"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  },
+  name: "require-react-display-names"
+});
 
 // src/rules/strict-component-boundaries.ts
 import { basename, extname, relative } from "node:path";
@@ -22274,7 +22623,7 @@ function isValidFixtureImport(pathParts) {
   const partsBeforeFixture = pathParts.slice(0, fixtureIndex);
   return !hasAnotherComponentInPath(partsBeforeFixture);
 }
-var strictComponentBoundaries = {
+var strict_component_boundaries_default = createRule({
   create(context) {
     const [{ allow = [], maxDepth = 1 } = {}] = context.options;
     const allowPatterns = allow.map(toRegExp);
@@ -22336,21 +22685,21 @@ var strictComponentBoundaries = {
       }
     ],
     type: "problem"
-  }
-};
-var strict_component_boundaries_default = strictComponentBoundaries;
+  },
+  name: "strict-component-boundaries"
+});
 
 // src/rules/use-exhaustive-dependencies.ts
-import { TSESTree as TSESTree10 } from "@typescript-eslint/types";
+import { TSESTree as TSESTree11 } from "@typescript-eslint/types";
 var FUNCTION_DECLARATIONS = new Set([
-  TSESTree10.AST_NODE_TYPES.FunctionExpression,
-  TSESTree10.AST_NODE_TYPES.ArrowFunctionExpression,
-  TSESTree10.AST_NODE_TYPES.FunctionDeclaration
+  TSESTree11.AST_NODE_TYPES.FunctionExpression,
+  TSESTree11.AST_NODE_TYPES.ArrowFunctionExpression,
+  TSESTree11.AST_NODE_TYPES.FunctionDeclaration
 ]);
 var UNSTABLE_VALUES = new Set([
   ...FUNCTION_DECLARATIONS,
-  TSESTree10.AST_NODE_TYPES.ObjectExpression,
-  TSESTree10.AST_NODE_TYPES.ArrayExpression
+  TSESTree11.AST_NODE_TYPES.ObjectExpression,
+  TSESTree11.AST_NODE_TYPES.ArrayExpression
 ]);
 var testingMetrics = {
   moduleLevelStableConst: 0,
@@ -22434,9 +22783,9 @@ var GLOBAL_BUILTINS = new Set([
 ]);
 function getHookName4(node) {
   const { callee } = node;
-  if (callee.type === TSESTree10.AST_NODE_TYPES.Identifier)
+  if (callee.type === TSESTree11.AST_NODE_TYPES.Identifier)
     return callee.name;
-  if (callee.type === TSESTree10.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree10.AST_NODE_TYPES.Identifier) {
+  if (callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree11.AST_NODE_TYPES.Identifier) {
     return callee.property.name;
   }
   return;
@@ -22444,9 +22793,9 @@ function getHookName4(node) {
 function getMemberExpressionDepth(node) {
   let depth = 0;
   let current = node;
-  if (current.type === TSESTree10.AST_NODE_TYPES.ChainExpression)
+  if (current.type === TSESTree11.AST_NODE_TYPES.ChainExpression)
     current = current.expression;
-  while (current.type === TSESTree10.AST_NODE_TYPES.MemberExpression) {
+  while (current.type === TSESTree11.AST_NODE_TYPES.MemberExpression) {
     depth += 1;
     current = current.object;
   }
@@ -22454,36 +22803,36 @@ function getMemberExpressionDepth(node) {
 }
 function getRootIdentifier(node) {
   let current = node;
-  if (current.type === TSESTree10.AST_NODE_TYPES.ChainExpression)
+  if (current.type === TSESTree11.AST_NODE_TYPES.ChainExpression)
     current = current.expression;
-  while (current.type === TSESTree10.AST_NODE_TYPES.MemberExpression || current.type === TSESTree10.AST_NODE_TYPES.TSNonNullExpression) {
-    if (current.type === TSESTree10.AST_NODE_TYPES.MemberExpression)
+  while (current.type === TSESTree11.AST_NODE_TYPES.MemberExpression || current.type === TSESTree11.AST_NODE_TYPES.TSNonNullExpression) {
+    if (current.type === TSESTree11.AST_NODE_TYPES.MemberExpression)
       current = current.object;
     else
       current = current.expression;
   }
-  return current.type === TSESTree10.AST_NODE_TYPES.Identifier ? current : undefined;
+  return current.type === TSESTree11.AST_NODE_TYPES.Identifier ? current : undefined;
 }
 function nodeToDependencyString(node, sourceCode) {
   return sourceCode.getText(node);
 }
 function nodeToSafeDependencyPath(node, sourceCode) {
-  if (node.type === TSESTree10.AST_NODE_TYPES.Identifier)
+  if (node.type === TSESTree11.AST_NODE_TYPES.Identifier)
     return node.name;
-  if (node.type === TSESTree10.AST_NODE_TYPES.ChainExpression) {
+  if (node.type === TSESTree11.AST_NODE_TYPES.ChainExpression) {
     return nodeToSafeDependencyPath(node.expression, sourceCode);
   }
   if (TS_RUNTIME_EXPRESSIONS.has(node.type)) {
     const expr = node;
     return nodeToSafeDependencyPath(expr.expression, sourceCode);
   }
-  if (node.type === TSESTree10.AST_NODE_TYPES.MemberExpression) {
+  if (node.type === TSESTree11.AST_NODE_TYPES.MemberExpression) {
     const objectPath = nodeToSafeDependencyPath(node.object, sourceCode);
     if (node.computed) {
       const propertyText = sourceCode.getText(node.property);
       return `${objectPath}[${propertyText}]`;
     }
-    const propertyName = node.property.type === TSESTree10.AST_NODE_TYPES.Identifier ? node.property.name : "";
+    const propertyName = node.property.type === TSESTree11.AST_NODE_TYPES.Identifier ? node.property.name : "";
     const separator = node.optional ? "?." : ".";
     return `${objectPath}${separator}${propertyName}`;
   }
@@ -22492,13 +22841,13 @@ function nodeToSafeDependencyPath(node, sourceCode) {
 function isStableArrayIndex(stableResult, node, identifierName) {
   if (!stableResult)
     return false;
-  if (!(stableResult instanceof Set) || node.type !== TSESTree10.AST_NODE_TYPES.VariableDeclarator || node.id.type !== TSESTree10.AST_NODE_TYPES.ArrayPattern) {
+  if (!(stableResult instanceof Set) || node.type !== TSESTree11.AST_NODE_TYPES.VariableDeclarator || node.id.type !== TSESTree11.AST_NODE_TYPES.ArrayPattern) {
     return false;
   }
   const { elements } = node.id;
   let index2 = 0;
   for (const element of elements) {
-    if (element.type === TSESTree10.AST_NODE_TYPES.Identifier && element.name === identifierName) {
+    if (element.type === TSESTree11.AST_NODE_TYPES.Identifier && element.name === identifierName) {
       return stableResult.has(index2);
     }
     index2 += 1;
@@ -22507,7 +22856,7 @@ function isStableArrayIndex(stableResult, node, identifierName) {
 }
 function isStableHookValue(init, node, identifierName, stableHooks) {
   const castInit = init;
-  if (castInit.type !== TSESTree10.AST_NODE_TYPES.CallExpression)
+  if (castInit.type !== TSESTree11.AST_NODE_TYPES.CallExpression)
     return false;
   const hookName = getHookName4(castInit);
   if (!hookName)
@@ -22527,35 +22876,35 @@ function isStableValue(variable, identifierName, stableHooks) {
     const { node, type: type3 } = definition;
     if (STABLE_VALUE_TYPES.has(type3))
       return true;
-    if (type3 === "Variable" && node.type === TSESTree10.AST_NODE_TYPES.VariableDeclarator) {
+    if (type3 === "Variable" && node.type === TSESTree11.AST_NODE_TYPES.VariableDeclarator) {
       const { parent } = node;
-      if (!parent || parent.type !== TSESTree10.AST_NODE_TYPES.VariableDeclaration || parent.kind !== "const") {
+      if (!parent || parent.type !== TSESTree11.AST_NODE_TYPES.VariableDeclaration || parent.kind !== "const") {
         continue;
       }
       const init = node.init;
       if (init && isStableHookValue(init, node, identifierName, stableHooks))
         return true;
-      if (init?.type === TSESTree10.AST_NODE_TYPES.CallExpression) {
+      if (init?.type === TSESTree11.AST_NODE_TYPES.CallExpression) {
         const { callee } = init;
-        if (callee.type === TSESTree10.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree10.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === TSESTree10.AST_NODE_TYPES.Identifier && callee.property.name === "joinBindings") {
+        if (callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree11.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === TSESTree11.AST_NODE_TYPES.Identifier && callee.property.name === "joinBindings") {
           return true;
         }
-        if (callee.type === TSESTree10.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree10.AST_NODE_TYPES.Identifier && callee.property.name === "map") {
+        if (callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree11.AST_NODE_TYPES.Identifier && callee.property.name === "map") {
           return true;
         }
       }
       if (init) {
-        if (init.type === TSESTree10.AST_NODE_TYPES.Literal || init.type === TSESTree10.AST_NODE_TYPES.TemplateLiteral) {
+        if (init.type === TSESTree11.AST_NODE_TYPES.Literal || init.type === TSESTree11.AST_NODE_TYPES.TemplateLiteral) {
           return true;
         }
-        if (init.type === TSESTree10.AST_NODE_TYPES.UnaryExpression && init.argument.type === TSESTree10.AST_NODE_TYPES.Literal) {
+        if (init.type === TSESTree11.AST_NODE_TYPES.UnaryExpression && init.argument.type === TSESTree11.AST_NODE_TYPES.Literal) {
           return true;
         }
       }
       const variableDefinition = variable.defs.find((definition2) => definition2.node === node);
-      if (variableDefinition && variableDefinition.node.type === TSESTree10.AST_NODE_TYPES.VariableDeclarator) {
+      if (variableDefinition && variableDefinition.node.type === TSESTree11.AST_NODE_TYPES.VariableDeclarator) {
         const declarationParent = variableDefinition.node.parent?.parent;
-        if (declarationParent && (declarationParent.type === TSESTree10.AST_NODE_TYPES.Program || declarationParent.type === TSESTree10.AST_NODE_TYPES.ExportNamedDeclaration)) {
+        if (declarationParent && (declarationParent.type === TSESTree11.AST_NODE_TYPES.Program || declarationParent.type === TSESTree11.AST_NODE_TYPES.ExportNamedDeclaration)) {
           testingMetrics.moduleLevelStableConst += 1;
           return true;
         }
@@ -22568,14 +22917,14 @@ function findTopmostMemberExpression(node) {
   let current = node;
   let { parent } = node;
   while (parent) {
-    if (parent.type === TSESTree10.AST_NODE_TYPES.CallExpression && parent.callee === current) {
-      if (current.type === TSESTree10.AST_NODE_TYPES.MemberExpression)
+    if (parent.type === TSESTree11.AST_NODE_TYPES.CallExpression && parent.callee === current) {
+      if (current.type === TSESTree11.AST_NODE_TYPES.MemberExpression)
         return current.object;
       break;
     }
-    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;
+    const isMemberParent = parent.type === TSESTree11.AST_NODE_TYPES.MemberExpression && parent.object === current;
+    const isChainParent = parent.type === TSESTree11.AST_NODE_TYPES.ChainExpression;
+    const isNonNullParent = parent.type === TSESTree11.AST_NODE_TYPES.TSNonNullExpression;
     if (!(isMemberParent || isChainParent || isNonNullParent))
       break;
     current = parent;
@@ -22584,21 +22933,21 @@ function findTopmostMemberExpression(node) {
   return current;
 }
 var IS_CEASE_BOUNDARY = new Set([
-  TSESTree10.AST_NODE_TYPES.FunctionDeclaration,
-  TSESTree10.AST_NODE_TYPES.FunctionExpression,
-  TSESTree10.AST_NODE_TYPES.ArrowFunctionExpression,
-  TSESTree10.AST_NODE_TYPES.VariableDeclarator
+  TSESTree11.AST_NODE_TYPES.FunctionDeclaration,
+  TSESTree11.AST_NODE_TYPES.FunctionExpression,
+  TSESTree11.AST_NODE_TYPES.ArrowFunctionExpression,
+  TSESTree11.AST_NODE_TYPES.VariableDeclarator
 ]);
 var TS_RUNTIME_EXPRESSIONS = new Set([
-  TSESTree10.AST_NODE_TYPES.TSNonNullExpression,
-  TSESTree10.AST_NODE_TYPES.TSAsExpression,
-  TSESTree10.AST_NODE_TYPES.TSSatisfiesExpression,
-  TSESTree10.AST_NODE_TYPES.TSTypeAssertion,
-  TSESTree10.AST_NODE_TYPES.TSInstantiationExpression
+  TSESTree11.AST_NODE_TYPES.TSNonNullExpression,
+  TSESTree11.AST_NODE_TYPES.TSAsExpression,
+  TSESTree11.AST_NODE_TYPES.TSSatisfiesExpression,
+  TSESTree11.AST_NODE_TYPES.TSTypeAssertion,
+  TSESTree11.AST_NODE_TYPES.TSInstantiationExpression
 ]);
 function isComputedPropertyIdentifier(identifier3) {
   const { parent } = identifier3;
-  return parent?.type === TSESTree10.AST_NODE_TYPES.Property && parent.computed && parent.key === identifier3;
+  return parent?.type === TSESTree11.AST_NODE_TYPES.Property && parent.computed && parent.key === identifier3;
 }
 function isInTypePosition(identifier3) {
   let parent = identifier3.parent;
@@ -22652,10 +23001,10 @@ function resolveFunctionReference(identifier3, scope) {
     return;
   for (const definition of variable.defs) {
     const { node } = definition;
-    if (node.type === TSESTree10.AST_NODE_TYPES.FunctionDeclaration) {
+    if (node.type === TSESTree11.AST_NODE_TYPES.FunctionDeclaration) {
       return node;
     }
-    if (node.type === TSESTree10.AST_NODE_TYPES.VariableDeclarator && node.init && (node.init.type === TSESTree10.AST_NODE_TYPES.ArrowFunctionExpression || node.init.type === TSESTree10.AST_NODE_TYPES.FunctionExpression)) {
+    if (node.type === TSESTree11.AST_NODE_TYPES.VariableDeclarator && node.init && (node.init.type === TSESTree11.AST_NODE_TYPES.ArrowFunctionExpression || node.init.type === TSESTree11.AST_NODE_TYPES.FunctionExpression)) {
       return node.init;
     }
   }
@@ -22665,7 +23014,7 @@ function collectCaptures(node, sourceCode) {
   const captures = new Array;
   const captureSet = new Set;
   function visit(current) {
-    if (current.type === TSESTree10.AST_NODE_TYPES.Identifier) {
+    if (current.type === TSESTree11.AST_NODE_TYPES.Identifier) {
       const { name } = current;
       if (captureSet.has(name) || GLOBAL_BUILTINS.has(name) || isInTypePosition(current))
         return;
@@ -22707,21 +23056,21 @@ function collectCaptures(node, sourceCode) {
         }
       }
     }
-    if (current.type === TSESTree10.AST_NODE_TYPES.TSSatisfiesExpression || current.type === TSESTree10.AST_NODE_TYPES.TSAsExpression || current.type === TSESTree10.AST_NODE_TYPES.TSTypeAssertion || current.type === TSESTree10.AST_NODE_TYPES.TSNonNullExpression) {
+    if (current.type === TSESTree11.AST_NODE_TYPES.TSSatisfiesExpression || current.type === TSESTree11.AST_NODE_TYPES.TSAsExpression || current.type === TSESTree11.AST_NODE_TYPES.TSTypeAssertion || current.type === TSESTree11.AST_NODE_TYPES.TSNonNullExpression) {
       visit(current.expression);
       return;
     }
-    if (current.type === TSESTree10.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === TSESTree11.AST_NODE_TYPES.MemberExpression) {
       visit(current.object);
       if (current.computed)
         visit(current.property);
       return;
     }
-    if (current.type === TSESTree10.AST_NODE_TYPES.ChainExpression) {
+    if (current.type === TSESTree11.AST_NODE_TYPES.ChainExpression) {
       visit(current.expression);
       return;
     }
-    if (current.type === TSESTree10.AST_NODE_TYPES.Property) {
+    if (current.type === TSESTree11.AST_NODE_TYPES.Property) {
       if (current.computed)
         visit(current.key);
       visit(current.value);
@@ -22746,7 +23095,7 @@ function parseDependencies(node, sourceCode) {
   for (const element of node.elements) {
     if (!element)
       continue;
-    const actualNode = element.type === TSESTree10.AST_NODE_TYPES.SpreadElement ? element.argument : element;
+    const actualNode = element.type === TSESTree11.AST_NODE_TYPES.SpreadElement ? element.argument : element;
     const name = nodeToDependencyString(actualNode, sourceCode);
     const depth = getMemberExpressionDepth(actualNode);
     dependencies4.push({
@@ -22823,9 +23172,9 @@ var useExhaustiveDependencies = {
         if (closureArgument === undefined)
           return;
         let closureFunction;
-        if (closureArgument.type === TSESTree10.AST_NODE_TYPES.ArrowFunctionExpression || closureArgument.type === TSESTree10.AST_NODE_TYPES.FunctionExpression) {
+        if (closureArgument.type === TSESTree11.AST_NODE_TYPES.ArrowFunctionExpression || closureArgument.type === TSESTree11.AST_NODE_TYPES.FunctionExpression) {
           closureFunction = closureArgument;
-        } else if (closureArgument.type === TSESTree10.AST_NODE_TYPES.Identifier) {
+        } else if (closureArgument.type === TSESTree11.AST_NODE_TYPES.Identifier) {
           const scope = getScope(callNode);
           closureFunction = resolveFunctionReference(closureArgument, scope);
         }
@@ -22859,7 +23208,7 @@ var useExhaustiveDependencies = {
         }
         if (!dependenciesArgument)
           return;
-        if (dependenciesArgument.type !== TSESTree10.AST_NODE_TYPES.ArrayExpression)
+        if (dependenciesArgument.type !== TSESTree11.AST_NODE_TYPES.ArrayExpression)
           return;
         const dependenciesArray = dependenciesArgument;
         const captures = collectCaptures(closureFunction, context.sourceCode);
@@ -23069,7 +23418,7 @@ var useExhaustiveDependencies = {
 var use_exhaustive_dependencies_default = useExhaustiveDependencies;
 
 // src/rules/use-hook-at-top-level.ts
-import { TSESTree as TSESTree11 } from "@typescript-eslint/types";
+import { TSESTree as TSESTree12 } from "@typescript-eslint/types";
 var HOOK_NAME_PATTERN = /^use[A-Z]/;
 var COMPONENT_NAME_PATTERN2 = /^[A-Z]/;
 function isReactHook(name) {
@@ -23079,23 +23428,23 @@ function isComponent(name) {
   return COMPONENT_NAME_PATTERN2.test(name);
 }
 function isComponentOrHook(node) {
-  if (node.type === TSESTree11.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+  if (node.type === TSESTree12.AST_NODE_TYPES.FunctionDeclaration && node.id) {
     const { name } = node.id;
     return isComponent(name) || isReactHook(name);
   }
-  if (node.type === TSESTree11.AST_NODE_TYPES.FunctionExpression || node.type === TSESTree11.AST_NODE_TYPES.ArrowFunctionExpression) {
+  if (node.type === TSESTree12.AST_NODE_TYPES.FunctionExpression || node.type === TSESTree12.AST_NODE_TYPES.ArrowFunctionExpression) {
     const { parent } = node;
     if (parent === undefined)
       return false;
-    if (parent.type === TSESTree11.AST_NODE_TYPES.VariableDeclarator && parent.id.type === TSESTree11.AST_NODE_TYPES.Identifier) {
+    if (parent.type === TSESTree12.AST_NODE_TYPES.VariableDeclarator && parent.id.type === TSESTree12.AST_NODE_TYPES.Identifier) {
       const { name } = parent.id;
       return isComponent(name) || isReactHook(name);
     }
-    if (parent.type === TSESTree11.AST_NODE_TYPES.Property && parent.key.type === TSESTree11.AST_NODE_TYPES.Identifier) {
+    if (parent.type === TSESTree12.AST_NODE_TYPES.Property && parent.key.type === TSESTree12.AST_NODE_TYPES.Identifier) {
       const { name } = parent.key;
       return isComponent(name) || isReactHook(name);
     }
-    if (parent.type === TSESTree11.AST_NODE_TYPES.MethodDefinition && parent.key.type === TSESTree11.AST_NODE_TYPES.Identifier) {
+    if (parent.type === TSESTree12.AST_NODE_TYPES.MethodDefinition && parent.key.type === TSESTree12.AST_NODE_TYPES.Identifier) {
       const { name } = parent.key;
       return isComponent(name) || isReactHook(name);
     }
@@ -23104,17 +23453,17 @@ function isComponentOrHook(node) {
 }
 function isHookCall(node) {
   const { callee } = node;
-  if (callee.type === TSESTree11.AST_NODE_TYPES.Identifier)
+  if (callee.type === TSESTree12.AST_NODE_TYPES.Identifier)
     return isReactHook(callee.name);
-  if (callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree11.AST_NODE_TYPES.Identifier) {
+  if (callee.type === TSESTree12.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree12.AST_NODE_TYPES.Identifier) {
     return isReactHook(callee.property.name);
   }
   return false;
 }
 var FUNCTION_BOUNDARIES2 = new Set([
-  TSESTree11.AST_NODE_TYPES.FunctionDeclaration,
-  TSESTree11.AST_NODE_TYPES.FunctionExpression,
-  TSESTree11.AST_NODE_TYPES.ArrowFunctionExpression
+  TSESTree12.AST_NODE_TYPES.FunctionDeclaration,
+  TSESTree12.AST_NODE_TYPES.FunctionExpression,
+  TSESTree12.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 function isInFinallyBlock(node) {
   let current = node.parent;
@@ -23123,7 +23472,7 @@ function isInFinallyBlock(node) {
   for (let depth = 0;depth < maxDepth && current; depth += 1) {
     if (FUNCTION_BOUNDARIES2.has(current.type))
       break;
-    if (current.type === TSESTree11.AST_NODE_TYPES.TryStatement) {
+    if (current.type === TSESTree12.AST_NODE_TYPES.TryStatement) {
       let checkNode = node;
       while (checkNode && checkNode !== current) {
         if (checkNode === current.finalizer) {
@@ -23171,14 +23520,14 @@ var useHookAtTopLevel = {
       if (ignoreHooks?.includes(hookName))
         return true;
       if (importSources && Object.keys(importSources).length > 0) {
-        if (node.callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression) {
-          const objectName = node.callee.object.type === TSESTree11.AST_NODE_TYPES.Identifier ? node.callee.object.name : undefined;
+        if (node.callee.type === TSESTree12.AST_NODE_TYPES.MemberExpression) {
+          const objectName = node.callee.object.type === TSESTree12.AST_NODE_TYPES.Identifier ? node.callee.object.name : undefined;
           if (objectName && importSources[objectName] === false)
             return true;
           if (objectName && importSources[objectName] === true)
             return false;
         }
-        if (node.callee.type === TSESTree11.AST_NODE_TYPES.Identifier) {
+        if (node.callee.type === TSESTree12.AST_NODE_TYPES.Identifier) {
           const importSource = importSourceMap.get(hookName);
           if (importSource && importSources[importSource] === false)
             return true;
@@ -23193,7 +23542,7 @@ var useHookAtTopLevel = {
       const current = getCurrentContext();
       const depth = current ? current.functionDepth + 1 : 0;
       const isComponentOrHookFlag = isComponentOrHook(functionNode);
-      if (functionNode.type === TSESTree11.AST_NODE_TYPES.FunctionDeclaration && functionNode.id) {
+      if (functionNode.type === TSESTree12.AST_NODE_TYPES.FunctionDeclaration && functionNode.id) {
         currentFunctionName = functionNode.id.name;
       }
       if (current?.isComponentOrHook) {
@@ -23232,7 +23581,7 @@ var useHookAtTopLevel = {
         if (!isHookCall(callNode))
           return;
         const { callee } = callNode;
-        const hookName = callee.type === TSESTree11.AST_NODE_TYPES.Identifier ? callee.name : callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree11.AST_NODE_TYPES.Identifier ? callee.property.name : undefined;
+        const hookName = callee.type === TSESTree12.AST_NODE_TYPES.Identifier ? callee.name : callee.type === TSESTree12.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree12.AST_NODE_TYPES.Identifier ? callee.property.name : undefined;
         if (!hookName || shouldIgnoreHook(hookName, callNode))
           return;
         const current = getCurrentContext();
@@ -23330,10 +23679,10 @@ var useHookAtTopLevel = {
         if (!configuration.importSources || Object.keys(configuration.importSources).length === 0)
           return;
         for (const specifier of importNode.specifiers) {
-          if (specifier.type !== TSESTree11.AST_NODE_TYPES.ImportSpecifier)
+          if (specifier.type !== TSESTree12.AST_NODE_TYPES.ImportSpecifier)
             continue;
           const { imported } = specifier;
-          if (imported.type !== TSESTree11.AST_NODE_TYPES.Identifier)
+          if (imported.type !== TSESTree12.AST_NODE_TYPES.Identifier)
             continue;
           if (isReactHook(imported.name))
             importSourceMap.set(specifier.local.name, source);
@@ -23509,6 +23858,9 @@ function createNoUselessUseSpringOptions(options3 = {}) {
 function createPreferPatternReplacementsOptions(patterns2 = []) {
   return { patterns: patterns2 };
 }
+function createRequireReactDisplayNamesOptions(options3 = {}) {
+  return { environment: "roblox-ts", ...options3 };
+}
 
 // src/index.ts
 var rules = {
@@ -23538,6 +23890,7 @@ var rules = {
   "require-named-effect-functions": require_named_effect_functions_default,
   "require-paired-calls": require_paired_calls_default,
   "require-react-component-keys": require_react_component_keys_default,
+  "require-react-display-names": require_react_display_names_default,
   "strict-component-boundaries": strict_component_boundaries_default,
   "use-exhaustive-dependencies": use_exhaustive_dependencies_default,
   "use-hook-at-top-level": use_hook_at_top_level_default
@@ -23562,6 +23915,7 @@ var recommended = {
     "cease-nonsense/prefer-udim2-shorthand": "error",
     "cease-nonsense/require-named-effect-functions": "error",
     "cease-nonsense/require-react-component-keys": "error",
+    "cease-nonsense/require-react-display-names": "error",
     "cease-nonsense/use-exhaustive-dependencies": "error",
     "cease-nonsense/use-hook-at-top-level": "error"
   }
@@ -23577,6 +23931,7 @@ export {
   src_default as default,
   createUseHookAtTopLevelOptions,
   createUseExhaustiveDependenciesOptions,
+  createRequireReactDisplayNamesOptions,
   createRequirePairedCallsOptions,
   createReactKeysOptions,
   createPreferPatternReplacementsOptions,
@@ -23591,4 +23946,4 @@ export {
   createBanInstancesOptions
 };
 
-//# debugId=928BD58DAA13C57A64756E2164756E21
+//# debugId=2B2944174D0F631464756E2164756E21