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

package/dist/index.js

@@ -1,10 +1,10 @@
 'use strict';
 
-var eff = require('@eslint-react/eff');
 var JSX7 = require('@eslint-react/jsx');
 var shared = require('@eslint-react/shared');
 var AST11 = require('@eslint-react/ast');
 var core = require('@eslint-react/core');
+var eff = require('@eslint-react/eff');
 var types = require('@typescript-eslint/types');
 var tsPattern = require('ts-pattern');
 var compareVersions = require('compare-versions');
@@ -42,7 +42,7 @@ var ts__default = /*#__PURE__*/_interopDefault(ts);
 
 // package.json
 var name = "eslint-plugin-react-x";
-var version = "1.23.3-next.7";
+var version = "1.24.0-beta.0";
 var createRule = shared.createRuleForPlugin("x");
 
 // src/rules/avoid-shorthand-boolean.ts
@@ -65,18 +65,19 @@ var avoid_shorthand_boolean_default = createRule({
   },
   name: RULE_NAME,
   create(context) {
-    function getReportDescriptor(node) {
-      return node.value != null ? eff.O.none() : eff.O.some({
-        messageId: "avoidShorthandBoolean",
-        node,
-        data: {
-          propName: JSX7__namespace.getPropName(node)
-        },
-        fix: (fixer) => fixer.insertTextAfter(node.name, `={true}`)
-      });
-    }
     return {
-      JSXAttribute: eff.F.flow(getReportDescriptor, eff.O.map(context.report))
+      JSXAttribute(node) {
+        if (node.value === null) {
+          context.report({
+            messageId: "avoidShorthandBoolean",
+            node,
+            data: {
+              propName: JSX7__namespace.getPropName(node)
+            },
+            fix: (fixer) => fixer.insertTextAfter(node.name, `={true}`)
+          });
+        }
+      }
     };
   },
   defaultOptions: []
@@ -139,7 +140,7 @@ var ensure_forward_ref_using_ref_default = createRule({
         if (component == null || !AST11__namespace.isFunction(component)) {
           return;
         }
-        const [_, ref] = component.params;
+        const ref = component.params[1];
         if (ref != null) {
           return;
         }
@@ -161,15 +162,15 @@ function getName(node) {
     return getName(node.expression);
   }
   if (node.type === types.AST_NODE_TYPES.Identifier || node.type === types.AST_NODE_TYPES.PrivateIdentifier) {
-    return eff.O.some(node.name);
+    return node.name;
   }
   if (node.type === types.AST_NODE_TYPES.Literal) {
-    return eff.O.some(String(node.value));
+    return String(node.value);
   }
   if (node.type === types.AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0) {
-    return eff.O.fromNullable(node.quasis[0]?.value.raw);
+    return node.quasis[0]?.value.raw;
   }
-  return eff.O.none();
+  return eff._;
 }
 var no_access_state_in_setstate_default = createRule({
   meta: {
@@ -188,89 +189,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 (!core.isThisSetState(node)) {
           return;
         }
-        setStateStack.push([node, false]);
+        setStateEntries.push([node, false]);
       },
       "CallExpression:exit"(node) {
         if (!core.isThisSetState(node)) {
           return;
         }
-        setStateStack.pop();
+        setStateEntries.pop();
       },
       ClassDeclaration(node) {
-        classStack.push([node, core.isClassComponent(node)]);
+        classEntries.push([node, core.isClassComponent(node)]);
       },
       "ClassDeclaration:exit"() {
-        classStack.pop();
+        classEntries.pop();
       },
       ClassExpression(node) {
-        classStack.push([node, core.isClassComponent(node)]);
+        classEntries.push([node, core.isClassComponent(node)]);
       },
       "ClassExpression:exit"() {
-        classStack.pop();
+        classEntries.pop();
       },
       MemberExpression(node) {
         if (!AST11__namespace.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 (!eff.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__namespace.isThisExpression(node.init) && node.id.type === types.AST_NODE_TYPES.ObjectPattern)) {
           return;
         }
-        const hasState = node.id.properties.some((prop) => {
-          if (prop.type === types.AST_NODE_TYPES.Property && AST11__namespace.isKeyLiteralLike(prop, prop.key)) {
-            return eff.O.exists(getName(prop.key), (name2) => name2 === "state");
-          }
-          return false;
-        });
+        const hasState = node.id.properties.some(
+          (prop) => prop.type === types.AST_NODE_TYPES.Property && AST11__namespace.isKeyLiteralLike(prop, prop.key) && getName(prop.key) === "state"
+        );
         if (!hasState) {
           return;
         }
@@ -323,32 +321,32 @@ function isUsingReactChildren(node, context) {
 function getMapIndexParamName(node, context) {
   const { callee } = node;
   if (callee.type !== types.AST_NODE_TYPES.MemberExpression) {
-    return eff.O.none();
+    return eff._;
   }
   if (callee.property.type !== types.AST_NODE_TYPES.Identifier) {
-    return eff.O.none();
+    return eff._;
   }
   const { name: name2 } = callee.property;
   if (!iteratorFunctionIndexParamPosition.has(name2)) {
-    return eff.O.none();
+    return eff._;
   }
   const callbackArg = node.arguments[isUsingReactChildren(node, context) ? 1 : 0];
   if (callbackArg == null) {
-    return eff.O.none();
+    return eff._;
   }
   if (!AST11__namespace.isOneOf([types.AST_NODE_TYPES.ArrowFunctionExpression, types.AST_NODE_TYPES.FunctionExpression])(callbackArg)) {
-    return eff.O.none();
+    return eff._;
   }
   const { params } = callbackArg;
   const indexParamPosition = iteratorFunctionIndexParamPosition.get(name2);
-  if (eff.isNullable(indexParamPosition)) {
-    return eff.O.none();
+  if (indexParamPosition == null) {
+    return eff._;
   }
   if (params.length < indexParamPosition + 1) {
-    return eff.O.none();
+    return eff._;
   }
   const param = params.at(indexParamPosition);
-  return param != null && "name" in param ? eff.O.some(param.name) : eff.O.none();
+  return param != null && "name" in param ? param.name : eff._;
 }
 var no_array_index_key_default = createRule({
   meta: {
@@ -366,7 +364,7 @@ var no_array_index_key_default = createRule({
   create(context) {
     const indexParamNames = [];
     function isArrayIndex(node) {
-      return node.type === types.AST_NODE_TYPES.Identifier && indexParamNames.some(eff.O.exists((name2) => name2 === node.name));
+      return node.type === types.AST_NODE_TYPES.Identifier && indexParamNames.some((name2) => name2 != null && name2 === node.name);
     }
     function isCreateOrCloneElementCall(node) {
       return core.isCreateElementCall(node, context) || core.isCloneElementCall(node, context);
@@ -375,7 +373,7 @@ var no_array_index_key_default = createRule({
       switch (node.type) {
         // key={bar}
         case types.AST_NODE_TYPES.Identifier: {
-          if (indexParamNames.some(eff.O.exists((name2) => name2 === node.name))) {
+          if (indexParamNames.some((name2) => name2 != null && name2 === node.name)) {
             return [{
               messageId: "noArrayIndexKey",
               node
@@ -429,7 +427,7 @@ var no_array_index_key_default = createRule({
         if (!isCreateOrCloneElementCall(node)) {
           return;
         }
-        const [_, props] = node.arguments;
+        const [, props] = node.arguments;
         if (props?.type !== types.AST_NODE_TYPES.ObjectExpression) {
           return;
         }
@@ -612,10 +610,17 @@ var no_children_prop_default = createRule({
   create(context) {
     return {
       JSXElement(node) {
-        const initialScope = context.sourceCode.getScope(node);
-        const prop = JSX7__namespace.getProp(node.openingElement.attributes, "children", initialScope);
-        const reportDescriptor = eff.O.map(prop, (prop2) => ({ messageId: "noChildrenProp", node: prop2 }));
-        eff.O.map(reportDescriptor, context.report);
+        const prop = JSX7__namespace.getProp(
+          "children",
+          context.sourceCode.getScope(node),
+          node.openingElement.attributes
+        );
+        if (prop) {
+          context.report({
+            messageId: "noChildrenProp",
+            node: prop
+          });
+        }
       }
     };
   },
@@ -684,7 +689,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;
           }
@@ -693,7 +698,7 @@ var no_class_component_default = createRule({
             node: component,
             data: {
               // eslint-disable-next-line eslint-plugin/no-unused-placeholders
-              name: eff.O.getOrElse(eff.F.constant("anonymous"))(name2)
+              name: name2
             }
           });
         }
@@ -759,22 +764,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__namespace.isOneOf([types.AST_NODE_TYPES.JSXElement, types.AST_NODE_TYPES.JSXFragment])(node.parent)) {
-        return eff.O.none();
+        return;
       }
       if (!hasCommentLike(node)) {
-        return eff.O.none();
+        return;
       }
       if (!node.parent.type.includes("JSX")) {
-        return eff.O.none();
+        return;
       }
-      return eff.O.some({
+      context.report({
         messageId: "noCommentTextnodes",
         node
       });
     };
-    const visitorFunction = eff.F.flow(getReportDescriptor, eff.O.map(context.report), eff.F.constVoid);
     return {
       JSXText: visitorFunction,
       Literal: visitorFunction
@@ -800,20 +804,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__namespace.is(types.AST_NODE_TYPES.JSXExpressionContainer)(jsxExpContainer)) {
-        return eff.O.none();
+        return;
       }
       if (!AST11__namespace.isOneOf([types.AST_NODE_TYPES.JSXElement, types.AST_NODE_TYPES.JSXFragment])(jsxExpContainer.parent)) {
-        return eff.O.none();
+        return;
       }
       if (!jsxExpContainer.parent.children.includes(jsxExpContainer)) {
-        return eff.O.none();
+        return;
       }
-      return eff.O.some({ messageId: "noComplexConditionalRendering", node: jsxExpContainer });
-    }
-    const visitorFunction = eff.F.flow(getReportDescriptor, eff.O.map(context.report), eff.F.constVoid);
+      context.report({
+        messageId: "noComplexConditionalRendering",
+        node: jsxExpContainer
+      });
+    };
     return {
       "JSXExpressionContainer > ConditionalExpression > ConditionalExpression": visitorFunction,
       "JSXExpressionContainer > ConditionalExpression > LogicalExpression": visitorFunction,
@@ -1057,13 +1063,9 @@ var no_create_ref_default = createRule({
   create(context) {
     return {
       CallExpression(node) {
-        if (!core.isCreateRefCall(node, context)) {
-          return;
-        }
-        if (eff.O.isSome(AST11__namespace.findParentNode(node, core.isClassComponent))) {
-          return;
+        if (core.isCreateRefCall(node, context) && !AST11__namespace.findParentNode(node, core.isClassComponent)) {
+          context.report({ messageId: "noCreateRef", node });
         }
-        context.report({ messageId: "noCreateRef", node });
       }
     };
   },
@@ -1105,14 +1107,10 @@ var no_default_props_default = createRule({
         if (!core.isComponentName(object.name)) {
           return;
         }
-        const isComponent = eff.F.pipe(
-          VAR__namespace.findVariable(object.name, context.sourceCode.getScope(node)),
-          eff.O.flatMap(VAR__namespace.getVariableNode(0)),
-          eff.O.exists((n) => AST11__namespace.isFunction(n) || core.isClassComponent(n))
-        );
-        if (!isComponent) {
-          return;
-        }
+        const variable = VAR__namespace.findVariable(object.name, context.sourceCode.getScope(node));
+        const variableNode = VAR__namespace.getVariableNode(variable, 0);
+        if (variableNode === eff._) return;
+        if (!AST11__namespace.isFunction(variableNode) && !core.isClassComponent(variableNode)) return;
         context.report({ messageId: "noDefaultProps", node: property });
       },
       PropertyDefinition(node) {
@@ -1137,19 +1135,19 @@ function getName2(node) {
     return getName2(node.expression);
   }
   if (node.type === types.AST_NODE_TYPES.Identifier || node.type === types.AST_NODE_TYPES.PrivateIdentifier) {
-    return eff.O.some(node.name);
+    return node.name;
   }
   if (node.type === types.AST_NODE_TYPES.Literal) {
-    return eff.O.some(String(node.value));
+    return node.value?.toString();
   }
   if (node.type === types.AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0) {
-    return eff.O.fromNullable(node.quasis[0]?.value.raw);
+    return node.quasis[0]?.value.raw;
   }
-  return eff.O.none();
+  return eff._;
 }
 function isAssignmentToThisState(node) {
   const { left } = node;
-  return left.type === types.AST_NODE_TYPES.MemberExpression && AST11__namespace.isThisExpression(left.object) && eff.O.exists(getName2(left.property), (name2) => name2 === "state");
+  return left.type === types.AST_NODE_TYPES.MemberExpression && AST11__namespace.isThisExpression(left.object) && getName2(left.property) === "state";
 }
 function isConstructorFunction(node) {
   return AST11__namespace.isOneOf([types.AST_NODE_TYPES.FunctionDeclaration, types.AST_NODE_TYPES.FunctionExpression])(node) && AST11__namespace.isOneOf([types.AST_NODE_TYPES.MethodDefinition, types.AST_NODE_TYPES.PropertyDefinition])(node.parent) && node.parent.key.type === types.AST_NODE_TYPES.Identifier && node.parent.key.name === "constructor";
@@ -1168,31 +1166,26 @@ var no_direct_mutation_state_default = createRule({
   },
   name: RULE_NAME22,
   create(context) {
-    function getReportDescriptor(node) {
-      if (!isAssignmentToThisState(node)) {
-        return eff.O.none();
-      }
-      return eff.F.pipe(
-        eff.O.Do,
-        eff.O.bind("parentClass", () => AST11__namespace.findParentNodeGuard(
+    return {
+      AssignmentExpression(node) {
+        if (!isAssignmentToThisState(node)) {
+          return;
+        }
+        const parentClass = AST11__namespace.findParentNodeGuard(
           node,
           AST11__namespace.isOneOf([
             types.AST_NODE_TYPES.ClassDeclaration,
             types.AST_NODE_TYPES.ClassExpression
           ])
-        )),
-        eff.O.bind("parentConstructor", () => AST11__namespace.findParentNodeGuard(node, isConstructorFunction)),
-        eff.O.filter(
-          ({ parentClass, parentConstructor }) => core.isClassComponent(parentClass) && context.sourceCode.getScope(node).block !== parentConstructor
-        ),
-        eff.O.map(() => ({
-          messageId: "noDirectMutationState",
-          node
-        }))
-      );
-    }
-    return {
-      AssignmentExpression: eff.F.flow(getReportDescriptor, eff.O.map(context.report))
+        );
+        if (!parentClass) return;
+        if (core.isClassComponent(parentClass) && context.sourceCode.getScope(node).block !== AST11__namespace.findParentNodeGuard(node, isConstructorFunction)) {
+          context.report({
+            messageId: "noDirectMutationState",
+            node
+          });
+        }
+      }
     };
   },
   defaultOptions: []
@@ -1223,7 +1216,7 @@ var no_duplicate_jsx_props_default = createRule({
             continue;
           }
           const name2 = attr.name.name;
-          if (!eff.isString(name2)) {
+          if (typeof name2 !== "string") {
             continue;
           }
           if (!props.includes(name2)) {
@@ -1287,16 +1280,10 @@ var no_duplicate_key_default = createRule({
             break;
           }
           default: {
-            const mbEntry = eff.F.pipe(
-              eff.O.Do,
-              eff.O.bind("call", () => AST11__namespace.findParentNodeGuard(jsxElement, AST11__namespace.isMapCallLoose)),
-              eff.O.bind("iter", ({ call: call2 }) => AST11__namespace.findParentNodeStop(jsxElement, call2, AST11__namespace.isFunction)),
-              eff.O.bind("arg0", ({ call: call2 }) => eff.O.fromNullable(call2.arguments[0]))
-            );
-            if (eff.O.isNone(mbEntry)) {
-              return;
-            }
-            const { arg0, call, iter } = mbEntry.value;
+            const call = AST11__namespace.findParentNodeGuard(jsxElement, AST11__namespace.isMapCallLoose);
+            const iter = call && AST11__namespace.findParentNodeStop(jsxElement, call, AST11__namespace.isFunction);
+            const arg0 = call?.arguments[0];
+            if (!call || !iter || !arg0) return;
             if (AST11__namespace.unwrapTypeExpression(arg0) !== iter) {
               return;
             }
@@ -1397,21 +1384,19 @@ function getComponentPropsFixes(node, typeArguments, fixer, context) {
   if (arg0 == null) {
     return [];
   }
-  const fixedArg0Text = tsPattern.match(arg0).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => eff.O.some(`...${n.name}`)).with({ type: types.AST_NODE_TYPES.ObjectPattern }, (n) => eff.O.some(n.properties.map(getText).join(", "))).otherwise(eff.O.none);
-  const fixedArg1Text = tsPattern.match(arg1).with(tsPattern.P.nullish, () => eff.O.some("ref")).with({ type: types.AST_NODE_TYPES.Identifier, name: "ref" }, () => eff.O.some("ref")).with({ type: types.AST_NODE_TYPES.Identifier, name: tsPattern.P.not("ref") }, (n) => eff.O.some(`ref: ${n.name}`)).otherwise(eff.O.none);
-  if (eff.O.isNone(fixedArg0Text) || eff.O.isNone(fixedArg1Text)) {
+  const fixedArg0Text = tsPattern.match(arg0).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => `...${n.name}`).with({ type: types.AST_NODE_TYPES.ObjectPattern }, (n) => n.properties.map(getText).join(", ")).otherwise(() => eff._);
+  const fixedArg1Text = tsPattern.match(arg1).with(tsPattern.P.nullish, () => "ref").with({ type: types.AST_NODE_TYPES.Identifier, name: "ref" }, () => "ref").with({ type: types.AST_NODE_TYPES.Identifier, name: tsPattern.P.not("ref") }, (n) => `ref: ${n.name}`).otherwise(() => eff._);
+  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(" ")
       ),
@@ -1423,8 +1408,8 @@ function getComponentPropsFixes(node, typeArguments, fixer, context) {
       arg0,
       [
         "{",
-        fixedRefText + ",",
-        fixedPropsText,
+        fixedArg1Text + ",",
+        fixedArg0Text,
         "}:",
         getText(typeArg1),
         "&",
@@ -1455,17 +1440,17 @@ var no_implicit_key_default = createRule({
   },
   name: RULE_NAME26,
   create(context) {
-    function getReportDescriptor(node) {
-      const initialScope = context.sourceCode.getScope(node);
-      const keyPropFound = JSX7__namespace.findPropInAttributes(node.attributes, initialScope)("key");
-      const keyPropOnElement = node.attributes.some((n) => AST11__namespace.is(types.AST_NODE_TYPES.JSXAttribute)(n) && n.name.name === "key");
-      if (eff.O.isSome(keyPropFound) && !keyPropOnElement) {
-        return eff.O.some({ messageId: "noImplicitKey", node: keyPropFound.value });
-      }
-      return eff.O.none();
-    }
     return {
-      JSXOpeningElement: eff.F.flow(getReportDescriptor, eff.O.map(context.report))
+      JSXOpeningElement(node) {
+        const initialScope = context.sourceCode.getScope(node);
+        const keyPropFound = JSX7__namespace.findPropInAttributes("key", initialScope, node.attributes);
+        const keyPropOnElement = node.attributes.some(
+          (n) => n.type === types.AST_NODE_TYPES.JSXAttribute && n.name.type === types.AST_NODE_TYPES.JSXIdentifier && n.name.name === "key"
+        );
+        if (keyPropFound && !keyPropOnElement) {
+          context.report({ messageId: "noImplicitKey", node: keyPropFound });
+        }
+      }
     };
   },
   defaultOptions: []
@@ -1511,11 +1496,12 @@ function inspectVariantTypes(types) {
   const booleans = types.filter(tsHelpers.isBooleanType);
   switch (true) {
     case (booleans.length === 1 && booleans[0] != null): {
-      const [first] = booleans;
-      const evaluated = eff.F.pipe(
-        tsPattern.match(first).when(tsApiUtils.isTrueLiteralType, () => eff.O.some("truthy boolean")).when(tsApiUtils.isFalseLiteralType, () => eff.O.some("falsy boolean")).otherwise(eff.O.none)
-      );
-      eff.O.map(evaluated, (v) => variantTypes.add(v));
+      const first = booleans[0];
+      if (tsApiUtils.isTrueLiteralType(first)) {
+        variantTypes.add("truthy boolean");
+      } else if (tsApiUtils.isFalseLiteralType(first)) {
+        variantTypes.add("falsy boolean");
+      }
       break;
     }
     case booleans.length === 2: {
@@ -1525,17 +1511,17 @@ function inspectVariantTypes(types) {
   }
   const strings = types.filter(tsHelpers.isStringType);
   if (strings.length > 0) {
-    const evaluated = tsPattern.match(strings).when((types2) => types2.every(tsHelpers.isTruthyStringType), eff.F.constant("truthy string")).when((types2) => types2.every(tsHelpers.isFalsyStringType), eff.F.constant("falsy string")).otherwise(eff.F.constant("string"));
+    const evaluated = tsPattern.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 = tsPattern.match(bigints).when((types2) => types2.every(tsHelpers.isTruthyBigIntType), eff.F.constant("truthy bigint")).when((types2) => types2.every(tsHelpers.isFalsyBigIntType), eff.F.constant("falsy bigint")).otherwise(eff.F.constant("bigint"));
+    const evaluated = tsPattern.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 = tsPattern.match(numbers).when((types2) => types2.every(tsHelpers.isTruthyNumberType), eff.F.constant("truthy number")).when((types2) => types2.every(tsHelpers.isFalsyNumberType), eff.F.constant("falsy number")).otherwise(eff.F.constant("number"));
+    const evaluated = tsPattern.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)) {
@@ -1553,19 +1539,15 @@ function inspectVariantTypes(types) {
   return variantTypes;
 }
 function isInitExpression(node) {
+  if (node == null) return false;
   return node.type !== types.AST_NODE_TYPES.VariableDeclaration;
 }
-function getVariableInitExpression(at) {
-  return (variable) => {
-    return eff.F.pipe(
-      eff.O.some(variable),
-      eff.O.flatMapNullable((v) => v.defs.at(at)),
-      eff.O.flatMap(
-        (d) => "init" in d.node ? eff.O.fromNullable(d.node.init) : eff.O.none()
-      ),
-      eff.O.filter(isInitExpression)
-    );
-  };
+function getVariableInitExpression(variable, at) {
+  const def = variable?.defs[at];
+  if (def?.node === eff._ || !("init" in def.node)) {
+    return eff._;
+  }
+  return isInitExpression(def.node.init) ? def.node.init : eff._;
 }
 var no_leaked_conditional_rendering_default = createRule({
   meta: {
@@ -1599,19 +1581,20 @@ var no_leaked_conditional_rendering_default = createRule({
     ];
     const services = utils.ESLintUtils.getParserServices(context, false);
     function getReportDescriptor(node) {
-      return tsPattern.match(node).when(AST11__namespace.isJSX, eff.O.none).with({ type: types.AST_NODE_TYPES.LogicalExpression, operator: "&&" }, ({ left, right }) => {
+      if (node === eff._) return eff._;
+      return tsPattern.match(node).when(AST11__namespace.isJSX, () => eff._).with({ type: types.AST_NODE_TYPES.LogicalExpression, operator: "&&" }, ({ left, right }) => {
         const isLeftUnaryNot = left.type === types.AST_NODE_TYPES.UnaryExpression && left.operator === "!";
         if (isLeftUnaryNot) {
           return getReportDescriptor(right);
         }
         const initialScope = context.sourceCode.getScope(left);
-        const isLeftNan = left.type === types.AST_NODE_TYPES.Identifier && left.name === "NaN" || eff.O.exists(VAR__namespace.getStaticValue(left, initialScope), (v) => v === "NaN");
+        const isLeftNan = left.type === types.AST_NODE_TYPES.Identifier && left.name === "NaN" || VAR__namespace.toResolved({ kind: "lazy", node: left, initialScope }).value === "NaN";
         if (isLeftNan) {
-          return eff.O.some({
+          return {
             messageId: "noLeakedConditionalRendering",
             node: left,
             data: { value: context.sourceCode.getText(left) }
-          });
+          };
         }
         const leftType = typeUtils.getConstrainedTypeAtLocation(services, left);
         const leftTypeVariants = inspectVariantTypes(tsApiUtils.unionTypeParts(leftType));
@@ -1619,22 +1602,24 @@ var no_leaked_conditional_rendering_default = createRule({
         if (isLeftValid) {
           return getReportDescriptor(right);
         }
-        return eff.O.some({
+        return {
           messageId: "noLeakedConditionalRendering",
           node: left,
           data: { value: context.sourceCode.getText(left) }
-        });
+        };
       }).with({ type: types.AST_NODE_TYPES.ConditionalExpression }, ({ alternate, consequent }) => {
-        return eff.O.orElse(getReportDescriptor(consequent), () => getReportDescriptor(alternate));
+        return getReportDescriptor(consequent) ?? getReportDescriptor(alternate);
       }).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
-        return eff.F.pipe(
-          VAR__namespace.findVariable(n.name, context.sourceCode.getScope(n)),
-          eff.O.flatMap(getVariableInitExpression(0)),
-          eff.O.flatMap(getReportDescriptor)
-        );
-      }).otherwise(eff.O.none);
+        const variable = VAR__namespace.findVariable(n.name, context.sourceCode.getScope(n));
+        const initExpression = getVariableInitExpression(variable, 0);
+        return getReportDescriptor(initExpression);
+      }).otherwise(() => eff._);
     }
-    const visitorFunction = eff.F.flow(getReportDescriptor, eff.O.map(context.report));
+    const visitorFunction = (node) => {
+      const descriptor = getReportDescriptor(node);
+      if (descriptor === eff._) return;
+      context.report(descriptor);
+    };
     return {
       "JSXExpressionContainer > ConditionalExpression": visitorFunction,
       "JSXExpressionContainer > LogicalExpression": visitorFunction
@@ -1670,13 +1655,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 & (core.ERFunctionComponentFlag.ForwardRef | core.ERFunctionComponentFlag.Memo)) > 0n;
-          if (eff.O.isSome(AST11__namespace.getFunctionIdentifier(node2))) {
+          if (AST11__namespace.getFunctionIdentifier(node2)) {
             continue;
           }
           if (!isMemoOrForwardRef) {
             continue;
           }
-          if (eff.O.isNone(displayName)) {
+          if (!displayName) {
             context.report({
               messageId: "noMissingComponentDisplayName",
               node: node2
@@ -1712,51 +1697,55 @@ var no_missing_key_default = createRule({
       switch (node.type) {
         case types.AST_NODE_TYPES.JSXElement: {
           const initialScope = context.sourceCode.getScope(node);
-          if (!JSX7__namespace.hasProp(node.openingElement.attributes, "key", initialScope)) {
-            return eff.O.some({
+          if (!JSX7__namespace.hasProp("key", initialScope, node.openingElement.attributes)) {
+            return {
               messageId: "noMissingKey",
               node
-            });
+            };
           }
-          return eff.O.none();
+          return null;
         }
         case types.AST_NODE_TYPES.JSXFragment: {
-          return eff.O.some({
+          return {
             messageId: "noMissingKeyWithFragment",
             node
-          });
+          };
         }
         default:
-          return eff.O.none();
+          return null;
       }
     }
     function checkExpression(node) {
       switch (node.type) {
         case types.AST_NODE_TYPES.ConditionalExpression:
-          if (!("consequent" in node)) {
-            return eff.O.none();
+          if ("consequent" in node) {
+            return checkIteratorElement(node.consequent) ?? checkIteratorElement(node.alternate);
           }
-          return eff.O.orElse(checkIteratorElement(node.consequent), () => checkIteratorElement(node.alternate));
+          return null;
         case types.AST_NODE_TYPES.JSXElement:
         case types.AST_NODE_TYPES.JSXFragment:
           return checkIteratorElement(node);
         case types.AST_NODE_TYPES.LogicalExpression:
-          if (!("left" in node)) {
-            return eff.O.none();
+          if ("left" in node) {
+            return checkIteratorElement(node.left) ?? checkIteratorElement(node.right);
           }
-          return eff.O.orElse(checkIteratorElement(node.left), () => checkIteratorElement(node.right));
+          return null;
         default:
-          return eff.O.none();
+          return null;
       }
     }
     function checkBlockStatement(node) {
-      return AST11__namespace.getNestedReturnStatements(node).reduce((acc, statement) => {
+      const descriptors = [];
+      for (const statement of AST11__namespace.getNestedReturnStatements(node)) {
         if (statement.argument == null) {
-          return acc;
+          continue;
         }
-        const mbDescriptor = checkIteratorElement(statement.argument);
-        return eff.O.isNone(mbDescriptor) ? acc : [...acc, mbDescriptor.value];
-      }, []);
+        const descriptor = checkIteratorElement(statement.argument);
+        if (descriptor != null) {
+          descriptors.push(descriptor);
+        }
+      }
+      return descriptors;
     }
     return {
       ArrayExpression(node) {
@@ -1769,7 +1758,7 @@ var no_missing_key_default = createRule({
         }
         const initialScope = context.sourceCode.getScope(node);
         for (const element of elements) {
-          if (!JSX7__namespace.hasProp(element.openingElement.attributes, "key", initialScope)) {
+          if (!JSX7__namespace.hasProp("key", initialScope, element.openingElement.attributes)) {
             context.report({
               messageId: "noMissingKey",
               node: element
@@ -1782,30 +1771,24 @@ var no_missing_key_default = createRule({
         if (state.isWithinChildrenToArray) {
           return;
         }
-        const isMapCall = AST11__namespace.isMapCallLoose(node);
-        const isArrayFromCall = tsPattern.isMatching({
-          type: types.AST_NODE_TYPES.CallExpression,
-          callee: {
-            type: types.AST_NODE_TYPES.MemberExpression,
-            property: {
-              name: "from"
-            }
-          }
-        }, node);
-        if (!isMapCall && !isArrayFromCall) {
+        const isMapCallLike = AST11__namespace.isMapCallLoose(node);
+        if (!isMapCallLike && !isArrayFromCall(node)) {
           return;
         }
-        const fn = node.arguments[isMapCall ? 0 : 1];
-        if (!AST11__namespace.isOneOf([types.AST_NODE_TYPES.ArrowFunctionExpression, types.AST_NODE_TYPES.FunctionExpression])(fn)) {
+        const fn = node.arguments[isMapCallLike ? 0 : 1];
+        if (fn?.type !== types.AST_NODE_TYPES.ArrowFunctionExpression && fn?.type !== types.AST_NODE_TYPES.FunctionExpression) {
           return;
         }
         if (fn.body.type === types.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;
         }
-        eff.O.map(checkExpression(fn.body), context.report);
+        const descriptor = checkExpression(fn.body);
+        if (descriptor != null) {
+          context.report(descriptor);
+        }
       },
       "CallExpression:exit"(node) {
         if (!core.isChildrenToArrayCall(node, context)) {
@@ -1828,6 +1811,9 @@ var no_missing_key_default = createRule({
   },
   defaultOptions: []
 });
+function isArrayFromCall(node) {
+  return node.type === types.AST_NODE_TYPES.CallExpression && node.callee.type === types.AST_NODE_TYPES.MemberExpression && node.callee.property.type === types.AST_NODE_TYPES.Identifier && node.callee.property.name === "from";
+}
 var RULE_NAME30 = "no-nested-components";
 var RULE_FEATURES30 = [
   "CHK"
@@ -1854,24 +1840,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__namespace.isFunction(node2) && functionComponents.some((component) => component.node === node2);
         };
         const isClassComponent11 = (node2) => {
           return AST11__namespace.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 (core.isDirectValueOfRenderPropertyLoose(component)) {
             continue;
           }
-          if (eff.O.isNone(componentName)) {
+          if (name2 === eff._) {
             continue;
           }
-          const name2 = componentName.value;
           const isInsideProperty = component.parent.type === types.AST_NODE_TYPES.Property;
-          const isInsideJSXPropValue = component.parent.type === types.AST_NODE_TYPES.JSXAttribute || eff.O.isSome(JSX7__namespace.findParentProp(node, (n) => n.value?.type === types.AST_NODE_TYPES.JSXExpressionContainer));
+          const isInsideJSXPropValue = component.parent.type === types.AST_NODE_TYPES.JSXAttribute || !!JSX7__namespace.findParentProp(node, (n) => n.value?.type === types.AST_NODE_TYPES.JSXExpressionContainer);
           if (isInsideJSXPropValue) {
             if (!core.isDeclaredInRenderPropLoose(component)) {
               context.report({
@@ -1894,13 +1883,8 @@ var no_nested_components_default = createRule({
             });
             continue;
           }
-          const isParnetComponentNotDirectValueOfRenderProperty = eff.O.exists(
-            AST11__namespace.findParentNodeGuard(
-              component,
-              isFunctionComponent
-            ),
-            eff.not(core.isDirectValueOfRenderPropertyLoose)
-          );
+          const parentComponent = AST11__namespace.findParentNodeGuard(component, isFunctionComponent);
+          const isParnetComponentNotDirectValueOfRenderProperty = !!parentComponent && !core.isDirectValueOfRenderPropertyLoose(parentComponent);
           if (isParnetComponentNotDirectValueOfRenderProperty) {
             context.report({
               messageId: isInsideProperty ? "nestedComponentInProps" : "nestedComponent",
@@ -1921,15 +1905,15 @@ var no_nested_components_default = createRule({
             });
           }
         }
-        for (const { name: name2, node: component } of classComponents) {
-          if (eff.O.isNone(AST11__namespace.findParentNode(component, eff.or(isClassComponent11, isFunctionComponent)))) {
+        for (const { name: name2 = "unknown", node: component } of classComponents) {
+          if (!AST11__namespace.findParentNode(component, (n) => isClassComponent11(n) || isFunctionComponent(n))) {
             continue;
           }
           context.report({
             messageId: "nestedComponent",
             node: component,
             data: {
-              name: eff.O.getOrElse(() => "unknown")(name2)
+              name: name2
             }
           });
         }
@@ -1974,15 +1958,11 @@ var no_prop_types_default = createRule({
         if (!core.isComponentName(object.name)) {
           return;
         }
-        const isComponent = eff.F.pipe(
-          VAR__namespace.findVariable(object.name, context.sourceCode.getScope(node)),
-          eff.O.flatMap(VAR__namespace.getVariableNode(0)),
-          eff.O.exists((n) => AST11__namespace.isFunction(n) || core.isClassComponent(n))
-        );
-        if (!isComponent) {
-          return;
+        const variable = VAR__namespace.findVariable(object.name, context.sourceCode.getScope(node));
+        const variableNode = variable && VAR__namespace.getVariableNode(variable, 0);
+        if (variableNode && (AST11__namespace.isFunction(variableNode) || core.isClassComponent(variableNode))) {
+          context.report({ messageId: "noPropTypes", node: property });
         }
-        context.report({ messageId: "noPropTypes", node: property });
       },
       PropertyDefinition(node) {
         if (!core.isClassComponent(node.parent.parent)) {
@@ -2026,7 +2006,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 & core.ERClassComponentFlag.PureComponent) === 0n) {
             continue;
           }
@@ -2037,7 +2017,7 @@ var no_redundant_should_component_update_default = createRule({
                 messageId: "noRedundantShouldComponentUpdate",
                 node: member,
                 data: {
-                  componentName: eff.O.getOrElse(() => "PureComponent")(name2)
+                  componentName: name2
                 }
               });
             }
@@ -2072,32 +2052,22 @@ var no_set_state_in_component_did_mount_default = createRule({
     if (!context.sourceCode.text.includes("componentDidMount")) {
       return {};
     }
-    function getReportDescriptor(node) {
-      if (!core.isThisSetState(node)) {
-        return eff.O.none();
-      }
-      return eff.F.pipe(
-        eff.O.Do,
-        eff.O.bind("clazz", () => AST11__namespace.findParentNodeGuard(node, core.isClassComponent)),
-        eff.O.bind("method", ({ clazz }) => AST11__namespace.findParentNodeStop(node, clazz, isComponentDidMount)),
-        eff.O.bind("methodScope", ({ method }) => eff.O.some(context.sourceCode.getScope(method))),
-        eff.O.bind("upperScope", () => eff.O.fromNullable(context.sourceCode.getScope(node).upper)),
-        eff.O.filter(
-          ({
-            clazz,
-            method,
-            methodScope,
-            upperScope
-          }) => method.parent === clazz.body && upperScope === methodScope
-        ),
-        eff.O.map(() => ({
-          messageId: "noSetStateInComponentDidMount",
-          node
-        }))
-      );
-    }
     return {
-      CallExpression: eff.F.flow(getReportDescriptor, eff.O.map(context.report))
+      CallExpression(node) {
+        if (!core.isThisSetState(node)) {
+          return;
+        }
+        const clazz = AST11__namespace.findParentNodeGuard(node, core.isClassComponent);
+        const method = clazz && AST11__namespace.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: []
@@ -2126,32 +2096,22 @@ var no_set_state_in_component_did_update_default = createRule({
     if (!context.sourceCode.text.includes("componentDidUpdate")) {
       return {};
     }
-    function getReportDescriptor(node) {
-      if (!core.isThisSetState(node)) {
-        return eff.O.none();
-      }
-      return eff.F.pipe(
-        eff.O.Do,
-        eff.O.bind("clazz", () => AST11__namespace.findParentNodeGuard(node, core.isClassComponent)),
-        eff.O.bind("method", ({ clazz }) => AST11__namespace.findParentNodeStop(node, clazz, isComponentDidUpdate)),
-        eff.O.bind("methodScope", ({ method }) => eff.O.some(context.sourceCode.getScope(method))),
-        eff.O.bind("upperScope", () => eff.O.fromNullable(context.sourceCode.getScope(node).upper)),
-        eff.O.filter(
-          ({
-            clazz,
-            method,
-            methodScope,
-            upperScope
-          }) => method.parent === clazz.body && upperScope === methodScope
-        ),
-        eff.O.map(() => ({
-          messageId: "noSetStateInComponentDidUpdate",
-          node
-        }))
-      );
-    }
     return {
-      CallExpression: eff.F.flow(getReportDescriptor, eff.O.map(context.report))
+      CallExpression(node) {
+        if (!core.isThisSetState(node)) {
+          return;
+        }
+        const clazz = AST11__namespace.findParentNodeGuard(node, core.isClassComponent);
+        const method = clazz && AST11__namespace.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: []
@@ -2180,32 +2140,22 @@ var no_set_state_in_component_will_update_default = createRule({
     if (!context.sourceCode.text.includes("componentWillUpdate")) {
       return {};
     }
-    function getReportDescriptor(node) {
-      if (!core.isThisSetState(node)) {
-        return eff.O.none();
-      }
-      return eff.F.pipe(
-        eff.O.Do,
-        eff.O.bind("clazz", () => AST11__namespace.findParentNodeGuard(node, core.isClassComponent)),
-        eff.O.bind("method", ({ clazz }) => AST11__namespace.findParentNodeStop(node, clazz, isComponentWillUpdate3)),
-        eff.O.bind("methodScope", ({ method }) => eff.O.some(context.sourceCode.getScope(method))),
-        eff.O.bind("upperScope", () => eff.O.fromNullable(context.sourceCode.getScope(node).upper)),
-        eff.O.filter(
-          ({
-            clazz,
-            method,
-            methodScope,
-            upperScope
-          }) => method.parent === clazz.body && upperScope === methodScope
-        ),
-        eff.O.map(() => ({
-          messageId: "noSetStateInComponentWillUpdate",
-          node
-        }))
-      );
-    }
     return {
-      CallExpression: eff.F.flow(getReportDescriptor, eff.O.map(context.report))
+      CallExpression(node) {
+        if (!core.isThisSetState(node)) {
+          return;
+        }
+        const clazz = AST11__namespace.findParentNodeGuard(node, core.isClassComponent);
+        const method = clazz && AST11__namespace.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: []
@@ -2215,14 +2165,14 @@ var RULE_FEATURES36 = [
   "CHK"
 ];
 function containsStringLiteral({ value }) {
-  return value?.type === types.AST_NODE_TYPES.Literal && eff.isString(value.value);
+  return value?.type === types.AST_NODE_TYPES.Literal && typeof value.value === "string";
 }
 function containsStringExpressionContainer({ value }) {
   if (value?.type !== types.AST_NODE_TYPES.JSXExpressionContainer) {
     return false;
   }
   if (value.expression.type === types.AST_NODE_TYPES.Literal) {
-    return eff.isString(value.expression.value);
+    return typeof value.expression.value === "string";
   }
   return value.expression.type === types.AST_NODE_TYPES.TemplateLiteral;
 }
@@ -2423,39 +2373,28 @@ var no_unstable_context_value_default = createRule({
         if (openingElementName.property.name !== "Provider") {
           return;
         }
-        eff.F.pipe(
-          eff.O.Do,
-          eff.O.bind("function", ctx.getCurrentFunction),
-          eff.O.bind("attribute", () => eff.O.fromNullable(
-            node.attributes.find((attribute) => {
-              return attribute.type === types.AST_NODE_TYPES.JSXAttribute && attribute.name.name === "value";
-            })
-          )),
-          eff.O.bind("value", ({ attribute }) => "value" in attribute ? eff.O.some(attribute.value) : eff.O.none()),
-          eff.O.bind("valueExpression", ({ value }) => value?.type === types.AST_NODE_TYPES.JSXExpressionContainer ? eff.O.some(value.expression) : eff.O.none()),
-          eff.O.bind("construction", ({ valueExpression }) => {
-            const initialScope = context.sourceCode.getScope(valueExpression);
-            return eff.O.some(VAR__namespace.getValueConstruction(valueExpression, initialScope));
-          }),
-          eff.O.map((vc) => {
-            if (vc.construction.kind === "None") {
-              return;
-            }
-            if (core.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 === eff._) return;
+        const attribute = node.attributes.find(
+          (attribute2) => attribute2.type === types.AST_NODE_TYPES.JSXAttribute && attribute2.name.name === "value"
         );
+        if (attribute === eff._ || !("value" in attribute)) return;
+        const value = attribute.value;
+        if (value?.type !== types.AST_NODE_TYPES.JSXExpressionContainer) return;
+        const valueExpression = value.expression;
+        const initialScope = context.sourceCode.getScope(valueExpression);
+        const construction = VAR__namespace.getValueConstruction(valueExpression, initialScope);
+        if (construction === eff._) return;
+        if (core.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({
@@ -2517,7 +2456,7 @@ var no_unstable_default_props_default = createRule({
               initialScope,
               VAR__namespace.ValueConstructionHint.StrictCallExpression
             );
-            if (construction.kind === "None") {
+            if (construction === eff._) {
               continue;
             }
             if (core.isReactHookCall(construction.node)) {
@@ -2535,13 +2474,10 @@ var no_unstable_default_props_default = createRule({
         }
       },
       "VariableDeclarator[id.type='ObjectPattern'][init.type='Identifier']"(node) {
-        const mbEntry = ctx.getCurrentFunction();
-        if (eff.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]);
       }
     };
   },
@@ -2573,15 +2509,15 @@ function getName3(node) {
     return getName3(node.expression);
   }
   if (node.type === types.AST_NODE_TYPES.Identifier || node.type === types.AST_NODE_TYPES.PrivateIdentifier) {
-    return eff.O.some(node.name);
+    return node.name;
   }
   if (node.type === types.AST_NODE_TYPES.Literal) {
-    return eff.O.some(String(node.value));
+    return node.value?.toString();
   }
   if (node.type === types.AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0) {
-    return eff.O.fromNullable(node.quasis[0]?.value.raw);
+    return node.quasis[0]?.value.raw;
   }
-  return eff.O.none();
+  return eff._;
 }
 var no_unused_class_component_members_default = createRule({
   meta: {
@@ -2597,12 +2533,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 (!core.isClassComponent(node)) {
         return;
       }
@@ -2610,37 +2546,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 || !core.isClassComponent(currentClass)) {
         return;
       }
-      const className = eff.O.map(AST11__namespace.getClassIdentifier(currentClass), (id) => id.name);
+      const className = AST11__namespace.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 (eff.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: eff.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 || !core.isClassComponent(currentClass)) {
         return;
       }
@@ -2652,7 +2588,7 @@ var no_unused_class_component_members_default = createRule({
       }
     }
     function methodExit() {
-      methodStack.pop();
+      methodEntries.pop();
     }
     return {
       ClassDeclaration: classEnter,
@@ -2660,8 +2596,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;
         }
@@ -2675,15 +2611,18 @@ var no_unused_class_component_members_default = createRule({
           propertyDefs.get(currentClass)?.add(node.property);
           return;
         }
-        eff.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;
         }
@@ -2693,10 +2632,9 @@ var no_unused_class_component_members_default = createRule({
         if (node.init != null && AST11__namespace.isThisExpression(node.init) && node.id.type === types.AST_NODE_TYPES.ObjectPattern) {
           for (const prop of node.id.properties) {
             if (prop.type === types.AST_NODE_TYPES.Property && AST11__namespace.isKeyLiteralLike(prop, prop.key)) {
-              const mbName = getName3(prop.key);
-              if (eff.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);
               }
             }
           }
@@ -2715,19 +2653,19 @@ function getName4(node) {
     return getName4(node.expression);
   }
   if (node.type === types.AST_NODE_TYPES.Identifier || node.type === types.AST_NODE_TYPES.PrivateIdentifier) {
-    return eff.O.some(node.name);
+    return node.name;
   }
   if (node.type === types.AST_NODE_TYPES.Literal) {
-    return eff.O.some(String(node.value));
+    return String(node.value);
   }
   if (node.type === types.AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0) {
-    return eff.O.fromNullable(node.quasis[0]?.value.raw);
+    return node.quasis[0]?.value.raw;
   }
-  return eff.O.none();
+  return eff._;
 }
 function isAssignmentToThisState2(node) {
   const { left } = node;
-  return left.type === types.AST_NODE_TYPES.MemberExpression && AST11__namespace.isThisExpression(left.object) && eff.O.exists(getName4(left.property), (name2) => name2 === "state");
+  return left.type === types.AST_NODE_TYPES.MemberExpression && AST11__namespace.isThisExpression(left.object) && getName4(left.property) === "state";
 }
 var isGetDerivedStateFromProps = tsPattern.isMatching({
   key: {
@@ -2752,72 +2690,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 || !core.isClassComponent(currentClass)) {
         return;
       }
-      const className = eff.O.map(AST11__namespace.getClassIdentifier(currentClass), (id) => id.name);
-      const [def, isUsed] = stateDefs.get(currentClass) ?? [eff.O.none(), false];
-      if (eff.O.isNone(def) || isUsed) {
+      const className = AST11__namespace.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: eff.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 || !core.isClassComponent(currentClass)) {
         return;
       }
       if (node.static) {
         if (isGetDerivedStateFromProps(node) && node.value.params.length > 1) {
-          const [def] = stateDefs.get(currentClass) ?? [eff.O.none()];
-          stateDefs.set(currentClass, [def, true]);
+          const defNode = stateDefs.get(currentClass)?.node;
+          stateDefs.set(currentClass, { node: defNode, isUsed: true });
         }
         return;
       }
-      if (eff.O.exists(getName4(node.key), (name2) => name2 === "state")) {
-        stateDefs.set(currentClass, [eff.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 || !core.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) ?? [eff.O.none(), false];
-        stateDefs.set(currentClass, [eff.O.some(node.left), isUsed]);
+        const isUsed = stateDefs.get(currentClass)?.isUsed ?? false;
+        stateDefs.set(currentClass, { node: node.left, isUsed });
       },
       ClassDeclaration: classEnter,
       "ClassDeclaration:exit": classExit,
@@ -2827,25 +2765,25 @@ var no_unused_state_default = createRule({
         if (!AST11__namespace.isThisExpression(node.object)) {
           return;
         }
-        if (!eff.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 || !core.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) ?? [eff.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,
@@ -2854,15 +2792,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 || !core.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)) {
@@ -2873,15 +2811,15 @@ var no_unused_state_default = createRule({
         }
         const hasState = node.id.properties.some((prop) => {
           if (prop.type === types.AST_NODE_TYPES.Property && AST11__namespace.isKeyLiteralLike(prop, prop.key)) {
-            return eff.O.exists(getName4(prop.key), (name2) => name2 === "state");
+            return getName4(prop.key) === "state";
           }
           return false;
         });
         if (!hasState) {
           return;
         }
-        const [def] = stateDefs.get(currentClass) ?? [eff.O.none(), false];
-        stateDefs.set(currentClass, [def, true]);
+        const defNode = stateDefs.get(currentClass)?.node;
+        stateDefs.set(currentClass, { node: defNode, isUsed: true });
       }
     };
   },
@@ -3001,15 +2939,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__namespace.isFunction(block)) {
             return false;
           }
-          return eff.O.exists(
-            AST11__namespace.getFunctionIdentifier(block),
-            (id) => core.isComponentName(id.name) && components.some((component) => component.node === block)
-          );
+          const id = AST11__namespace.getFunctionIdentifier(block);
+          return !!id && core.isComponentName(id.name) && components.some((component) => component.node === block);
         }
         for (const [initialScope, memberExpression] of memberExpressionWithNames) {
           let scope = initialScope;
@@ -3138,7 +3076,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;
@@ -3174,24 +3112,23 @@ var prefer_shorthand_boolean_default = createRule({
   },
   name: RULE_NAME48,
   create(context) {
-    function getReportDescriptor(node) {
-      const { value } = node;
-      const propName = JSX7__namespace.getPropName(node);
-      const hasValueTrue = value?.type === types.AST_NODE_TYPES.JSXExpressionContainer && value.expression.type === types.AST_NODE_TYPES.Literal && value.expression.value === true;
-      if (!hasValueTrue) {
-        return eff.O.none();
-      }
-      return eff.O.some({
-        messageId: "preferShorthandBoolean",
-        node,
-        data: {
-          propName
-        },
-        fix: (fixer) => fixer.removeRange([node.name.range[1], value.range[1]])
-      });
-    }
     return {
-      JSXAttribute: eff.F.flow(getReportDescriptor, eff.O.map(context.report))
+      JSXAttribute(node) {
+        const { value } = node;
+        const propName = JSX7__namespace.getPropName(node);
+        const hasValueTrue = value?.type === types.AST_NODE_TYPES.JSXExpressionContainer && value.expression.type === types.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: []
@@ -3216,31 +3153,32 @@ var prefer_shorthand_fragment_default = createRule({
   },
   name: RULE_NAME49,
   create(context) {
-    function getReportDescriptor(node) {
-      if (JSX7__namespace.getElementName(node.openingElement).split(".").at(-1) !== "Fragment") {
-        return eff.O.none();
-      }
-      const hasAttributes = node.openingElement.attributes.length > 0;
-      if (hasAttributes) {
-        return eff.O.none();
-      }
-      return eff.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: eff.F.flow(getReportDescriptor, eff.O.map(context.report))
+      JSXElement(node) {
+        if (JSX7__namespace.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: []
@@ -3262,23 +3200,23 @@ var use_jsx_vars_default = createRule({
   },
   name: RULE_NAME50,
   create(context) {
-    function getName5(node) {
-      switch (node.type) {
-        case types.AST_NODE_TYPES.JSXIdentifier:
-          return eff.O.some(node.name);
-        case types.AST_NODE_TYPES.JSXMemberExpression:
-          return getName5(node.object);
-        default:
-          return eff.O.none();
-      }
-    }
     return {
       JSXOpeningElement(node) {
-        if (node.name.type === types.AST_NODE_TYPES.JSXIdentifier && /^[a-z]/u.test(node.name.name)) {
-          return;
-        }
-        for (const name2 of eff.O.toArray(getName5(node.name))) {
-          context.sourceCode.markVariableAsUsed(name2, node);
+        switch (node.name.type) {
+          case types.AST_NODE_TYPES.JSXIdentifier: {
+            if (/^[a-z]/u.test(node.name.name)) {
+              return;
+            }
+            context.sourceCode.markVariableAsUsed(node.name.name, node);
+            break;
+          }
+          case types.AST_NODE_TYPES.JSXMemberExpression: {
+            const { object } = node.name;
+            if (object.type === types.AST_NODE_TYPES.JSXIdentifier) {
+              context.sourceCode.markVariableAsUsed(object.name, node);
+            }
+            break;
+          }
         }
       }
     };