eslint-plugin-react-x 1.23.3-next.7 → 1.24.0-beta.0

package/dist/index.mjs

@@ -1,8 +1,8 @@
-import { F, O, isString, not, or, isNullable } from '@eslint-react/eff';
 import * as JSX7 from '@eslint-react/jsx';
 import { createRuleForPlugin, getSettingsFromContext, unsafeDecodeSettings } from '@eslint-react/shared';
 import * as AST11 from '@eslint-react/ast';
 import { isForwardRefCall, isThisSetState, isClassComponent, isChildrenCount, isChildrenForEach, isChildrenMap, isChildrenOnly, isChildrenToArray, useComponentCollectorLegacy, isCloneElementCall, isCreateRefCall, isComponentName, useComponentCollector, ERFunctionComponentFlag, isChildrenToArrayCall, ERComponentHint, isDirectValueOfRenderPropertyLoose, isDeclaredInRenderPropLoose, isInsideCreateElementProps, isInsideRenderMethod, ERClassComponentFlag, isReactHookCall, isCreateElementCall, isInitializedFromReact } from '@eslint-react/core';
+import { _ } from '@eslint-react/eff';
 import { AST_NODE_TYPES } from '@typescript-eslint/types';
 import { isMatching, match, P } from 'ts-pattern';
 import { compare } from 'compare-versions';
@@ -15,7 +15,7 @@ import { getTypeImmutability, isUnknown, isImmutable, isReadonlyShallow, isReado
 
 // package.json
 var name = "eslint-plugin-react-x";
-var version = "1.23.3-next.7";
+var version = "1.24.0-beta.0";
 var createRule = createRuleForPlugin("x");
 
 // src/rules/avoid-shorthand-boolean.ts
@@ -38,18 +38,19 @@ var avoid_shorthand_boolean_default = createRule({
   },
   name: RULE_NAME,
   create(context) {
-    function getReportDescriptor(node) {
-      return node.value != null ? O.none() : O.some({
-        messageId: "avoidShorthandBoolean",
-        node,
-        data: {
-          propName: JSX7.getPropName(node)
-        },
-        fix: (fixer) => fixer.insertTextAfter(node.name, `={true}`)
-      });
-    }
     return {
-      JSXAttribute: F.flow(getReportDescriptor, O.map(context.report))
+      JSXAttribute(node) {
+        if (node.value === null) {
+          context.report({
+            messageId: "avoidShorthandBoolean",
+            node,
+            data: {
+              propName: JSX7.getPropName(node)
+            },
+            fix: (fixer) => fixer.insertTextAfter(node.name, `={true}`)
+          });
+        }
+      }
     };
   },
   defaultOptions: []
@@ -112,7 +113,7 @@ var ensure_forward_ref_using_ref_default = createRule({
         if (component == null || !AST11.isFunction(component)) {
           return;
         }
-        const [_, ref] = component.params;
+        const ref = component.params[1];
         if (ref != null) {
           return;
         }
@@ -134,15 +135,15 @@ function getName(node) {
     return getName(node.expression);
   }
   if (node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.PrivateIdentifier) {
-    return O.some(node.name);
+    return node.name;
   }
   if (node.type === AST_NODE_TYPES.Literal) {
-    return O.some(String(node.value));
+    return String(node.value);
   }
   if (node.type === AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0) {
-    return O.fromNullable(node.quasis[0]?.value.raw);
+    return node.quasis[0]?.value.raw;
   }
-  return O.none();
+  return _;
 }
 var no_access_state_in_setstate_default = createRule({
   meta: {
@@ -161,89 +162,86 @@ var no_access_state_in_setstate_default = createRule({
     if (!context.sourceCode.text.includes("setState")) {
       return {};
     }
-    const classStack = [];
-    const methodStack = [];
-    const setStateStack = [];
+    const classEntries = [];
+    const methodEntries = [];
+    const setStateEntries = [];
     return {
       CallExpression(node) {
         if (!isThisSetState(node)) {
           return;
         }
-        setStateStack.push([node, false]);
+        setStateEntries.push([node, false]);
       },
       "CallExpression:exit"(node) {
         if (!isThisSetState(node)) {
           return;
         }
-        setStateStack.pop();
+        setStateEntries.pop();
       },
       ClassDeclaration(node) {
-        classStack.push([node, isClassComponent(node)]);
+        classEntries.push([node, isClassComponent(node)]);
       },
       "ClassDeclaration:exit"() {
-        classStack.pop();
+        classEntries.pop();
       },
       ClassExpression(node) {
-        classStack.push([node, isClassComponent(node)]);
+        classEntries.push([node, isClassComponent(node)]);
       },
       "ClassExpression:exit"() {
-        classStack.pop();
+        classEntries.pop();
       },
       MemberExpression(node) {
         if (!AST11.isThisExpression(node.object)) {
           return;
         }
-        const [currClass, isComponent] = classStack.at(-1) ?? [];
+        const [currClass, isComponent] = classEntries.at(-1) ?? [];
         if (currClass == null || !isComponent) {
           return;
         }
-        const [currMethod, isStatic] = methodStack.at(-1) ?? [];
+        const [currMethod, isStatic] = methodEntries.at(-1) ?? [];
         if (currMethod == null || isStatic) {
           return;
         }
-        const [setState, hasThisState] = setStateStack.at(-1) ?? [];
+        const [setState, hasThisState] = setStateEntries.at(-1) ?? [];
         if (setState == null || hasThisState) {
           return;
         }
-        if (!O.exists(getName(node.property), (name2) => name2 === "state")) {
+        if (getName(node.property) !== "state") {
           return;
         }
         context.report({ messageId: "noAccessStateInSetstate", node });
       },
       MethodDefinition(node) {
-        methodStack.push([node, node.static]);
+        methodEntries.push([node, node.static]);
       },
       "MethodDefinition:exit"() {
-        methodStack.pop();
+        methodEntries.pop();
       },
       PropertyDefinition(node) {
-        methodStack.push([node, node.static]);
+        methodEntries.push([node, node.static]);
       },
       "PropertyDefinition:exit"() {
-        methodStack.pop();
+        methodEntries.pop();
       },
       VariableDeclarator(node) {
-        const [currClass, isComponent] = classStack.at(-1) ?? [];
+        const [currClass, isComponent] = classEntries.at(-1) ?? [];
         if (currClass == null || !isComponent) {
           return;
         }
-        const [currMethod, isStatic] = methodStack.at(-1) ?? [];
+        const [currMethod, isStatic] = methodEntries.at(-1) ?? [];
         if (currMethod == null || isStatic) {
           return;
         }
-        const [setState, hasThisState] = setStateStack.at(-1) ?? [];
+        const [setState, hasThisState] = setStateEntries.at(-1) ?? [];
         if (setState == null || hasThisState) {
           return;
         }
         if (!(node.init != null && AST11.isThisExpression(node.init) && node.id.type === AST_NODE_TYPES.ObjectPattern)) {
           return;
         }
-        const hasState = node.id.properties.some((prop) => {
-          if (prop.type === AST_NODE_TYPES.Property && AST11.isKeyLiteralLike(prop, prop.key)) {
-            return O.exists(getName(prop.key), (name2) => name2 === "state");
-          }
-          return false;
-        });
+        const hasState = node.id.properties.some(
+          (prop) => prop.type === AST_NODE_TYPES.Property && AST11.isKeyLiteralLike(prop, prop.key) && getName(prop.key) === "state"
+        );
         if (!hasState) {
           return;
         }
@@ -296,32 +294,32 @@ function isUsingReactChildren(node, context) {
 function getMapIndexParamName(node, context) {
   const { callee } = node;
   if (callee.type !== AST_NODE_TYPES.MemberExpression) {
-    return O.none();
+    return _;
   }
   if (callee.property.type !== AST_NODE_TYPES.Identifier) {
-    return O.none();
+    return _;
   }
   const { name: name2 } = callee.property;
   if (!iteratorFunctionIndexParamPosition.has(name2)) {
-    return O.none();
+    return _;
   }
   const callbackArg = node.arguments[isUsingReactChildren(node, context) ? 1 : 0];
   if (callbackArg == null) {
-    return O.none();
+    return _;
   }
   if (!AST11.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(callbackArg)) {
-    return O.none();
+    return _;
   }
   const { params } = callbackArg;
   const indexParamPosition = iteratorFunctionIndexParamPosition.get(name2);
-  if (isNullable(indexParamPosition)) {
-    return O.none();
+  if (indexParamPosition == null) {
+    return _;
   }
   if (params.length < indexParamPosition + 1) {
-    return O.none();
+    return _;
   }
   const param = params.at(indexParamPosition);
-  return param != null && "name" in param ? O.some(param.name) : O.none();
+  return param != null && "name" in param ? param.name : _;
 }
 var no_array_index_key_default = createRule({
   meta: {
@@ -339,7 +337,7 @@ var no_array_index_key_default = createRule({
   create(context) {
     const indexParamNames = [];
     function isArrayIndex(node) {
-      return node.type === AST_NODE_TYPES.Identifier && indexParamNames.some(O.exists((name2) => name2 === node.name));
+      return node.type === AST_NODE_TYPES.Identifier && indexParamNames.some((name2) => name2 != null && name2 === node.name);
     }
     function isCreateOrCloneElementCall(node) {
       return isCreateElementCall(node, context) || isCloneElementCall(node, context);
@@ -348,7 +346,7 @@ var no_array_index_key_default = createRule({
       switch (node.type) {
         // key={bar}
         case AST_NODE_TYPES.Identifier: {
-          if (indexParamNames.some(O.exists((name2) => name2 === node.name))) {
+          if (indexParamNames.some((name2) => name2 != null && name2 === node.name)) {
             return [{
               messageId: "noArrayIndexKey",
               node
@@ -402,7 +400,7 @@ var no_array_index_key_default = createRule({
         if (!isCreateOrCloneElementCall(node)) {
           return;
         }
-        const [_, props] = node.arguments;
+        const [, props] = node.arguments;
         if (props?.type !== AST_NODE_TYPES.ObjectExpression) {
           return;
         }
@@ -585,10 +583,17 @@ var no_children_prop_default = createRule({
   create(context) {
     return {
       JSXElement(node) {
-        const initialScope = context.sourceCode.getScope(node);
-        const prop = JSX7.getProp(node.openingElement.attributes, "children", initialScope);
-        const reportDescriptor = O.map(prop, (prop2) => ({ messageId: "noChildrenProp", node: prop2 }));
-        O.map(reportDescriptor, context.report);
+        const prop = JSX7.getProp(
+          "children",
+          context.sourceCode.getScope(node),
+          node.openingElement.attributes
+        );
+        if (prop) {
+          context.report({
+            messageId: "noChildrenProp",
+            node: prop
+          });
+        }
       }
     };
   },
@@ -657,7 +662,7 @@ var no_class_component_default = createRule({
       ...listeners,
       "Program:exit"(node) {
         const components = ctx.getAllComponents(node);
-        for (const { name: name2, node: component } of components.values()) {
+        for (const { name: name2 = "anonymous", node: component } of components.values()) {
           if (component.body.body.some((m) => isComponentDidCatch(m) || isGetDerivedStateFromError(m))) {
             continue;
           }
@@ -666,7 +671,7 @@ var no_class_component_default = createRule({
             node: component,
             data: {
               // eslint-disable-next-line eslint-plugin/no-unused-placeholders
-              name: O.getOrElse(F.constant("anonymous"))(name2)
+              name: name2
             }
           });
         }
@@ -732,22 +737,21 @@ var no_comment_textnodes_default = createRule({
       const rawValue = context.sourceCode.getText(node);
       return /^\s*\/(?:\/|\*)/mu.test(rawValue);
     }
-    const getReportDescriptor = (node) => {
+    const visitorFunction = (node) => {
       if (!AST11.isOneOf([AST_NODE_TYPES.JSXElement, AST_NODE_TYPES.JSXFragment])(node.parent)) {
-        return O.none();
+        return;
       }
       if (!hasCommentLike(node)) {
-        return O.none();
+        return;
       }
       if (!node.parent.type.includes("JSX")) {
-        return O.none();
+        return;
       }
-      return O.some({
+      context.report({
         messageId: "noCommentTextnodes",
         node
       });
     };
-    const visitorFunction = F.flow(getReportDescriptor, O.map(context.report), F.constVoid);
     return {
       JSXText: visitorFunction,
       Literal: visitorFunction
@@ -773,20 +777,22 @@ var no_complex_conditional_rendering_default = createRule({
   },
   name: RULE_NAME15,
   create(context) {
-    function getReportDescriptor(node) {
+    const visitorFunction = (node) => {
       const jsxExpContainer = node.parent?.parent;
       if (!AST11.is(AST_NODE_TYPES.JSXExpressionContainer)(jsxExpContainer)) {
-        return O.none();
+        return;
       }
       if (!AST11.isOneOf([AST_NODE_TYPES.JSXElement, AST_NODE_TYPES.JSXFragment])(jsxExpContainer.parent)) {
-        return O.none();
+        return;
       }
       if (!jsxExpContainer.parent.children.includes(jsxExpContainer)) {
-        return O.none();
+        return;
       }
-      return O.some({ messageId: "noComplexConditionalRendering", node: jsxExpContainer });
-    }
-    const visitorFunction = F.flow(getReportDescriptor, O.map(context.report), F.constVoid);
+      context.report({
+        messageId: "noComplexConditionalRendering",
+        node: jsxExpContainer
+      });
+    };
     return {
       "JSXExpressionContainer > ConditionalExpression > ConditionalExpression": visitorFunction,
       "JSXExpressionContainer > ConditionalExpression > LogicalExpression": visitorFunction,
@@ -1030,13 +1036,9 @@ var no_create_ref_default = createRule({
   create(context) {
     return {
       CallExpression(node) {
-        if (!isCreateRefCall(node, context)) {
-          return;
+        if (isCreateRefCall(node, context) && !AST11.findParentNode(node, isClassComponent)) {
+          context.report({ messageId: "noCreateRef", node });
         }
-        if (O.isSome(AST11.findParentNode(node, isClassComponent))) {
-          return;
-        }
-        context.report({ messageId: "noCreateRef", node });
       }
     };
   },
@@ -1078,14 +1080,10 @@ var no_default_props_default = createRule({
         if (!isComponentName(object.name)) {
           return;
         }
-        const isComponent = F.pipe(
-          VAR.findVariable(object.name, context.sourceCode.getScope(node)),
-          O.flatMap(VAR.getVariableNode(0)),
-          O.exists((n) => AST11.isFunction(n) || isClassComponent(n))
-        );
-        if (!isComponent) {
-          return;
-        }
+        const variable = VAR.findVariable(object.name, context.sourceCode.getScope(node));
+        const variableNode = VAR.getVariableNode(variable, 0);
+        if (variableNode === _) return;
+        if (!AST11.isFunction(variableNode) && !isClassComponent(variableNode)) return;
         context.report({ messageId: "noDefaultProps", node: property });
       },
       PropertyDefinition(node) {
@@ -1110,19 +1108,19 @@ function getName2(node) {
     return getName2(node.expression);
   }
   if (node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.PrivateIdentifier) {
-    return O.some(node.name);
+    return node.name;
   }
   if (node.type === AST_NODE_TYPES.Literal) {
-    return O.some(String(node.value));
+    return node.value?.toString();
   }
   if (node.type === AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0) {
-    return O.fromNullable(node.quasis[0]?.value.raw);
+    return node.quasis[0]?.value.raw;
   }
-  return O.none();
+  return _;
 }
 function isAssignmentToThisState(node) {
   const { left } = node;
-  return left.type === AST_NODE_TYPES.MemberExpression && AST11.isThisExpression(left.object) && O.exists(getName2(left.property), (name2) => name2 === "state");
+  return left.type === AST_NODE_TYPES.MemberExpression && AST11.isThisExpression(left.object) && getName2(left.property) === "state";
 }
 function isConstructorFunction(node) {
   return AST11.isOneOf([AST_NODE_TYPES.FunctionDeclaration, AST_NODE_TYPES.FunctionExpression])(node) && AST11.isOneOf([AST_NODE_TYPES.MethodDefinition, AST_NODE_TYPES.PropertyDefinition])(node.parent) && node.parent.key.type === AST_NODE_TYPES.Identifier && node.parent.key.name === "constructor";
@@ -1141,31 +1139,26 @@ var no_direct_mutation_state_default = createRule({
   },
   name: RULE_NAME22,
   create(context) {
-    function getReportDescriptor(node) {
-      if (!isAssignmentToThisState(node)) {
-        return O.none();
-      }
-      return F.pipe(
-        O.Do,
-        O.bind("parentClass", () => AST11.findParentNodeGuard(
+    return {
+      AssignmentExpression(node) {
+        if (!isAssignmentToThisState(node)) {
+          return;
+        }
+        const parentClass = AST11.findParentNodeGuard(
           node,
           AST11.isOneOf([
             AST_NODE_TYPES.ClassDeclaration,
             AST_NODE_TYPES.ClassExpression
           ])
-        )),
-        O.bind("parentConstructor", () => AST11.findParentNodeGuard(node, isConstructorFunction)),
-        O.filter(
-          ({ parentClass, parentConstructor }) => isClassComponent(parentClass) && context.sourceCode.getScope(node).block !== parentConstructor
-        ),
-        O.map(() => ({
-          messageId: "noDirectMutationState",
-          node
-        }))
-      );
-    }
-    return {
-      AssignmentExpression: F.flow(getReportDescriptor, O.map(context.report))
+        );
+        if (!parentClass) return;
+        if (isClassComponent(parentClass) && context.sourceCode.getScope(node).block !== AST11.findParentNodeGuard(node, isConstructorFunction)) {
+          context.report({
+            messageId: "noDirectMutationState",
+            node
+          });
+        }
+      }
     };
   },
   defaultOptions: []
@@ -1196,7 +1189,7 @@ var no_duplicate_jsx_props_default = createRule({
             continue;
           }
           const name2 = attr.name.name;
-          if (!isString(name2)) {
+          if (typeof name2 !== "string") {
             continue;
           }
           if (!props.includes(name2)) {
@@ -1260,16 +1253,10 @@ var no_duplicate_key_default = createRule({
             break;
           }
           default: {
-            const mbEntry = F.pipe(
-              O.Do,
-              O.bind("call", () => AST11.findParentNodeGuard(jsxElement, AST11.isMapCallLoose)),
-              O.bind("iter", ({ call: call2 }) => AST11.findParentNodeStop(jsxElement, call2, AST11.isFunction)),
-              O.bind("arg0", ({ call: call2 }) => O.fromNullable(call2.arguments[0]))
-            );
-            if (O.isNone(mbEntry)) {
-              return;
-            }
-            const { arg0, call, iter } = mbEntry.value;
+            const call = AST11.findParentNodeGuard(jsxElement, AST11.isMapCallLoose);
+            const iter = call && AST11.findParentNodeStop(jsxElement, call, AST11.isFunction);
+            const arg0 = call?.arguments[0];
+            if (!call || !iter || !arg0) return;
             if (AST11.unwrapTypeExpression(arg0) !== iter) {
               return;
             }
@@ -1370,21 +1357,19 @@ function getComponentPropsFixes(node, typeArguments, fixer, context) {
   if (arg0 == null) {
     return [];
   }
-  const fixedArg0Text = match(arg0).with({ type: AST_NODE_TYPES.Identifier }, (n) => O.some(`...${n.name}`)).with({ type: AST_NODE_TYPES.ObjectPattern }, (n) => O.some(n.properties.map(getText).join(", "))).otherwise(O.none);
-  const fixedArg1Text = match(arg1).with(P.nullish, () => O.some("ref")).with({ type: AST_NODE_TYPES.Identifier, name: "ref" }, () => O.some("ref")).with({ type: AST_NODE_TYPES.Identifier, name: P.not("ref") }, (n) => O.some(`ref: ${n.name}`)).otherwise(O.none);
-  if (O.isNone(fixedArg0Text) || O.isNone(fixedArg1Text)) {
+  const fixedArg0Text = match(arg0).with({ type: AST_NODE_TYPES.Identifier }, (n) => `...${n.name}`).with({ type: AST_NODE_TYPES.ObjectPattern }, (n) => n.properties.map(getText).join(", ")).otherwise(() => _);
+  const fixedArg1Text = match(arg1).with(P.nullish, () => "ref").with({ type: AST_NODE_TYPES.Identifier, name: "ref" }, () => "ref").with({ type: AST_NODE_TYPES.Identifier, name: P.not("ref") }, (n) => `ref: ${n.name}`).otherwise(() => _);
+  if (fixedArg0Text == null || fixedArg1Text == null) {
     return [];
   }
-  const fixedPropsText = fixedArg0Text.value;
-  const fixedRefText = fixedArg1Text.value;
   if (typeArg0 == null || typeArg1 == null) {
     return [
       fixer.replaceText(
         arg0,
         [
           "{",
-          fixedRefText + ",",
-          fixedPropsText,
+          fixedArg1Text + ",",
+          fixedArg0Text,
           "}"
         ].join(" ")
       ),
@@ -1396,8 +1381,8 @@ function getComponentPropsFixes(node, typeArguments, fixer, context) {
       arg0,
       [
         "{",
-        fixedRefText + ",",
-        fixedPropsText,
+        fixedArg1Text + ",",
+        fixedArg0Text,
         "}:",
         getText(typeArg1),
         "&",
@@ -1428,17 +1413,17 @@ var no_implicit_key_default = createRule({
   },
   name: RULE_NAME26,
   create(context) {
-    function getReportDescriptor(node) {
-      const initialScope = context.sourceCode.getScope(node);
-      const keyPropFound = JSX7.findPropInAttributes(node.attributes, initialScope)("key");
-      const keyPropOnElement = node.attributes.some((n) => AST11.is(AST_NODE_TYPES.JSXAttribute)(n) && n.name.name === "key");
-      if (O.isSome(keyPropFound) && !keyPropOnElement) {
-        return O.some({ messageId: "noImplicitKey", node: keyPropFound.value });
-      }
-      return O.none();
-    }
     return {
-      JSXOpeningElement: F.flow(getReportDescriptor, O.map(context.report))
+      JSXOpeningElement(node) {
+        const initialScope = context.sourceCode.getScope(node);
+        const keyPropFound = JSX7.findPropInAttributes("key", initialScope, node.attributes);
+        const keyPropOnElement = node.attributes.some(
+          (n) => n.type === AST_NODE_TYPES.JSXAttribute && n.name.type === AST_NODE_TYPES.JSXIdentifier && n.name.name === "key"
+        );
+        if (keyPropFound && !keyPropOnElement) {
+          context.report({ messageId: "noImplicitKey", node: keyPropFound });
+        }
+      }
     };
   },
   defaultOptions: []
@@ -1484,11 +1469,12 @@ function inspectVariantTypes(types) {
   const booleans = types.filter(tsHelpers.isBooleanType);
   switch (true) {
     case (booleans.length === 1 && booleans[0] != null): {
-      const [first] = booleans;
-      const evaluated = F.pipe(
-        match(first).when(isTrueLiteralType, () => O.some("truthy boolean")).when(isFalseLiteralType, () => O.some("falsy boolean")).otherwise(O.none)
-      );
-      O.map(evaluated, (v) => variantTypes.add(v));
+      const first = booleans[0];
+      if (isTrueLiteralType(first)) {
+        variantTypes.add("truthy boolean");
+      } else if (isFalseLiteralType(first)) {
+        variantTypes.add("falsy boolean");
+      }
       break;
     }
     case booleans.length === 2: {
@@ -1498,17 +1484,17 @@ function inspectVariantTypes(types) {
   }
   const strings = types.filter(tsHelpers.isStringType);
   if (strings.length > 0) {
-    const evaluated = match(strings).when((types2) => types2.every(tsHelpers.isTruthyStringType), F.constant("truthy string")).when((types2) => types2.every(tsHelpers.isFalsyStringType), F.constant("falsy string")).otherwise(F.constant("string"));
+    const evaluated = match(strings).when((types2) => types2.every(tsHelpers.isTruthyStringType), () => "truthy string").when((types2) => types2.every(tsHelpers.isFalsyStringType), () => "falsy string").otherwise(() => "string");
     variantTypes.add(evaluated);
   }
   const bigints = types.filter(tsHelpers.isBigIntType);
   if (bigints.length > 0) {
-    const evaluated = match(bigints).when((types2) => types2.every(tsHelpers.isTruthyBigIntType), F.constant("truthy bigint")).when((types2) => types2.every(tsHelpers.isFalsyBigIntType), F.constant("falsy bigint")).otherwise(F.constant("bigint"));
+    const evaluated = match(bigints).when((types2) => types2.every(tsHelpers.isTruthyBigIntType), () => "truthy bigint").when((types2) => types2.every(tsHelpers.isFalsyBigIntType), () => "falsy bigint").otherwise(() => "bigint");
     variantTypes.add(evaluated);
   }
   const numbers = types.filter(tsHelpers.isNumberType);
   if (numbers.length > 0) {
-    const evaluated = match(numbers).when((types2) => types2.every(tsHelpers.isTruthyNumberType), F.constant("truthy number")).when((types2) => types2.every(tsHelpers.isFalsyNumberType), F.constant("falsy number")).otherwise(F.constant("number"));
+    const evaluated = match(numbers).when((types2) => types2.every(tsHelpers.isTruthyNumberType), () => "truthy number").when((types2) => types2.every(tsHelpers.isFalsyNumberType), () => "falsy number").otherwise(() => "number");
     variantTypes.add(evaluated);
   }
   if (types.some(tsHelpers.isEnumType)) {
@@ -1526,19 +1512,15 @@ function inspectVariantTypes(types) {
   return variantTypes;
 }
 function isInitExpression(node) {
+  if (node == null) return false;
   return node.type !== AST_NODE_TYPES.VariableDeclaration;
 }
-function getVariableInitExpression(at) {
-  return (variable) => {
-    return F.pipe(
-      O.some(variable),
-      O.flatMapNullable((v) => v.defs.at(at)),
-      O.flatMap(
-        (d) => "init" in d.node ? O.fromNullable(d.node.init) : O.none()
-      ),
-      O.filter(isInitExpression)
-    );
-  };
+function getVariableInitExpression(variable, at) {
+  const def = variable?.defs[at];
+  if (def?.node === _ || !("init" in def.node)) {
+    return _;
+  }
+  return isInitExpression(def.node.init) ? def.node.init : _;
 }
 var no_leaked_conditional_rendering_default = createRule({
   meta: {
@@ -1572,19 +1554,20 @@ var no_leaked_conditional_rendering_default = createRule({
     ];
     const services = ESLintUtils.getParserServices(context, false);
     function getReportDescriptor(node) {
-      return match(node).when(AST11.isJSX, O.none).with({ type: AST_NODE_TYPES.LogicalExpression, operator: "&&" }, ({ left, right }) => {
+      if (node === _) return _;
+      return match(node).when(AST11.isJSX, () => _).with({ type: AST_NODE_TYPES.LogicalExpression, operator: "&&" }, ({ left, right }) => {
         const isLeftUnaryNot = left.type === AST_NODE_TYPES.UnaryExpression && left.operator === "!";
         if (isLeftUnaryNot) {
           return getReportDescriptor(right);
         }
         const initialScope = context.sourceCode.getScope(left);
-        const isLeftNan = left.type === AST_NODE_TYPES.Identifier && left.name === "NaN" || O.exists(VAR.getStaticValue(left, initialScope), (v) => v === "NaN");
+        const isLeftNan = left.type === AST_NODE_TYPES.Identifier && left.name === "NaN" || VAR.toResolved({ kind: "lazy", node: left, initialScope }).value === "NaN";
         if (isLeftNan) {
-          return O.some({
+          return {
             messageId: "noLeakedConditionalRendering",
             node: left,
             data: { value: context.sourceCode.getText(left) }
-          });
+          };
         }
         const leftType = getConstrainedTypeAtLocation(services, left);
         const leftTypeVariants = inspectVariantTypes(unionTypeParts(leftType));
@@ -1592,22 +1575,24 @@ var no_leaked_conditional_rendering_default = createRule({
         if (isLeftValid) {
           return getReportDescriptor(right);
         }
-        return O.some({
+        return {
           messageId: "noLeakedConditionalRendering",
           node: left,
           data: { value: context.sourceCode.getText(left) }
-        });
+        };
       }).with({ type: AST_NODE_TYPES.ConditionalExpression }, ({ alternate, consequent }) => {
-        return O.orElse(getReportDescriptor(consequent), () => getReportDescriptor(alternate));
+        return getReportDescriptor(consequent) ?? getReportDescriptor(alternate);
       }).with({ type: AST_NODE_TYPES.Identifier }, (n) => {
-        return F.pipe(
-          VAR.findVariable(n.name, context.sourceCode.getScope(n)),
-          O.flatMap(getVariableInitExpression(0)),
-          O.flatMap(getReportDescriptor)
-        );
-      }).otherwise(O.none);
+        const variable = VAR.findVariable(n.name, context.sourceCode.getScope(n));
+        const initExpression = getVariableInitExpression(variable, 0);
+        return getReportDescriptor(initExpression);
+      }).otherwise(() => _);
     }
-    const visitorFunction = F.flow(getReportDescriptor, O.map(context.report));
+    const visitorFunction = (node) => {
+      const descriptor = getReportDescriptor(node);
+      if (descriptor === _) return;
+      context.report(descriptor);
+    };
     return {
       "JSXExpressionContainer > ConditionalExpression": visitorFunction,
       "JSXExpressionContainer > LogicalExpression": visitorFunction
@@ -1643,13 +1628,13 @@ var no_missing_component_display_name_default = createRule({
         const components = ctx.getAllComponents(node);
         for (const { node: node2, displayName, flag } of components.values()) {
           const isMemoOrForwardRef = (flag & (ERFunctionComponentFlag.ForwardRef | ERFunctionComponentFlag.Memo)) > 0n;
-          if (O.isSome(AST11.getFunctionIdentifier(node2))) {
+          if (AST11.getFunctionIdentifier(node2)) {
             continue;
           }
           if (!isMemoOrForwardRef) {
             continue;
           }
-          if (O.isNone(displayName)) {
+          if (!displayName) {
             context.report({
               messageId: "noMissingComponentDisplayName",
               node: node2
@@ -1685,51 +1670,55 @@ var no_missing_key_default = createRule({
       switch (node.type) {
         case AST_NODE_TYPES.JSXElement: {
           const initialScope = context.sourceCode.getScope(node);
-          if (!JSX7.hasProp(node.openingElement.attributes, "key", initialScope)) {
-            return O.some({
+          if (!JSX7.hasProp("key", initialScope, node.openingElement.attributes)) {
+            return {
               messageId: "noMissingKey",
               node
-            });
+            };
           }
-          return O.none();
+          return null;
         }
         case AST_NODE_TYPES.JSXFragment: {
-          return O.some({
+          return {
             messageId: "noMissingKeyWithFragment",
             node
-          });
+          };
         }
         default:
-          return O.none();
+          return null;
       }
     }
     function checkExpression(node) {
       switch (node.type) {
         case AST_NODE_TYPES.ConditionalExpression:
-          if (!("consequent" in node)) {
-            return O.none();
+          if ("consequent" in node) {
+            return checkIteratorElement(node.consequent) ?? checkIteratorElement(node.alternate);
           }
-          return O.orElse(checkIteratorElement(node.consequent), () => checkIteratorElement(node.alternate));
+          return null;
         case AST_NODE_TYPES.JSXElement:
         case AST_NODE_TYPES.JSXFragment:
           return checkIteratorElement(node);
         case AST_NODE_TYPES.LogicalExpression:
-          if (!("left" in node)) {
-            return O.none();
+          if ("left" in node) {
+            return checkIteratorElement(node.left) ?? checkIteratorElement(node.right);
           }
-          return O.orElse(checkIteratorElement(node.left), () => checkIteratorElement(node.right));
+          return null;
         default:
-          return O.none();
+          return null;
       }
     }
     function checkBlockStatement(node) {
-      return AST11.getNestedReturnStatements(node).reduce((acc, statement) => {
+      const descriptors = [];
+      for (const statement of AST11.getNestedReturnStatements(node)) {
         if (statement.argument == null) {
-          return acc;
+          continue;
+        }
+        const descriptor = checkIteratorElement(statement.argument);
+        if (descriptor != null) {
+          descriptors.push(descriptor);
         }
-        const mbDescriptor = checkIteratorElement(statement.argument);
-        return O.isNone(mbDescriptor) ? acc : [...acc, mbDescriptor.value];
-      }, []);
+      }
+      return descriptors;
     }
     return {
       ArrayExpression(node) {
@@ -1742,7 +1731,7 @@ var no_missing_key_default = createRule({
         }
         const initialScope = context.sourceCode.getScope(node);
         for (const element of elements) {
-          if (!JSX7.hasProp(element.openingElement.attributes, "key", initialScope)) {
+          if (!JSX7.hasProp("key", initialScope, element.openingElement.attributes)) {
             context.report({
               messageId: "noMissingKey",
               node: element
@@ -1755,30 +1744,24 @@ var no_missing_key_default = createRule({
         if (state.isWithinChildrenToArray) {
           return;
         }
-        const isMapCall = AST11.isMapCallLoose(node);
-        const isArrayFromCall = isMatching({
-          type: AST_NODE_TYPES.CallExpression,
-          callee: {
-            type: AST_NODE_TYPES.MemberExpression,
-            property: {
-              name: "from"
-            }
-          }
-        }, node);
-        if (!isMapCall && !isArrayFromCall) {
+        const isMapCallLike = AST11.isMapCallLoose(node);
+        if (!isMapCallLike && !isArrayFromCall(node)) {
           return;
         }
-        const fn = node.arguments[isMapCall ? 0 : 1];
-        if (!AST11.isOneOf([AST_NODE_TYPES.ArrowFunctionExpression, AST_NODE_TYPES.FunctionExpression])(fn)) {
+        const fn = node.arguments[isMapCallLike ? 0 : 1];
+        if (fn?.type !== AST_NODE_TYPES.ArrowFunctionExpression && fn?.type !== AST_NODE_TYPES.FunctionExpression) {
           return;
         }
         if (fn.body.type === AST_NODE_TYPES.BlockStatement) {
-          for (const descriptor of checkBlockStatement(fn.body)) {
-            context.report(descriptor);
+          for (const descriptor2 of checkBlockStatement(fn.body)) {
+            context.report(descriptor2);
           }
           return;
         }
-        O.map(checkExpression(fn.body), context.report);
+        const descriptor = checkExpression(fn.body);
+        if (descriptor != null) {
+          context.report(descriptor);
+        }
       },
       "CallExpression:exit"(node) {
         if (!isChildrenToArrayCall(node, context)) {
@@ -1801,6 +1784,9 @@ var no_missing_key_default = createRule({
   },
   defaultOptions: []
 });
+function isArrayFromCall(node) {
+  return node.type === AST_NODE_TYPES.CallExpression && node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === "from";
+}
 var RULE_NAME30 = "no-nested-components";
 var RULE_FEATURES30 = [
   "CHK"
@@ -1827,24 +1813,27 @@ var no_nested_components_default = createRule({
       ...collector.listeners,
       ...collectorLegacy.listeners,
       "Program:exit"(node) {
-        const functionComponents = Array.from(collector.ctx.getAllComponents(node).values());
-        const classComponents = Array.from(collectorLegacy.ctx.getAllComponents(node).values());
+        const functionComponents = [
+          ...collector.ctx.getAllComponents(node).values()
+        ];
+        const classComponents = [
+          ...collectorLegacy.ctx.getAllComponents(node).values()
+        ];
         const isFunctionComponent = (node2) => {
           return AST11.isFunction(node2) && functionComponents.some((component) => component.node === node2);
         };
         const isClassComponent11 = (node2) => {
           return AST11.isClass(node2) && classComponents.some((component) => component.node === node2);
         };
-        for (const { name: componentName, node: component } of functionComponents) {
+        for (const { name: name2, node: component } of functionComponents) {
           if (isDirectValueOfRenderPropertyLoose(component)) {
             continue;
           }
-          if (O.isNone(componentName)) {
+          if (name2 === _) {
             continue;
           }
-          const name2 = componentName.value;
           const isInsideProperty = component.parent.type === AST_NODE_TYPES.Property;
-          const isInsideJSXPropValue = component.parent.type === AST_NODE_TYPES.JSXAttribute || O.isSome(JSX7.findParentProp(node, (n) => n.value?.type === AST_NODE_TYPES.JSXExpressionContainer));
+          const isInsideJSXPropValue = component.parent.type === AST_NODE_TYPES.JSXAttribute || !!JSX7.findParentProp(node, (n) => n.value?.type === AST_NODE_TYPES.JSXExpressionContainer);
           if (isInsideJSXPropValue) {
             if (!isDeclaredInRenderPropLoose(component)) {
               context.report({
@@ -1867,13 +1856,8 @@ var no_nested_components_default = createRule({
             });
             continue;
           }
-          const isParnetComponentNotDirectValueOfRenderProperty = O.exists(
-            AST11.findParentNodeGuard(
-              component,
-              isFunctionComponent
-            ),
-            not(isDirectValueOfRenderPropertyLoose)
-          );
+          const parentComponent = AST11.findParentNodeGuard(component, isFunctionComponent);
+          const isParnetComponentNotDirectValueOfRenderProperty = !!parentComponent && !isDirectValueOfRenderPropertyLoose(parentComponent);
           if (isParnetComponentNotDirectValueOfRenderProperty) {
             context.report({
               messageId: isInsideProperty ? "nestedComponentInProps" : "nestedComponent",
@@ -1894,15 +1878,15 @@ var no_nested_components_default = createRule({
             });
           }
         }
-        for (const { name: name2, node: component } of classComponents) {
-          if (O.isNone(AST11.findParentNode(component, or(isClassComponent11, isFunctionComponent)))) {
+        for (const { name: name2 = "unknown", node: component } of classComponents) {
+          if (!AST11.findParentNode(component, (n) => isClassComponent11(n) || isFunctionComponent(n))) {
             continue;
           }
           context.report({
             messageId: "nestedComponent",
             node: component,
             data: {
-              name: O.getOrElse(() => "unknown")(name2)
+              name: name2
             }
           });
         }
@@ -1947,15 +1931,11 @@ var no_prop_types_default = createRule({
         if (!isComponentName(object.name)) {
           return;
         }
-        const isComponent = F.pipe(
-          VAR.findVariable(object.name, context.sourceCode.getScope(node)),
-          O.flatMap(VAR.getVariableNode(0)),
-          O.exists((n) => AST11.isFunction(n) || isClassComponent(n))
-        );
-        if (!isComponent) {
-          return;
+        const variable = VAR.findVariable(object.name, context.sourceCode.getScope(node));
+        const variableNode = variable && VAR.getVariableNode(variable, 0);
+        if (variableNode && (AST11.isFunction(variableNode) || isClassComponent(variableNode))) {
+          context.report({ messageId: "noPropTypes", node: property });
         }
-        context.report({ messageId: "noPropTypes", node: property });
       },
       PropertyDefinition(node) {
         if (!isClassComponent(node.parent.parent)) {
@@ -1999,7 +1979,7 @@ var no_redundant_should_component_update_default = createRule({
       ...listeners,
       "Program:exit"(node) {
         const components = ctx.getAllComponents(node);
-        for (const { name: name2, node: component, flag } of components.values()) {
+        for (const { name: name2 = "PureComponent", node: component, flag } of components.values()) {
           if ((flag & ERClassComponentFlag.PureComponent) === 0n) {
             continue;
           }
@@ -2010,7 +1990,7 @@ var no_redundant_should_component_update_default = createRule({
                 messageId: "noRedundantShouldComponentUpdate",
                 node: member,
                 data: {
-                  componentName: O.getOrElse(() => "PureComponent")(name2)
+                  componentName: name2
                 }
               });
             }
@@ -2045,32 +2025,22 @@ var no_set_state_in_component_did_mount_default = createRule({
     if (!context.sourceCode.text.includes("componentDidMount")) {
       return {};
     }
-    function getReportDescriptor(node) {
-      if (!isThisSetState(node)) {
-        return O.none();
-      }
-      return F.pipe(
-        O.Do,
-        O.bind("clazz", () => AST11.findParentNodeGuard(node, isClassComponent)),
-        O.bind("method", ({ clazz }) => AST11.findParentNodeStop(node, clazz, isComponentDidMount)),
-        O.bind("methodScope", ({ method }) => O.some(context.sourceCode.getScope(method))),
-        O.bind("upperScope", () => O.fromNullable(context.sourceCode.getScope(node).upper)),
-        O.filter(
-          ({
-            clazz,
-            method,
-            methodScope,
-            upperScope
-          }) => method.parent === clazz.body && upperScope === methodScope
-        ),
-        O.map(() => ({
-          messageId: "noSetStateInComponentDidMount",
-          node
-        }))
-      );
-    }
     return {
-      CallExpression: F.flow(getReportDescriptor, O.map(context.report))
+      CallExpression(node) {
+        if (!isThisSetState(node)) {
+          return;
+        }
+        const clazz = AST11.findParentNodeGuard(node, isClassComponent);
+        const method = clazz && AST11.findParentNodeStop(node, clazz, isComponentDidMount);
+        const methodScope = method && context.sourceCode.getScope(method);
+        const upperScope = context.sourceCode.getScope(node).upper;
+        if (clazz && method && method.parent === clazz.body && upperScope === methodScope) {
+          context.report({
+            messageId: "noSetStateInComponentDidMount",
+            node
+          });
+        }
+      }
     };
   },
   defaultOptions: []
@@ -2099,32 +2069,22 @@ var no_set_state_in_component_did_update_default = createRule({
     if (!context.sourceCode.text.includes("componentDidUpdate")) {
       return {};
     }
-    function getReportDescriptor(node) {
-      if (!isThisSetState(node)) {
-        return O.none();
-      }
-      return F.pipe(
-        O.Do,
-        O.bind("clazz", () => AST11.findParentNodeGuard(node, isClassComponent)),
-        O.bind("method", ({ clazz }) => AST11.findParentNodeStop(node, clazz, isComponentDidUpdate)),
-        O.bind("methodScope", ({ method }) => O.some(context.sourceCode.getScope(method))),
-        O.bind("upperScope", () => O.fromNullable(context.sourceCode.getScope(node).upper)),
-        O.filter(
-          ({
-            clazz,
-            method,
-            methodScope,
-            upperScope
-          }) => method.parent === clazz.body && upperScope === methodScope
-        ),
-        O.map(() => ({
-          messageId: "noSetStateInComponentDidUpdate",
-          node
-        }))
-      );
-    }
     return {
-      CallExpression: F.flow(getReportDescriptor, O.map(context.report))
+      CallExpression(node) {
+        if (!isThisSetState(node)) {
+          return;
+        }
+        const clazz = AST11.findParentNodeGuard(node, isClassComponent);
+        const method = clazz && AST11.findParentNodeStop(node, clazz, isComponentDidUpdate);
+        const methodScope = method && context.sourceCode.getScope(method);
+        const upperScope = context.sourceCode.getScope(node).upper;
+        if (clazz && method && method.parent === clazz.body && upperScope === methodScope) {
+          context.report({
+            messageId: "noSetStateInComponentDidUpdate",
+            node
+          });
+        }
+      }
     };
   },
   defaultOptions: []
@@ -2153,32 +2113,22 @@ var no_set_state_in_component_will_update_default = createRule({
     if (!context.sourceCode.text.includes("componentWillUpdate")) {
       return {};
     }
-    function getReportDescriptor(node) {
-      if (!isThisSetState(node)) {
-        return O.none();
-      }
-      return F.pipe(
-        O.Do,
-        O.bind("clazz", () => AST11.findParentNodeGuard(node, isClassComponent)),
-        O.bind("method", ({ clazz }) => AST11.findParentNodeStop(node, clazz, isComponentWillUpdate3)),
-        O.bind("methodScope", ({ method }) => O.some(context.sourceCode.getScope(method))),
-        O.bind("upperScope", () => O.fromNullable(context.sourceCode.getScope(node).upper)),
-        O.filter(
-          ({
-            clazz,
-            method,
-            methodScope,
-            upperScope
-          }) => method.parent === clazz.body && upperScope === methodScope
-        ),
-        O.map(() => ({
-          messageId: "noSetStateInComponentWillUpdate",
-          node
-        }))
-      );
-    }
     return {
-      CallExpression: F.flow(getReportDescriptor, O.map(context.report))
+      CallExpression(node) {
+        if (!isThisSetState(node)) {
+          return;
+        }
+        const clazz = AST11.findParentNodeGuard(node, isClassComponent);
+        const method = clazz && AST11.findParentNodeStop(node, clazz, isComponentWillUpdate3);
+        const methodScope = method && context.sourceCode.getScope(method);
+        const upperScope = context.sourceCode.getScope(node).upper;
+        if (clazz && method && method.parent === clazz.body && upperScope === methodScope) {
+          context.report({
+            messageId: "noSetStateInComponentWillUpdate",
+            node
+          });
+        }
+      }
     };
   },
   defaultOptions: []
@@ -2188,14 +2138,14 @@ var RULE_FEATURES36 = [
   "CHK"
 ];
 function containsStringLiteral({ value }) {
-  return value?.type === AST_NODE_TYPES.Literal && isString(value.value);
+  return value?.type === AST_NODE_TYPES.Literal && typeof value.value === "string";
 }
 function containsStringExpressionContainer({ value }) {
   if (value?.type !== AST_NODE_TYPES.JSXExpressionContainer) {
     return false;
   }
   if (value.expression.type === AST_NODE_TYPES.Literal) {
-    return isString(value.expression.value);
+    return typeof value.expression.value === "string";
   }
   return value.expression.type === AST_NODE_TYPES.TemplateLiteral;
 }
@@ -2396,39 +2346,28 @@ var no_unstable_context_value_default = createRule({
         if (openingElementName.property.name !== "Provider") {
           return;
         }
-        F.pipe(
-          O.Do,
-          O.bind("function", ctx.getCurrentFunction),
-          O.bind("attribute", () => O.fromNullable(
-            node.attributes.find((attribute) => {
-              return attribute.type === AST_NODE_TYPES.JSXAttribute && attribute.name.name === "value";
-            })
-          )),
-          O.bind("value", ({ attribute }) => "value" in attribute ? O.some(attribute.value) : O.none()),
-          O.bind("valueExpression", ({ value }) => value?.type === AST_NODE_TYPES.JSXExpressionContainer ? O.some(value.expression) : O.none()),
-          O.bind("construction", ({ valueExpression }) => {
-            const initialScope = context.sourceCode.getScope(valueExpression);
-            return O.some(VAR.getValueConstruction(valueExpression, initialScope));
-          }),
-          O.map((vc) => {
-            if (vc.construction.kind === "None") {
-              return;
-            }
-            if (isReactHookCall(vc.construction.node)) {
-              return;
-            }
-            const prevs = constructions.get(vc.function.node) ?? [];
-            constructions.set(vc.function.node, [...prevs, vc.construction]);
-          })
+        const functionEntry = ctx.getCurrentEntry();
+        if (functionEntry === _) return;
+        const attribute = node.attributes.find(
+          (attribute2) => attribute2.type === AST_NODE_TYPES.JSXAttribute && attribute2.name.name === "value"
         );
+        if (attribute === _ || !("value" in attribute)) return;
+        const value = attribute.value;
+        if (value?.type !== AST_NODE_TYPES.JSXExpressionContainer) return;
+        const valueExpression = value.expression;
+        const initialScope = context.sourceCode.getScope(valueExpression);
+        const construction = VAR.getValueConstruction(valueExpression, initialScope);
+        if (construction === _) return;
+        if (isReactHookCall(construction.node)) {
+          return;
+        }
+        const prevs = constructions.get(functionEntry.node) ?? [];
+        constructions.set(functionEntry.node, [...prevs, construction]);
       },
       "Program:exit"(node) {
         const components = ctx.getAllComponents(node).values();
         for (const { node: component } of components) {
           for (const construction of constructions.get(component) ?? []) {
-            if (construction.kind === "None") {
-              continue;
-            }
             const { kind, node: constructionNode } = construction;
             const messageId = kind.startsWith("Function") ? "noUnstableContextValueWithFunction" : "noUnstableContextValueWithIdentifier";
             context.report({
@@ -2490,7 +2429,7 @@ var no_unstable_default_props_default = createRule({
               initialScope,
               VAR.ValueConstructionHint.StrictCallExpression
             );
-            if (construction.kind === "None") {
+            if (construction === _) {
               continue;
             }
             if (isReactHookCall(construction.node)) {
@@ -2508,13 +2447,10 @@ var no_unstable_default_props_default = createRule({
         }
       },
       "VariableDeclarator[id.type='ObjectPattern'][init.type='Identifier']"(node) {
-        const mbEntry = ctx.getCurrentFunction();
-        if (O.isNone(mbEntry)) {
-          return;
-        }
-        const entry = mbEntry.value;
-        const prevs = declarators.get(entry.node) ?? [];
-        declarators.set(entry.node, [...prevs, node]);
+        const functionEntry = ctx.getCurrentEntry();
+        if (!functionEntry) return;
+        const prevs = declarators.get(functionEntry.node) ?? [];
+        declarators.set(functionEntry.node, [...prevs, node]);
       }
     };
   },
@@ -2546,15 +2482,15 @@ function getName3(node) {
     return getName3(node.expression);
   }
   if (node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.PrivateIdentifier) {
-    return O.some(node.name);
+    return node.name;
   }
   if (node.type === AST_NODE_TYPES.Literal) {
-    return O.some(String(node.value));
+    return node.value?.toString();
   }
   if (node.type === AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0) {
-    return O.fromNullable(node.quasis[0]?.value.raw);
+    return node.quasis[0]?.value.raw;
   }
-  return O.none();
+  return _;
 }
 var no_unused_class_component_members_default = createRule({
   meta: {
@@ -2570,12 +2506,12 @@ var no_unused_class_component_members_default = createRule({
   },
   name: RULE_NAME42,
   create(context) {
-    const classStack = [];
-    const methodStack = [];
+    const classEntries = [];
+    const methodEntries = [];
     const propertyDefs = /* @__PURE__ */ new WeakMap();
     const propertyUsages = /* @__PURE__ */ new WeakMap();
     function classEnter(node) {
-      classStack.push(node);
+      classEntries.push(node);
       if (!isClassComponent(node)) {
         return;
       }
@@ -2583,37 +2519,37 @@ var no_unused_class_component_members_default = createRule({
       propertyUsages.set(node, /* @__PURE__ */ new Set());
     }
     function classExit() {
-      const currentClass = classStack.pop();
+      const currentClass = classEntries.pop();
       if (currentClass == null || !isClassComponent(currentClass)) {
         return;
       }
-      const className = O.map(AST11.getClassIdentifier(currentClass), (id) => id.name);
+      const className = AST11.getClassIdentifier(currentClass)?.name;
       const defs = propertyDefs.get(currentClass);
       const usages = propertyUsages.get(currentClass);
       if (defs == null) {
         return;
       }
       for (const def of defs) {
-        const name2 = getName3(def);
-        if (O.isNone(name2)) {
+        const methodName = getName3(def);
+        if (methodName == null) {
           continue;
         }
-        if (usages?.has(name2.value) || LIFECYCLE_METHODS.has(name2.value)) {
+        if (usages?.has(methodName) || LIFECYCLE_METHODS.has(methodName)) {
           continue;
         }
         context.report({
           messageId: "noUnusedClassComponentMembers",
           node: def,
           data: {
-            className: O.getOrElse(className, () => "Component"),
-            methodName: name2.value
+            className: className ?? "Component",
+            methodName
           }
         });
       }
     }
     function methodEnter(node) {
-      methodStack.push(node);
-      const currentClass = classStack.at(-1);
+      methodEntries.push(node);
+      const currentClass = classEntries.at(-1);
       if (currentClass == null || !isClassComponent(currentClass)) {
         return;
       }
@@ -2625,7 +2561,7 @@ var no_unused_class_component_members_default = createRule({
       }
     }
     function methodExit() {
-      methodStack.pop();
+      methodEntries.pop();
     }
     return {
       ClassDeclaration: classEnter,
@@ -2633,8 +2569,8 @@ var no_unused_class_component_members_default = createRule({
       ClassExpression: classEnter,
       "ClassExpression:exit": classExit,
       MemberExpression(node) {
-        const currentClass = classStack.at(-1);
-        const currentMethod = methodStack.at(-1);
+        const currentClass = classEntries.at(-1);
+        const currentMethod = methodEntries.at(-1);
         if (currentClass == null || currentMethod == null) {
           return;
         }
@@ -2648,15 +2584,18 @@ var no_unused_class_component_members_default = createRule({
           propertyDefs.get(currentClass)?.add(node.property);
           return;
         }
-        O.map(getName3(node.property), (name2) => propertyUsages.get(currentClass)?.add(name2));
+        const propertyName = getName3(node.property);
+        if (propertyName != null) {
+          propertyUsages.get(currentClass)?.add(propertyName);
+        }
       },
       MethodDefinition: methodEnter,
       "MethodDefinition:exit": methodExit,
       PropertyDefinition: methodEnter,
       "PropertyDefinition:exit": methodExit,
       VariableDeclarator(node) {
-        const currentClass = classStack.at(-1);
-        const currentMethod = methodStack.at(-1);
+        const currentClass = classEntries.at(-1);
+        const currentMethod = methodEntries.at(-1);
         if (currentClass == null || currentMethod == null) {
           return;
         }
@@ -2666,10 +2605,9 @@ var no_unused_class_component_members_default = createRule({
         if (node.init != null && AST11.isThisExpression(node.init) && node.id.type === AST_NODE_TYPES.ObjectPattern) {
           for (const prop of node.id.properties) {
             if (prop.type === AST_NODE_TYPES.Property && AST11.isKeyLiteralLike(prop, prop.key)) {
-              const mbName = getName3(prop.key);
-              if (O.isSome(mbName)) {
-                const name2 = mbName.value;
-                propertyUsages.get(currentClass)?.add(name2);
+              const keyName = getName3(prop.key);
+              if (keyName != null) {
+                propertyUsages.get(currentClass)?.add(keyName);
               }
             }
           }
@@ -2688,19 +2626,19 @@ function getName4(node) {
     return getName4(node.expression);
   }
   if (node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.PrivateIdentifier) {
-    return O.some(node.name);
+    return node.name;
   }
   if (node.type === AST_NODE_TYPES.Literal) {
-    return O.some(String(node.value));
+    return String(node.value);
   }
   if (node.type === AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0) {
-    return O.fromNullable(node.quasis[0]?.value.raw);
+    return node.quasis[0]?.value.raw;
   }
-  return O.none();
+  return _;
 }
 function isAssignmentToThisState2(node) {
   const { left } = node;
-  return left.type === AST_NODE_TYPES.MemberExpression && AST11.isThisExpression(left.object) && O.exists(getName4(left.property), (name2) => name2 === "state");
+  return left.type === AST_NODE_TYPES.MemberExpression && AST11.isThisExpression(left.object) && getName4(left.property) === "state";
 }
 var isGetDerivedStateFromProps = isMatching({
   key: {
@@ -2725,72 +2663,72 @@ var no_unused_state_default = createRule({
   },
   name: RULE_NAME43,
   create(context) {
-    const classStack = [];
-    const methodStack = [];
-    const constructorStack = [];
+    const classEntries = [];
+    const methodEntries = [];
+    const constructorEntries = [];
     const stateDefs = /* @__PURE__ */ new WeakMap();
     function classEnter(node) {
-      classStack.push(node);
+      classEntries.push(node);
     }
     function classExit() {
-      const currentClass = classStack.pop();
+      const currentClass = classEntries.pop();
       if (currentClass == null || !isClassComponent(currentClass)) {
         return;
       }
-      const className = O.map(AST11.getClassIdentifier(currentClass), (id) => id.name);
-      const [def, isUsed] = stateDefs.get(currentClass) ?? [O.none(), false];
-      if (O.isNone(def) || isUsed) {
+      const className = AST11.getClassIdentifier(currentClass)?.name;
+      const { node: defNode, isUsed } = stateDefs.get(currentClass) ?? {};
+      if (!defNode || isUsed) {
         return;
       }
       context.report({
         messageId: "noUnusedState",
-        node: def.value,
+        node: defNode,
         data: {
-          className: O.getOrElse(className, () => "Component")
+          className: className ?? "Component"
         }
       });
     }
     function methodEnter(node) {
-      methodStack.push(node);
-      const currentClass = classStack.at(-1);
+      methodEntries.push(node);
+      const currentClass = classEntries.at(-1);
       if (currentClass == null || !isClassComponent(currentClass)) {
         return;
       }
       if (node.static) {
         if (isGetDerivedStateFromProps(node) && node.value.params.length > 1) {
-          const [def] = stateDefs.get(currentClass) ?? [O.none()];
-          stateDefs.set(currentClass, [def, true]);
+          const defNode = stateDefs.get(currentClass)?.node;
+          stateDefs.set(currentClass, { node: defNode, isUsed: true });
         }
         return;
       }
-      if (O.exists(getName4(node.key), (name2) => name2 === "state")) {
-        stateDefs.set(currentClass, [O.some(node.key), false]);
+      if (getName4(node.key) === "state") {
+        stateDefs.set(currentClass, { node: node.key, isUsed: false });
       }
     }
     function methodExit() {
-      methodStack.pop();
+      methodEntries.pop();
     }
     function constructorEnter(node) {
-      constructorStack.push(node);
+      constructorEntries.push(node);
     }
     function constructorExit() {
-      constructorStack.pop();
+      constructorEntries.pop();
     }
     return {
       AssignmentExpression(node) {
         if (!isAssignmentToThisState2(node)) {
           return;
         }
-        const currentClass = classStack.at(-1);
+        const currentClass = classEntries.at(-1);
         if (currentClass == null || !isClassComponent(currentClass)) {
           return;
         }
-        const currentConstructor = constructorStack.at(-1);
+        const currentConstructor = constructorEntries.at(-1);
         if (currentConstructor == null || !currentClass.body.body.includes(currentConstructor)) {
           return;
         }
-        const [_, isUsed] = stateDefs.get(currentClass) ?? [O.none(), false];
-        stateDefs.set(currentClass, [O.some(node.left), isUsed]);
+        const isUsed = stateDefs.get(currentClass)?.isUsed ?? false;
+        stateDefs.set(currentClass, { node: node.left, isUsed });
       },
       ClassDeclaration: classEnter,
       "ClassDeclaration:exit": classExit,
@@ -2800,25 +2738,25 @@ var no_unused_state_default = createRule({
         if (!AST11.isThisExpression(node.object)) {
           return;
         }
-        if (!O.exists(getName4(node.property), (name2) => name2 === "state")) {
+        if (getName4(node.property) !== "state") {
           return;
         }
-        const currentClass = classStack.at(-1);
+        const currentClass = classEntries.at(-1);
         if (currentClass == null || !isClassComponent(currentClass)) {
           return;
         }
-        const currentMethod = methodStack.at(-1);
+        const currentMethod = methodEntries.at(-1);
         if (currentMethod == null || currentMethod.static) {
           return;
         }
-        if (currentMethod === constructorStack.at(-1)) {
+        if (currentMethod === constructorEntries.at(-1)) {
           return;
         }
         if (!currentClass.body.body.includes(currentMethod)) {
           return;
         }
-        const [def] = stateDefs.get(currentClass) ?? [O.none(), false];
-        stateDefs.set(currentClass, [def, true]);
+        const defNode = stateDefs.get(currentClass)?.node;
+        stateDefs.set(currentClass, { node: defNode, isUsed: true });
       },
       MethodDefinition: methodEnter,
       "MethodDefinition:exit": methodExit,
@@ -2827,15 +2765,15 @@ var no_unused_state_default = createRule({
       PropertyDefinition: methodEnter,
       "PropertyDefinition:exit": methodExit,
       VariableDeclarator(node) {
-        const currentClass = classStack.at(-1);
+        const currentClass = classEntries.at(-1);
         if (currentClass == null || !isClassComponent(currentClass)) {
           return;
         }
-        const currentMethod = methodStack.at(-1);
+        const currentMethod = methodEntries.at(-1);
         if (currentMethod == null || currentMethod.static) {
           return;
         }
-        if (currentMethod === constructorStack.at(-1)) {
+        if (currentMethod === constructorEntries.at(-1)) {
           return;
         }
         if (!currentClass.body.body.includes(currentMethod)) {
@@ -2846,15 +2784,15 @@ var no_unused_state_default = createRule({
         }
         const hasState = node.id.properties.some((prop) => {
           if (prop.type === AST_NODE_TYPES.Property && AST11.isKeyLiteralLike(prop, prop.key)) {
-            return O.exists(getName4(prop.key), (name2) => name2 === "state");
+            return getName4(prop.key) === "state";
           }
           return false;
         });
         if (!hasState) {
           return;
         }
-        const [def] = stateDefs.get(currentClass) ?? [O.none(), false];
-        stateDefs.set(currentClass, [def, true]);
+        const defNode = stateDefs.get(currentClass)?.node;
+        stateDefs.set(currentClass, { node: defNode, isUsed: true });
       }
     };
   },
@@ -2974,15 +2912,15 @@ var prefer_destructuring_assignment_default = createRule({
         }
       },
       "Program:exit"(node) {
-        const components = Array.from(ctx.getAllComponents(node).values());
+        const components = [
+          ...ctx.getAllComponents(node).values()
+        ];
         function isFunctionComponent(block) {
           if (!AST11.isFunction(block)) {
             return false;
           }
-          return O.exists(
-            AST11.getFunctionIdentifier(block),
-            (id) => isComponentName(id.name) && components.some((component) => component.node === block)
-          );
+          const id = AST11.getFunctionIdentifier(block);
+          return !!id && isComponentName(id.name) && components.some((component) => component.node === block);
         }
         for (const [initialScope, memberExpression] of memberExpressionWithNames) {
           let scope = initialScope;
@@ -3111,7 +3049,7 @@ var prefer_read_only_props_default = createRule({
       ...listeners,
       "Program:exit"(node) {
         const components = ctx.getAllComponents(node);
-        for (const [_, component] of components) {
+        for (const [, component] of components) {
           const [props] = component.node.params;
           if (props == null) {
             continue;
@@ -3147,24 +3085,23 @@ var prefer_shorthand_boolean_default = createRule({
   },
   name: RULE_NAME48,
   create(context) {
-    function getReportDescriptor(node) {
-      const { value } = node;
-      const propName = JSX7.getPropName(node);
-      const hasValueTrue = value?.type === AST_NODE_TYPES.JSXExpressionContainer && value.expression.type === AST_NODE_TYPES.Literal && value.expression.value === true;
-      if (!hasValueTrue) {
-        return O.none();
-      }
-      return O.some({
-        messageId: "preferShorthandBoolean",
-        node,
-        data: {
-          propName
-        },
-        fix: (fixer) => fixer.removeRange([node.name.range[1], value.range[1]])
-      });
-    }
     return {
-      JSXAttribute: F.flow(getReportDescriptor, O.map(context.report))
+      JSXAttribute(node) {
+        const { value } = node;
+        const propName = JSX7.getPropName(node);
+        const hasValueTrue = value?.type === AST_NODE_TYPES.JSXExpressionContainer && value.expression.type === AST_NODE_TYPES.Literal && value.expression.value === true;
+        if (!hasValueTrue) {
+          return;
+        }
+        context.report({
+          messageId: "preferShorthandBoolean",
+          node,
+          data: {
+            propName
+          },
+          fix: (fixer) => fixer.removeRange([node.name.range[1], value.range[1]])
+        });
+      }
     };
   },
   defaultOptions: []
@@ -3189,31 +3126,32 @@ var prefer_shorthand_fragment_default = createRule({
   },
   name: RULE_NAME49,
   create(context) {
-    function getReportDescriptor(node) {
-      if (JSX7.getElementName(node.openingElement).split(".").at(-1) !== "Fragment") {
-        return O.none();
-      }
-      const hasAttributes = node.openingElement.attributes.length > 0;
-      if (hasAttributes) {
-        return O.none();
-      }
-      return O.some({
-        messageId: "preferShorthandFragment",
-        node,
-        fix: (fixer) => {
-          const { closingElement, openingElement } = node;
-          if (closingElement == null) {
-            return [];
-          }
-          return [
-            fixer.replaceTextRange([openingElement.range[0], openingElement.range[1]], "<>"),
-            fixer.replaceTextRange([closingElement.range[0], closingElement.range[1]], "</>")
-          ];
-        }
-      });
-    }
     return {
-      JSXElement: F.flow(getReportDescriptor, O.map(context.report))
+      JSXElement(node) {
+        if (JSX7.getElementName(node.openingElement).split(".").at(-1) !== "Fragment") {
+          return;
+        }
+        const hasAttributes = node.openingElement.attributes.length > 0;
+        if (hasAttributes) {
+          return;
+        }
+        context.report({
+          messageId: "preferShorthandFragment",
+          node,
+          fix: (fixer) => {
+            const { closingElement, openingElement } = node;
+            if (closingElement == null) {
+              return [];
+            }
+            return [
+              // eslint-disable-next-line eslint-plugin/prefer-replace-text
+              fixer.replaceTextRange([openingElement.range[0], openingElement.range[1]], "<>"),
+              // eslint-disable-next-line eslint-plugin/prefer-replace-text
+              fixer.replaceTextRange([closingElement.range[0], closingElement.range[1]], "</>")
+            ];
+          }
+        });
+      }
     };
   },
   defaultOptions: []
@@ -3235,23 +3173,23 @@ var use_jsx_vars_default = createRule({
   },
   name: RULE_NAME50,
   create(context) {
-    function getName5(node) {
-      switch (node.type) {
-        case AST_NODE_TYPES.JSXIdentifier:
-          return O.some(node.name);
-        case AST_NODE_TYPES.JSXMemberExpression:
-          return getName5(node.object);
-        default:
-          return O.none();
-      }
-    }
     return {
       JSXOpeningElement(node) {
-        if (node.name.type === AST_NODE_TYPES.JSXIdentifier && /^[a-z]/u.test(node.name.name)) {
-          return;
-        }
-        for (const name2 of O.toArray(getName5(node.name))) {
-          context.sourceCode.markVariableAsUsed(name2, node);
+        switch (node.name.type) {
+          case AST_NODE_TYPES.JSXIdentifier: {
+            if (/^[a-z]/u.test(node.name.name)) {
+              return;
+            }
+            context.sourceCode.markVariableAsUsed(node.name.name, node);
+            break;
+          }
+          case AST_NODE_TYPES.JSXMemberExpression: {
+            const { object } = node.name;
+            if (object.type === AST_NODE_TYPES.JSXIdentifier) {
+              context.sourceCode.markVariableAsUsed(object.name, node);
+            }
+            break;
+          }
         }
       }
     };