@pobammer-ts/eslint-cease-nonsense-rules 1.10.0 → 1.12.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,7 +16346,9 @@ 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.",
       bannedInstanceCustom: "{{customMessage}}"
@@ -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]]);
                 }
-              ]
-            });
-          }
+              }
+            ]
+          });
         }
       }
     };
@@ -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()"
     },
     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";
@@ -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()"
     },
     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") {
@@ -19558,9 +19675,9 @@ var preferClassProperties = {
     },
     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;
@@ -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({
@@ -19763,18 +19880,438 @@ var preferPascalCaseEnums = {
     },
     schema: [],
     type: "suggestion"
+  },
+  name: "prefer-pascal-case-enums"
+});
+
+// src/utilities/pattern-replacement/pattern-matcher.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES10 } from "@typescript-eslint/types";
+
+// src/utilities/pattern-replacement/constant-folder.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES9 } from "@typescript-eslint/types";
+function normalizeZero(num) {
+  return Object.is(num, -0) ? 0 : num;
+}
+function unwrap(node) {
+  switch (node.type) {
+    case AST_NODE_TYPES9.TSAsExpression:
+    case AST_NODE_TYPES9.TSNonNullExpression:
+      return unwrap(node.expression);
+    default:
+      return node;
   }
-};
-var prefer_pascal_case_enums_default = preferPascalCaseEnums;
+}
+function evaluateConstant(node) {
+  const expression = unwrap(node);
+  if (expression.type === AST_NODE_TYPES9.Literal && typeof expression.value === "number") {
+    return normalizeZero(expression.value);
+  }
+  if (expression.type === AST_NODE_TYPES9.UnaryExpression) {
+    const argument = evaluateConstant(expression.argument);
+    if (argument === undefined)
+      return;
+    switch (expression.operator) {
+      case "-":
+        return normalizeZero(-argument);
+      case "+":
+        return normalizeZero(Number(argument));
+      default:
+        return;
+    }
+  }
+  if (expression.type === AST_NODE_TYPES9.BinaryExpression) {
+    if (expression.left.type === AST_NODE_TYPES9.PrivateIdentifier)
+      return;
+    const left = evaluateConstant(expression.left);
+    const right = evaluateConstant(expression.right);
+    if (left === undefined || right === undefined)
+      return;
+    let result;
+    switch (expression.operator) {
+      case "+":
+        result = left + right;
+        break;
+      case "-":
+        result = left - right;
+        break;
+      case "*":
+        result = left * right;
+        break;
+      case "/":
+        result = left / right;
+        break;
+      default:
+        return;
+    }
+    return Number.isFinite(result) ? normalizeZero(result) : undefined;
+  }
+  return;
+}
+
+// src/utilities/pattern-replacement/pattern-matcher.ts
+function buildPatternIndex(patterns2) {
+  const index2 = new Map;
+  for (const pattern4 of patterns2) {
+    const key = pattern4.type === "constructor" ? `constructor:${pattern4.typeName}` : `staticMethod:${pattern4.typeName}:${pattern4.methodName}`;
+    const existing = index2.get(key);
+    if (existing)
+      existing.push(pattern4);
+    else
+      index2.set(key, [pattern4]);
+  }
+  return index2;
+}
+function resolveCallee(node) {
+  const callee = unwrap(node.callee);
+  if (node.type === AST_NODE_TYPES10.NewExpression && callee.type === AST_NODE_TYPES10.Identifier) {
+    return { kind: "constructor", typeName: callee.name };
+  }
+  if (node.type === AST_NODE_TYPES10.CallExpression) {
+    const member = callee.type === AST_NODE_TYPES10.ChainExpression ? unwrap(callee.expression) : callee;
+    if (member.type === AST_NODE_TYPES10.MemberExpression && !member.computed) {
+      const object3 = unwrap(member.object);
+      if (object3.type === AST_NODE_TYPES10.Identifier && member.property.type === AST_NODE_TYPES10.Identifier) {
+        return {
+          kind: "staticMethod",
+          methodName: member.property.name,
+          typeName: object3.name
+        };
+      }
+    }
+  }
+  return { kind: "unknown" };
+}
+function captureParameter(node, sourceCode) {
+  const expression = unwrap(node);
+  const sourceText = sourceCode.getText(expression);
+  const constValue = evaluateConstant(expression);
+  let expressionKey;
+  let isComplex = false;
+  if (expression.type === AST_NODE_TYPES10.Literal && typeof expression.value === "number") {
+    expressionKey = `literal:${normalizeZero(expression.value)}`;
+  } else if (expression.type === AST_NODE_TYPES10.Identifier) {
+    if (expression.name === "undefined")
+      expressionKey = "undefined";
+    else
+      expressionKey = `id:${expression.name}`;
+  } else if (constValue === undefined) {
+    expressionKey = `complex:${sourceText}`;
+    isComplex = true;
+  } else
+    expressionKey = `const:${constValue}`;
+  if (constValue === undefined)
+    return { expressionKey, isComplex, node: expression, sourceText };
+  return { constValue, expressionKey, isComplex, node: expression, sourceText };
+}
+function matchParameters(patterns2, parameters3, sourceCode) {
+  const captures = new Map;
+  const optionalStart = patterns2.findIndex((parsedArg) => parsedArg.kind === "optional");
+  const minimumParameters = optionalStart === -1 ? patterns2.length : optionalStart;
+  if (parameters3.length < minimumParameters || parameters3.length > patterns2.length)
+    return;
+  for (let index2 = 0;index2 < patterns2.length; index2 += 1) {
+    const pattern4 = patterns2[index2];
+    if (pattern4 === undefined)
+      continue;
+    const parameter2 = parameters3[index2];
+    const unwrappedParameter = parameter2 === undefined ? undefined : unwrap(parameter2);
+    const isMissing = parameter2 === undefined || unwrappedParameter?.type === AST_NODE_TYPES10.Identifier && unwrappedParameter.name === "undefined";
+    if (pattern4.kind === "literal") {
+      if (isMissing)
+        return;
+      const captured = captureParameter(parameter2, sourceCode);
+      if (captured.constValue !== pattern4.value)
+        return;
+    } else if (pattern4.kind === "optional") {
+      if (isMissing)
+        continue;
+      const captured = captureParameter(parameter2, sourceCode);
+      if (captured.constValue !== pattern4.value)
+        return;
+    } else if (pattern4.kind === "capture") {
+      if (isMissing)
+        return;
+      const captured = captureParameter(parameter2, sourceCode);
+      const captureName = pattern4.name;
+      const existing = captures.get(captureName);
+      if (existing !== undefined && existing.expressionKey !== captured.expressionKey)
+        return;
+      captures.set(captureName, captured);
+    } else if (pattern4.kind === "wildcard" && isMissing)
+      return;
+  }
+  return captures;
+}
+var CONDITION_PATTERN = regex2("^(?<operator>[!<>=]+)\\s*(?<target>.+)$");
+function parseCondition(condition) {
+  const match = CONDITION_PATTERN.exec(condition);
+  return match ? [match.groups.operator, match.groups.target] : ["==", "0"];
+}
+function evaluateConditions(conditions, captures) {
+  for (const [name, condition] of conditions) {
+    const captured = captures.get(name);
+    if (captured?.constValue === undefined)
+      return false;
+    const value = captured.constValue;
+    const [operator, targetStr] = parseCondition(condition);
+    const target2 = Number.parseFloat(targetStr);
+    if (!Number.isFinite(target2))
+      return false;
+    let passes;
+    switch (operator) {
+      case "!=":
+        passes = value !== target2;
+        break;
+      case "==":
+        passes = value === target2;
+        break;
+      case ">":
+        passes = value > target2;
+        break;
+      case "<":
+        passes = value < target2;
+        break;
+      case ">=":
+        passes = value >= target2;
+        break;
+      case "<=":
+        passes = value <= target2;
+        break;
+      default:
+        passes = false;
+    }
+    if (!passes)
+      return false;
+  }
+  return true;
+}
+function canSafelySubstitute(captures) {
+  for (const [, captured] of captures)
+    if (captured.isComplex)
+      return false;
+  return true;
+}
+// src/utilities/pattern-replacement/pattern-parser.ts
+var CONSTRUCTOR_PATTERN = regex2("^new\\s+(?<typeName>\\w+)\\((?<argumentsString>.*)\\)$");
+var STATIC_METHOD_PATTERN = regex2("^(?<typeName>\\w+)\\.(?<methodName>\\w+)\\((?<argumentsString>.*)\\)$");
+var STATIC_ACCESS_PATTERN = regex2("^(?<typeName>\\w+)\\.(?<property>\\w+)$");
+var CALL_PATTERN = regex2("^(?<name>\\w+)\\((?<argumentsString>.*)\\)$");
+function parseParameters(parametersString) {
+  const trimmed = parametersString.trim();
+  if (trimmed === "")
+    return [];
+  const parameters3 = trimmed.split(",").map((parameter2) => parameter2.trim());
+  const result = new Array;
+  let size = 0;
+  for (const parameter2 of parameters3) {
+    if (parameter2 === "_")
+      result[size++] = { kind: "wildcard" };
+    else if (parameter2.startsWith("$"))
+      result[size++] = { kind: "capture", name: parameter2.slice(1) };
+    else if (parameter2.endsWith("?")) {
+      const value = Number.parseFloat(parameter2.slice(0, -1));
+      result[size++] = { kind: "optional", value };
+    } else {
+      const value = Number.parseFloat(parameter2);
+      result[size++] = { kind: "literal", value };
+    }
+  }
+  return result;
+}
+function parseReplacement(replacement) {
+  const staticMatch = STATIC_ACCESS_PATTERN.exec(replacement);
+  if (staticMatch && !replacement.includes("("))
+    return { ...staticMatch.groups, kind: "staticAccess" };
+  const callMatch = CALL_PATTERN.exec(replacement);
+  if (callMatch) {
+    const { name, argumentsString } = callMatch.groups;
+    const parameters3 = argumentsString.trim() === "" ? [] : argumentsString.split(",").map((value) => value.trim());
+    return { kind: "call", name, parameters: parameters3 };
+  }
+  return { kind: "identifier", name: replacement };
+}
+function parsePattern(match, replacement, when) {
+  const conditions = new Map;
+  if (when)
+    for (const [key, value] of Object.entries(when))
+      conditions.set(key, value);
+  const constructorMatch = CONSTRUCTOR_PATTERN.exec(match);
+  if (constructorMatch) {
+    const { typeName, argumentsString } = constructorMatch.groups;
+    return {
+      conditions,
+      original: match,
+      parameters: parseParameters(argumentsString),
+      replacement: parseReplacement(replacement),
+      type: "constructor",
+      typeName
+    };
+  }
+  const staticMethodMatch = STATIC_METHOD_PATTERN.exec(match);
+  if (staticMethodMatch) {
+    const { typeName, methodName, argumentsString } = staticMethodMatch.groups;
+    return {
+      conditions,
+      methodName,
+      original: match,
+      parameters: parseParameters(argumentsString),
+      replacement: parseReplacement(replacement),
+      type: "staticMethod",
+      typeName
+    };
+  }
+  throw new Error(`Invalid pattern: ${match}`);
+}
+// src/utilities/pattern-replacement/pattern-types.ts
+function pattern4(configuration) {
+  return configuration;
+}
+// src/utilities/pattern-replacement/replacement-generator.ts
+function getReplacementIdentifier(replacement) {
+  switch (replacement.kind) {
+    case "identifier":
+      return replacement.name;
+    case "call":
+      return replacement.name;
+    case "staticAccess":
+      return;
+  }
+}
+function generateReplacement(replacement, captures) {
+  const { kind } = replacement;
+  switch (kind) {
+    case "identifier":
+      return replacement.name;
+    case "staticAccess":
+      return `${replacement.typeName}.${replacement.property}`;
+    case "call": {
+      const parameters3 = replacement.parameters.map((argument) => {
+        if (argument.startsWith("$")) {
+          const captureName = argument.slice(1);
+          const captured = captures.get(captureName);
+          if (captured === undefined)
+            throw new Error(`Missing capture: ${captureName}`);
+          return captured.sourceText;
+        }
+        return argument;
+      });
+      return `${replacement.name}(${parameters3.join(", ")})`;
+    }
+    default:
+      throw new Error(`Unknown replacement kind: ${kind}`);
+  }
+}
+// src/rules/prefer-pattern-replacements.ts
+var isRuleOptions2 = Compile(build_default.Object({
+  patterns: build_default.Array(build_default.Object({}, { additionalProperties: true }))
+}));
+function parsePatterns(patterns2) {
+  return patterns2.map((pattern5) => parsePattern(pattern5.match, pattern5.replacement, pattern5.when));
+}
+var prefer_pattern_replacements_default = createRule({
+  create(context) {
+    const validatedOptions = isRuleOptions2.Check(context.options[0]) ? context.options[0] : undefined;
+    if (!validatedOptions || validatedOptions.patterns.length === 0)
+      return {};
+    const parsedPatterns = parsePatterns(validatedOptions.patterns);
+    const patternIndex = buildPatternIndex(parsedPatterns);
+    const { sourceCode } = context;
+    function hasNameConflict(node, identifierName) {
+      let scope = sourceCode.getScope(node);
+      while (scope) {
+        if (scope.set.has(identifierName))
+          return true;
+        scope = scope.upper ?? undefined;
+      }
+      return false;
+    }
+    function checkNode(node) {
+      const resolved = resolveCallee(node);
+      if (resolved.kind === "unknown")
+        return;
+      const key = resolved.kind === "constructor" ? `constructor:${resolved.typeName}` : `staticMethod:${resolved.typeName}:${resolved.methodName}`;
+      const candidates2 = patternIndex.get(key);
+      if (!candidates2 || candidates2.length === 0)
+        return;
+      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)) {
+          skippedConflicts.push({
+            conflict: replacementId,
+            replacement: generateReplacement(pattern5.replacement, captures)
+          });
+          continue;
+        }
+        const originalText = sourceCode.getText(node);
+        const replacementText = generateReplacement(pattern5.replacement, captures);
+        context.report({
+          data: { original: originalText, replacement: replacementText },
+          fix: (fixer) => fixer.replaceText(node, replacementText),
+          messageId: "preferReplacement",
+          node
+        });
+        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,
+      NewExpression: checkNode
+    };
+  },
+  defaultOptions: [{ patterns: [] }],
+  meta: {
+    docs: {
+      description: "Enforce using configured replacements for common constructor/method patterns"
+    },
+    fixable: "code",
+    messages: {
+      preferReplacement: "Prefer '{{replacement}}' over '{{original}}'",
+      skippedDueToConflict: "Pattern '{{replacement}}' was skipped because '{{conflict}}' is already in scope."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          patterns: {
+            items: { type: "object" },
+            type: "array"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "suggestion"
+  },
+  name: "prefer-pattern-replacements"
+});
 
 // src/rules/prefer-sequence-overloads.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES9 } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES11 } from "@typescript-eslint/types";
 var sequenceDescriptors = [
   { keypointName: "ColorSequenceKeypoint", sequenceName: "ColorSequence" },
   { keypointName: "NumberSequenceKeypoint", sequenceName: "NumberSequence" }
 ];
 function isSequenceIdentifier(node) {
-  if (node.type !== AST_NODE_TYPES9.Identifier)
+  if (node.type !== AST_NODE_TYPES11.Identifier)
     return false;
   for (const { sequenceName } of sequenceDescriptors)
     if (sequenceName === node.name)
@@ -19788,16 +20325,16 @@ function findDescriptor(sequenceName) {
   return;
 }
 var isNumericLiteral = Compile(build_default.Object({
-  type: build_default.Literal(AST_NODE_TYPES9.Literal),
+  type: build_default.Literal(AST_NODE_TYPES11.Literal),
   value: build_default.Number()
 }));
 function isExpressionArgument(argument) {
-  return argument !== undefined && argument.type !== AST_NODE_TYPES9.SpreadElement;
+  return argument !== undefined && argument.type !== AST_NODE_TYPES11.SpreadElement;
 }
 function extractKeypoint(element, descriptor) {
-  if (element === undefined || element.type !== AST_NODE_TYPES9.NewExpression)
+  if (element === undefined || element.type !== AST_NODE_TYPES11.NewExpression)
     return;
-  if (element.callee.type !== AST_NODE_TYPES9.Identifier || element.callee.name !== descriptor.keypointName)
+  if (element.callee.type !== AST_NODE_TYPES11.Identifier || element.callee.name !== descriptor.keypointName)
     return;
   if (element.arguments.length !== 2)
     return;
@@ -19811,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 {
@@ -19827,7 +20360,7 @@ var preferSequenceOverloads = {
         if (descriptor === undefined || node.arguments.length !== 1)
           return;
         const [argument] = node.arguments;
-        if (argument === undefined || argument.type !== AST_NODE_TYPES9.ArrayExpression || argument.elements.length !== 2)
+        if (argument === undefined || argument.type !== AST_NODE_TYPES11.ArrayExpression || argument.elements.length !== 2)
           return;
         const firstElement = argument.elements[0] ?? undefined;
         const secondElement = argument.elements[1] ?? undefined;
@@ -19861,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.",
@@ -19869,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([
@@ -19985,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) {
@@ -20010,9 +20545,9 @@ var preferSingularEnums = {
     },
     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";
@@ -20173,16 +20708,16 @@ var preferUDim2Shorthand = {
 var prefer_udim2_shorthand_default = preferUDim2Shorthand;
 
 // src/rules/react-hooks-strict-return.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES10 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES12 } from "@typescript-eslint/utils";
 var MAX_RETURN_ELEMENTS = 2;
 var HOOK_PATTERN = /^use[A-Z0-9].*$/;
 function isHookNode(node) {
   let name;
-  if (node.type === AST_NODE_TYPES10.VariableDeclarator && node.id.type === AST_NODE_TYPES10.Identifier) {
+  if (node.type === AST_NODE_TYPES12.VariableDeclarator && node.id.type === AST_NODE_TYPES12.Identifier) {
     ({ name } = node.id);
-  } else if (node.type === AST_NODE_TYPES10.FunctionDeclaration && node.id)
+  } else if (node.type === AST_NODE_TYPES12.FunctionDeclaration && node.id)
     ({ name } = node.id);
-  else if (node.type === AST_NODE_TYPES10.FunctionExpression && node.id)
+  else if (node.type === AST_NODE_TYPES12.FunctionExpression && node.id)
     ({ name } = node.id);
   return name !== undefined && HOOK_PATTERN.test(name);
 }
@@ -20206,27 +20741,27 @@ function getArrayElementsFromVariable(scope, name) {
     if (!identifier3.parent)
       continue;
     const { parent } = identifier3;
-    if (parent.type !== AST_NODE_TYPES10.VariableDeclarator)
+    if (parent.type !== AST_NODE_TYPES12.VariableDeclarator)
       continue;
-    if (!parent.init || parent.init.type !== AST_NODE_TYPES10.ArrayExpression)
+    if (!parent.init || parent.init.type !== AST_NODE_TYPES12.ArrayExpression)
       continue;
     elements.push(...parent.init.elements);
   }
   return elements;
 }
 function countReturnElements(argument, scope) {
-  if (argument.type === AST_NODE_TYPES10.Identifier)
+  if (argument.type === AST_NODE_TYPES12.Identifier)
     return getArrayElementsFromVariable(scope, argument.name).length;
-  if (argument.type !== AST_NODE_TYPES10.ArrayExpression)
+  if (argument.type !== AST_NODE_TYPES12.ArrayExpression)
     return 0;
   let count = 0;
   for (const element of argument.elements) {
     if (element === null)
       count += 1;
-    else if (element.type === AST_NODE_TYPES10.SpreadElement) {
-      if (element.argument.type === AST_NODE_TYPES10.Identifier) {
+    else if (element.type === AST_NODE_TYPES12.SpreadElement) {
+      if (element.argument.type === AST_NODE_TYPES12.Identifier) {
         count += getArrayElementsFromVariable(scope, element.argument.name).length;
-      } else if (element.argument.type === AST_NODE_TYPES10.ArrayExpression) {
+      } else if (element.argument.type === AST_NODE_TYPES12.ArrayExpression) {
         count += element.argument.elements.length;
       } else
         count += 1;
@@ -20239,14 +20774,14 @@ function exceedsMaxReturnProperties(node, scope) {
   const { argument } = node;
   if (argument === null)
     return false;
-  if (argument.type === AST_NODE_TYPES10.ObjectExpression)
+  if (argument.type === AST_NODE_TYPES12.ObjectExpression)
     return false;
-  if (argument.type === AST_NODE_TYPES10.Identifier) {
+  if (argument.type === AST_NODE_TYPES12.Identifier) {
     const variable = getVariableByName(scope, argument.name);
     if (variable) {
       for (const { identifier: identifier3 } of variable.references) {
         const { parent } = identifier3;
-        if (parent?.type === AST_NODE_TYPES10.VariableDeclarator && parent.init?.type === AST_NODE_TYPES10.ObjectExpression) {
+        if (parent?.type === AST_NODE_TYPES12.VariableDeclarator && parent.init?.type === AST_NODE_TYPES12.ObjectExpression) {
           return false;
         }
       }
@@ -20254,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) {
@@ -20268,13 +20803,13 @@ var reactHooksStrictReturn = {
     return {
       ArrowFunctionExpression(node) {
         const { parent } = node;
-        if (parent?.type === AST_NODE_TYPES10.VariableDeclarator && parent.id.type === AST_NODE_TYPES10.Identifier && HOOK_PATTERN.test(parent.id.name)) {
+        if (parent?.type === AST_NODE_TYPES12.VariableDeclarator && parent.id.type === AST_NODE_TYPES12.Identifier && HOOK_PATTERN.test(parent.id.name)) {
           hookDepth += 1;
         }
       },
       "ArrowFunctionExpression:exit"(node) {
         const { parent } = node;
-        if (parent?.type === AST_NODE_TYPES10.VariableDeclarator && parent.id.type === AST_NODE_TYPES10.Identifier && HOOK_PATTERN.test(parent.id.name)) {
+        if (parent?.type === AST_NODE_TYPES12.VariableDeclarator && parent.id.type === AST_NODE_TYPES12.Identifier && HOOK_PATTERN.test(parent.id.name)) {
           hookDepth -= 1;
         }
       },
@@ -20307,9 +20842,9 @@ var reactHooksStrictReturn = {
     },
     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";
@@ -20323,7 +20858,7 @@ var isHookConfiguration = build_default.Object({
   allowAsync: build_default.Boolean(),
   name: build_default.String()
 });
-var isRuleOptions2 = Compile(build_default.Object({
+var isRuleOptions3 = Compile(build_default.Object({
   environment: isEnvironmentMode,
   hooks: build_default.Array(isHookConfiguration)
 }, { additionalProperties: true }));
@@ -20334,7 +20869,7 @@ function parseOptions2(options3) {
       hooks: DEFAULT_HOOKS
     };
   }
-  if (!isRuleOptions2.Check(options3)) {
+  if (!isRuleOptions3.Check(options3)) {
     return {
       environment: "roblox-ts",
       hooks: DEFAULT_HOOKS
@@ -20555,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 },
@@ -20644,7 +21178,7 @@ var requireNamedEffectFunctions = {
 var require_named_effect_functions_default = requireNamedEffectFunctions;
 
 // src/rules/require-paired-calls.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES11 } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES13 } from "@typescript-eslint/types";
 var isStringArray = Compile(build_default.Readonly(build_default.Array(build_default.String())));
 var isPairConfiguration = Compile(build_default.Readonly(build_default.Object({
   alternatives: build_default.Optional(isStringArray),
@@ -20655,27 +21189,27 @@ var isPairConfiguration = Compile(build_default.Readonly(build_default.Object({
   requireSync: build_default.Optional(build_default.Boolean()),
   yieldingFunctions: build_default.Optional(isStringArray)
 })));
-var isRuleOptions3 = Compile(build_default.Partial(build_default.Readonly(build_default.Object({
+var isRuleOptions4 = Compile(build_default.Partial(build_default.Readonly(build_default.Object({
   allowConditionalClosers: build_default.Optional(build_default.Boolean()),
   allowMultipleOpeners: build_default.Optional(build_default.Boolean()),
   maxNestingDepth: build_default.Optional(build_default.Number()),
   pairs: build_default.Readonly(build_default.Array(isPairConfiguration))
 }))));
 var LOOP_NODE_TYPES = new Set([
-  AST_NODE_TYPES11.DoWhileStatement,
-  AST_NODE_TYPES11.ForInStatement,
-  AST_NODE_TYPES11.ForOfStatement,
-  AST_NODE_TYPES11.ForStatement,
-  AST_NODE_TYPES11.WhileStatement
+  AST_NODE_TYPES13.DoWhileStatement,
+  AST_NODE_TYPES13.ForInStatement,
+  AST_NODE_TYPES13.ForOfStatement,
+  AST_NODE_TYPES13.ForStatement,
+  AST_NODE_TYPES13.WhileStatement
 ]);
 var DEFAULT_ROBLOX_YIELDING_FUNCTIONS = ["task.wait", "wait", "*.WaitForChild", "*.*Async"];
 function getCallName(node) {
   const { callee } = node;
-  if (callee.type === AST_NODE_TYPES11.Identifier)
+  if (callee.type === AST_NODE_TYPES13.Identifier)
     return callee.name;
-  if (callee.type === AST_NODE_TYPES11.MemberExpression) {
-    const object3 = callee.object.type === AST_NODE_TYPES11.Identifier ? callee.object.name : undefined;
-    const property = callee.property.type === AST_NODE_TYPES11.Identifier ? callee.property.name : undefined;
+  if (callee.type === AST_NODE_TYPES13.MemberExpression) {
+    const object3 = callee.object.type === AST_NODE_TYPES13.Identifier ? callee.object.name : undefined;
+    const property = callee.property.type === AST_NODE_TYPES13.Identifier ? callee.property.name : undefined;
     if (object3 !== undefined && property !== undefined)
       return `${object3}.${property}`;
   }
@@ -20711,12 +21245,12 @@ function isLoopLikeStatement(node) {
   return LOOP_NODE_TYPES.has(node.type);
 }
 function isSwitchStatement(node) {
-  return node?.type === AST_NODE_TYPES11.SwitchStatement;
+  return node?.type === AST_NODE_TYPES13.SwitchStatement;
 }
 function findLabeledStatementBody(label, startingNode) {
   let current = startingNode;
   while (current) {
-    if (current.type === AST_NODE_TYPES11.LabeledStatement && current.label.name === label.name)
+    if (current.type === AST_NODE_TYPES13.LabeledStatement && current.label.name === label.name)
       return current.body;
     current = current.parent ?? undefined;
   }
@@ -20765,7 +21299,7 @@ var messages = {
 var rule = {
   create(context) {
     const [rawOptions] = context.options;
-    const baseOptions = isRuleOptions3.Check(rawOptions) ? rawOptions : {};
+    const baseOptions = isRuleOptions4.Check(rawOptions) ? rawOptions : {};
     const options3 = {
       allowConditionalClosers: baseOptions.allowConditionalClosers ?? false,
       allowMultipleOpeners: baseOptions.allowMultipleOpeners ?? true,
@@ -20865,12 +21399,12 @@ var rule = {
       if (configuration.platform !== "roblox")
         return false;
       const yieldingFunctions = configuration.yieldingFunctions ?? DEFAULT_ROBLOX_YIELDING_FUNCTIONS;
-      return yieldingFunctions.some((pattern4) => {
-        if (pattern4.startsWith("*.")) {
-          const methodName = pattern4.slice(2);
+      return yieldingFunctions.some((pattern5) => {
+        if (pattern5.startsWith("*.")) {
+          const methodName = pattern5.slice(2);
           return functionName.endsWith(`.${methodName}`);
         }
-        return functionName === pattern4;
+        return functionName === pattern5;
       });
     }
     function onFunctionEnter(node) {
@@ -20978,7 +21512,7 @@ var rule = {
     function onIfConsequentExit(node) {
       const consequentNode = node;
       const { parent } = consequentNode;
-      if (parent?.type === AST_NODE_TYPES11.IfStatement) {
+      if (parent?.type === AST_NODE_TYPES13.IfStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -20993,7 +21527,7 @@ var rule = {
     function onIfAlternateExit(node) {
       const alternateNode = node;
       const { parent } = alternateNode;
-      if (parent?.type === AST_NODE_TYPES11.IfStatement) {
+      if (parent?.type === AST_NODE_TYPES13.IfStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -21042,7 +21576,7 @@ var rule = {
     function onTryBlockExit(node) {
       const blockNode = node;
       const { parent } = blockNode;
-      if (parent?.type === AST_NODE_TYPES11.TryStatement) {
+      if (parent?.type === AST_NODE_TYPES13.TryStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -21061,7 +21595,7 @@ var rule = {
     function onCatchClauseExit(node) {
       const catchNode = node;
       const { parent } = catchNode;
-      if (parent?.type === AST_NODE_TYPES11.TryStatement) {
+      if (parent?.type === AST_NODE_TYPES13.TryStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -21124,7 +21658,7 @@ var rule = {
     function onSwitchCaseExit(node) {
       const caseNode = node;
       const { parent } = caseNode;
-      if (parent?.type === AST_NODE_TYPES11.SwitchStatement) {
+      if (parent?.type === AST_NODE_TYPES13.SwitchStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -21155,7 +21689,7 @@ var rule = {
       for (const { opener, config, node: node2 } of openerStack) {
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const statementType = statementNode.type === AST_NODE_TYPES11.ReturnStatement ? "return" : "throw";
+        const statementType = statementNode.type === AST_NODE_TYPES13.ReturnStatement ? "return" : "throw";
         const lineNumber = statementNode.loc?.start.line ?? 0;
         context.report({
           data: {
@@ -21172,7 +21706,7 @@ var rule = {
       const statementNode = node;
       if (openerStack.length === 0)
         return;
-      const targetLoop = statementNode.type === AST_NODE_TYPES11.ContinueStatement ? resolveContinueTargetLoop(statementNode) : resolveBreakTargetLoop(statementNode);
+      const targetLoop = statementNode.type === AST_NODE_TYPES13.ContinueStatement ? resolveContinueTargetLoop(statementNode) : resolveBreakTargetLoop(statementNode);
       if (!targetLoop)
         return;
       for (const { node: openerNode, config, opener, loopAncestors } of openerStack) {
@@ -21180,7 +21714,7 @@ var rule = {
           continue;
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const statementType = statementNode.type === AST_NODE_TYPES11.BreakStatement ? "break" : "continue";
+        const statementType = statementNode.type === AST_NODE_TYPES13.BreakStatement ? "break" : "continue";
         const lineNumber = statementNode.loc?.start.line ?? 0;
         context.report({
           data: {
@@ -21318,7 +21852,7 @@ var rule = {
           continue;
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const asyncType = asyncNode.type === AST_NODE_TYPES11.AwaitExpression ? "await" : "yield";
+        const asyncType = asyncNode.type === AST_NODE_TYPES13.AwaitExpression ? "await" : "yield";
         context.report({
           data: { asyncType, closer, opener },
           messageId: "asyncViolation",
@@ -21495,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;
     }
   }
@@ -21580,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([
@@ -21648,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;
     }
@@ -21656,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;
@@ -21722,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,
@@ -21778,7 +22314,9 @@ 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"
@@ -21826,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";
@@ -21849,8 +22598,8 @@ function resolveRelativeImport(importSource, sourceFile) {
 }
 
 // src/rules/strict-component-boundaries.ts
-function toRegExp(pattern4) {
-  return new RegExp(pattern4, "i");
+function toRegExp(pattern5) {
+  return new RegExp(pattern5, "i");
 }
 function pathSegmentsFromSource(source) {
   return source.split("/").filter((part) => !part.startsWith("."));
@@ -21874,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);
@@ -21936,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,
@@ -22034,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;
@@ -22044,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;
   }
@@ -22054,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}`;
   }
@@ -22092,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;
@@ -22107,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)
@@ -22127,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;
         }
@@ -22168,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;
@@ -22184,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;
@@ -22252,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;
     }
   }
@@ -22265,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;
@@ -22307,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);
@@ -22346,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({
@@ -22423,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);
         }
@@ -22459,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);
@@ -22669,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) {
@@ -22679,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);
     }
@@ -22704,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;
@@ -22723,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) {
@@ -22771,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;
@@ -22793,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) {
@@ -22832,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();
@@ -22930,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);
@@ -23106,6 +23855,12 @@ function createNoUselessUseSpringOptions(options3 = {}) {
     ...options3
   };
 }
+function createPreferPatternReplacementsOptions(patterns2 = []) {
+  return { patterns: patterns2 };
+}
+function createRequireReactDisplayNamesOptions(options3 = {}) {
+  return { environment: "roblox-ts", ...options3 };
+}
 
 // src/index.ts
 var rules = {
@@ -23127,6 +23882,7 @@ var rules = {
   "prefer-early-return": prefer_early_return_default,
   "prefer-module-scope-constants": prefer_module_scope_constants_default,
   "prefer-pascal-case-enums": prefer_pascal_case_enums_default,
+  "prefer-pattern-replacements": prefer_pattern_replacements_default,
   "prefer-sequence-overloads": prefer_sequence_overloads_default,
   "prefer-singular-enums": prefer_singular_enums_default,
   "prefer-udim2-shorthand": prefer_udim2_shorthand_default,
@@ -23134,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
@@ -23158,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"
   }
@@ -23168,12 +23926,15 @@ var plugin = {
 };
 var src_default = plugin;
 export {
+  pattern4 as pattern,
   defaultRobloxProfilePair,
   src_default as default,
   createUseHookAtTopLevelOptions,
   createUseExhaustiveDependenciesOptions,
+  createRequireReactDisplayNamesOptions,
   createRequirePairedCallsOptions,
   createReactKeysOptions,
+  createPreferPatternReplacementsOptions,
   createPairConfiguration,
   createNoUselessUseSpringOptions,
   createNoShorthandOptions,
@@ -23185,4 +23946,4 @@ export {
   createBanInstancesOptions
 };
 
-//# debugId=CB943D9A894DADAF64756E2164756E21
+//# debugId=A19451816DAA8A5E64756E2164756E21