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

package/dist/index.js

@@ -9071,7 +9071,7 @@ function ConstructorOptions(type) {
 }
 
 // node_modules/typebox/build/type/types/function.mjs
-function Function2(parameters, returnType, options = {}) {
+function _Function_(parameters, returnType, options = {}) {
   return exports_memory.Create({ ["~kind"]: "Function" }, { type: "function", parameters, returnType }, options);
 }
 function IsFunction3(value) {
@@ -9603,7 +9603,6 @@ function _Object_(properties, options = {}) {
   const required = requiredKeys.length > 0 ? { required: requiredKeys } : {};
   return exports_memory.Create({ "~kind": "Object" }, { type: "object", ...required, properties }, options);
 }
-var Object2 = _Object_;
 function IsObject3(value) {
   return IsKind(value, "Object");
 }
@@ -9641,6 +9640,87 @@ function IsString4(value) {
   return IsKind(value, "String");
 }
 
+// node_modules/typebox/build/type/types/union.mjs
+function Union(anyOf, options = {}) {
+  return exports_memory.Create({ "~kind": "Union" }, { anyOf }, options);
+}
+function IsUnion(value) {
+  return IsKind(value, "Union");
+}
+function UnionOptions(type) {
+  return exports_memory.Discard(type, ["~kind", "anyOf"]);
+}
+
+// node_modules/typebox/build/type/engine/patterns/pattern.mjs
+function ParsePatternIntoTypes(pattern) {
+  const parsed = Pattern(pattern);
+  const result = exports_guard.IsEqual(parsed.length, 2) ? parsed[0] : [];
+  return result;
+}
+
+// node_modules/typebox/build/type/engine/template-literal/finite.mjs
+function FromLiteral(value) {
+  return true;
+}
+function FromTypesReduce(types) {
+  const [left, ...right] = types;
+  return IsSchema(left) ? FromType2(left) ? FromTypesReduce(right) : false : true;
+}
+function FromTypes(types) {
+  const result = exports_guard.IsEqual(types.length, 0) ? false : FromTypesReduce(types);
+  return result;
+}
+function FromType2(type) {
+  return IsUnion(type) ? FromTypes(type.anyOf) : IsLiteral(type) ? FromLiteral(type.const) : false;
+}
+function TemplateLiteralFinite(types) {
+  const result = FromTypes(types);
+  return result;
+}
+
+// node_modules/typebox/build/type/engine/template-literal/create.mjs
+function TemplateLiteralCreate(pattern) {
+  return exports_memory.Create({ ["~kind"]: "TemplateLiteral" }, { type: "string", pattern }, {});
+}
+
+// node_modules/typebox/build/type/engine/template-literal/decode.mjs
+function FromLiteralPush(variants, value, result = []) {
+  const [left, ...right] = variants;
+  return exports_guard.IsString(left) ? FromLiteralPush(right, value, [...result, `${left}${value}`]) : result;
+}
+function FromLiteral2(variants, value) {
+  return exports_guard.IsEqual(variants.length, 0) ? [`${value}`] : FromLiteralPush(variants, value);
+}
+function FromUnion(variants, types, result = []) {
+  const [left, ...right] = types;
+  return IsSchema(left) ? FromUnion(variants, right, [...result, ...FromType3(variants, left)]) : result;
+}
+function FromType3(variants, type) {
+  const result = IsUnion(type) ? FromUnion(variants, type.anyOf) : IsLiteral(type) ? FromLiteral2(variants, type.const) : Unreachable();
+  return result;
+}
+function DecodeFromSpan(variants, types) {
+  const [left, ...right] = types;
+  return IsSchema(left) ? DecodeFromSpan(FromType3(variants, left), right) : variants;
+}
+function VariantsToLiterals(variants) {
+  return variants.map((variant) => Literal(variant));
+}
+function DecodeTypesAsUnion(types) {
+  const variants = DecodeFromSpan([], types);
+  const literals = VariantsToLiterals(variants);
+  const result = Union(literals);
+  return result;
+}
+function DecodeTypes(types) {
+  return exports_guard.IsEqual(types.length, 0) ? Unreachable() : exports_guard.IsEqual(types.length, 1) && IsLiteral(types[0]) ? types[0] : DecodeTypesAsUnion(types);
+}
+function TemplateLiteralDecode(pattern) {
+  const types = ParsePatternIntoTypes(pattern);
+  const result = exports_guard.IsEqual(types.length, 0) ? String2() : TemplateLiteralFinite(types) ? DecodeTypes(types) : TemplateLiteralCreate(pattern);
+  return result;
+}
+
 // node_modules/typebox/build/type/engine/record/record-create.mjs
 function CreateRecord(key, value) {
   const type = "object";
@@ -9669,7 +9749,7 @@ function RecordPattern(type) {
 }
 function RecordKey(type) {
   const pattern = RecordPattern(type);
-  const result = exports_guard.IsEqual(pattern, IntegerKey) ? Integer() : exports_guard.IsEqual(pattern, NumberKey) ? Number2() : String2();
+  const result = exports_guard.IsEqual(pattern, StringKey) ? String2() : exports_guard.IsEqual(pattern, IntegerKey) ? Integer() : exports_guard.IsEqual(pattern, NumberKey) ? Number2() : TemplateLiteralDecode(pattern);
   return result;
 }
 function RecordValue(type) {
@@ -9710,16 +9790,6 @@ function Undefined(options) {
 function IsUndefined3(value) {
   return IsKind(value, "Undefined");
 }
-// node_modules/typebox/build/type/types/union.mjs
-function Union(anyOf, options = {}) {
-  return exports_memory.Create({ "~kind": "Union" }, { anyOf }, options);
-}
-function IsUnion(value) {
-  return IsKind(value, "Union");
-}
-function UnionOptions(type) {
-  return exports_memory.Discard(type, ["~kind", "anyOf"]);
-}
 // node_modules/typebox/build/type/types/unsafe.mjs
 function Unsafe(schema) {
   return exports_memory.Create({ ["~kind"]: "Unsafe" }, {}, schema);
@@ -9811,7 +9881,7 @@ function KeywordAnyMapping(input) {
   return Any();
 }
 function KeywordObjectMapping(input) {
-  return Object2({});
+  return _Object_({});
 }
 function KeywordNeverMapping(input) {
   return Never();
@@ -9972,7 +10042,7 @@ function PropertiesMapping(input) {
 function _Object_Mapping(input) {
   const [properties2, patternProperties] = input;
   const options = exports_guard.IsEqual(exports_guard.Keys(patternProperties).length, 0) ? {} : { patternProperties };
-  return Object2(properties2, options);
+  return _Object_(properties2, options);
 }
 function ElementNamedMapping(input) {
   return exports_guard.IsEqual(input.length, 5) ? ReadonlyAdd(OptionalAdd(input[4])) : exports_guard.IsEqual(input.length, 3) ? input[2] : exports_guard.IsEqual(input.length, 4) ? exports_guard.IsEqual(input[2], "readonly") ? ReadonlyAdd(input[3]) : OptionalAdd(input[3]) : Unreachable2();
@@ -10020,7 +10090,7 @@ function ParameterListMapping(input) {
   return Delimited(input);
 }
 function _Function_Mapping(input) {
-  return Function2(input[1], input[4]);
+  return _Function_(input[1], input[4]);
 }
 function ConstructorMapping(input) {
   return Constructor(input[2], input[5]);
@@ -10439,7 +10509,7 @@ var KeyOf = (input) => If2(If2(If2(Const("keyof", input), ([_0, input2]) => [[_0
 var IndexArray_0 = (input, result = []) => If2(If2(If2(Const("[", input), ([_0, input2]) => If2(Type(input2), ([_1, input3]) => If2(Const("]", input3), ([_2, input4]) => [[_0, _1, _2], input4]))), ([_0, input2]) => [_0, input2], () => If2(If2(Const("[", input), ([_0, input2]) => If2(Const("]", input2), ([_1, input3]) => [[_0, _1], input3])), ([_0, input2]) => [_0, input2], () => [])), ([_0, input2]) => IndexArray_0(input2, [...result, _0]), () => [result, input]);
 var IndexArray = (input) => If2(IndexArray_0(input), ([_0, input2]) => [IndexArrayMapping(_0), input2]);
 var Extends = (input) => If2(If2(If2(Const("extends", input), ([_0, input2]) => If2(Type(input2), ([_1, input3]) => If2(Const("?", input3), ([_2, input4]) => If2(Type(input4), ([_3, input5]) => If2(Const(":", input5), ([_4, input6]) => If2(Type(input6), ([_5, input7]) => [[_0, _1, _2, _3, _4, _5], input7])))))), ([_0, input2]) => [_0, input2], () => If2([[], input], ([_0, input2]) => [_0, input2], () => [])), ([_0, input2]) => [ExtendsMapping(_0), input2]);
-var Base2 = (input) => If2(If2(If2(Const("(", input), ([_0, input2]) => If2(Type(input2), ([_1, input3]) => If2(Const(")", input3), ([_2, input4]) => [[_0, _1, _2], input4]))), ([_0, input2]) => [_0, input2], () => If2(Keyword(input), ([_0, input2]) => [_0, input2], () => If2(_Object_2(input), ([_0, input2]) => [_0, input2], () => If2(Tuple2(input), ([_0, input2]) => [_0, input2], () => If2(TemplateLiteral(input), ([_0, input2]) => [_0, input2], () => If2(Literal2(input), ([_0, input2]) => [_0, input2], () => If2(Constructor2(input), ([_0, input2]) => [_0, input2], () => If2(_Function_(input), ([_0, input2]) => [_0, input2], () => If2(Mapped(input), ([_0, input2]) => [_0, input2], () => If2(Options(input), ([_0, input2]) => [_0, input2], () => If2(GenericCall(input), ([_0, input2]) => [_0, input2], () => If2(Reference(input), ([_0, input2]) => [_0, input2], () => [])))))))))))), ([_0, input2]) => [BaseMapping(_0), input2]);
+var Base2 = (input) => If2(If2(If2(Const("(", input), ([_0, input2]) => If2(Type(input2), ([_1, input3]) => If2(Const(")", input3), ([_2, input4]) => [[_0, _1, _2], input4]))), ([_0, input2]) => [_0, input2], () => If2(Keyword(input), ([_0, input2]) => [_0, input2], () => If2(_Object_2(input), ([_0, input2]) => [_0, input2], () => If2(Tuple2(input), ([_0, input2]) => [_0, input2], () => If2(TemplateLiteral(input), ([_0, input2]) => [_0, input2], () => If2(Literal2(input), ([_0, input2]) => [_0, input2], () => If2(Constructor2(input), ([_0, input2]) => [_0, input2], () => If2(_Function_2(input), ([_0, input2]) => [_0, input2], () => If2(Mapped(input), ([_0, input2]) => [_0, input2], () => If2(Options(input), ([_0, input2]) => [_0, input2], () => If2(GenericCall(input), ([_0, input2]) => [_0, input2], () => If2(Reference(input), ([_0, input2]) => [_0, input2], () => [])))))))))))), ([_0, input2]) => [BaseMapping(_0), input2]);
 var Factor = (input) => If2(If2(KeyOf(input), ([_0, input2]) => If2(Base2(input2), ([_1, input3]) => If2(IndexArray(input3), ([_2, input4]) => If2(Extends(input4), ([_3, input5]) => [[_0, _1, _2, _3], input5])))), ([_0, input2]) => [FactorMapping(_0), input2]);
 var ExprTermTail = (input) => If2(If2(If2(Const("&", input), ([_0, input2]) => If2(Factor(input2), ([_1, input3]) => If2(ExprTermTail(input3), ([_2, input4]) => [[_0, _1, _2], input4]))), ([_0, input2]) => [_0, input2], () => If2([[], input], ([_0, input2]) => [_0, input2], () => [])), ([_0, input2]) => [ExprTermTailMapping(_0), input2]);
 var ExprTerm = (input) => If2(If2(Factor(input), ([_0, input2]) => If2(ExprTermTail(input2), ([_1, input3]) => [[_0, _1], input3])), ([_0, input2]) => [ExprTermMapping(_0), input2]);
@@ -10483,7 +10553,7 @@ var ParameterBase = (input) => If2(If2(ParameterReadonlyOptional(input), ([_0, i
 var Parameter2 = (input) => If2(If2(If2(Const("...", input), ([_0, input2]) => If2(ParameterBase(input2), ([_1, input3]) => [[_0, _1], input3])), ([_0, input2]) => [_0, input2], () => If2(If2(ParameterBase(input), ([_0, input2]) => [[_0], input2]), ([_0, input2]) => [_0, input2], () => [])), ([_0, input2]) => [ParameterMapping(_0), input2]);
 var ParameterList_0 = (input, result = []) => If2(If2(Parameter2(input), ([_0, input2]) => If2(Const(",", input2), ([_1, input3]) => [[_0, _1], input3])), ([_0, input2]) => ParameterList_0(input2, [...result, _0]), () => [result, input]);
 var ParameterList = (input) => If2(If2(ParameterList_0(input), ([_0, input2]) => If2(If2(If2(Parameter2(input2), ([_02, input3]) => [[_02], input3]), ([_02, input3]) => [_02, input3], () => If2([[], input2], ([_02, input3]) => [_02, input3], () => [])), ([_1, input3]) => [[_0, _1], input3])), ([_0, input2]) => [ParameterListMapping(_0), input2]);
-var _Function_ = (input) => If2(If2(Const("(", input), ([_0, input2]) => If2(ParameterList(input2), ([_1, input3]) => If2(Const(")", input3), ([_2, input4]) => If2(Const("=>", input4), ([_3, input5]) => If2(Type(input5), ([_4, input6]) => [[_0, _1, _2, _3, _4], input6]))))), ([_0, input2]) => [_Function_Mapping(_0), input2]);
+var _Function_2 = (input) => If2(If2(Const("(", input), ([_0, input2]) => If2(ParameterList(input2), ([_1, input3]) => If2(Const(")", input3), ([_2, input4]) => If2(Const("=>", input4), ([_3, input5]) => If2(Type(input5), ([_4, input6]) => [[_0, _1, _2, _3, _4], input6]))))), ([_0, input2]) => [_Function_Mapping(_0), input2]);
 var Constructor2 = (input) => If2(If2(Const("new", input), ([_0, input2]) => If2(Const("(", input2), ([_1, input3]) => If2(ParameterList(input3), ([_2, input4]) => If2(Const(")", input4), ([_3, input5]) => If2(Const("=>", input5), ([_4, input6]) => If2(Type(input6), ([_5, input7]) => [[_0, _1, _2, _3, _4, _5], input7])))))), ([_0, input2]) => [ConstructorMapping(_0), input2]);
 var MappedReadonly = (input) => If2(If2(If2(Const("+", input), ([_0, input2]) => If2(Const("readonly", input2), ([_1, input3]) => [[_0, _1], input3])), ([_0, input2]) => [_0, input2], () => If2(If2(Const("-", input), ([_0, input2]) => If2(Const("readonly", input2), ([_1, input3]) => [[_0, _1], input3])), ([_0, input2]) => [_0, input2], () => If2(If2(Const("readonly", input), ([_0, input2]) => [[_0], input2]), ([_0, input2]) => [_0, input2], () => If2([[], input], ([_0, input2]) => [_0, input2], () => [])))), ([_0, input2]) => [MappedReadonlyMapping(_0), input2]);
 var MappedOptional = (input) => If2(If2(If2(Const("+", input), ([_0, input2]) => If2(Const("?", input2), ([_1, input3]) => [[_0, _1], input3])), ([_0, input2]) => [_0, input2], () => If2(If2(Const("-", input), ([_0, input2]) => If2(Const("?", input2), ([_1, input3]) => [[_0, _1], input3])), ([_0, input2]) => [_0, input2], () => If2(If2(Const("?", input), ([_0, input2]) => [[_0], input2]), ([_0, input2]) => [_0, input2], () => If2([[], input], ([_0, input2]) => [_0, input2], () => [])))), ([_0, input2]) => [MappedOptionalMapping(_0), input2]);
@@ -10591,72 +10661,6 @@ function IsExtendsTrueLike(value) {
   return IsExtendsUnion(value) || IsExtendsTrue(value);
 }
 
-// node_modules/typebox/build/type/engine/patterns/pattern.mjs
-function ParsePatternIntoTypes(pattern) {
-  const parsed = Pattern(pattern);
-  const result = exports_guard.IsEqual(parsed.length, 2) ? parsed[0] : Unreachable();
-  return result;
-}
-
-// node_modules/typebox/build/type/engine/template-literal/finite.mjs
-function FromLiteral(value) {
-  return true;
-}
-function FromTypesReduce(types) {
-  const [left, ...right] = types;
-  return IsSchema(left) ? FromType2(left) ? FromTypesReduce(right) : false : true;
-}
-function FromTypes(types) {
-  const result = exports_guard.IsEqual(types.length, 0) ? false : FromTypesReduce(types);
-  return result;
-}
-function FromType2(type) {
-  return IsUnion(type) ? FromTypes(type.anyOf) : IsLiteral(type) ? FromLiteral(type.const) : false;
-}
-function TemplateLiteralFinite(types) {
-  const result = FromTypes(types);
-  return result;
-}
-
-// node_modules/typebox/build/type/engine/template-literal/decode.mjs
-function FromLiteralPush(variants, value, result = []) {
-  const [left, ...right] = variants;
-  return exports_guard.IsString(left) ? FromLiteralPush(right, value, [...result, `${left}${value}`]) : result;
-}
-function FromLiteral2(variants, value) {
-  return exports_guard.IsEqual(variants.length, 0) ? [`${value}`] : FromLiteralPush(variants, value);
-}
-function FromUnion(variants, types, result = []) {
-  const [left, ...right] = types;
-  return IsSchema(left) ? FromUnion(variants, right, [...result, ...FromType3(variants, left)]) : result;
-}
-function FromType3(variants, type) {
-  const result = IsUnion(type) ? FromUnion(variants, type.anyOf) : IsLiteral(type) ? FromLiteral2(variants, type.const) : Unreachable();
-  return result;
-}
-function DecodeFromSpan(variants, types) {
-  const [left, ...right] = types;
-  return IsSchema(left) ? DecodeFromSpan(FromType3(variants, left), right) : variants;
-}
-function VariantsToLiterals(variants) {
-  return variants.map((variant) => Literal(variant));
-}
-function DecodeTypesAsUnion(types) {
-  const variants = DecodeFromSpan([], types);
-  const literals = VariantsToLiterals(variants);
-  const result = Union(literals);
-  return result;
-}
-function DecodeTypes(types) {
-  return exports_guard.IsEqual(types.length, 0) ? Unreachable() : exports_guard.IsEqual(types.length, 1) && IsLiteral(types[0]) ? types[0] : DecodeTypesAsUnion(types);
-}
-function TemplateLiteralDecode(pattern) {
-  const types = ParsePatternIntoTypes(pattern);
-  const finite = TemplateLiteralFinite(types);
-  const result = finite ? DecodeTypes(types) : String2();
-  return result;
-}
-
 // node_modules/typebox/build/type/engine/enum/enum-to-union.mjs
 function FromEnumValue(value) {
   return exports_guard.IsString(value) || exports_guard.IsNumber(value) ? Literal(value) : exports_guard.IsNull(value) ? Null() : Never();
@@ -10823,7 +10827,7 @@ function TupleElementsToProperties(types) {
 }
 function TupleToObject(type) {
   const properties2 = TupleElementsToProperties(type.items);
-  const result = Object2(properties2);
+  const result = _Object_(properties2);
   return result;
 }
 
@@ -10858,7 +10862,7 @@ function Composite(left, right) {
   const leftProperties = GetProperties(left);
   const rightProperties = GetProperties(right);
   const properties2 = CompositeProperties(leftProperties, rightProperties);
-  return Object2(properties2);
+  return _Object_(properties2);
 }
 
 // node_modules/typebox/build/type/engine/evaluate/narrow.mjs
@@ -10868,18 +10872,22 @@ function Narrow(left, right) {
 }
 
 // node_modules/typebox/build/type/engine/evaluate/distribute.mjs
-function CanDistribute(type) {
+function IsObjectLike(type) {
   return IsObject3(type) || IsTuple(type);
 }
-function DistributeNormalize(type) {
-  return IsIntersect(type) ? EvaluateIntersect(type.allOf) : type;
+function IsUnionOperand(left, right) {
+  const isUnionLeft = IsUnion(left);
+  const isUnionRight = IsUnion(right);
+  const result = isUnionLeft || isUnionRight;
+  return result;
 }
 function DistributeOperation(left, right) {
-  const normalLeft = DistributeNormalize(left);
-  const normalRight = DistributeNormalize(right);
-  const isObjectLeft = CanDistribute(normalLeft);
-  const IsObjectRight = CanDistribute(normalRight);
-  const result = isObjectLeft && IsObjectRight ? Composite(EvaluateType(normalLeft), normalRight) : isObjectLeft && !IsObjectRight ? EvaluateType(normalLeft) : !isObjectLeft && IsObjectRight ? normalRight : Narrow(EvaluateType(normalLeft), normalRight);
+  const evaluatedLeft = EvaluateType(left);
+  const evaluatedRight = EvaluateType(right);
+  const isUnionOperand = IsUnionOperand(evaluatedLeft, evaluatedRight);
+  const isObjectLeft = IsObjectLike(evaluatedLeft);
+  const IsObjectRight = IsObjectLike(evaluatedRight);
+  const result = isUnionOperand ? EvaluateIntersect([evaluatedLeft, evaluatedRight]) : isObjectLeft && IsObjectRight ? Composite(evaluatedLeft, evaluatedRight) : isObjectLeft && !IsObjectRight ? evaluatedLeft : !isObjectLeft && IsObjectRight ? evaluatedRight : Narrow(evaluatedLeft, evaluatedRight);
   return result;
 }
 function DistributeType(type, types, result = []) {
@@ -11026,7 +11034,7 @@ function ExtendsObjectToObject(inferred, left, right) {
   return ExtendsProperties(inferred, left, right);
 }
 function ExtendsObject(inferred, left, right) {
-  return IsObject3(right) ? ExtendsObjectToObject(inferred, left, right.properties) : ExtendsRight(inferred, Object2(left), right);
+  return IsObject3(right) ? ExtendsObjectToObject(inferred, left, right.properties) : ExtendsRight(inferred, _Object_(left), right);
 }
 
 // node_modules/typebox/build/type/extends/promise.mjs
@@ -11246,7 +11254,7 @@ function FromTypes4(types) {
   }, []);
 }
 function FromType6(type) {
-  return IsRef(type) ? FromRef4(type.$ref) : IsArray3(type) ? Array2(FromType6(type.items), ArrayOptions(type)) : IsAsyncIterator3(type) ? AsyncIterator(FromType6(type.iteratorItems)) : IsConstructor3(type) ? Constructor(FromTypes4(type.parameters), FromType6(type.instanceType)) : IsFunction3(type) ? Function2(FromTypes4(type.parameters), FromType6(type.returnType)) : IsIntersect(type) ? Intersect(FromTypes4(type.allOf)) : IsIterator3(type) ? Iterator(FromType6(type.iteratorItems)) : IsObject3(type) ? Object2(FromProperties3(type.properties)) : IsPromise(type) ? Promise2(FromType6(type.item)) : IsRecord(type) ? Record(RecordKey(type), FromType6(RecordValue(type))) : IsUnion(type) ? Union(FromTypes4(type.anyOf)) : IsTuple(type) ? Tuple(FromTypes4(type.items)) : type;
+  return IsRef(type) ? FromRef4(type.$ref) : IsArray3(type) ? Array2(FromType6(type.items), ArrayOptions(type)) : IsAsyncIterator3(type) ? AsyncIterator(FromType6(type.iteratorItems)) : IsConstructor3(type) ? Constructor(FromTypes4(type.parameters), FromType6(type.instanceType)) : IsFunction3(type) ? _Function_(FromTypes4(type.parameters), FromType6(type.returnType)) : IsIntersect(type) ? Intersect(FromTypes4(type.allOf)) : IsIterator3(type) ? Iterator(FromType6(type.iteratorItems)) : IsObject3(type) ? _Object_(FromProperties3(type.properties)) : IsPromise(type) ? Promise2(FromType6(type.item)) : IsRecord(type) ? Record(RecordKey(type), FromType6(RecordValue(type))) : IsUnion(type) ? Union(FromTypes4(type.anyOf)) : IsTuple(type) ? Tuple(FromTypes4(type.items)) : type;
 }
 function CyclicAnyFromParameters(defs, ref2) {
   return ref2 in defs ? FromType6(defs[ref2]) : Unknown();
@@ -11258,7 +11266,7 @@ function CyclicExtends(type) {
 function CyclicInterface(context, heritage, properties2) {
   const instantiatedHeritage = InstantiateTypes(context, { callstack: [] }, heritage);
   const instantiatedProperties = InstantiateProperties({}, { callstack: [] }, properties2);
-  const evaluatedInterface = EvaluateIntersect([...instantiatedHeritage, Object2(instantiatedProperties)]);
+  const evaluatedInterface = EvaluateIntersect([...instantiatedHeritage, _Object_(instantiatedProperties)]);
   return evaluatedInterface;
 }
 function CyclicDefinitions(context, dependencies) {
@@ -11769,7 +11777,7 @@ function FromType9(type) {
 // node_modules/typebox/build/type/engine/object/collapse.mjs
 function CollapseToObject(type) {
   const properties2 = FromType9(type);
-  const result = Object2(properties2);
+  const result = _Object_(properties2);
   return result;
 }
 // node_modules/typebox/build/type/engine/indexed/instantiate.mjs
@@ -11814,7 +11822,7 @@ function InstanceTypeInstantiate(context, state, type, options = {}) {
 function InterfaceImmediate(context, state, heritage, properties2, options) {
   const instantiatedHeritage = InstantiateTypes(context, { callstack: [] }, heritage);
   const instantiatedProperties = InstantiateProperties(context, { callstack: [] }, properties2);
-  const evaluatedInterface = EvaluateIntersect([...instantiatedHeritage, Object2(instantiatedProperties)]);
+  const evaluatedInterface = EvaluateIntersect([...instantiatedHeritage, _Object_(instantiatedProperties)]);
   return exports_memory.Update(evaluatedInterface, {}, options);
 }
 function InterfaceInstantiate(context, state, heritage, properties2, options) {
@@ -11934,7 +11942,7 @@ function MappedProperties(context, state, identifier2, keys, as, type) {
 function MappedAction(context, state, identifier2, key, as, type) {
   const keys = MappedKeys(key);
   const mapped = MappedProperties(context, state, identifier2, keys, as, type);
-  const result = Object2(mapped);
+  const result = _Object_(mapped);
   return result;
 }
 function MappedImmediate(context, state, identifier2, key, as, property, options) {
@@ -12019,7 +12027,7 @@ function OmitAction(type, indexer) {
   const indexable = ToIndexable(type);
   const indexableKeys = ToIndexableKeys(indexer);
   const omitted = FromKeys(indexable, indexableKeys);
-  const result = Object2(omitted);
+  const result = _Object_(omitted);
   return result;
 }
 function OmitImmediate(context, state, type, indexer, options) {
@@ -12101,13 +12109,13 @@ function FromObject6(properties2) {
   const mapped = exports_guard.Keys(properties2).reduce((result2, left) => {
     return { ...result2, [left]: Optional(properties2[left]) };
   }, {});
-  const result = Object2(mapped);
+  const result = _Object_(mapped);
   return result;
 }
 
 // node_modules/typebox/build/type/engine/partial/from-type.mjs
 function FromType11(type) {
-  return IsCyclic(type) ? FromCyclic3(type.$defs, type.$ref) : IsIntersect(type) ? FromIntersect3(type.allOf) : IsUnion(type) ? FromUnion6(type.anyOf) : IsObject3(type) ? FromObject6(type.properties) : Object2({});
+  return IsCyclic(type) ? FromCyclic3(type.$defs, type.$ref) : IsIntersect(type) ? FromIntersect3(type.allOf) : IsUnion(type) ? FromUnion6(type.anyOf) : IsObject3(type) ? FromObject6(type.properties) : _Object_({});
 }
 
 // node_modules/typebox/build/type/engine/partial/instantiate.mjs
@@ -12139,7 +12147,7 @@ function PickAction(type, indexer) {
   const indexable = ToIndexable(type);
   const keys = ToIndexableKeys(indexer);
   const applied = FromKeys2(indexable, keys);
-  const result = Object2(applied);
+  const result = _Object_(applied);
   return result;
 }
 function PickImmediate(context, state, type, indexer, options) {
@@ -12184,7 +12192,7 @@ function FromObject7(properties2) {
   const mapped = exports_guard.Keys(properties2).reduce((result2, left) => {
     return { ...result2, [left]: Readonly(properties2[left]) };
   }, {});
-  const result = Object2(mapped);
+  const result = _Object_(mapped);
   return result;
 }
 
@@ -12221,7 +12229,7 @@ function FromAnyKey(value) {
 
 // node_modules/typebox/build/type/engine/record/from-key-boolean.mjs
 function FromBooleanKey(value) {
-  return Object2({ true: value, false: value });
+  return _Object_({ true: value, false: value });
 }
 
 // node_modules/typebox/build/type/engine/record/from-key-enum.mjs
@@ -12246,7 +12254,7 @@ function FromIntersectKey(types, value) {
 
 // node_modules/typebox/build/type/engine/record/from-key-literal.mjs
 function FromLiteralKey(key, value) {
-  return exports_guard.IsString(key) || exports_guard.IsNumber(key) ? Object2({ [key]: value }) : exports_guard.IsEqual(key, false) ? Object2({ false: value }) : exports_guard.IsEqual(key, true) ? Object2({ true: value }) : Object2({});
+  return exports_guard.IsString(key) || exports_guard.IsNumber(key) ? _Object_({ [key]: value }) : exports_guard.IsEqual(key, false) ? _Object_({ false: value }) : exports_guard.IsEqual(key, true) ? _Object_({ true: value }) : _Object_({});
 }
 
 // node_modules/typebox/build/type/engine/record/from-key-number.mjs
@@ -12282,7 +12290,7 @@ function CreateProperties(types, value) {
 }
 function CreateObject(types, value) {
   const properties2 = CreateProperties(types, value);
-  const result = Object2(properties2);
+  const result = _Object_(properties2);
   return result;
 }
 function FromUnionKey(types, value) {
@@ -12293,7 +12301,7 @@ function FromUnionKey(types, value) {
 
 // node_modules/typebox/build/type/engine/record/from-key.mjs
 function FromKey(key, value) {
-  const result = IsAny(key) ? FromAnyKey(value) : IsBoolean4(key) ? FromBooleanKey(value) : IsEnum(key) ? FromEnumKey(key.enum, value) : IsInteger3(key) ? FromIntegerKey(key, value) : IsIntersect(key) ? FromIntersectKey(key.allOf, value) : IsLiteral(key) ? FromLiteralKey(key.const, value) : IsNumber4(key) ? FromNumberKey(key, value) : IsUnion(key) ? FromUnionKey(key.anyOf, value) : IsString4(key) ? FromStringKey(key, value) : IsTemplateLiteral(key) ? FromTemplateKey(key.pattern, value) : Object2({});
+  const result = IsAny(key) ? FromAnyKey(value) : IsBoolean4(key) ? FromBooleanKey(value) : IsEnum(key) ? FromEnumKey(key.enum, value) : IsInteger3(key) ? FromIntegerKey(key, value) : IsIntersect(key) ? FromIntersectKey(key.allOf, value) : IsLiteral(key) ? FromLiteralKey(key.const, value) : IsNumber4(key) ? FromNumberKey(key, value) : IsUnion(key) ? FromUnionKey(key.anyOf, value) : IsString4(key) ? FromStringKey(key, value) : IsTemplateLiteral(key) ? FromTemplateKey(key.pattern, value) : _Object_({});
   return result;
 }
 
@@ -12337,13 +12345,13 @@ function FromObject8(properties2) {
   const mapped = exports_guard.Keys(properties2).reduce((result2, left) => {
     return { ...result2, [left]: OptionalRemove(properties2[left]) };
   }, {});
-  const result = Object2(mapped);
+  const result = _Object_(mapped);
   return result;
 }
 
 // node_modules/typebox/build/type/engine/required/from-type.mjs
 function FromType13(type) {
-  return IsCyclic(type) ? FromCyclic5(type.$defs, type.$ref) : IsIntersect(type) ? FromIntersect5(type.allOf) : IsUnion(type) ? FromUnion8(type.anyOf) : IsObject3(type) ? FromObject8(type.properties) : Object2({});
+  return IsCyclic(type) ? FromCyclic5(type.$defs, type.$ref) : IsIntersect(type) ? FromIntersect5(type.allOf) : IsUnion(type) ? FromUnion8(type.anyOf) : IsObject3(type) ? FromObject8(type.properties) : _Object_({});
 }
 
 // node_modules/typebox/build/type/action/required.mjs
@@ -12383,11 +12391,6 @@ function ReturnTypeInstantiate(context, state, type, options) {
   return CanInstantiate(context, [type]) ? ReturnTypeImmediate(context, state, type, options) : ReturnTypeDeferred(type, options);
 }
 
-// node_modules/typebox/build/type/engine/template-literal/create.mjs
-function TemplateLiteralCreate(pattern) {
-  return exports_memory.Create({ ["~kind"]: "TemplateLiteral" }, { type: "string", pattern }, {});
-}
-
 // node_modules/typebox/build/type/engine/template-literal/encode.mjs
 function JoinString(input) {
   return input.join("|");
@@ -12502,7 +12505,7 @@ function InstantiateType(context, state, input) {
   const immutable = IsImmutable(input);
   const modifiers = ModifierActions(input, IsReadonly(input) ? "add" : "none", IsOptional(input) ? "add" : "none");
   const type = IsBase(modifiers[0]) ? modifiers[0].Clone() : modifiers[0];
-  const instantiated = IsRef(type) ? RefInstantiate(context, state, type.$ref) : IsArray3(type) ? Array2(InstantiateType(context, state, type.items), ArrayOptions(type)) : IsAsyncIterator3(type) ? AsyncIterator(InstantiateType(context, state, type.iteratorItems), AsyncIteratorOptions(type)) : IsCall(type) ? CallInstantiate(context, state, type.target, type.arguments) : IsConstructor3(type) ? Constructor(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.instanceType), ConstructorOptions(type)) : IsDeferred(type) ? InstantiateDeferred(context, state, type.action, type.parameters, type.options) : IsFunction3(type) ? Function2(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.returnType), FunctionOptions(type)) : IsIntersect(type) ? Intersect(InstantiateTypes(context, state, type.allOf), IntersectOptions(type)) : IsIterator3(type) ? Iterator(InstantiateType(context, state, type.iteratorItems), IteratorOptions(type)) : IsObject3(type) ? Object2(InstantiateProperties(context, state, type.properties), ObjectOptions(type)) : IsPromise(type) ? Promise2(InstantiateType(context, state, type.item), PromiseOptions(type)) : IsRecord(type) ? RecordFromPattern(RecordPattern(type), InstantiateType(context, state, RecordValue(type))) : IsRest(type) ? Rest(InstantiateType(context, state, type.items)) : IsTuple(type) ? Tuple(InstantiateElements(context, state, type.items), TupleOptions(type)) : IsUnion(type) ? Union(InstantiateTypes(context, state, type.anyOf), UnionOptions(type)) : type;
+  const instantiated = IsRef(type) ? RefInstantiate(context, state, type.$ref) : IsArray3(type) ? Array2(InstantiateType(context, state, type.items), ArrayOptions(type)) : IsAsyncIterator3(type) ? AsyncIterator(InstantiateType(context, state, type.iteratorItems), AsyncIteratorOptions(type)) : IsCall(type) ? CallInstantiate(context, state, type.target, type.arguments) : IsConstructor3(type) ? Constructor(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.instanceType), ConstructorOptions(type)) : IsDeferred(type) ? InstantiateDeferred(context, state, type.action, type.parameters, type.options) : IsFunction3(type) ? _Function_(InstantiateTypes(context, state, type.parameters), InstantiateType(context, state, type.returnType), FunctionOptions(type)) : IsIntersect(type) ? Intersect(InstantiateTypes(context, state, type.allOf), IntersectOptions(type)) : IsIterator3(type) ? Iterator(InstantiateType(context, state, type.iteratorItems), IteratorOptions(type)) : IsObject3(type) ? _Object_(InstantiateProperties(context, state, type.properties), ObjectOptions(type)) : IsPromise(type) ? Promise2(InstantiateType(context, state, type.item), PromiseOptions(type)) : IsRecord(type) ? RecordFromPattern(RecordPattern(type), InstantiateType(context, state, RecordValue(type))) : IsRest(type) ? Rest(InstantiateType(context, state, type.items)) : IsTuple(type) ? Tuple(InstantiateElements(context, state, type.items), TupleOptions(type)) : IsUnion(type) ? Union(InstantiateTypes(context, state, type.anyOf), UnionOptions(type)) : type;
   const withImmutable = immutable ? Immutable(instantiated) : instantiated;
   const withModifiers = ApplyReadonly2(modifiers[1], ApplyOptional2(modifiers[2], withImmutable));
   return withModifiers;
@@ -12578,7 +12581,7 @@ __export(exports_typebox, {
   Options: () => Options2,
   Optional: () => Optional,
   Omit: () => Omit,
-  Object: () => Object2,
+  Object: () => _Object_,
   Number: () => Number2,
   Null: () => Null,
   NonNullable: () => NonNullable,
@@ -12643,7 +12646,7 @@ __export(exports_typebox, {
   Immutable: () => Immutable,
   Identifier: () => Identifier,
   Generic: () => Generic,
-  Function: () => Function2,
+  Function: () => _Function_,
   Extract: () => Extract,
   ExtendsResult: () => exports_result,
   Extends: () => Extends2,
@@ -16164,7 +16167,7 @@ var Parser = Pipeline([
   (context, type3, value) => Assert3(context, type3, value)
 ]);
 // node_modules/typebox/build/value/delta/edit.mjs
-var Insert = Object2({
+var Insert = _Object_({
   type: Literal("insert"),
   path: String2(),
   value: Unknown()
@@ -16174,7 +16177,7 @@ var Update2 = Object({
   path: String2(),
   value: Unknown()
 });
-var Delete2 = Object2({
+var Delete2 = _Object_({
   type: Literal("delete"),
   path: String2()
 });
@@ -19398,6 +19401,18 @@ function isStaticArrayExpression(context, arrayExpr, seen, options3) {
 function isStaticExpressionInner(node, seen, options3) {
   return isStaticExpression(undefined, node, seen, options3);
 }
+function checkStaticBinaryOrLogical(context, expression, seen, options3) {
+  if (!(isNonPrivateExpression(expression.left) && isNonPrivateExpression(expression.right)))
+    return false;
+  return isStaticExpression(context, expression.left, seen, options3) && isStaticExpression(context, expression.right, seen, options3);
+}
+function checkStaticCallOrNewExpression(context, args, callee, seen, options3) {
+  if (context === undefined)
+    return false;
+  if (!isStaticCallCallee(context, callee, seen, options3))
+    return false;
+  return (args ?? []).every((argument) => argument.type !== AST_NODE_TYPES4.SpreadElement && isStaticExpression(context, argument, seen, options3));
+}
 function isStaticExpression(context, expression, seen, options3) {
   const unwrapped = unwrapExpression(expression);
   if (seen.has(unwrapped))
@@ -19412,9 +19427,7 @@ function isStaticExpression(context, expression, seen, options3) {
       return STATIC_UNARY_OPERATORS.has(unwrapped.operator) && isStaticExpression(context, unwrapped.argument, seen, options3);
     case AST_NODE_TYPES4.BinaryExpression:
     case AST_NODE_TYPES4.LogicalExpression:
-      if (!(isNonPrivateExpression(unwrapped.left) && isNonPrivateExpression(unwrapped.right)))
-        return false;
-      return isStaticExpression(context, unwrapped.left, seen, options3) && isStaticExpression(context, unwrapped.right, seen, options3);
+      return checkStaticBinaryOrLogical(context, unwrapped, seen, options3);
     case AST_NODE_TYPES4.ConditionalExpression:
       return isStaticExpression(context, unwrapped.test, seen, options3) && isStaticExpression(context, unwrapped.consequent, seen, options3) && isStaticExpression(context, unwrapped.alternate, seen, options3);
     case AST_NODE_TYPES4.ArrayExpression:
@@ -19428,11 +19441,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((argument) => argument.type !== AST_NODE_TYPES4.SpreadElement && isStaticExpression(context, argument, seen, options3));
+      return checkStaticCallOrNewExpression(context, unwrapped.arguments, unwrapped.callee, seen, options3);
     case AST_NODE_TYPES4.NewExpression:
-      return context !== undefined && isStaticCallCallee(context, unwrapped.callee, seen, options3) && (unwrapped.arguments ?? []).every((argument) => argument.type !== AST_NODE_TYPES4.SpreadElement && isStaticExpression(context, argument, seen, options3));
+      return checkStaticCallOrNewExpression(context, unwrapped.arguments, unwrapped.callee, seen, options3);
     case AST_NODE_TYPES4.SequenceExpression:
-      return unwrapped.expressions.length > 0 && unwrapped.expressions.every((expression2) => isStaticExpression(context, expression2, seen, options3));
+      return unwrapped.expressions.length > 0 && unwrapped.expressions.every((expr) => isStaticExpression(context, expr, seen, options3));
     case AST_NODE_TYPES4.AssignmentExpression:
       return isStaticExpression(context, unwrapped.right, seen, options3);
     default:
@@ -19738,53 +19751,1126 @@ var prefer_early_return_default = createRule({
   name: "prefer-early-return"
 });
 
-// src/rules/prefer-module-scope-constants.ts
-var import_scope_manager3 = __toESM(require_dist2(), 1);
-import { AST_NODE_TYPES as AST_NODE_TYPES7 } from "@typescript-eslint/utils";
-var SCREAMING_SNAKE_CASE = /^[A-Z][A-Z0-9_]*$/;
-function isTopScope(scope) {
-  const { type: type3 } = scope;
-  if (type3 === import_scope_manager3.ScopeType.module || type3 === import_scope_manager3.ScopeType.global)
-    return true;
-  if (scope.upper?.type === import_scope_manager3.ScopeType.global) {
-    const { block } = scope.upper;
-    if (block.type === AST_NODE_TYPES7.Program && block.sourceType === "script")
+// src/rules/prefer-enum-item.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES7, ESLintUtils as ESLintUtils3 } from "@typescript-eslint/utils";
+
+// node_modules/ts-api-utils/lib/index.js
+import ts9 from "typescript";
+function isFlagSet(allFlags, flag) {
+  return (allFlags & flag) !== 0;
+}
+function isFlagSetOnObject(obj, flag) {
+  return isFlagSet(obj.flags, flag);
+}
+var isTypeFlagSet = isFlagSetOnObject;
+function includesModifier(modifiers, ...kinds) {
+  if (modifiers === undefined) {
+    return false;
+  }
+  for (const modifier of modifiers) {
+    if (kinds.includes(modifier.kind)) {
       return true;
+    }
   }
   return false;
 }
-var prefer_module_scope_constants_default = createRule({
-  create(context) {
-    let inConstDeclaration = false;
-    return {
-      VariableDeclaration(node) {
-        inConstDeclaration = node.kind === "const";
-      },
-      "VariableDeclaration:exit"() {
-        inConstDeclaration = false;
-      },
-      VariableDeclarator(node) {
-        const { id: id2 } = node;
-        if (id2.type !== AST_NODE_TYPES7.Identifier || !SCREAMING_SNAKE_CASE.test(id2.name))
-          return;
-        if (!inConstDeclaration) {
-          context.report({
-            messageId: "mustUseConst",
-            node
-          });
+var [tsMajor, tsMinor] = ts9.versionMajorMinor.split(".").map((raw) => Number.parseInt(raw, 10));
+function isNumericOrStringLikeLiteral(node) {
+  switch (node.kind) {
+    case ts9.SyntaxKind.NoSubstitutionTemplateLiteral:
+    case ts9.SyntaxKind.NumericLiteral:
+    case ts9.SyntaxKind.StringLiteral:
+      return true;
+    default:
+      return false;
+  }
+}
+function isFunctionScopeBoundary(node) {
+  switch (node.kind) {
+    case ts9.SyntaxKind.ArrowFunction:
+    case ts9.SyntaxKind.CallSignature:
+    case ts9.SyntaxKind.ClassDeclaration:
+    case ts9.SyntaxKind.ClassExpression:
+    case ts9.SyntaxKind.Constructor:
+    case ts9.SyntaxKind.ConstructorType:
+    case ts9.SyntaxKind.ConstructSignature:
+    case ts9.SyntaxKind.EnumDeclaration:
+    case ts9.SyntaxKind.FunctionDeclaration:
+    case ts9.SyntaxKind.FunctionExpression:
+    case ts9.SyntaxKind.FunctionType:
+    case ts9.SyntaxKind.GetAccessor:
+    case ts9.SyntaxKind.MethodDeclaration:
+    case ts9.SyntaxKind.MethodSignature:
+    case ts9.SyntaxKind.ModuleDeclaration:
+    case ts9.SyntaxKind.SetAccessor:
+      return true;
+    case ts9.SyntaxKind.SourceFile:
+      return ts9.isExternalModule(node);
+    default:
+      return false;
+  }
+}
+var IntrinsicTypeFlags = ts9.TypeFlags.Intrinsic ?? ts9.TypeFlags.Any | ts9.TypeFlags.Unknown | ts9.TypeFlags.String | ts9.TypeFlags.Number | ts9.TypeFlags.BigInt | ts9.TypeFlags.Boolean | ts9.TypeFlags.BooleanLiteral | ts9.TypeFlags.ESSymbol | ts9.TypeFlags.Void | ts9.TypeFlags.Undefined | ts9.TypeFlags.Null | ts9.TypeFlags.Never | ts9.TypeFlags.NonPrimitive;
+function isUnionType(type3) {
+  return isTypeFlagSet(type3, ts9.TypeFlags.Union);
+}
+function unionConstituents(type3) {
+  return isUnionType(type3) ? type3.types : [type3];
+}
+function identifierToKeywordKind(node) {
+  return "originalKeywordKind" in node ? node.originalKeywordKind : ts9.identifierToKeywordKind(node);
+}
+function getDeclarationDomain(node) {
+  switch (node.parent.kind) {
+    case ts9.SyntaxKind.ClassDeclaration:
+    case ts9.SyntaxKind.ClassExpression:
+      return 2 | 4;
+    case ts9.SyntaxKind.EnumDeclaration:
+      return 7;
+    case ts9.SyntaxKind.FunctionDeclaration:
+    case ts9.SyntaxKind.FunctionExpression:
+      return 4;
+    case ts9.SyntaxKind.ImportClause:
+    case ts9.SyntaxKind.NamespaceImport:
+      return 7 | 8;
+    case ts9.SyntaxKind.ImportEqualsDeclaration:
+    case ts9.SyntaxKind.ImportSpecifier:
+      return node.parent.name === node ? 7 | 8 : undefined;
+    case ts9.SyntaxKind.InterfaceDeclaration:
+    case ts9.SyntaxKind.TypeAliasDeclaration:
+    case ts9.SyntaxKind.TypeParameter:
+      return 2;
+    case ts9.SyntaxKind.ModuleDeclaration:
+      return 1;
+    case ts9.SyntaxKind.Parameter:
+      if (node.parent.parent.kind === ts9.SyntaxKind.IndexSignature || identifierToKeywordKind(node) === ts9.SyntaxKind.ThisKeyword) {
+        return;
+      }
+    case ts9.SyntaxKind.BindingElement:
+    case ts9.SyntaxKind.VariableDeclaration:
+      return node.parent.name === node ? 4 : undefined;
+  }
+}
+function getPropertyName(propertyName) {
+  if (propertyName.kind === ts9.SyntaxKind.ComputedPropertyName) {
+    const expression = unwrapParentheses(propertyName.expression);
+    if (ts9.isPrefixUnaryExpression(expression)) {
+      let negate = false;
+      switch (expression.operator) {
+        case ts9.SyntaxKind.MinusToken:
+          negate = true;
+        case ts9.SyntaxKind.PlusToken:
+          return ts9.isNumericLiteral(expression.operand) ? `${negate ? "-" : ""}${expression.operand.text}` : ts9.isBigIntLiteral(expression.operand) ? `${negate ? "-" : ""}${expression.operand.text.slice(0, -1)}` : undefined;
+        default:
           return;
+      }
+    }
+    if (ts9.isBigIntLiteral(expression)) {
+      return expression.text.slice(0, -1);
+    }
+    if (isNumericOrStringLikeLiteral(expression)) {
+      return expression.text;
+    }
+    return;
+  }
+  return propertyName.kind === ts9.SyntaxKind.PrivateIdentifier ? undefined : propertyName.text;
+}
+function unwrapParentheses(node) {
+  while (node.kind === ts9.SyntaxKind.ParenthesizedExpression) {
+    node = node.expression;
+  }
+  return node;
+}
+function getUsageDomain(node) {
+  const parent = node.parent;
+  switch (parent.kind) {
+    case ts9.SyntaxKind.BindingElement:
+      if (parent.initializer === node) {
+        return 5;
+      }
+      break;
+    case ts9.SyntaxKind.BreakStatement:
+    case ts9.SyntaxKind.ClassDeclaration:
+    case ts9.SyntaxKind.ClassExpression:
+    case ts9.SyntaxKind.ContinueStatement:
+    case ts9.SyntaxKind.EnumDeclaration:
+    case ts9.SyntaxKind.FunctionDeclaration:
+    case ts9.SyntaxKind.FunctionExpression:
+    case ts9.SyntaxKind.GetAccessor:
+    case ts9.SyntaxKind.ImportClause:
+    case ts9.SyntaxKind.ImportSpecifier:
+    case ts9.SyntaxKind.InterfaceDeclaration:
+    case ts9.SyntaxKind.JsxAttribute:
+    case ts9.SyntaxKind.LabeledStatement:
+    case ts9.SyntaxKind.MethodDeclaration:
+    case ts9.SyntaxKind.MethodSignature:
+    case ts9.SyntaxKind.ModuleDeclaration:
+    case ts9.SyntaxKind.NamedTupleMember:
+    case ts9.SyntaxKind.NamespaceExport:
+    case ts9.SyntaxKind.NamespaceExportDeclaration:
+    case ts9.SyntaxKind.NamespaceImport:
+    case ts9.SyntaxKind.PropertySignature:
+    case ts9.SyntaxKind.SetAccessor:
+    case ts9.SyntaxKind.TypeAliasDeclaration:
+    case ts9.SyntaxKind.TypeParameter:
+    case ts9.SyntaxKind.TypePredicate:
+      break;
+    case ts9.SyntaxKind.EnumMember:
+    case ts9.SyntaxKind.ImportEqualsDeclaration:
+    case ts9.SyntaxKind.Parameter:
+    case ts9.SyntaxKind.PropertyAccessExpression:
+    case ts9.SyntaxKind.PropertyAssignment:
+    case ts9.SyntaxKind.PropertyDeclaration:
+    case ts9.SyntaxKind.VariableDeclaration:
+      if (parent.name !== node) {
+        return 5;
+      }
+      break;
+    case ts9.SyntaxKind.ExportAssignment:
+      return 7;
+    case ts9.SyntaxKind.ExportSpecifier:
+      if (parent.propertyName === undefined || parent.propertyName === node) {
+        return 7;
+      }
+      break;
+    case ts9.SyntaxKind.ExpressionWithTypeArguments:
+      return parent.parent.token === ts9.SyntaxKind.ImplementsKeyword || parent.parent.parent.kind === ts9.SyntaxKind.InterfaceDeclaration ? 2 : 4;
+    case ts9.SyntaxKind.QualifiedName:
+      if (parent.left === node) {
+        if (getEntityNameParent(parent).kind === ts9.SyntaxKind.TypeQuery) {
+          return 1 | 8;
         }
-        const scope = context.sourceCode.getScope(node);
-        if (isTopScope(scope))
-          return;
-        context.report({
-          messageId: "mustBeModuleScope",
-          node
-        });
+        return 1;
       }
+      break;
+    case ts9.SyntaxKind.TypeQuery:
+      return 5 | 8;
+    case ts9.SyntaxKind.TypeReference:
+      return identifierToKeywordKind(node) !== ts9.SyntaxKind.ConstKeyword ? 2 : undefined;
+    default:
+      return 5;
+  }
+}
+function getEntityNameParent(name) {
+  let parent = name.parent;
+  while (parent.kind === ts9.SyntaxKind.QualifiedName) {
+    parent = parent.parent;
+  }
+  return parent;
+}
+function isBlockScopeBoundary(node) {
+  switch (node.kind) {
+    case ts9.SyntaxKind.Block: {
+      const parent = node.parent;
+      return parent.kind !== ts9.SyntaxKind.CatchClause && (parent.kind === ts9.SyntaxKind.SourceFile || !isFunctionScopeBoundary(parent)) ? 2 : 0;
+    }
+    case ts9.SyntaxKind.CaseBlock:
+    case ts9.SyntaxKind.CatchClause:
+    case ts9.SyntaxKind.ForInStatement:
+    case ts9.SyntaxKind.ForOfStatement:
+    case ts9.SyntaxKind.ForStatement:
+    case ts9.SyntaxKind.WithStatement:
+      return 2;
+    default:
+      return 0;
+  }
+}
+var AbstractScope = class {
+  constructor(global) {
+    this.global = global;
+  }
+  namespaceScopes = undefined;
+  uses = [];
+  variables = /* @__PURE__ */ new Map;
+  #enumScopes = undefined;
+  addUse(use) {
+    this.uses.push(use);
+  }
+  addVariable(identifier3, name, selector, exported, domain) {
+    const variables = this.getDestinationScope(selector).getVariables();
+    const declaration = {
+      declaration: name,
+      domain,
+      exported
     };
-  },
-  defaultOptions: [],
+    const variable = variables.get(identifier3);
+    if (variable === undefined) {
+      variables.set(identifier3, {
+        declarations: [declaration],
+        domain,
+        uses: []
+      });
+    } else {
+      variable.domain |= domain;
+      variable.declarations.push(declaration);
+    }
+  }
+  createOrReuseEnumScope(name, _exported) {
+    let scope;
+    if (this.#enumScopes === undefined) {
+      this.#enumScopes = /* @__PURE__ */ new Map;
+    } else {
+      scope = this.#enumScopes.get(name);
+    }
+    if (scope === undefined) {
+      scope = new EnumScope(this);
+      this.#enumScopes.set(name, scope);
+    }
+    return scope;
+  }
+  createOrReuseNamespaceScope(name, _exported, ambient, hasExportStatement) {
+    let scope;
+    if (this.namespaceScopes === undefined) {
+      this.namespaceScopes = /* @__PURE__ */ new Map;
+    } else {
+      scope = this.namespaceScopes.get(name);
+    }
+    if (scope === undefined) {
+      scope = new NamespaceScope(ambient, hasExportStatement, this);
+      this.namespaceScopes.set(name, scope);
+    } else {
+      scope.refresh(ambient, hasExportStatement);
+    }
+    return scope;
+  }
+  end(cb) {
+    if (this.namespaceScopes !== undefined) {
+      this.namespaceScopes.forEach((value) => value.finish(cb));
+    }
+    this.namespaceScopes = this.#enumScopes = undefined;
+    this.applyUses();
+    this.variables.forEach((variable) => {
+      for (const declaration of variable.declarations) {
+        const result = {
+          declarations: [],
+          domain: declaration.domain,
+          exported: declaration.exported,
+          inGlobalScope: this.global,
+          uses: []
+        };
+        for (const other of variable.declarations) {
+          if (other.domain & declaration.domain) {
+            result.declarations.push(other.declaration);
+          }
+        }
+        for (const use of variable.uses) {
+          if (use.domain & declaration.domain) {
+            result.uses.push(use);
+          }
+        }
+        cb(result, declaration.declaration, this);
+      }
+    });
+  }
+  getFunctionScope() {
+    return this;
+  }
+  getVariables() {
+    return this.variables;
+  }
+  markExported(_name) {}
+  addUseToParent(_use) {}
+  applyUse(use, variables = this.variables) {
+    const variable = variables.get(use.location.text);
+    if (variable === undefined || (variable.domain & use.domain) === 0) {
+      return false;
+    }
+    variable.uses.push(use);
+    return true;
+  }
+  applyUses() {
+    for (const use of this.uses) {
+      if (!this.applyUse(use)) {
+        this.addUseToParent(use);
+      }
+    }
+    this.uses = [];
+  }
+};
+var NonRootScope = class extends AbstractScope {
+  constructor(parent, boundary) {
+    super(false);
+    this.parent = parent;
+    this.boundary = boundary;
+  }
+  getDestinationScope(selector) {
+    return this.boundary & selector ? this : this.parent.getDestinationScope(selector);
+  }
+  addUseToParent(use) {
+    return this.parent.addUse(use, this);
+  }
+};
+var AbstractNamedExpressionScope = class extends NonRootScope {
+  #domain;
+  #name;
+  constructor(name, domain, parent) {
+    super(parent, 1);
+    this.#name = name;
+    this.#domain = domain;
+  }
+  addUse(use, source) {
+    if (source !== this.innerScope) {
+      return this.innerScope.addUse(use);
+    }
+    if (use.domain & this.#domain && use.location.text === this.#name.text) {
+      this.uses.push(use);
+    } else {
+      return this.parent.addUse(use, this);
+    }
+  }
+  end(cb) {
+    this.innerScope.end(cb);
+    return cb({
+      declarations: [this.#name],
+      domain: this.#domain,
+      exported: false,
+      inGlobalScope: false,
+      uses: this.uses
+    }, this.#name, this);
+  }
+  getDestinationScope() {
+    return this.innerScope;
+  }
+  getFunctionScope() {
+    return this.innerScope;
+  }
+};
+var BlockScope = class extends NonRootScope {
+  #functionScope;
+  constructor(functionScope, parent) {
+    super(parent, 2);
+    this.#functionScope = functionScope;
+  }
+  getFunctionScope() {
+    return this.#functionScope;
+  }
+};
+var ClassExpressionScope = class extends AbstractNamedExpressionScope {
+  innerScope = new NonRootScope(this, 1);
+  constructor(name, parent) {
+    super(name, 4 | 2, parent);
+  }
+};
+var ConditionalTypeScope = class extends NonRootScope {
+  #state = 0;
+  constructor(parent) {
+    super(parent, 8);
+  }
+  addUse(use) {
+    if (this.#state === 2) {
+      return void this.uses.push(use);
+    }
+    return this.parent.addUse(use, this);
+  }
+  updateState(newState) {
+    this.#state = newState;
+  }
+};
+var EnumScope = class extends NonRootScope {
+  constructor(parent) {
+    super(parent, 1);
+  }
+  end() {
+    this.applyUses();
+  }
+};
+var FunctionScope = class extends NonRootScope {
+  constructor(parent) {
+    super(parent, 1);
+  }
+  beginBody() {
+    this.applyUses();
+  }
+};
+var FunctionExpressionScope = class extends AbstractNamedExpressionScope {
+  innerScope = new FunctionScope(this);
+  constructor(name, parent) {
+    super(name, 4, parent);
+  }
+  beginBody() {
+    return this.innerScope.beginBody();
+  }
+};
+var NamespaceScope = class extends NonRootScope {
+  #ambient;
+  #exports = undefined;
+  #hasExport;
+  #innerScope = new NonRootScope(this, 1);
+  constructor(ambient, hasExport, parent) {
+    super(parent, 1);
+    this.#ambient = ambient;
+    this.#hasExport = hasExport;
+  }
+  addUse(use, source) {
+    if (source !== this.#innerScope) {
+      return this.#innerScope.addUse(use);
+    }
+    this.uses.push(use);
+  }
+  createOrReuseEnumScope(name, exported) {
+    if (!exported && (!this.#ambient || this.#hasExport)) {
+      return this.#innerScope.createOrReuseEnumScope(name, exported);
+    }
+    return super.createOrReuseEnumScope(name, exported);
+  }
+  createOrReuseNamespaceScope(name, exported, ambient, hasExportStatement) {
+    if (!exported && (!this.#ambient || this.#hasExport)) {
+      return this.#innerScope.createOrReuseNamespaceScope(name, exported, ambient || this.#ambient, hasExportStatement);
+    }
+    return super.createOrReuseNamespaceScope(name, exported, ambient || this.#ambient, hasExportStatement);
+  }
+  end(cb) {
+    this.#innerScope.end((variable, key, scope) => {
+      if (scope !== this.#innerScope || !variable.exported && (!this.#ambient || this.#exports !== undefined && !this.#exports.has(key.text))) {
+        return cb(variable, key, scope);
+      }
+      const namespaceVar = this.variables.get(key.text);
+      if (namespaceVar === undefined) {
+        this.variables.set(key.text, {
+          declarations: variable.declarations.map(mapDeclaration),
+          domain: variable.domain,
+          uses: [...variable.uses]
+        });
+      } else {
+        outer:
+          for (const declaration of variable.declarations) {
+            for (const existing of namespaceVar.declarations) {
+              if (existing.declaration === declaration) {
+                continue outer;
+              }
+              namespaceVar.declarations.push(mapDeclaration(declaration));
+            }
+          }
+        namespaceVar.domain |= variable.domain;
+        for (const use of variable.uses) {
+          if (namespaceVar.uses.includes(use)) {
+            continue;
+          }
+          namespaceVar.uses.push(use);
+        }
+      }
+    });
+    this.applyUses();
+    this.#innerScope = new NonRootScope(this, 1);
+  }
+  finish(cb) {
+    return super.end(cb);
+  }
+  getDestinationScope() {
+    return this.#innerScope;
+  }
+  markExported(name) {
+    if (this.#exports === undefined) {
+      this.#exports = /* @__PURE__ */ new Set;
+    }
+    this.#exports.add(name.text);
+  }
+  refresh(ambient, hasExport) {
+    this.#ambient = ambient;
+    this.#hasExport = hasExport;
+  }
+};
+var RootScope = class extends AbstractScope {
+  #exportAll;
+  #exports = undefined;
+  #innerScope = new NonRootScope(this, 1);
+  constructor(exportAll, global) {
+    super(global);
+    this.#exportAll = exportAll;
+  }
+  addUse(use, origin) {
+    if (origin === this.#innerScope) {
+      return super.addUse(use);
+    }
+    return this.#innerScope.addUse(use);
+  }
+  addVariable(identifier3, name, selector, exported, domain) {
+    if (domain & 8) {
+      return super.addVariable(identifier3, name, selector, exported, domain);
+    }
+    return this.#innerScope.addVariable(identifier3, name, selector, exported, domain);
+  }
+  end(cb) {
+    this.#innerScope.end((value, key) => {
+      value.exported ||= this.#exportAll || this.#exports !== undefined && this.#exports.includes(key.text);
+      value.inGlobalScope = this.global;
+      return cb(value, key, this);
+    });
+    return super.end((value, key, scope) => {
+      value.exported ||= scope === this && this.#exports !== undefined && this.#exports.includes(key.text);
+      return cb(value, key, scope);
+    });
+  }
+  getDestinationScope() {
+    return this;
+  }
+  markExported(id2) {
+    if (this.#exports === undefined) {
+      this.#exports = [id2.text];
+    } else {
+      this.#exports.push(id2.text);
+    }
+  }
+};
+function mapDeclaration(declaration) {
+  return {
+    declaration,
+    domain: getDeclarationDomain(declaration),
+    exported: true
+  };
+}
+var UsageWalker = class {
+  #result = /* @__PURE__ */ new Map;
+  #scope;
+  getUsage(sourceFile) {
+    const variableCallback = (variable, key) => {
+      this.#result.set(key, variable);
+    };
+    const isModule = ts9.isExternalModule(sourceFile);
+    this.#scope = new RootScope(sourceFile.isDeclarationFile && isModule && !containsExportStatement(sourceFile), !isModule);
+    const cb = (node) => {
+      if (isBlockScopeBoundary(node)) {
+        return continueWithScope(node, new BlockScope(this.#scope.getFunctionScope(), this.#scope), handleBlockScope);
+      }
+      switch (node.kind) {
+        case ts9.SyntaxKind.ArrowFunction:
+        case ts9.SyntaxKind.CallSignature:
+        case ts9.SyntaxKind.Constructor:
+        case ts9.SyntaxKind.ConstructorType:
+        case ts9.SyntaxKind.ConstructSignature:
+        case ts9.SyntaxKind.FunctionDeclaration:
+        case ts9.SyntaxKind.FunctionExpression:
+        case ts9.SyntaxKind.FunctionType:
+        case ts9.SyntaxKind.GetAccessor:
+        case ts9.SyntaxKind.MethodDeclaration:
+        case ts9.SyntaxKind.MethodSignature:
+        case ts9.SyntaxKind.SetAccessor:
+          return this.#handleFunctionLikeDeclaration(node, cb, variableCallback);
+        case ts9.SyntaxKind.ClassDeclaration:
+          this.#handleDeclaration(node, true, 4 | 2);
+          return continueWithScope(node, new NonRootScope(this.#scope, 1));
+        case ts9.SyntaxKind.ClassExpression:
+          return continueWithScope(node, node.name !== undefined ? new ClassExpressionScope(node.name, this.#scope) : new NonRootScope(this.#scope, 1));
+        case ts9.SyntaxKind.ConditionalType:
+          return this.#handleConditionalType(node, cb, variableCallback);
+        case ts9.SyntaxKind.EnumDeclaration:
+          this.#handleDeclaration(node, true, 7);
+          return continueWithScope(node, this.#scope.createOrReuseEnumScope(node.name.text, includesModifier(node.modifiers, ts9.SyntaxKind.ExportKeyword)));
+        case ts9.SyntaxKind.EnumMember:
+          this.#scope.addVariable(getPropertyName(node.name), node.name, 1, true, 4);
+          break;
+        case ts9.SyntaxKind.ExportAssignment:
+          if (node.expression.kind === ts9.SyntaxKind.Identifier) {
+            return this.#scope.markExported(node.expression);
+          }
+          break;
+        case ts9.SyntaxKind.ExportSpecifier:
+          if (node.propertyName !== undefined) {
+            return this.#scope.markExported(node.propertyName, node.name);
+          }
+          return this.#scope.markExported(node.name);
+        case ts9.SyntaxKind.Identifier: {
+          const domain = getUsageDomain(node);
+          if (domain !== undefined) {
+            this.#scope.addUse({ domain, location: node });
+          }
+          return;
+        }
+        case ts9.SyntaxKind.ImportClause:
+        case ts9.SyntaxKind.ImportEqualsDeclaration:
+        case ts9.SyntaxKind.ImportSpecifier:
+        case ts9.SyntaxKind.NamespaceImport:
+          this.#handleDeclaration(node, false, 7 | 8);
+          break;
+        case ts9.SyntaxKind.InterfaceDeclaration:
+        case ts9.SyntaxKind.TypeAliasDeclaration:
+          this.#handleDeclaration(node, true, 2);
+          return continueWithScope(node, new NonRootScope(this.#scope, 4));
+        case ts9.SyntaxKind.MappedType:
+          return continueWithScope(node, new NonRootScope(this.#scope, 4));
+        case ts9.SyntaxKind.ModuleDeclaration:
+          return this.#handleModule(node, continueWithScope);
+        case ts9.SyntaxKind.Parameter:
+          if (node.parent.kind !== ts9.SyntaxKind.IndexSignature && (node.name.kind !== ts9.SyntaxKind.Identifier || identifierToKeywordKind(node.name) !== ts9.SyntaxKind.ThisKeyword)) {
+            this.#handleBindingName(node.name, false, false);
+          }
+          break;
+        case ts9.SyntaxKind.TypeParameter:
+          this.#scope.addVariable(node.name.text, node.name, node.parent.kind === ts9.SyntaxKind.InferType ? 8 : 7, false, 2);
+          break;
+        case ts9.SyntaxKind.VariableDeclarationList:
+          this.#handleVariableDeclaration(node);
+          break;
+      }
+      return ts9.forEachChild(node, cb);
+    };
+    const continueWithScope = (node, scope, next = forEachChild) => {
+      const savedScope = this.#scope;
+      this.#scope = scope;
+      next(node);
+      this.#scope.end(variableCallback);
+      this.#scope = savedScope;
+    };
+    const handleBlockScope = (node) => {
+      if (node.kind === ts9.SyntaxKind.CatchClause && node.variableDeclaration !== undefined) {
+        this.#handleBindingName(node.variableDeclaration.name, true, false);
+      }
+      return ts9.forEachChild(node, cb);
+    };
+    ts9.forEachChild(sourceFile, cb);
+    this.#scope.end(variableCallback);
+    return this.#result;
+    function forEachChild(node) {
+      return ts9.forEachChild(node, cb);
+    }
+  }
+  #handleBindingName(name, blockScoped, exported) {
+    if (name.kind === ts9.SyntaxKind.Identifier) {
+      return this.#scope.addVariable(name.text, name, blockScoped ? 3 : 1, exported, 4);
+    }
+    forEachDestructuringIdentifier(name, (declaration) => {
+      this.#scope.addVariable(declaration.name.text, declaration.name, blockScoped ? 3 : 1, exported, 4);
+    });
+  }
+  #handleConditionalType(node, cb, varCb) {
+    const savedScope = this.#scope;
+    const scope = this.#scope = new ConditionalTypeScope(savedScope);
+    cb(node.checkType);
+    scope.updateState(1);
+    cb(node.extendsType);
+    scope.updateState(2);
+    cb(node.trueType);
+    scope.updateState(3);
+    cb(node.falseType);
+    scope.end(varCb);
+    this.#scope = savedScope;
+  }
+  #handleDeclaration(node, blockScoped, domain) {
+    if (node.name !== undefined) {
+      this.#scope.addVariable(node.name.text, node.name, blockScoped ? 3 : 1, includesModifier(node.modifiers, ts9.SyntaxKind.ExportKeyword), domain);
+    }
+  }
+  #handleFunctionLikeDeclaration(node, cb, varCb) {
+    if (ts9.canHaveDecorators(node)) {
+      ts9.getDecorators(node)?.forEach(cb);
+    }
+    const savedScope = this.#scope;
+    if (node.kind === ts9.SyntaxKind.FunctionDeclaration) {
+      this.#handleDeclaration(node, false, 4);
+    }
+    const scope = this.#scope = node.kind === ts9.SyntaxKind.FunctionExpression && node.name !== undefined ? new FunctionExpressionScope(node.name, savedScope) : new FunctionScope(savedScope);
+    if (node.name !== undefined) {
+      cb(node.name);
+    }
+    if (node.typeParameters !== undefined) {
+      node.typeParameters.forEach(cb);
+    }
+    node.parameters.forEach(cb);
+    if (node.type !== undefined) {
+      cb(node.type);
+    }
+    if (node.body !== undefined) {
+      scope.beginBody();
+      cb(node.body);
+    }
+    scope.end(varCb);
+    this.#scope = savedScope;
+  }
+  #handleModule(node, next) {
+    if (node.flags & ts9.NodeFlags.GlobalAugmentation) {
+      return next(node, this.#scope.createOrReuseNamespaceScope("-global", false, true, false));
+    }
+    if (node.name.kind === ts9.SyntaxKind.Identifier) {
+      const exported = isNamespaceExported(node);
+      this.#scope.addVariable(node.name.text, node.name, 1, exported, 1 | 4);
+      const ambient = includesModifier(node.modifiers, ts9.SyntaxKind.DeclareKeyword);
+      return next(node, this.#scope.createOrReuseNamespaceScope(node.name.text, exported, ambient, ambient && namespaceHasExportStatement(node)));
+    }
+    return next(node, this.#scope.createOrReuseNamespaceScope(`"${node.name.text}"`, false, true, namespaceHasExportStatement(node)));
+  }
+  #handleVariableDeclaration(declarationList) {
+    const blockScoped = isBlockScopedVariableDeclarationList(declarationList);
+    const exported = declarationList.parent.kind === ts9.SyntaxKind.VariableStatement && includesModifier(declarationList.parent.modifiers, ts9.SyntaxKind.ExportKeyword);
+    for (const declaration of declarationList.declarations) {
+      this.#handleBindingName(declaration.name, blockScoped, exported);
+    }
+  }
+};
+function containsExportStatement(block) {
+  for (const statement of block.statements) {
+    if (statement.kind === ts9.SyntaxKind.ExportDeclaration || statement.kind === ts9.SyntaxKind.ExportAssignment) {
+      return true;
+    }
+  }
+  return false;
+}
+function forEachDestructuringIdentifier(pattern4, fn) {
+  for (const element of pattern4.elements) {
+    if (element.kind !== ts9.SyntaxKind.BindingElement) {
+      continue;
+    }
+    let result;
+    if (element.name.kind === ts9.SyntaxKind.Identifier) {
+      result = fn(element);
+    } else {
+      result = forEachDestructuringIdentifier(element.name, fn);
+    }
+    if (result) {
+      return result;
+    }
+  }
+}
+function isBlockScopedVariableDeclarationList(declarationList) {
+  return (declarationList.flags & ts9.NodeFlags.BlockScoped) !== 0;
+}
+function isNamespaceExported(node) {
+  return node.parent.kind === ts9.SyntaxKind.ModuleDeclaration || includesModifier(node.modifiers, ts9.SyntaxKind.ExportKeyword);
+}
+function namespaceHasExportStatement(ns) {
+  if (ns.body === undefined || ns.body.kind !== ts9.SyntaxKind.ModuleBlock) {
+    return false;
+  }
+  return containsExportStatement(ns.body);
+}
+
+// src/rules/prefer-enum-item.ts
+import { SymbolFlags } from "typescript";
+function isJSXAttributeValue(node) {
+  const { parent } = node;
+  return parent !== undefined && parent.type === AST_NODE_TYPES7.JSXAttribute && parent.value === node;
+}
+function canHaveContextualEnumType(node) {
+  const { parent } = node;
+  if (parent === undefined)
+    return false;
+  switch (parent.type) {
+    case AST_NODE_TYPES7.CallExpression:
+    case AST_NODE_TYPES7.NewExpression:
+      return parent.arguments.includes(node);
+    case AST_NODE_TYPES7.Property:
+      return parent.value === node;
+    case AST_NODE_TYPES7.JSXAttribute:
+      return parent.value === node;
+    case AST_NODE_TYPES7.VariableDeclarator: {
+      if (parent.init !== node)
+        return false;
+      const { id: id2 } = parent;
+      return id2.type === AST_NODE_TYPES7.Identifier && id2.typeAnnotation !== undefined;
+    }
+    default:
+      return false;
+  }
+}
+var ENUM_PREFIX = "Enum.";
+var enumLiteralIndexCache = new WeakMap;
+function getFullEnumPath(checker, type3) {
+  const symbol3 = type3.getSymbol();
+  if (symbol3 === undefined)
+    return;
+  const fullName = checker.getFullyQualifiedName(symbol3);
+  if (!fullName.startsWith(ENUM_PREFIX))
+    return;
+  return fullName;
+}
+function getPropertyLiteralType(checker, type3, propertyName) {
+  const property = type3.getProperty(propertyName);
+  if (property === undefined)
+    return;
+  const propertyType = checker.getTypeOfSymbol(property);
+  if (propertyType.isStringLiteral())
+    return propertyType.value;
+  if (propertyType.isNumberLiteral())
+    return propertyType.value;
+  return;
+}
+function getUnionTypes(type3) {
+  if (isUnionType(type3))
+    return unionConstituents(type3);
+  return [type3];
+}
+function createEnumMatch(enumPath) {
+  return { enumPath };
+}
+var prefer_enum_item_default = createRule({
+  create(context) {
+    const [{ fixNumericToValue = false, performanceMode = false } = {}] = context.options;
+    const services = ESLintUtils3.getParserServices(context);
+    const checker = services.program.getTypeChecker();
+    const unionTypesCache = new WeakMap;
+    const enumPathCache = new WeakMap;
+    const enumItemInfoCache = new WeakMap;
+    const enumLookupCache = new WeakMap;
+    function getUnionTypesCached(type3) {
+      const cached = unionTypesCache.get(type3);
+      if (cached !== undefined)
+        return cached;
+      const resolved = isUnionType(type3) ? unionConstituents(type3) : [type3];
+      unionTypesCache.set(type3, resolved);
+      return resolved;
+    }
+    function getFullEnumPathCached(type3) {
+      const cached = enumPathCache.get(type3);
+      if (cached !== undefined)
+        return cached === false ? undefined : cached;
+      const resolved = getFullEnumPath(checker, type3);
+      enumPathCache.set(type3, resolved ?? false);
+      return resolved;
+    }
+    function getEnumItemInfo(type3) {
+      const cached = enumItemInfoCache.get(type3);
+      if (cached !== undefined)
+        return cached === false ? undefined : cached;
+      const enumPath = getFullEnumPathCached(type3);
+      if (enumPath === undefined) {
+        enumItemInfoCache.set(type3, false);
+        return;
+      }
+      const nameLiteral = getPropertyLiteralType(checker, type3, "Name");
+      const valueLiteral = getPropertyLiteralType(checker, type3, "Value");
+      const info = {
+        enumPath,
+        ...typeof nameLiteral === "string" ? { nameLiteral } : {},
+        ...typeof valueLiteral === "number" ? { valueLiteral } : {}
+      };
+      enumItemInfoCache.set(type3, info);
+      return info;
+    }
+    function getEnumLookup(type3) {
+      const cached = enumLookupCache.get(type3);
+      if (cached !== undefined)
+        return cached === false ? undefined : cached;
+      const unionTypes = getUnionTypesCached(type3);
+      const stringMap = new Map;
+      const numberMap = new Map;
+      let hasAny = false;
+      for (const memberType of unionTypes) {
+        const info = getEnumItemInfo(memberType);
+        if (info === undefined)
+          continue;
+        hasAny = true;
+        if (info.nameLiteral !== undefined && !stringMap.has(info.nameLiteral)) {
+          stringMap.set(info.nameLiteral, info.enumPath);
+        }
+        if (info.valueLiteral !== undefined && !numberMap.has(info.valueLiteral)) {
+          numberMap.set(info.valueLiteral, info.enumPath);
+        }
+      }
+      if (!hasAny) {
+        enumLookupCache.set(type3, false);
+        return;
+      }
+      const lookup = { numberMap, stringMap };
+      enumLookupCache.set(type3, lookup);
+      return lookup;
+    }
+    function resolveAliasSymbol(symbol3) {
+      if ((symbol3.flags & SymbolFlags.Alias) !== 0)
+        return checker.getAliasedSymbol(symbol3);
+      return symbol3;
+    }
+    function buildEnumLiteralIndex(anchorNode) {
+      const resolved = checker.resolveName("Enum", anchorNode, SymbolFlags.Namespace, false);
+      if (resolved === undefined)
+        return;
+      const enumSymbol = resolveAliasSymbol(resolved);
+      if ((enumSymbol.flags & SymbolFlags.Namespace) === 0)
+        return;
+      const stringSet = new Set;
+      const numberSet = new Set;
+      const stack = [enumSymbol];
+      const visited2 = new Set;
+      while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === undefined)
+          continue;
+        if (visited2.has(current))
+          continue;
+        visited2.add(current);
+        const exports = checker.getExportsOfModule(current);
+        for (const exportSymbol of exports) {
+          const unaliased = resolveAliasSymbol(exportSymbol);
+          if ((unaliased.flags & SymbolFlags.Namespace) !== 0) {
+            stack.push(unaliased);
+            continue;
+          }
+          const type3 = checker.getTypeOfSymbol(unaliased);
+          const info = getEnumItemInfo(type3);
+          if (info === undefined)
+            continue;
+          if (info.nameLiteral !== undefined)
+            stringSet.add(info.nameLiteral);
+          if (info.valueLiteral !== undefined)
+            numberSet.add(info.valueLiteral);
+        }
+      }
+      if (stringSet.size === 0 && numberSet.size === 0)
+        return;
+      return { numberSet, stringSet };
+    }
+    function getEnumLiteralIndex(anchorNode) {
+      const cached = enumLiteralIndexCache.get(checker);
+      if (cached !== undefined)
+        return cached === false ? undefined : cached;
+      const built = buildEnumLiteralIndex(anchorNode);
+      enumLiteralIndexCache.set(checker, built ?? false);
+      return built;
+    }
+    function getContextualType(node) {
+      const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+      return checker.getContextualType(tsNode);
+    }
+    function shouldSkipLiteral(node, value) {
+      if (!performanceMode)
+        return false;
+      const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+      if (tsNode === undefined)
+        return false;
+      const index2 = getEnumLiteralIndex(tsNode);
+      if (index2 === undefined)
+        return false;
+      if (typeof value === "string")
+        return !index2.stringSet.has(value);
+      return !index2.numberSet.has(value);
+    }
+    function findEnumMatch(contextualType, literalValue) {
+      if (performanceMode) {
+        const lookup = getEnumLookup(contextualType);
+        if (lookup === undefined)
+          return;
+        const enumPath = typeof literalValue === "string" ? lookup.stringMap.get(literalValue) : lookup.numberMap.get(literalValue);
+        return enumPath === undefined ? undefined : createEnumMatch(enumPath);
+      }
+      const unionTypes = getUnionTypes(contextualType);
+      for (const memberType of unionTypes) {
+        const enumPath = getFullEnumPath(checker, memberType);
+        if (enumPath === undefined)
+          continue;
+        if (typeof literalValue === "string") {
+          const nameProperty = getPropertyLiteralType(checker, memberType, "Name");
+          if (nameProperty === literalValue)
+            return createEnumMatch(enumPath);
+        } else {
+          const valueProperty = getPropertyLiteralType(checker, memberType, "Value");
+          if (valueProperty === literalValue)
+            return createEnumMatch(enumPath);
+        }
+      }
+      return;
+    }
+    return {
+      Literal(node) {
+        const { value } = node;
+        if (typeof value !== "string" && typeof value !== "number")
+          return;
+        if (!canHaveContextualEnumType(node))
+          return;
+        if (shouldSkipLiteral(node, value))
+          return;
+        const contextualType = getContextualType(node);
+        if (contextualType === undefined)
+          return;
+        const match = findEnumMatch(contextualType, value);
+        if (match === undefined)
+          return;
+        const isString = typeof value === "string";
+        const displayValue = isString ? `"${value}"` : String(value);
+        const fixPath = fixNumericToValue && !isString ? `${match.enumPath}.Value` : match.enumPath;
+        const needsJSXBraces = isJSXAttributeValue(node);
+        const fixText = needsJSXBraces ? `{${fixPath}}` : fixPath;
+        context.report({
+          data: {
+            enumType: match.enumPath.split(".").slice(0, -1).join("."),
+            expected: fixPath,
+            value: displayValue
+          },
+          fix(fixer) {
+            return fixer.replaceText(node, fixText);
+          },
+          messageId: "preferEnumItem",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [{ fixNumericToValue: false, performanceMode: false }],
+  meta: {
+    docs: {
+      description: "Enforce using EnumItem values instead of string or number literals."
+    },
+    fixable: "code",
+    messages: {
+      preferEnumItem: "Use `{{ expected }}` instead of `{{ value }}`. EnumItems provide type safety and avoid magic values."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          fixNumericToValue: {
+            default: false,
+            description: "When true, numeric literals fix to Enum.X.Y.Value instead of Enum.X.Y",
+            type: "boolean"
+          },
+          performanceMode: {
+            default: false,
+            description: "When true, uses caching to speed up enum lookups without changing behavior",
+            type: "boolean"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "suggestion"
+  },
+  name: "prefer-enum-item"
+});
+
+// src/rules/prefer-module-scope-constants.ts
+var import_scope_manager3 = __toESM(require_dist2(), 1);
+import { AST_NODE_TYPES as AST_NODE_TYPES8 } from "@typescript-eslint/utils";
+var SCREAMING_SNAKE_CASE = /^[A-Z][A-Z0-9_]*$/;
+function isTopScope(scope) {
+  const { type: type3 } = scope;
+  if (type3 === import_scope_manager3.ScopeType.module || type3 === import_scope_manager3.ScopeType.global)
+    return true;
+  if (scope.upper?.type === import_scope_manager3.ScopeType.global) {
+    const { block } = scope.upper;
+    if (block.type === AST_NODE_TYPES8.Program && block.sourceType === "script")
+      return true;
+  }
+  return false;
+}
+var prefer_module_scope_constants_default = createRule({
+  create(context) {
+    let inConstDeclaration = false;
+    return {
+      VariableDeclaration(node) {
+        inConstDeclaration = node.kind === "const";
+      },
+      "VariableDeclaration:exit"() {
+        inConstDeclaration = false;
+      },
+      VariableDeclarator(node) {
+        const { id: id2 } = node;
+        if (id2.type !== AST_NODE_TYPES8.Identifier || !SCREAMING_SNAKE_CASE.test(id2.name))
+          return;
+        if (!inConstDeclaration) {
+          context.report({
+            messageId: "mustUseConst",
+            node
+          });
+          return;
+        }
+        const scope = context.sourceCode.getScope(node);
+        if (isTopScope(scope))
+          return;
+        context.report({
+          messageId: "mustBeModuleScope",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
   meta: {
     docs: {
       description: "Prefer that screaming snake case variables always be defined using `const`, and always appear at module scope."
@@ -19800,7 +20886,7 @@ var prefer_module_scope_constants_default = createRule({
 });
 
 // src/rules/prefer-pascal-case-enums.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES8 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES9 } from "@typescript-eslint/utils";
 
 // src/utilities/casing-utilities.ts
 var SPLIT_LOWER_TO_UPPER = regex2("([\\p{Ll}\\d])(\\p{Lu})", "gu");
@@ -19840,9 +20926,9 @@ function toPascalCase(value) {
 // src/rules/prefer-pascal-case-enums.ts
 var STARTS_WITH_DIGIT = regex2("^\\d");
 function getIdentifierName(node) {
-  if (node.type === AST_NODE_TYPES8.Identifier)
+  if (node.type === AST_NODE_TYPES9.Identifier)
     return node.name;
-  if (node.type !== AST_NODE_TYPES8.Literal || typeof node.value !== "string")
+  if (node.type !== AST_NODE_TYPES9.Literal || typeof node.value !== "string")
     return;
   return STARTS_WITH_DIGIT.test(node.value) ? undefined : node.value;
 }
@@ -19885,17 +20971,17 @@ var prefer_pascal_case_enums_default = createRule({
 });
 
 // src/utilities/pattern-replacement/pattern-matcher.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES10 } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES11 } from "@typescript-eslint/types";
 
 // src/utilities/pattern-replacement/constant-folder.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES9 } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES10 } from "@typescript-eslint/types";
 function normalizeZero(num) {
   return Object.is(num, -0) ? 0 : num;
 }
 function unwrap(node) {
   switch (node.type) {
-    case AST_NODE_TYPES9.TSAsExpression:
-    case AST_NODE_TYPES9.TSNonNullExpression:
+    case AST_NODE_TYPES10.TSAsExpression:
+    case AST_NODE_TYPES10.TSNonNullExpression:
       return unwrap(node.expression);
     default:
       return node;
@@ -19903,10 +20989,10 @@ function unwrap(node) {
 }
 function evaluateConstant(node) {
   const expression = unwrap(node);
-  if (expression.type === AST_NODE_TYPES9.Literal && typeof expression.value === "number") {
+  if (expression.type === AST_NODE_TYPES10.Literal && typeof expression.value === "number") {
     return normalizeZero(expression.value);
   }
-  if (expression.type === AST_NODE_TYPES9.UnaryExpression) {
+  if (expression.type === AST_NODE_TYPES10.UnaryExpression) {
     const argument = evaluateConstant(expression.argument);
     if (argument === undefined)
       return;
@@ -19919,8 +21005,8 @@ function evaluateConstant(node) {
         return;
     }
   }
-  if (expression.type === AST_NODE_TYPES9.BinaryExpression) {
-    if (expression.left.type === AST_NODE_TYPES9.PrivateIdentifier)
+  if (expression.type === AST_NODE_TYPES10.BinaryExpression) {
+    if (expression.left.type === AST_NODE_TYPES10.PrivateIdentifier)
       return;
     const left = evaluateConstant(expression.left);
     const right = evaluateConstant(expression.right);
@@ -19963,14 +21049,14 @@ function buildPatternIndex(patterns2) {
 }
 function resolveCallee(node) {
   const callee = unwrap(node.callee);
-  if (node.type === AST_NODE_TYPES10.NewExpression && callee.type === AST_NODE_TYPES10.Identifier) {
+  if (node.type === AST_NODE_TYPES11.NewExpression && callee.type === AST_NODE_TYPES11.Identifier) {
     return { kind: "constructor", typeName: callee.name };
   }
-  if (node.type === AST_NODE_TYPES10.CallExpression) {
-    const member = callee.type === AST_NODE_TYPES10.ChainExpression ? unwrap(callee.expression) : callee;
-    if (member.type === AST_NODE_TYPES10.MemberExpression && !member.computed) {
+  if (node.type === AST_NODE_TYPES11.CallExpression) {
+    const member = callee.type === AST_NODE_TYPES11.ChainExpression ? unwrap(callee.expression) : callee;
+    if (member.type === AST_NODE_TYPES11.MemberExpression && !member.computed) {
       const object3 = unwrap(member.object);
-      if (object3.type === AST_NODE_TYPES10.Identifier && member.property.type === AST_NODE_TYPES10.Identifier) {
+      if (object3.type === AST_NODE_TYPES11.Identifier && member.property.type === AST_NODE_TYPES11.Identifier) {
         return {
           kind: "staticMethod",
           methodName: member.property.name,
@@ -19987,9 +21073,9 @@ function captureParameter(node, sourceCode) {
   const constValue = evaluateConstant(expression);
   let expressionKey;
   let isComplex = false;
-  if (expression.type === AST_NODE_TYPES10.Literal && typeof expression.value === "number") {
+  if (expression.type === AST_NODE_TYPES11.Literal && typeof expression.value === "number") {
     expressionKey = `literal:${normalizeZero(expression.value)}`;
-  } else if (expression.type === AST_NODE_TYPES10.Identifier) {
+  } else if (expression.type === AST_NODE_TYPES11.Identifier) {
     if (expression.name === "undefined")
       expressionKey = "undefined";
     else
@@ -20015,7 +21101,7 @@ function matchParameters(patterns2, parameters3, sourceCode) {
       continue;
     const parameter2 = parameters3[index2];
     const unwrappedParameter = parameter2 === undefined ? undefined : unwrap(parameter2);
-    const isMissing = parameter2 === undefined || unwrappedParameter?.type === AST_NODE_TYPES10.Identifier && unwrappedParameter.name === "undefined";
+    const isMissing = parameter2 === undefined || unwrappedParameter?.type === AST_NODE_TYPES11.Identifier && unwrappedParameter.name === "undefined";
     if (pattern4.kind === "literal") {
       if (isMissing)
         return;
@@ -20305,13 +21391,13 @@ var prefer_pattern_replacements_default = createRule({
 });
 
 // src/rules/prefer-sequence-overloads.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES11 } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES12 } from "@typescript-eslint/types";
 var sequenceDescriptors = [
   { keypointName: "ColorSequenceKeypoint", sequenceName: "ColorSequence" },
   { keypointName: "NumberSequenceKeypoint", sequenceName: "NumberSequence" }
 ];
 function isSequenceIdentifier(node) {
-  if (node.type !== AST_NODE_TYPES11.Identifier)
+  if (node.type !== AST_NODE_TYPES12.Identifier)
     return false;
   for (const { sequenceName } of sequenceDescriptors)
     if (sequenceName === node.name)
@@ -20325,16 +21411,16 @@ function findDescriptor(sequenceName) {
   return;
 }
 var isNumericLiteral = Compile(build_default.Object({
-  type: build_default.Literal(AST_NODE_TYPES11.Literal),
+  type: build_default.Literal(AST_NODE_TYPES12.Literal),
   value: build_default.Number()
 }));
 function isExpressionArgument(argument) {
-  return argument !== undefined && argument.type !== AST_NODE_TYPES11.SpreadElement;
+  return argument !== undefined && argument.type !== AST_NODE_TYPES12.SpreadElement;
 }
 function extractKeypoint(element, descriptor) {
-  if (element === undefined || element.type !== AST_NODE_TYPES11.NewExpression)
+  if (element === undefined || element.type !== AST_NODE_TYPES12.NewExpression)
     return;
-  if (element.callee.type !== AST_NODE_TYPES11.Identifier || element.callee.name !== descriptor.keypointName)
+  if (element.callee.type !== AST_NODE_TYPES12.Identifier || element.callee.name !== descriptor.keypointName)
     return;
   if (element.arguments.length !== 2)
     return;
@@ -20360,7 +21446,7 @@ var prefer_sequence_overloads_default = createRule({
         if (descriptor === undefined || node.arguments.length !== 1)
           return;
         const [argument] = node.arguments;
-        if (argument === undefined || argument.type !== AST_NODE_TYPES11.ArrayExpression || argument.elements.length !== 2)
+        if (argument === undefined || argument.type !== AST_NODE_TYPES12.ArrayExpression || argument.elements.length !== 2)
           return;
         const firstElement = argument.elements[0] ?? undefined;
         const secondElement = argument.elements[1] ?? undefined;
@@ -20597,51 +21683,70 @@ function reconstructText(node) {
   }
   return text;
 }
+function evaluateLiteral(node) {
+  const { value } = node;
+  return isNumber(value) ? value : undefined;
+}
+function evaluateUnary(node) {
+  const { argument, operator } = node;
+  if (!isRecord3(argument))
+    return;
+  const argumentValue = evaluateExpression(argument);
+  if (argumentValue === undefined)
+    return;
+  if (operator === "-")
+    return -argumentValue;
+  if (operator === "+")
+    return argumentValue;
+  return;
+}
+function evaluateBinaryOperation(operator, left, right) {
+  switch (operator) {
+    case "+":
+      return left + right;
+    case "-":
+      return left - right;
+    case "*":
+      return left * right;
+    case "/":
+      return right === 0 ? undefined : left / right;
+    case "%":
+      return right === 0 ? undefined : left % right;
+    default:
+      return;
+  }
+}
+function evaluateBinary(node) {
+  const { right, left, operator } = node;
+  if (!(isRecord3(left) && isRecord3(right)))
+    return;
+  if (typeof operator !== "string" || !OPERATORS2.has(operator))
+    return;
+  const leftValue = evaluateExpression(left);
+  const rightValue = evaluateExpression(right);
+  if (leftValue === undefined || rightValue === undefined)
+    return;
+  return evaluateBinaryOperation(operator, leftValue, rightValue);
+}
 function evaluateExpression(node) {
   if (!isRecord3(node))
     return;
-  const nodeType = node.type;
-  let value;
-  if (nodeType === TSESTree7.AST_NODE_TYPES.Literal) {
-    const { value: literalValue } = node;
-    value = isNumber(literalValue) ? literalValue : undefined;
-  }
-  if (nodeType === TSESTree7.AST_NODE_TYPES.UnaryExpression) {
-    const { argument, operator } = node;
-    if (isRecord3(argument)) {
-      const argumentValue = evaluateExpression(argument);
-      if (operator === "-" && argumentValue !== undefined)
-        value = -argumentValue;
-      if (operator === "+" && argumentValue !== undefined)
-        value = argumentValue;
-    }
-  }
-  if (nodeType === TSESTree7.AST_NODE_TYPES.BinaryExpression) {
-    const { right, left, operator } = node;
-    if (isRecord3(left) && isRecord3(right) && typeof operator === "string" && OPERATORS2.has(operator)) {
-      const leftValue = evaluateExpression(left);
-      const rightValue = evaluateExpression(right);
-      if (leftValue !== undefined && rightValue !== undefined) {
-        if (operator === "+")
-          value = leftValue + rightValue;
-        if (operator === "-")
-          value = leftValue - rightValue;
-        if (operator === "*")
-          value = leftValue * rightValue;
-        if (operator === "/")
-          value = rightValue === 0 ? undefined : leftValue / rightValue;
-        if (operator === "%")
-          value = rightValue === 0 ? undefined : leftValue % rightValue;
-      }
-    }
+  switch (node.type) {
+    case TSESTree7.AST_NODE_TYPES.Literal:
+      return evaluateLiteral(node);
+    case TSESTree7.AST_NODE_TYPES.UnaryExpression:
+      return evaluateUnary(node);
+    case TSESTree7.AST_NODE_TYPES.BinaryExpression:
+      return evaluateBinary(node);
+    default:
+      return;
   }
-  return value;
 }
 function collectArguments(_context2, parameters3) {
   if (parameters3.length !== 4)
     return;
-  const texts = [undefined, undefined, undefined, undefined];
-  for (let index2 = 0;index2 < 4; index2++) {
+  const texts = new Array(4);
+  for (let index2 = 0;index2 < 4; index2 += 1) {
     const parameter2 = parameters3[index2];
     if (!(isRecord3(parameter2) && hasTypeProperty(parameter2)))
       return;
@@ -20653,8 +21758,9 @@ function collectArguments(_context2, parameters3) {
     texts[index2] = text;
   }
   const [scaleXText, offsetXText, scaleYText, offsetYText] = texts;
-  if (scaleXText === undefined || offsetXText === undefined || scaleYText === undefined || offsetYText === undefined)
+  if (scaleXText === undefined || offsetXText === undefined || scaleYText === undefined || offsetYText === undefined) {
     return;
+  }
   return { offsetXText, offsetYText, scaleXText, scaleYText };
 }
 var preferUDim2Shorthand = {
@@ -20708,16 +21814,16 @@ var preferUDim2Shorthand = {
 var prefer_udim2_shorthand_default = preferUDim2Shorthand;
 
 // src/rules/react-hooks-strict-return.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES12 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES13 } from "@typescript-eslint/utils";
 var MAX_RETURN_ELEMENTS = 2;
 var HOOK_PATTERN = /^use[A-Z0-9].*$/;
 function isHookNode(node) {
   let name;
-  if (node.type === AST_NODE_TYPES12.VariableDeclarator && node.id.type === AST_NODE_TYPES12.Identifier) {
+  if (node.type === AST_NODE_TYPES13.VariableDeclarator && node.id.type === AST_NODE_TYPES13.Identifier) {
     ({ name } = node.id);
-  } else if (node.type === AST_NODE_TYPES12.FunctionDeclaration && node.id)
+  } else if (node.type === AST_NODE_TYPES13.FunctionDeclaration && node.id)
     ({ name } = node.id);
-  else if (node.type === AST_NODE_TYPES12.FunctionExpression && node.id)
+  else if (node.type === AST_NODE_TYPES13.FunctionExpression && node.id)
     ({ name } = node.id);
   return name !== undefined && HOOK_PATTERN.test(name);
 }
@@ -20741,27 +21847,27 @@ function getArrayElementsFromVariable(scope, name) {
     if (!identifier3.parent)
       continue;
     const { parent } = identifier3;
-    if (parent.type !== AST_NODE_TYPES12.VariableDeclarator)
+    if (parent.type !== AST_NODE_TYPES13.VariableDeclarator)
       continue;
-    if (!parent.init || parent.init.type !== AST_NODE_TYPES12.ArrayExpression)
+    if (!parent.init || parent.init.type !== AST_NODE_TYPES13.ArrayExpression)
       continue;
     elements.push(...parent.init.elements);
   }
   return elements;
 }
 function countReturnElements(argument, scope) {
-  if (argument.type === AST_NODE_TYPES12.Identifier)
+  if (argument.type === AST_NODE_TYPES13.Identifier)
     return getArrayElementsFromVariable(scope, argument.name).length;
-  if (argument.type !== AST_NODE_TYPES12.ArrayExpression)
+  if (argument.type !== AST_NODE_TYPES13.ArrayExpression)
     return 0;
   let count = 0;
   for (const element of argument.elements) {
     if (element === null)
       count += 1;
-    else if (element.type === AST_NODE_TYPES12.SpreadElement) {
-      if (element.argument.type === AST_NODE_TYPES12.Identifier) {
+    else if (element.type === AST_NODE_TYPES13.SpreadElement) {
+      if (element.argument.type === AST_NODE_TYPES13.Identifier) {
         count += getArrayElementsFromVariable(scope, element.argument.name).length;
-      } else if (element.argument.type === AST_NODE_TYPES12.ArrayExpression) {
+      } else if (element.argument.type === AST_NODE_TYPES13.ArrayExpression) {
         count += element.argument.elements.length;
       } else
         count += 1;
@@ -20774,14 +21880,14 @@ function exceedsMaxReturnProperties(node, scope) {
   const { argument } = node;
   if (argument === null)
     return false;
-  if (argument.type === AST_NODE_TYPES12.ObjectExpression)
+  if (argument.type === AST_NODE_TYPES13.ObjectExpression)
     return false;
-  if (argument.type === AST_NODE_TYPES12.Identifier) {
+  if (argument.type === AST_NODE_TYPES13.Identifier) {
     const variable = getVariableByName(scope, argument.name);
     if (variable) {
       for (const { identifier: identifier3 } of variable.references) {
         const { parent } = identifier3;
-        if (parent?.type === AST_NODE_TYPES12.VariableDeclarator && parent.init?.type === AST_NODE_TYPES12.ObjectExpression) {
+        if (parent?.type === AST_NODE_TYPES13.VariableDeclarator && parent.init?.type === AST_NODE_TYPES13.ObjectExpression) {
           return false;
         }
       }
@@ -20803,13 +21909,13 @@ var react_hooks_strict_return_default = createRule({
     return {
       ArrowFunctionExpression(node) {
         const { parent } = node;
-        if (parent?.type === AST_NODE_TYPES12.VariableDeclarator && parent.id.type === AST_NODE_TYPES12.Identifier && HOOK_PATTERN.test(parent.id.name)) {
+        if (parent?.type === AST_NODE_TYPES13.VariableDeclarator && parent.id.type === AST_NODE_TYPES13.Identifier && HOOK_PATTERN.test(parent.id.name)) {
           hookDepth += 1;
         }
       },
       "ArrowFunctionExpression:exit"(node) {
         const { parent } = node;
-        if (parent?.type === AST_NODE_TYPES12.VariableDeclarator && parent.id.type === AST_NODE_TYPES12.Identifier && HOOK_PATTERN.test(parent.id.name)) {
+        if (parent?.type === AST_NODE_TYPES13.VariableDeclarator && parent.id.type === AST_NODE_TYPES13.Identifier && HOOK_PATTERN.test(parent.id.name)) {
           hookDepth -= 1;
         }
       },
@@ -20890,6 +21996,67 @@ function getHookName3(callExpression) {
   }
   return;
 }
+function findVariableInScope(identifier3, scope) {
+  let variable;
+  let currentScope = scope;
+  while (typeof currentScope === "object" && currentScope !== null) {
+    const current = currentScope;
+    variable = current.set.get(identifier3.name);
+    if (typeof variable === "object" && variable !== null)
+      break;
+    currentScope = current.upper;
+  }
+  return variable;
+}
+function processFunctionDeclaration(node) {
+  const castNode = node;
+  return {
+    isAsync: Boolean(castNode.async),
+    node,
+    type: "function-declaration"
+  };
+}
+function processArrowFunction(init) {
+  const arrowNode = init;
+  return {
+    isAsync: Boolean(init.async),
+    node: arrowNode,
+    type: "arrow"
+  };
+}
+function processFunctionExpression(init) {
+  const exprNode = init;
+  return {
+    isAsync: Boolean(init.async),
+    node: exprNode,
+    type: "function-expression"
+  };
+}
+function checkVariableDeclaratorDef(node) {
+  const castNode = node;
+  if (castNode.type !== TSESTree8.AST_NODE_TYPES.VariableDeclarator)
+    return;
+  if (typeof castNode.init !== "object" || castNode.init === null)
+    return;
+  const castInit = castNode.init;
+  if (castInit.type === TSESTree8.AST_NODE_TYPES.ArrowFunctionExpression)
+    return processArrowFunction(castNode.init);
+  if (castInit.type === TSESTree8.AST_NODE_TYPES.FunctionExpression)
+    return processFunctionExpression(castNode.init);
+  return;
+}
+function processSingleDefinition(definition) {
+  if (typeof definition !== "object" || definition === null)
+    return;
+  const castDef = definition;
+  const { node } = castDef;
+  if (typeof node !== "object" || node === null)
+    return;
+  const castNode = node;
+  if (castNode.type === TSESTree8.AST_NODE_TYPES.FunctionDeclaration)
+    return processFunctionDeclaration(node);
+  return checkVariableDeclaratorDef(node);
+}
 function resolveIdentifierToFunction(identifier3, context) {
   try {
     const scope = context.sourceCode.getScope?.(identifier3);
@@ -20899,54 +22066,16 @@ function resolveIdentifierToFunction(identifier3, context) {
     const setVal = scopeObj.set;
     if (!(setVal instanceof Map))
       return;
-    let variable;
-    let currentScope = scope;
-    while (typeof currentScope === "object" && currentScope !== null) {
-      const current = currentScope;
-      variable = current.set.get(identifier3.name);
-      if (typeof variable === "object" && variable !== null)
-        break;
-      currentScope = current.upper;
-    }
+    const variable = findVariableInScope(identifier3, scope);
     if (typeof variable !== "object" || variable === null)
       return;
     const castVariable = variable;
     if (!Array.isArray(castVariable.defs) || castVariable.defs.length === 0)
       return;
     for (const definition of castVariable.defs) {
-      if (typeof definition !== "object" || definition === null)
-        continue;
-      const castDefinition = definition;
-      const { node } = castDefinition;
-      if (typeof node !== "object" || node === null)
-        continue;
-      const castNode = node;
-      if (castNode.type === TSESTree8.AST_NODE_TYPES.FunctionDeclaration) {
-        return {
-          isAsync: Boolean(castNode.async),
-          node,
-          type: "function-declaration"
-        };
-      }
-      if (castNode.type === TSESTree8.AST_NODE_TYPES.VariableDeclarator && typeof castNode.init === "object" && castNode.init !== null) {
-        const castInit = castNode.init;
-        if (castInit.type === TSESTree8.AST_NODE_TYPES.ArrowFunctionExpression) {
-          const arrowNode = castNode.init;
-          return {
-            isAsync: Boolean(arrowNode.async),
-            node: arrowNode,
-            type: "arrow"
-          };
-        }
-        if (castInit.type === TSESTree8.AST_NODE_TYPES.FunctionExpression) {
-          const castInitNode = castNode.init;
-          return {
-            isAsync: Boolean(castInitNode.async),
-            node: castInitNode,
-            type: "function-expression"
-          };
-        }
-      }
+      const result = processSingleDefinition(definition);
+      if (result !== undefined)
+        return result;
     }
     return;
   } catch {
@@ -21178,7 +22307,7 @@ var requireNamedEffectFunctions = {
 var require_named_effect_functions_default = requireNamedEffectFunctions;
 
 // src/rules/require-paired-calls.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES13 } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES14 } from "@typescript-eslint/types";
 var isStringArray = Compile(build_default.Readonly(build_default.Array(build_default.String())));
 var isPairConfiguration = Compile(build_default.Readonly(build_default.Object({
   alternatives: build_default.Optional(isStringArray),
@@ -21196,20 +22325,20 @@ var isRuleOptions4 = Compile(build_default.Partial(build_default.Readonly(build_
   pairs: build_default.Readonly(build_default.Array(isPairConfiguration))
 }))));
 var LOOP_NODE_TYPES = new Set([
-  AST_NODE_TYPES13.DoWhileStatement,
-  AST_NODE_TYPES13.ForInStatement,
-  AST_NODE_TYPES13.ForOfStatement,
-  AST_NODE_TYPES13.ForStatement,
-  AST_NODE_TYPES13.WhileStatement
+  AST_NODE_TYPES14.DoWhileStatement,
+  AST_NODE_TYPES14.ForInStatement,
+  AST_NODE_TYPES14.ForOfStatement,
+  AST_NODE_TYPES14.ForStatement,
+  AST_NODE_TYPES14.WhileStatement
 ]);
 var DEFAULT_ROBLOX_YIELDING_FUNCTIONS = ["task.wait", "wait", "*.WaitForChild", "*.*Async"];
 function getCallName(node) {
   const { callee } = node;
-  if (callee.type === AST_NODE_TYPES13.Identifier)
+  if (callee.type === AST_NODE_TYPES14.Identifier)
     return callee.name;
-  if (callee.type === AST_NODE_TYPES13.MemberExpression) {
-    const object3 = callee.object.type === AST_NODE_TYPES13.Identifier ? callee.object.name : undefined;
-    const property = callee.property.type === AST_NODE_TYPES13.Identifier ? callee.property.name : undefined;
+  if (callee.type === AST_NODE_TYPES14.MemberExpression) {
+    const object3 = callee.object.type === AST_NODE_TYPES14.Identifier ? callee.object.name : undefined;
+    const property = callee.property.type === AST_NODE_TYPES14.Identifier ? callee.property.name : undefined;
     if (object3 !== undefined && property !== undefined)
       return `${object3}.${property}`;
   }
@@ -21245,12 +22374,12 @@ function isLoopLikeStatement(node) {
   return LOOP_NODE_TYPES.has(node.type);
 }
 function isSwitchStatement(node) {
-  return node?.type === AST_NODE_TYPES13.SwitchStatement;
+  return node?.type === AST_NODE_TYPES14.SwitchStatement;
 }
 function findLabeledStatementBody(label, startingNode) {
   let current = startingNode;
   while (current) {
-    if (current.type === AST_NODE_TYPES13.LabeledStatement && current.label.name === label.name)
+    if (current.type === AST_NODE_TYPES14.LabeledStatement && current.label.name === label.name)
       return current.body;
     current = current.parent ?? undefined;
   }
@@ -21512,7 +22641,7 @@ var rule = {
     function onIfConsequentExit(node) {
       const consequentNode = node;
       const { parent } = consequentNode;
-      if (parent?.type === AST_NODE_TYPES13.IfStatement) {
+      if (parent?.type === AST_NODE_TYPES14.IfStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -21527,7 +22656,7 @@ var rule = {
     function onIfAlternateExit(node) {
       const alternateNode = node;
       const { parent } = alternateNode;
-      if (parent?.type === AST_NODE_TYPES13.IfStatement) {
+      if (parent?.type === AST_NODE_TYPES14.IfStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -21576,7 +22705,7 @@ var rule = {
     function onTryBlockExit(node) {
       const blockNode = node;
       const { parent } = blockNode;
-      if (parent?.type === AST_NODE_TYPES13.TryStatement) {
+      if (parent?.type === AST_NODE_TYPES14.TryStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -21595,7 +22724,7 @@ var rule = {
     function onCatchClauseExit(node) {
       const catchNode = node;
       const { parent } = catchNode;
-      if (parent?.type === AST_NODE_TYPES13.TryStatement) {
+      if (parent?.type === AST_NODE_TYPES14.TryStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -21658,7 +22787,7 @@ var rule = {
     function onSwitchCaseExit(node) {
       const caseNode = node;
       const { parent } = caseNode;
-      if (parent?.type === AST_NODE_TYPES13.SwitchStatement) {
+      if (parent?.type === AST_NODE_TYPES14.SwitchStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -21689,7 +22818,7 @@ var rule = {
       for (const { opener, config, node: node2 } of openerStack) {
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const statementType = statementNode.type === AST_NODE_TYPES13.ReturnStatement ? "return" : "throw";
+        const statementType = statementNode.type === AST_NODE_TYPES14.ReturnStatement ? "return" : "throw";
         const lineNumber = statementNode.loc?.start.line ?? 0;
         context.report({
           data: {
@@ -21706,7 +22835,7 @@ var rule = {
       const statementNode = node;
       if (openerStack.length === 0)
         return;
-      const targetLoop = statementNode.type === AST_NODE_TYPES13.ContinueStatement ? resolveContinueTargetLoop(statementNode) : resolveBreakTargetLoop(statementNode);
+      const targetLoop = statementNode.type === AST_NODE_TYPES14.ContinueStatement ? resolveContinueTargetLoop(statementNode) : resolveBreakTargetLoop(statementNode);
       if (!targetLoop)
         return;
       for (const { node: openerNode, config, opener, loopAncestors } of openerStack) {
@@ -21714,7 +22843,7 @@ var rule = {
           continue;
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const statementType = statementNode.type === AST_NODE_TYPES13.BreakStatement ? "break" : "continue";
+        const statementType = statementNode.type === AST_NODE_TYPES14.BreakStatement ? "break" : "continue";
         const lineNumber = statementNode.loc?.start.line ?? 0;
         context.report({
           data: {
@@ -21852,7 +22981,7 @@ var rule = {
           continue;
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const asyncType = asyncNode.type === AST_NODE_TYPES13.AwaitExpression ? "await" : "yield";
+        const asyncType = asyncNode.type === AST_NODE_TYPES14.AwaitExpression ? "await" : "yield";
         context.report({
           data: { asyncType, closer, opener },
           messageId: "asyncViolation",
@@ -23880,6 +25009,7 @@ var rules = {
   "no-warn": no_warn_default,
   "prefer-class-properties": prefer_class_properties_default,
   "prefer-early-return": prefer_early_return_default,
+  "prefer-enum-item": prefer_enum_item_default,
   "prefer-module-scope-constants": prefer_module_scope_constants_default,
   "prefer-pascal-case-enums": prefer_pascal_case_enums_default,
   "prefer-pattern-replacements": prefer_pattern_replacements_default,
@@ -23946,4 +25076,4 @@ export {
   createBanInstancesOptions
 };
 
-//# debugId=2B2944174D0F631464756E2164756E21
+//# debugId=A96F64DDBF4FBDA864756E2164756E21