npm - @pobammer-ts/eslint-cease-nonsense-rules - Versions diffs - 1.11.0 → 1.12.0 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (56) hide show

package/README.md +58 -0
package/dist/build-metadata.json +3 -3
package/dist/index.d.ts +7 -6
package/dist/index.d.ts.map +1 -1
package/dist/index.js +605 -250
package/dist/index.js.map +45 -42
package/dist/rules/ban-instances.d.ts +6 -7
package/dist/rules/ban-instances.d.ts.map +1 -1
package/dist/rules/ban-react-fc.d.ts +4 -7
package/dist/rules/ban-react-fc.d.ts.map +1 -1
package/dist/rules/enforce-ianitor-check-type.d.ts +7 -3
package/dist/rules/enforce-ianitor-check-type.d.ts.map +1 -1
package/dist/rules/no-async-constructor.d.ts +4 -5
package/dist/rules/no-async-constructor.d.ts.map +1 -1
package/dist/rules/no-color3-constructor.d.ts +4 -3
package/dist/rules/no-color3-constructor.d.ts.map +1 -1
package/dist/rules/no-commented-code.d.ts.map +1 -1
package/dist/rules/no-god-components.d.ts.map +1 -1
package/dist/rules/no-identity-map.d.ts +4 -2
package/dist/rules/no-identity-map.d.ts.map +1 -1
package/dist/rules/no-instance-methods-without-this.d.ts +4 -9
package/dist/rules/no-instance-methods-without-this.d.ts.map +1 -1
package/dist/rules/no-print.d.ts +4 -3
package/dist/rules/no-print.d.ts.map +1 -1
package/dist/rules/no-useless-use-spring.d.ts +4 -4
package/dist/rules/no-useless-use-spring.d.ts.map +1 -1
package/dist/rules/no-warn.d.ts +4 -3
package/dist/rules/no-warn.d.ts.map +1 -1
package/dist/rules/prefer-class-properties.d.ts +4 -3
package/dist/rules/prefer-class-properties.d.ts.map +1 -1
package/dist/rules/prefer-early-return.d.ts +4 -4
package/dist/rules/prefer-early-return.d.ts.map +1 -1
package/dist/rules/prefer-module-scope-constants.d.ts +4 -2
package/dist/rules/prefer-module-scope-constants.d.ts.map +1 -1
package/dist/rules/prefer-pascal-case-enums.d.ts +4 -4
package/dist/rules/prefer-pascal-case-enums.d.ts.map +1 -1
package/dist/rules/prefer-pattern-replacements.d.ts +6 -11
package/dist/rules/prefer-pattern-replacements.d.ts.map +1 -1
package/dist/rules/prefer-sequence-overloads.d.ts +4 -7
package/dist/rules/prefer-sequence-overloads.d.ts.map +1 -1
package/dist/rules/prefer-singular-enums.d.ts +4 -4
package/dist/rules/prefer-singular-enums.d.ts.map +1 -1
package/dist/rules/react-hooks-strict-return.d.ts +4 -3
package/dist/rules/react-hooks-strict-return.d.ts.map +1 -1
package/dist/rules/require-named-effect-functions.d.ts.map +1 -1
package/dist/rules/require-react-component-keys.d.ts +4 -5
package/dist/rules/require-react-component-keys.d.ts.map +1 -1
package/dist/rules/require-react-display-names.d.ts +11 -0
package/dist/rules/require-react-display-names.d.ts.map +1 -0
package/dist/rules/strict-component-boundaries.d.ts +4 -8
package/dist/rules/strict-component-boundaries.d.ts.map +1 -1
package/dist/utilities/configure-utilities.d.ts +7 -0
package/dist/utilities/configure-utilities.d.ts.map +1 -1
package/dist/utilities/create-rule.d.ts +9 -0
package/dist/utilities/create-rule.d.ts.map +1 -0
package/package.json +17 -17

package/dist/index.js CHANGED Viewed

@@ -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,9 +19880,9 @@ var preferPascalCaseEnums = {
     },
     schema: [],
     type: "suggestion"
-  }
-};
-var prefer_pascal_case_enums_default = preferPascalCaseEnums;
+  },
+  name: "prefer-pascal-case-enums"
+});
 // src/utilities/pattern-replacement/pattern-matcher.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES10 } from "@typescript-eslint/types";
@@ -20091,7 +20208,7 @@ var isRuleOptions2 = Compile(build_default.Object({
 function parsePatterns(patterns2) {
   return patterns2.map((pattern5) => parsePattern(pattern5.match, pattern5.replacement, pattern5.when));
 }
-var preferPatternReplacements = {
+var prefer_pattern_replacements_default = createRule({
   create(context) {
     const validatedOptions = isRuleOptions2.Check(context.options[0]) ? context.options[0] : undefined;
     if (!validatedOptions || validatedOptions.patterns.length === 0)
@@ -20116,14 +20233,20 @@ var preferPatternReplacements = {
       const candidates2 = patternIndex.get(key);
       if (!candidates2 || candidates2.length === 0)
         return;
+      const skippedConflicts = [];
       for (const pattern5 of candidates2) {
         const captures = matchParameters(pattern5.parameters, node.arguments, sourceCode);
         if (!(captures && evaluateConditions(pattern5.conditions, captures) && canSafelySubstitute(captures))) {
           continue;
         }
         const replacementId = getReplacementIdentifier(pattern5.replacement);
-        if (replacementId && hasNameConflict(node, replacementId))
+        if (replacementId && hasNameConflict(node, replacementId)) {
+          skippedConflicts.push({
+            conflict: replacementId,
+            replacement: generateReplacement(pattern5.replacement, captures)
+          });
           continue;
+        }
         const originalText = sourceCode.getText(node);
         const replacementText = generateReplacement(pattern5.replacement, captures);
         context.report({
@@ -20132,8 +20255,22 @@ var preferPatternReplacements = {
           messageId: "preferReplacement",
           node
         });
+        for (const { replacement, conflict } of skippedConflicts) {
+          context.report({
+            data: { conflict, replacement },
+            messageId: "skippedDueToConflict",
+            node
+          });
+        }
         return;
       }
+      for (const { replacement, conflict } of skippedConflicts) {
+        context.report({
+          data: { conflict, replacement },
+          messageId: "skippedDueToConflict",
+          node
+        });
+      }
     }
     return {
       CallExpression: checkNode,
@@ -20143,12 +20280,12 @@ var preferPatternReplacements = {
   defaultOptions: [{ patterns: [] }],
   meta: {
     docs: {
-      description: "Enforce using configured replacements for common constructor/method patterns",
-      recommended: false
+      description: "Enforce using configured replacements for common constructor/method patterns"
     },
     fixable: "code",
     messages: {
-      preferReplacement: "Prefer '{{replacement}}' over '{{original}}'"
+      preferReplacement: "Prefer '{{replacement}}' over '{{original}}'",
+      skippedDueToConflict: "Pattern '{{replacement}}' was skipped because '{{conflict}}' is already in scope."
     },
     schema: [
       {
@@ -20163,9 +20300,9 @@ var preferPatternReplacements = {
       }
     ],
     type: "suggestion"
-  }
-};
-var prefer_pattern_replacements_default = preferPatternReplacements;
+  },
+  name: "prefer-pattern-replacements"
+});
 // src/rules/prefer-sequence-overloads.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES11 } from "@typescript-eslint/types";
@@ -20211,11 +20348,7 @@ function extractKeypoint(element, descriptor) {
     value: valueArgument
   };
 }
-var docs2 = {
-  description: "Prefer the optimized ColorSequence and NumberSequence constructor overloads over passing ColorSequenceKeypoint or NumberSequenceKeypoint arrays when only using endpoints 0 and 1.",
-  recommended: true
-};
-var preferSequenceOverloads = {
+var prefer_sequence_overloads_default = createRule({
   create(context) {
     const { sourceCode } = context;
     return {
@@ -20261,7 +20394,9 @@ var preferSequenceOverloads = {
   },
   defaultOptions: [],
   meta: {
-    docs: docs2,
+    docs: {
+      description: "Prefer using single or two-point overloads for Roblox Sequence methods instead of all three overloads."
+    },
     fixable: "code",
     messages: {
       preferSingleOverload: "Use the single-argument {{sequenceName}} constructor overload instead of redundant keypoints when both endpoints share the same value.",
@@ -20269,9 +20404,9 @@ var preferSequenceOverloads = {
     },
     schema: [],
     type: "problem"
-  }
-};
-var prefer_sequence_overloads_default = preferSequenceOverloads;
+  },
+  name: "prefer-sequence-overloads"
+});
 // src/rules/prefer-singular-enums.ts
 var IRREGULAR_PLURALS = new Set([
@@ -20385,7 +20520,7 @@ function isPlural(name) {
   const last = getLastAlphaToken(name);
   return last ? isPluralWord(last.lower, last.original) : false;
 }
-var preferSingularEnums = {
+var prefer_singular_enums_default = createRule({
   create(context) {
     return {
       TSEnumDeclaration(node) {
@@ -20410,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";
@@ -20654,7 +20789,7 @@ function exceedsMaxReturnProperties(node, scope) {
   }
   return countReturnElements(argument, scope) > MAX_RETURN_ELEMENTS;
 }
-var reactHooksStrictReturn = {
+var react_hooks_strict_return_default = createRule({
   create(context) {
     let hookDepth = 0;
     function enterHook(node) {
@@ -20707,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";
@@ -20955,8 +21090,7 @@ var requireNamedEffectFunctions = {
           return;
         }
         if (argumentNode.type === TSESTree8.AST_NODE_TYPES.FunctionExpression) {
-          const functionExpressionNode = argumentNode;
-          const functionHasId = Boolean(functionExpressionNode.id);
+          const functionHasId = Boolean(argumentNode.id);
           if (functionHasId && argumentNode.async) {
             context.report({
               data: { hook: hookName },
@@ -21895,40 +22029,44 @@ function ascendPastWrappers(node) {
   return current;
 }
 function hasKeyAttribute(node) {
-  for (const attribute of node.openingElement.attributes)
+  for (const attribute of node.openingElement.attributes) {
     if (attribute.type === TSESTree9.AST_NODE_TYPES.JSXAttribute && attribute.name.name === "key")
       return true;
+  }
   return false;
 }
-function isReactComponentHOC2(callExpr) {
+function isHigherOrderComponent(callExpr) {
   const { callee } = callExpr;
-  if (callee.type === TSESTree9.AST_NODE_TYPES.Identifier)
+  if (callee.type === TSESTree9.AST_NODE_TYPES.Identifier) {
     return callee.name === "forwardRef" || callee.name === "memo";
-  if (callee.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree9.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === TSESTree9.AST_NODE_TYPES.Identifier)
+  }
+  if (callee.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree9.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === TSESTree9.AST_NODE_TYPES.Identifier) {
     return callee.property.name === "forwardRef" || callee.property.name === "memo";
+  }
   return false;
 }
 function getEnclosingFunctionLike(node) {
   let current = node.parent;
   while (current) {
-    if (current.type === TSESTree9.AST_NODE_TYPES.ArrowFunctionExpression || current.type === TSESTree9.AST_NODE_TYPES.FunctionExpression || current.type === TSESTree9.AST_NODE_TYPES.FunctionDeclaration)
+    if (current.type === TSESTree9.AST_NODE_TYPES.ArrowFunctionExpression || current.type === TSESTree9.AST_NODE_TYPES.FunctionExpression || current.type === TSESTree9.AST_NODE_TYPES.FunctionDeclaration) {
       return current;
+    }
     current = current.parent;
   }
   return;
 }
-function isIterationOrMemoCallback(callExpr, iterationMethods, memoizationHooks) {
-  const { callee } = callExpr;
+function isIterationOrMemoCallback(callExpression, iterationMethods, memoizationHooks) {
+  const { callee } = callExpression;
   if (callee.type === TSESTree9.AST_NODE_TYPES.Identifier && memoizationHooks.has(callee.name))
     return true;
   if (callee.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree9.AST_NODE_TYPES.Identifier) {
-    const methodName = callee.property.name;
-    if (iterationMethods.has(methodName))
+    const { name } = callee.property;
+    if (iterationMethods.has(name))
       return true;
-    if (methodName === "from" && callee.object.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.object.type === TSESTree9.AST_NODE_TYPES.Identifier && callee.object.object.name === "Array" && callExpr.arguments.length >= 2) {
+    if (name === "from" && callee.object.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.object.type === TSESTree9.AST_NODE_TYPES.Identifier && callee.object.object.name === "Array" && callExpression.arguments.length >= 2) {
       return true;
     }
-    if (methodName === "call" && callee.object.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.object.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.object.property.type === TSESTree9.AST_NODE_TYPES.Identifier && iterationMethods.has(callee.object.object.property.name)) {
+    if (name === "call" && callee.object.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.object.type === TSESTree9.AST_NODE_TYPES.MemberExpression && callee.object.object.property.type === TSESTree9.AST_NODE_TYPES.Identifier && iterationMethods.has(callee.object.object.property.name)) {
       return true;
     }
   }
@@ -21980,23 +22118,24 @@ function referenceActsAsCallback(reference, iterationMethods, memoizationHooks)
   const callExpression = findEnclosingCallExpression(reference.identifier);
   if (!callExpression)
     return false;
-  if (isReactComponentHOC2(callExpression))
+  if (isHigherOrderComponent(callExpression))
     return false;
   return isIterationOrMemoCallback(callExpression, iterationMethods, memoizationHooks);
 }
 function isFunctionUsedAsCallback(context, functionLike, iterationMethods, memoizationHooks) {
   const inlineCall = findEnclosingCallExpression(functionLike);
   if (inlineCall) {
-    if (isReactComponentHOC2(inlineCall))
+    if (isHigherOrderComponent(inlineCall))
       return false;
     return isIterationOrMemoCallback(inlineCall, iterationMethods, memoizationHooks);
   }
   const variable = getVariableForFunction(context, functionLike);
   if (!variable)
     return false;
-  for (const reference of variable.references)
+  for (const reference of variable.references) {
     if (referenceActsAsCallback(reference, iterationMethods, memoizationHooks))
       return true;
+  }
   return false;
 }
 var SHOULD_ASCEND_TYPES = new Set([
@@ -22048,7 +22187,7 @@ function isTopLevelReturn(node) {
     if (IS_FUNCTION_EXPRESSION.has(currentNode.type)) {
       const functionParent = ascendPastWrappers(currentNode.parent);
       if (functionParent?.type === TSESTree9.AST_NODE_TYPES.CallExpression) {
-        return isReactComponentHOC2(functionParent);
+        return isHigherOrderComponent(functionParent);
       }
       return true;
     }
@@ -22056,8 +22195,9 @@ function isTopLevelReturn(node) {
   }
   if (parent.type === TSESTree9.AST_NODE_TYPES.ArrowFunctionExpression) {
     const functionParent = ascendPastWrappers(parent.parent);
-    if (functionParent?.type === TSESTree9.AST_NODE_TYPES.CallExpression)
-      return isReactComponentHOC2(functionParent);
+    if (functionParent?.type === TSESTree9.AST_NODE_TYPES.CallExpression) {
+      return isHigherOrderComponent(functionParent);
+    }
     return true;
   }
   return false;
@@ -22122,11 +22262,7 @@ function isTernaryJSXChild(node) {
     return false;
   return containerParent.type === TSESTree9.AST_NODE_TYPES.JSXElement || containerParent.type === TSESTree9.AST_NODE_TYPES.JSXFragment;
 }
-var docs3 = {
-  description: "Enforce key props on all React elements except top-level returns",
-  recommended: true
-};
-var requireReactComponentKeys = {
+var require_react_component_keys_default = createRule({
   create(context) {
     const options3 = {
       ...DEFAULT_OPTIONS3,
@@ -22178,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"
@@ -22226,9 +22364,220 @@ var requireReactComponentKeys = {
       }
     ],
     type: "problem"
-  }
+  },
+  name: "require-react-component-keys"
+});
+// src/rules/require-react-display-names.ts
+import { TSESTree as TSESTree10 } from "@typescript-eslint/types";
+var DEFAULT_OPTIONS4 = {
+  environment: "roblox-ts"
 };
-var require_react_component_keys_default = requireReactComponentKeys;
+var REACT_SOURCES_ROBLOX = new Set(["@rbxts/react", "@rbxts/roact"]);
+var REACT_SOURCES_STANDARD = new Set(["react", "react-dom"]);
+function getReactSources(environment2) {
+  return environment2 === "roblox-ts" ? REACT_SOURCES_ROBLOX : REACT_SOURCES_STANDARD;
+}
+function isReactImport(node, reactSources) {
+  return reactSources.has(node.source.value);
+}
+function isMemoCall(node, memoIdentifiers, reactNamespaces) {
+  const { callee } = node;
+  if (callee.type === TSESTree10.AST_NODE_TYPES.Identifier)
+    return memoIdentifiers.has(callee.name);
+  if (callee.type === TSESTree10.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree10.AST_NODE_TYPES.Identifier && callee.property.type === TSESTree10.AST_NODE_TYPES.Identifier) {
+    return reactNamespaces.has(callee.object.name) && callee.property.name === "memo";
+  }
+  return false;
+}
+function isCreateContextCall(node, createContextIdentifiers, reactNamespaces) {
+  const { callee } = node;
+  if (callee.type === TSESTree10.AST_NODE_TYPES.Identifier)
+    return createContextIdentifiers.has(callee.name);
+  if (callee.type === TSESTree10.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree10.AST_NODE_TYPES.Identifier && callee.property.type === TSESTree10.AST_NODE_TYPES.Identifier) {
+    return reactNamespaces.has(callee.object.name) && callee.property.name === "createContext";
+  }
+  return false;
+}
+function getVariableName(node) {
+  if (node.id.type === TSESTree10.AST_NODE_TYPES.Identifier)
+    return node.id.name;
+  return;
+}
+function isNodeInExport(node) {
+  let current = node;
+  while (current) {
+    const { type: type3 } = current;
+    if (type3 === TSESTree10.AST_NODE_TYPES.ExportNamedDeclaration)
+      return true;
+    if (type3 === TSESTree10.AST_NODE_TYPES.ExportDefaultDeclaration)
+      return true;
+    current = current.parent;
+  }
+  return false;
+}
+function isReferenceExported(reference) {
+  return isNodeInExport(reference.identifier);
+}
+var require_react_display_names_default = createRule({
+  create(context) {
+    const options3 = {
+      ...DEFAULT_OPTIONS4,
+      ...context.options[0]
+    };
+    const reactSources = getReactSources(options3.environment);
+    const memoIdentifiers = new Set;
+    const createContextIdentifiers = new Set;
+    const reactNamespaces = new Set;
+    const trackedVariables = new Map;
+    const displayNameAssignments = new Set;
+    return {
+      "AssignmentExpression[left.type='MemberExpression'][left.property.name='displayName']"(node) {
+        const left = node.left;
+        if (left.object.type === TSESTree10.AST_NODE_TYPES.Identifier) {
+          displayNameAssignments.add(left.object.name);
+        }
+      },
+      ExportDefaultDeclaration(node) {
+        const { declaration } = node;
+        if (declaration.type === TSESTree10.AST_NODE_TYPES.CallExpression) {
+          if (isMemoCall(declaration, memoIdentifiers, reactNamespaces)) {
+            context.report({
+              messageId: "directMemoExport",
+              node
+            });
+            return;
+          }
+          if (isCreateContextCall(declaration, createContextIdentifiers, reactNamespaces)) {
+            context.report({
+              messageId: "directContextExport",
+              node
+            });
+            return;
+          }
+        }
+        if (declaration.type === TSESTree10.AST_NODE_TYPES.Identifier) {
+          const tracked = trackedVariables.get(declaration.name);
+          if (tracked) {
+            trackedVariables.set(declaration.name, {
+              ...tracked,
+              isDefaultExported: true
+            });
+          }
+        }
+      },
+      ExportNamedDeclaration(node) {
+        if (!node.specifiers)
+          return;
+        for (const specifier of node.specifiers) {
+          if (specifier.type !== TSESTree10.AST_NODE_TYPES.ExportSpecifier)
+            continue;
+          const localName = specifier.local.type === TSESTree10.AST_NODE_TYPES.Identifier ? specifier.local.name : specifier.local.value;
+          const exportedName = specifier.exported.type === TSESTree10.AST_NODE_TYPES.Identifier ? specifier.exported.name : specifier.exported.value;
+          if (exportedName === "default") {
+            const tracked = trackedVariables.get(localName);
+            if (tracked) {
+              trackedVariables.set(localName, {
+                ...tracked,
+                isDefaultExported: true
+              });
+            }
+          }
+        }
+      },
+      ImportDeclaration(node) {
+        if (!isReactImport(node, reactSources))
+          return;
+        for (const specifier of node.specifiers) {
+          if (specifier.type === TSESTree10.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === TSESTree10.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+            reactNamespaces.add(specifier.local.name);
+          } else if (specifier.type === TSESTree10.AST_NODE_TYPES.ImportSpecifier) {
+            const importedName = specifier.imported.type === TSESTree10.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+            if (importedName === "memo")
+              memoIdentifiers.add(specifier.local.name);
+            else if (importedName === "createContext")
+              createContextIdentifiers.add(specifier.local.name);
+          }
+        }
+      },
+      "Program:exit"() {
+        for (const [name, tracked] of trackedVariables) {
+          const hasDisplayName = displayNameAssignments.has(name);
+          if (hasDisplayName)
+            continue;
+          const declaredVariables = context.sourceCode.getDeclaredVariables(tracked.node);
+          const variable = declaredVariables.find((declared) => declared.name === name);
+          let isExported = tracked.isDefaultExported;
+          if (variable)
+            isExported ||= variable.references.some(isReferenceExported);
+          const declarationParent = tracked.node.parent;
+          if (declarationParent?.parent?.type === TSESTree10.AST_NODE_TYPES.ExportNamedDeclaration) {
+            isExported = true;
+          }
+          if (isExported) {
+            context.report({
+              data: { name },
+              messageId: tracked.kind === "memo" ? "missingMemoDisplayName" : "missingContextDisplayName",
+              node: tracked.node
+            });
+          }
+        }
+      },
+      VariableDeclarator(node) {
+        if (!node.init || node.init.type !== TSESTree10.AST_NODE_TYPES.CallExpression)
+          return;
+        const name = getVariableName(node);
+        if (!name)
+          return;
+        if (isMemoCall(node.init, memoIdentifiers, reactNamespaces)) {
+          trackedVariables.set(name, {
+            hasDisplayName: false,
+            isDefaultExported: false,
+            kind: "memo",
+            name,
+            node
+          });
+        } else if (isCreateContextCall(node.init, createContextIdentifiers, reactNamespaces)) {
+          trackedVariables.set(name, {
+            hasDisplayName: false,
+            isDefaultExported: false,
+            kind: "context",
+            name,
+            node
+          });
+        }
+      }
+    };
+  },
+  defaultOptions: [DEFAULT_OPTIONS4],
+  meta: {
+    docs: {
+      description: "Require displayName property on exported React.memo components and React.createContext contexts for better debugging."
+    },
+    messages: {
+      directContextExport: "Do not export createContext result directly. Assign to a variable, set displayName, then export.",
+      directMemoExport: "Do not export memo result directly. Assign to a variable, set displayName, then export both named and default.",
+      missingContextDisplayName: "Exported Context '{{name}}' is missing displayName. Add `{{name}}.displayName = \"{{name}}\";` before exporting.",
+      missingMemoDisplayName: "Exported memoized component '{{name}}' is missing displayName. Add `{{name}}.displayName = \"{{name}}\";` before exporting."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          environment: {
+            default: "roblox-ts",
+            description: "The React environment: 'roblox-ts' uses @rbxts/react, 'standard' uses react.",
+            enum: ["roblox-ts", "standard"],
+            type: "string"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  },
+  name: "require-react-display-names"
+});
 // src/rules/strict-component-boundaries.ts
 import { basename, extname, relative } from "node:path";
@@ -22274,7 +22623,7 @@ function isValidFixtureImport(pathParts) {
   const partsBeforeFixture = pathParts.slice(0, fixtureIndex);
   return !hasAnotherComponentInPath(partsBeforeFixture);
 }
-var strictComponentBoundaries = {
+var strict_component_boundaries_default = createRule({
   create(context) {
     const [{ allow = [], maxDepth = 1 } = {}] = context.options;
     const allowPatterns = allow.map(toRegExp);
@@ -22336,21 +22685,21 @@ var strictComponentBoundaries = {
       }
     ],
     type: "problem"
-  }
-};
-var strict_component_boundaries_default = strictComponentBoundaries;
+  },
+  name: "strict-component-boundaries"
+});
 // src/rules/use-exhaustive-dependencies.ts
-import { TSESTree as TSESTree10 } from "@typescript-eslint/types";
+import { TSESTree as TSESTree11 } from "@typescript-eslint/types";
 var FUNCTION_DECLARATIONS = new Set([
-  TSESTree10.AST_NODE_TYPES.FunctionExpression,
-  TSESTree10.AST_NODE_TYPES.ArrowFunctionExpression,
-  TSESTree10.AST_NODE_TYPES.FunctionDeclaration
+  TSESTree11.AST_NODE_TYPES.FunctionExpression,
+  TSESTree11.AST_NODE_TYPES.ArrowFunctionExpression,
+  TSESTree11.AST_NODE_TYPES.FunctionDeclaration
 ]);
 var UNSTABLE_VALUES = new Set([
   ...FUNCTION_DECLARATIONS,
-  TSESTree10.AST_NODE_TYPES.ObjectExpression,
-  TSESTree10.AST_NODE_TYPES.ArrayExpression
+  TSESTree11.AST_NODE_TYPES.ObjectExpression,
+  TSESTree11.AST_NODE_TYPES.ArrayExpression
 ]);
 var testingMetrics = {
   moduleLevelStableConst: 0,
@@ -22434,9 +22783,9 @@ var GLOBAL_BUILTINS = new Set([
 ]);
 function getHookName4(node) {
   const { callee } = node;
-  if (callee.type === TSESTree10.AST_NODE_TYPES.Identifier)
+  if (callee.type === TSESTree11.AST_NODE_TYPES.Identifier)
     return callee.name;
-  if (callee.type === TSESTree10.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree10.AST_NODE_TYPES.Identifier) {
+  if (callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree11.AST_NODE_TYPES.Identifier) {
     return callee.property.name;
   }
   return;
@@ -22444,9 +22793,9 @@ function getHookName4(node) {
 function getMemberExpressionDepth(node) {
   let depth = 0;
   let current = node;
-  if (current.type === TSESTree10.AST_NODE_TYPES.ChainExpression)
+  if (current.type === TSESTree11.AST_NODE_TYPES.ChainExpression)
     current = current.expression;
-  while (current.type === TSESTree10.AST_NODE_TYPES.MemberExpression) {
+  while (current.type === TSESTree11.AST_NODE_TYPES.MemberExpression) {
     depth += 1;
     current = current.object;
   }
@@ -22454,36 +22803,36 @@ function getMemberExpressionDepth(node) {
 }
 function getRootIdentifier(node) {
   let current = node;
-  if (current.type === TSESTree10.AST_NODE_TYPES.ChainExpression)
+  if (current.type === TSESTree11.AST_NODE_TYPES.ChainExpression)
     current = current.expression;
-  while (current.type === TSESTree10.AST_NODE_TYPES.MemberExpression || current.type === TSESTree10.AST_NODE_TYPES.TSNonNullExpression) {
-    if (current.type === TSESTree10.AST_NODE_TYPES.MemberExpression)
+  while (current.type === TSESTree11.AST_NODE_TYPES.MemberExpression || current.type === TSESTree11.AST_NODE_TYPES.TSNonNullExpression) {
+    if (current.type === TSESTree11.AST_NODE_TYPES.MemberExpression)
       current = current.object;
     else
       current = current.expression;
   }
-  return current.type === TSESTree10.AST_NODE_TYPES.Identifier ? current : undefined;
+  return current.type === TSESTree11.AST_NODE_TYPES.Identifier ? current : undefined;
 }
 function nodeToDependencyString(node, sourceCode) {
   return sourceCode.getText(node);
 }
 function nodeToSafeDependencyPath(node, sourceCode) {
-  if (node.type === TSESTree10.AST_NODE_TYPES.Identifier)
+  if (node.type === TSESTree11.AST_NODE_TYPES.Identifier)
     return node.name;
-  if (node.type === TSESTree10.AST_NODE_TYPES.ChainExpression) {
+  if (node.type === TSESTree11.AST_NODE_TYPES.ChainExpression) {
     return nodeToSafeDependencyPath(node.expression, sourceCode);
   }
   if (TS_RUNTIME_EXPRESSIONS.has(node.type)) {
     const expr = node;
     return nodeToSafeDependencyPath(expr.expression, sourceCode);
   }
-  if (node.type === TSESTree10.AST_NODE_TYPES.MemberExpression) {
+  if (node.type === TSESTree11.AST_NODE_TYPES.MemberExpression) {
     const objectPath = nodeToSafeDependencyPath(node.object, sourceCode);
     if (node.computed) {
       const propertyText = sourceCode.getText(node.property);
       return `${objectPath}[${propertyText}]`;
     }
-    const propertyName = node.property.type === TSESTree10.AST_NODE_TYPES.Identifier ? node.property.name : "";
+    const propertyName = node.property.type === TSESTree11.AST_NODE_TYPES.Identifier ? node.property.name : "";
     const separator = node.optional ? "?." : ".";
     return `${objectPath}${separator}${propertyName}`;
   }
@@ -22492,13 +22841,13 @@ function nodeToSafeDependencyPath(node, sourceCode) {
 function isStableArrayIndex(stableResult, node, identifierName) {
   if (!stableResult)
     return false;
-  if (!(stableResult instanceof Set) || node.type !== TSESTree10.AST_NODE_TYPES.VariableDeclarator || node.id.type !== TSESTree10.AST_NODE_TYPES.ArrayPattern) {
+  if (!(stableResult instanceof Set) || node.type !== TSESTree11.AST_NODE_TYPES.VariableDeclarator || node.id.type !== TSESTree11.AST_NODE_TYPES.ArrayPattern) {
     return false;
   }
   const { elements } = node.id;
   let index2 = 0;
   for (const element of elements) {
-    if (element.type === TSESTree10.AST_NODE_TYPES.Identifier && element.name === identifierName) {
+    if (element.type === TSESTree11.AST_NODE_TYPES.Identifier && element.name === identifierName) {
       return stableResult.has(index2);
     }
     index2 += 1;
@@ -22507,7 +22856,7 @@ function isStableArrayIndex(stableResult, node, identifierName) {
 }
 function isStableHookValue(init, node, identifierName, stableHooks) {
   const castInit = init;
-  if (castInit.type !== TSESTree10.AST_NODE_TYPES.CallExpression)
+  if (castInit.type !== TSESTree11.AST_NODE_TYPES.CallExpression)
     return false;
   const hookName = getHookName4(castInit);
   if (!hookName)
@@ -22527,35 +22876,35 @@ function isStableValue(variable, identifierName, stableHooks) {
     const { node, type: type3 } = definition;
     if (STABLE_VALUE_TYPES.has(type3))
       return true;
-    if (type3 === "Variable" && node.type === TSESTree10.AST_NODE_TYPES.VariableDeclarator) {
+    if (type3 === "Variable" && node.type === TSESTree11.AST_NODE_TYPES.VariableDeclarator) {
       const { parent } = node;
-      if (!parent || parent.type !== TSESTree10.AST_NODE_TYPES.VariableDeclaration || parent.kind !== "const") {
+      if (!parent || parent.type !== TSESTree11.AST_NODE_TYPES.VariableDeclaration || parent.kind !== "const") {
         continue;
       }
       const init = node.init;
       if (init && isStableHookValue(init, node, identifierName, stableHooks))
         return true;
-      if (init?.type === TSESTree10.AST_NODE_TYPES.CallExpression) {
+      if (init?.type === TSESTree11.AST_NODE_TYPES.CallExpression) {
         const { callee } = init;
-        if (callee.type === TSESTree10.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree10.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === TSESTree10.AST_NODE_TYPES.Identifier && callee.property.name === "joinBindings") {
+        if (callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression && callee.object.type === TSESTree11.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === TSESTree11.AST_NODE_TYPES.Identifier && callee.property.name === "joinBindings") {
           return true;
         }
-        if (callee.type === TSESTree10.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree10.AST_NODE_TYPES.Identifier && callee.property.name === "map") {
+        if (callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree11.AST_NODE_TYPES.Identifier && callee.property.name === "map") {
           return true;
         }
       }
       if (init) {
-        if (init.type === TSESTree10.AST_NODE_TYPES.Literal || init.type === TSESTree10.AST_NODE_TYPES.TemplateLiteral) {
+        if (init.type === TSESTree11.AST_NODE_TYPES.Literal || init.type === TSESTree11.AST_NODE_TYPES.TemplateLiteral) {
           return true;
         }
-        if (init.type === TSESTree10.AST_NODE_TYPES.UnaryExpression && init.argument.type === TSESTree10.AST_NODE_TYPES.Literal) {
+        if (init.type === TSESTree11.AST_NODE_TYPES.UnaryExpression && init.argument.type === TSESTree11.AST_NODE_TYPES.Literal) {
           return true;
         }
       }
       const variableDefinition = variable.defs.find((definition2) => definition2.node === node);
-      if (variableDefinition && variableDefinition.node.type === TSESTree10.AST_NODE_TYPES.VariableDeclarator) {
+      if (variableDefinition && variableDefinition.node.type === TSESTree11.AST_NODE_TYPES.VariableDeclarator) {
         const declarationParent = variableDefinition.node.parent?.parent;
-        if (declarationParent && (declarationParent.type === TSESTree10.AST_NODE_TYPES.Program || declarationParent.type === TSESTree10.AST_NODE_TYPES.ExportNamedDeclaration)) {
+        if (declarationParent && (declarationParent.type === TSESTree11.AST_NODE_TYPES.Program || declarationParent.type === TSESTree11.AST_NODE_TYPES.ExportNamedDeclaration)) {
           testingMetrics.moduleLevelStableConst += 1;
           return true;
         }
@@ -22568,14 +22917,14 @@ function findTopmostMemberExpression(node) {
   let current = node;
   let { parent } = node;
   while (parent) {
-    if (parent.type === TSESTree10.AST_NODE_TYPES.CallExpression && parent.callee === current) {
-      if (current.type === TSESTree10.AST_NODE_TYPES.MemberExpression)
+    if (parent.type === TSESTree11.AST_NODE_TYPES.CallExpression && parent.callee === current) {
+      if (current.type === TSESTree11.AST_NODE_TYPES.MemberExpression)
         return current.object;
       break;
     }
-    const isMemberParent = parent.type === TSESTree10.AST_NODE_TYPES.MemberExpression && parent.object === current;
-    const isChainParent = parent.type === TSESTree10.AST_NODE_TYPES.ChainExpression;
-    const isNonNullParent = parent.type === TSESTree10.AST_NODE_TYPES.TSNonNullExpression;
+    const isMemberParent = parent.type === TSESTree11.AST_NODE_TYPES.MemberExpression && parent.object === current;
+    const isChainParent = parent.type === TSESTree11.AST_NODE_TYPES.ChainExpression;
+    const isNonNullParent = parent.type === TSESTree11.AST_NODE_TYPES.TSNonNullExpression;
     if (!(isMemberParent || isChainParent || isNonNullParent))
       break;
     current = parent;
@@ -22584,21 +22933,21 @@ function findTopmostMemberExpression(node) {
   return current;
 }
 var IS_CEASE_BOUNDARY = new Set([
-  TSESTree10.AST_NODE_TYPES.FunctionDeclaration,
-  TSESTree10.AST_NODE_TYPES.FunctionExpression,
-  TSESTree10.AST_NODE_TYPES.ArrowFunctionExpression,
-  TSESTree10.AST_NODE_TYPES.VariableDeclarator
+  TSESTree11.AST_NODE_TYPES.FunctionDeclaration,
+  TSESTree11.AST_NODE_TYPES.FunctionExpression,
+  TSESTree11.AST_NODE_TYPES.ArrowFunctionExpression,
+  TSESTree11.AST_NODE_TYPES.VariableDeclarator
 ]);
 var TS_RUNTIME_EXPRESSIONS = new Set([
-  TSESTree10.AST_NODE_TYPES.TSNonNullExpression,
-  TSESTree10.AST_NODE_TYPES.TSAsExpression,
-  TSESTree10.AST_NODE_TYPES.TSSatisfiesExpression,
-  TSESTree10.AST_NODE_TYPES.TSTypeAssertion,
-  TSESTree10.AST_NODE_TYPES.TSInstantiationExpression
+  TSESTree11.AST_NODE_TYPES.TSNonNullExpression,
+  TSESTree11.AST_NODE_TYPES.TSAsExpression,
+  TSESTree11.AST_NODE_TYPES.TSSatisfiesExpression,
+  TSESTree11.AST_NODE_TYPES.TSTypeAssertion,
+  TSESTree11.AST_NODE_TYPES.TSInstantiationExpression
 ]);
 function isComputedPropertyIdentifier(identifier3) {
   const { parent } = identifier3;
-  return parent?.type === TSESTree10.AST_NODE_TYPES.Property && parent.computed && parent.key === identifier3;
+  return parent?.type === TSESTree11.AST_NODE_TYPES.Property && parent.computed && parent.key === identifier3;
 }
 function isInTypePosition(identifier3) {
   let parent = identifier3.parent;
@@ -22652,10 +23001,10 @@ function resolveFunctionReference(identifier3, scope) {
     return;
   for (const definition of variable.defs) {
     const { node } = definition;
-    if (node.type === TSESTree10.AST_NODE_TYPES.FunctionDeclaration) {
+    if (node.type === TSESTree11.AST_NODE_TYPES.FunctionDeclaration) {
       return node;
     }
-    if (node.type === TSESTree10.AST_NODE_TYPES.VariableDeclarator && node.init && (node.init.type === TSESTree10.AST_NODE_TYPES.ArrowFunctionExpression || node.init.type === TSESTree10.AST_NODE_TYPES.FunctionExpression)) {
+    if (node.type === TSESTree11.AST_NODE_TYPES.VariableDeclarator && node.init && (node.init.type === TSESTree11.AST_NODE_TYPES.ArrowFunctionExpression || node.init.type === TSESTree11.AST_NODE_TYPES.FunctionExpression)) {
       return node.init;
     }
   }
@@ -22665,7 +23014,7 @@ function collectCaptures(node, sourceCode) {
   const captures = new Array;
   const captureSet = new Set;
   function visit(current) {
-    if (current.type === TSESTree10.AST_NODE_TYPES.Identifier) {
+    if (current.type === TSESTree11.AST_NODE_TYPES.Identifier) {
       const { name } = current;
       if (captureSet.has(name) || GLOBAL_BUILTINS.has(name) || isInTypePosition(current))
         return;
@@ -22707,21 +23056,21 @@ function collectCaptures(node, sourceCode) {
         }
       }
     }
-    if (current.type === TSESTree10.AST_NODE_TYPES.TSSatisfiesExpression || current.type === TSESTree10.AST_NODE_TYPES.TSAsExpression || current.type === TSESTree10.AST_NODE_TYPES.TSTypeAssertion || current.type === TSESTree10.AST_NODE_TYPES.TSNonNullExpression) {
+    if (current.type === TSESTree11.AST_NODE_TYPES.TSSatisfiesExpression || current.type === TSESTree11.AST_NODE_TYPES.TSAsExpression || current.type === TSESTree11.AST_NODE_TYPES.TSTypeAssertion || current.type === TSESTree11.AST_NODE_TYPES.TSNonNullExpression) {
       visit(current.expression);
       return;
     }
-    if (current.type === TSESTree10.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === TSESTree11.AST_NODE_TYPES.MemberExpression) {
       visit(current.object);
       if (current.computed)
         visit(current.property);
       return;
     }
-    if (current.type === TSESTree10.AST_NODE_TYPES.ChainExpression) {
+    if (current.type === TSESTree11.AST_NODE_TYPES.ChainExpression) {
       visit(current.expression);
       return;
     }
-    if (current.type === TSESTree10.AST_NODE_TYPES.Property) {
+    if (current.type === TSESTree11.AST_NODE_TYPES.Property) {
       if (current.computed)
         visit(current.key);
       visit(current.value);
@@ -22746,7 +23095,7 @@ function parseDependencies(node, sourceCode) {
   for (const element of node.elements) {
     if (!element)
       continue;
-    const actualNode = element.type === TSESTree10.AST_NODE_TYPES.SpreadElement ? element.argument : element;
+    const actualNode = element.type === TSESTree11.AST_NODE_TYPES.SpreadElement ? element.argument : element;
     const name = nodeToDependencyString(actualNode, sourceCode);
     const depth = getMemberExpressionDepth(actualNode);
     dependencies4.push({
@@ -22823,9 +23172,9 @@ var useExhaustiveDependencies = {
         if (closureArgument === undefined)
           return;
         let closureFunction;
-        if (closureArgument.type === TSESTree10.AST_NODE_TYPES.ArrowFunctionExpression || closureArgument.type === TSESTree10.AST_NODE_TYPES.FunctionExpression) {
+        if (closureArgument.type === TSESTree11.AST_NODE_TYPES.ArrowFunctionExpression || closureArgument.type === TSESTree11.AST_NODE_TYPES.FunctionExpression) {
           closureFunction = closureArgument;
-        } else if (closureArgument.type === TSESTree10.AST_NODE_TYPES.Identifier) {
+        } else if (closureArgument.type === TSESTree11.AST_NODE_TYPES.Identifier) {
           const scope = getScope(callNode);
           closureFunction = resolveFunctionReference(closureArgument, scope);
         }
@@ -22859,7 +23208,7 @@ var useExhaustiveDependencies = {
         }
         if (!dependenciesArgument)
           return;
-        if (dependenciesArgument.type !== TSESTree10.AST_NODE_TYPES.ArrayExpression)
+        if (dependenciesArgument.type !== TSESTree11.AST_NODE_TYPES.ArrayExpression)
           return;
         const dependenciesArray = dependenciesArgument;
         const captures = collectCaptures(closureFunction, context.sourceCode);
@@ -23069,7 +23418,7 @@ var useExhaustiveDependencies = {
 var use_exhaustive_dependencies_default = useExhaustiveDependencies;
 // src/rules/use-hook-at-top-level.ts
-import { TSESTree as TSESTree11 } from "@typescript-eslint/types";
+import { TSESTree as TSESTree12 } from "@typescript-eslint/types";
 var HOOK_NAME_PATTERN = /^use[A-Z]/;
 var COMPONENT_NAME_PATTERN2 = /^[A-Z]/;
 function isReactHook(name) {
@@ -23079,23 +23428,23 @@ function isComponent(name) {
   return COMPONENT_NAME_PATTERN2.test(name);
 }
 function isComponentOrHook(node) {
-  if (node.type === TSESTree11.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+  if (node.type === TSESTree12.AST_NODE_TYPES.FunctionDeclaration && node.id) {
     const { name } = node.id;
     return isComponent(name) || isReactHook(name);
   }
-  if (node.type === TSESTree11.AST_NODE_TYPES.FunctionExpression || node.type === TSESTree11.AST_NODE_TYPES.ArrowFunctionExpression) {
+  if (node.type === TSESTree12.AST_NODE_TYPES.FunctionExpression || node.type === TSESTree12.AST_NODE_TYPES.ArrowFunctionExpression) {
     const { parent } = node;
     if (parent === undefined)
       return false;
-    if (parent.type === TSESTree11.AST_NODE_TYPES.VariableDeclarator && parent.id.type === TSESTree11.AST_NODE_TYPES.Identifier) {
+    if (parent.type === TSESTree12.AST_NODE_TYPES.VariableDeclarator && parent.id.type === TSESTree12.AST_NODE_TYPES.Identifier) {
       const { name } = parent.id;
       return isComponent(name) || isReactHook(name);
     }
-    if (parent.type === TSESTree11.AST_NODE_TYPES.Property && parent.key.type === TSESTree11.AST_NODE_TYPES.Identifier) {
+    if (parent.type === TSESTree12.AST_NODE_TYPES.Property && parent.key.type === TSESTree12.AST_NODE_TYPES.Identifier) {
       const { name } = parent.key;
       return isComponent(name) || isReactHook(name);
     }
-    if (parent.type === TSESTree11.AST_NODE_TYPES.MethodDefinition && parent.key.type === TSESTree11.AST_NODE_TYPES.Identifier) {
+    if (parent.type === TSESTree12.AST_NODE_TYPES.MethodDefinition && parent.key.type === TSESTree12.AST_NODE_TYPES.Identifier) {
       const { name } = parent.key;
       return isComponent(name) || isReactHook(name);
     }
@@ -23104,17 +23453,17 @@ function isComponentOrHook(node) {
 }
 function isHookCall(node) {
   const { callee } = node;
-  if (callee.type === TSESTree11.AST_NODE_TYPES.Identifier)
+  if (callee.type === TSESTree12.AST_NODE_TYPES.Identifier)
     return isReactHook(callee.name);
-  if (callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree11.AST_NODE_TYPES.Identifier) {
+  if (callee.type === TSESTree12.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree12.AST_NODE_TYPES.Identifier) {
     return isReactHook(callee.property.name);
   }
   return false;
 }
 var FUNCTION_BOUNDARIES2 = new Set([
-  TSESTree11.AST_NODE_TYPES.FunctionDeclaration,
-  TSESTree11.AST_NODE_TYPES.FunctionExpression,
-  TSESTree11.AST_NODE_TYPES.ArrowFunctionExpression
+  TSESTree12.AST_NODE_TYPES.FunctionDeclaration,
+  TSESTree12.AST_NODE_TYPES.FunctionExpression,
+  TSESTree12.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 function isInFinallyBlock(node) {
   let current = node.parent;
@@ -23123,7 +23472,7 @@ function isInFinallyBlock(node) {
   for (let depth = 0;depth < maxDepth && current; depth += 1) {
     if (FUNCTION_BOUNDARIES2.has(current.type))
       break;
-    if (current.type === TSESTree11.AST_NODE_TYPES.TryStatement) {
+    if (current.type === TSESTree12.AST_NODE_TYPES.TryStatement) {
       let checkNode = node;
       while (checkNode && checkNode !== current) {
         if (checkNode === current.finalizer) {
@@ -23171,14 +23520,14 @@ var useHookAtTopLevel = {
       if (ignoreHooks?.includes(hookName))
         return true;
       if (importSources && Object.keys(importSources).length > 0) {
-        if (node.callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression) {
-          const objectName = node.callee.object.type === TSESTree11.AST_NODE_TYPES.Identifier ? node.callee.object.name : undefined;
+        if (node.callee.type === TSESTree12.AST_NODE_TYPES.MemberExpression) {
+          const objectName = node.callee.object.type === TSESTree12.AST_NODE_TYPES.Identifier ? node.callee.object.name : undefined;
           if (objectName && importSources[objectName] === false)
             return true;
           if (objectName && importSources[objectName] === true)
             return false;
         }
-        if (node.callee.type === TSESTree11.AST_NODE_TYPES.Identifier) {
+        if (node.callee.type === TSESTree12.AST_NODE_TYPES.Identifier) {
           const importSource = importSourceMap.get(hookName);
           if (importSource && importSources[importSource] === false)
             return true;
@@ -23193,7 +23542,7 @@ var useHookAtTopLevel = {
       const current = getCurrentContext();
       const depth = current ? current.functionDepth + 1 : 0;
       const isComponentOrHookFlag = isComponentOrHook(functionNode);
-      if (functionNode.type === TSESTree11.AST_NODE_TYPES.FunctionDeclaration && functionNode.id) {
+      if (functionNode.type === TSESTree12.AST_NODE_TYPES.FunctionDeclaration && functionNode.id) {
         currentFunctionName = functionNode.id.name;
       }
       if (current?.isComponentOrHook) {
@@ -23232,7 +23581,7 @@ var useHookAtTopLevel = {
         if (!isHookCall(callNode))
           return;
         const { callee } = callNode;
-        const hookName = callee.type === TSESTree11.AST_NODE_TYPES.Identifier ? callee.name : callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree11.AST_NODE_TYPES.Identifier ? callee.property.name : undefined;
+        const hookName = callee.type === TSESTree12.AST_NODE_TYPES.Identifier ? callee.name : callee.type === TSESTree12.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree12.AST_NODE_TYPES.Identifier ? callee.property.name : undefined;
         if (!hookName || shouldIgnoreHook(hookName, callNode))
           return;
         const current = getCurrentContext();
@@ -23330,10 +23679,10 @@ var useHookAtTopLevel = {
         if (!configuration.importSources || Object.keys(configuration.importSources).length === 0)
           return;
         for (const specifier of importNode.specifiers) {
-          if (specifier.type !== TSESTree11.AST_NODE_TYPES.ImportSpecifier)
+          if (specifier.type !== TSESTree12.AST_NODE_TYPES.ImportSpecifier)
             continue;
           const { imported } = specifier;
-          if (imported.type !== TSESTree11.AST_NODE_TYPES.Identifier)
+          if (imported.type !== TSESTree12.AST_NODE_TYPES.Identifier)
             continue;
           if (isReactHook(imported.name))
             importSourceMap.set(specifier.local.name, source);
@@ -23509,6 +23858,9 @@ function createNoUselessUseSpringOptions(options3 = {}) {
 function createPreferPatternReplacementsOptions(patterns2 = []) {
   return { patterns: patterns2 };
 }
+function createRequireReactDisplayNamesOptions(options3 = {}) {
+  return { environment: "roblox-ts", ...options3 };
+}
 // src/index.ts
 var rules = {
@@ -23538,6 +23890,7 @@ var rules = {
   "require-named-effect-functions": require_named_effect_functions_default,
   "require-paired-calls": require_paired_calls_default,
   "require-react-component-keys": require_react_component_keys_default,
+  "require-react-display-names": require_react_display_names_default,
   "strict-component-boundaries": strict_component_boundaries_default,
   "use-exhaustive-dependencies": use_exhaustive_dependencies_default,
   "use-hook-at-top-level": use_hook_at_top_level_default
@@ -23562,6 +23915,7 @@ var recommended = {
     "cease-nonsense/prefer-udim2-shorthand": "error",
     "cease-nonsense/require-named-effect-functions": "error",
     "cease-nonsense/require-react-component-keys": "error",
+    "cease-nonsense/require-react-display-names": "error",
     "cease-nonsense/use-exhaustive-dependencies": "error",
     "cease-nonsense/use-hook-at-top-level": "error"
   }
@@ -23577,6 +23931,7 @@ export {
   src_default as default,
   createUseHookAtTopLevelOptions,
   createUseExhaustiveDependenciesOptions,
+  createRequireReactDisplayNamesOptions,
   createRequirePairedCallsOptions,
   createReactKeysOptions,
   createPreferPatternReplacementsOptions,
@@ -23591,4 +23946,4 @@ export {
   createBanInstancesOptions
 };
-//# debugId=928BD58DAA13C57A64756E2164756E21
+//# debugId=A19451816DAA8A5E64756E2164756E21