/**
 * @license React
 * eslint-plugin-react-hooks.development.js
 *
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

"use strict";
"production" !== process.env.NODE_ENV &&
  (function () {
    function _unsupportedIterableToArray(o, minLen) {
      if (o) {
        if ("string" === typeof o) return _arrayLikeToArray(o, minLen);
        var n = Object.prototype.toString.call(o).slice(8, -1);
        "Object" === n && o.constructor && (n = o.constructor.name);
        if ("Map" === n || "Set" === n) return Array.from(o);
        if (
          "Arguments" === n ||
          /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)
        )
          return _arrayLikeToArray(o, minLen);
      }
    }
    function _arrayLikeToArray(arr, len) {
      if (null == len || len > arr.length) len = arr.length;
      for (var i = 0, arr2 = Array(len); i < len; i++) arr2[i] = arr[i];
      return arr2;
    }
    function _createForOfIteratorHelper(o, allowArrayLike) {
      var it;
      if ("undefined" === typeof Symbol || null == o[Symbol.iterator]) {
        if (
          Array.isArray(o) ||
          (it = _unsupportedIterableToArray(o)) ||
          (allowArrayLike && o && "number" === typeof o.length)
        ) {
          it && (o = it);
          var i = 0;
          allowArrayLike = function () {};
          return {
            s: allowArrayLike,
            n: function () {
              return i >= o.length ? { done: !0 } : { done: !1, value: o[i++] };
            },
            e: function (e) {
              throw e;
            },
            f: allowArrayLike
          };
        }
        throw new TypeError(
          "Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."
        );
      }
      var normalCompletion = !0,
        didErr = !1,
        err;
      return {
        s: function () {
          it = o[Symbol.iterator]();
        },
        n: function () {
          var step = it.next();
          normalCompletion = step.done;
          return step;
        },
        e: function (e) {
          didErr = !0;
          err = e;
        },
        f: function () {
          try {
            normalCompletion || null == it.return || it.return();
          } finally {
            if (didErr) throw err;
          }
        }
      };
    }
    function isHook(node) {
      if ("Identifier" === node.type)
        return (node = node.name), "use" === node || /^use[A-Z0-9]/.test(node);
      if (
        "MemberExpression" === node.type &&
        !node.computed &&
        isHook(node.property)
      ) {
        node = node.object;
        var isPascalCaseNameSpace = /^[A-Z].*/;
        return (
          "Identifier" === node.type && isPascalCaseNameSpace.test(node.name)
        );
      }
      return !1;
    }
    function isComponentName(node) {
      return "Identifier" === node.type && /^[A-Z]/.test(node.name);
    }
    function isReactFunction(node, functionName) {
      return (
        node.name === functionName ||
        ("MemberExpression" === node.type &&
          "React" === node.object.name &&
          node.property.name === functionName)
      );
    }
    function isForwardRefCallback(node) {
      return !!(
        node.parent &&
        node.parent.callee &&
        isReactFunction(node.parent.callee, "forwardRef")
      );
    }
    function isMemoCallback(node) {
      return !!(
        node.parent &&
        node.parent.callee &&
        isReactFunction(node.parent.callee, "memo")
      );
    }
    function isInsideComponentOrHook(node) {
      for (; node; ) {
        var functionName = getFunctionName(node);
        if (
          (functionName &&
            (isComponentName(functionName) || isHook(functionName))) ||
          isForwardRefCallback(node) ||
          isMemoCallback(node)
        )
          return !0;
        node = node.parent;
      }
      return !1;
    }
    function getFunctionName(node) {
      if (
        "FunctionDeclaration" === node.type ||
        ("FunctionExpression" === node.type && node.id)
      )
        return node.id;
      if (
        "FunctionExpression" === node.type ||
        "ArrowFunctionExpression" === node.type
      )
        return "VariableDeclarator" === node.parent.type &&
          node.parent.init === node
          ? node.parent.id
          : "AssignmentExpression" === node.parent.type &&
              node.parent.right === node &&
              "=" === node.parent.operator
            ? node.parent.left
            : "Property" !== node.parent.type ||
                node.parent.value !== node ||
                node.parent.computed
              ? "AssignmentPattern" !== node.parent.type ||
                node.parent.right !== node ||
                node.parent.computed
                ? void 0
                : node.parent.left
              : node.parent.key;
    }
    function collectRecommendations(_ref6) {
      function createDepTree() {
        return {
          isUsed: !1,
          isSatisfiedRecursively: !1,
          isSubtreeUsed: !1,
          children: new Map()
        };
      }
      function getOrCreateNodeByPath(rootNode, path) {
        path = path.split(".");
        path = _createForOfIteratorHelper(path);
        var _step4;
        try {
          for (path.s(); !(_step4 = path.n()).done; ) {
            var key = _step4.value,
              child = rootNode.children.get(key);
            child ||
              ((child = createDepTree()), rootNode.children.set(key, child));
            rootNode = child;
          }
        } catch (err) {
          path.e(err);
        } finally {
          path.f();
        }
        return rootNode;
      }
      function markAllParentsByPath(rootNode, path, fn) {
        path = path.split(".");
        path = _createForOfIteratorHelper(path);
        var _step5;
        try {
          for (path.s(); !(_step5 = path.n()).done; ) {
            var child = rootNode.children.get(_step5.value);
            if (!child) break;
            fn(child);
            rootNode = child;
          }
        } catch (err) {
          path.e(err);
        } finally {
          path.f();
        }
      }
      function scanTreeRecursively(
        node,
        missingPaths,
        satisfyingPaths,
        keyToPath
      ) {
        node.children.forEach(function (child, key) {
          var path = keyToPath(key);
          child.isSatisfiedRecursively
            ? child.isSubtreeUsed && satisfyingPaths.add(path)
            : child.isUsed
              ? missingPaths.add(path)
              : scanTreeRecursively(
                  child,
                  missingPaths,
                  satisfyingPaths,
                  function (childKey) {
                    return path + "." + childKey;
                  }
                );
        });
      }
      var dependencies = _ref6.dependencies,
        declaredDependencies = _ref6.declaredDependencies,
        stableDependencies = _ref6.stableDependencies,
        externalDependencies = _ref6.externalDependencies,
        isEffect = _ref6.isEffect,
        depTree = createDepTree();
      dependencies.forEach(function (_, key) {
        getOrCreateNodeByPath(depTree, key).isUsed = !0;
        markAllParentsByPath(depTree, key, function (parent) {
          parent.isSubtreeUsed = !0;
        });
      });
      declaredDependencies.forEach(function (_ref7) {
        getOrCreateNodeByPath(depTree, _ref7.key).isSatisfiedRecursively = !0;
      });
      stableDependencies.forEach(function (key) {
        getOrCreateNodeByPath(depTree, key).isSatisfiedRecursively = !0;
      });
      _ref6 = new Set();
      var satisfyingDependencies = new Set();
      scanTreeRecursively(
        depTree,
        _ref6,
        satisfyingDependencies,
        function (key) {
          return key;
        }
      );
      var suggestedDependencies = [],
        unnecessaryDependencies = new Set(),
        duplicateDependencies = new Set();
      declaredDependencies.forEach(function (_ref8) {
        _ref8 = _ref8.key;
        satisfyingDependencies.has(_ref8)
          ? -1 === suggestedDependencies.indexOf(_ref8)
            ? suggestedDependencies.push(_ref8)
            : duplicateDependencies.add(_ref8)
          : !isEffect ||
              _ref8.endsWith(".current") ||
              externalDependencies.has(_ref8)
            ? unnecessaryDependencies.add(_ref8)
            : -1 === suggestedDependencies.indexOf(_ref8) &&
              suggestedDependencies.push(_ref8);
      });
      _ref6.forEach(function (key) {
        suggestedDependencies.push(key);
      });
      return {
        suggestedDependencies: suggestedDependencies,
        unnecessaryDependencies: unnecessaryDependencies,
        duplicateDependencies: duplicateDependencies,
        missingDependencies: _ref6
      };
    }
    function getConstructionExpressionType(node) {
      switch (node.type) {
        case "ObjectExpression":
          return "object";
        case "ArrayExpression":
          return "array";
        case "ArrowFunctionExpression":
        case "FunctionExpression":
          return "function";
        case "ClassExpression":
          return "class";
        case "ConditionalExpression":
          if (
            null != getConstructionExpressionType(node.consequent) ||
            null != getConstructionExpressionType(node.alternate)
          )
            return "conditional";
          break;
        case "LogicalExpression":
          if (
            null != getConstructionExpressionType(node.left) ||
            null != getConstructionExpressionType(node.right)
          )
            return "logical expression";
          break;
        case "JSXFragment":
          return "JSX fragment";
        case "JSXElement":
          return "JSX element";
        case "AssignmentExpression":
          if (null != getConstructionExpressionType(node.right))
            return "assignment expression";
          break;
        case "NewExpression":
          return "object construction";
        case "Literal":
          if (node.value instanceof RegExp) return "regular expression";
          break;
        case "TypeCastExpression":
        case "AsExpression":
        case "TSAsExpression":
          return getConstructionExpressionType(node.expression);
      }
      return null;
    }
    function scanForConstructions(_ref9) {
      var declaredDependenciesNode = _ref9.declaredDependenciesNode,
        componentScope = _ref9.componentScope,
        scope = _ref9.scope;
      return _ref9.declaredDependencies
        .map(function (_ref10) {
          var key = _ref10.key;
          _ref10 = componentScope.variables.find(function (v) {
            return v.name === key;
          });
          if (null == _ref10) return null;
          var node = _ref10.defs[0];
          if (null == node) return null;
          if (
            "Variable" === node.type &&
            "VariableDeclarator" === node.node.type &&
            "Identifier" === node.node.id.type &&
            null != node.node.init
          ) {
            var constantExpressionType = getConstructionExpressionType(
              node.node.init
            );
            if (null != constantExpressionType)
              return [_ref10, constantExpressionType];
          }
          return "FunctionName" === node.type &&
            "FunctionDeclaration" === node.node.type
            ? [_ref10, "function"]
            : "ClassName" === node.type && "ClassDeclaration" === node.node.type
              ? [_ref10, "class"]
              : null;
        })
        .filter(Boolean)
        .map(function (_ref11) {
          var ref = _ref11[0];
          _ref11 = _ref11[1];
          var JSCompiler_temp_const = ref.defs[0];
          a: {
            for (
              var foundWriteExpr = !1, i = 0;
              i < ref.references.length;
              i++
            ) {
              var reference = ref.references[i];
              if (reference.writeExpr)
                if (foundWriteExpr) {
                  ref = !0;
                  break a;
                } else {
                  foundWriteExpr = !0;
                  continue;
                }
              for (
                var currentScope = reference.from;
                currentScope !== scope && null != currentScope;

              )
                currentScope = currentScope.upper;
              if (
                currentScope !== scope &&
                !isAncestorNodeOf(
                  declaredDependenciesNode,
                  reference.identifier
                )
              ) {
                ref = !0;
                break a;
              }
            }
            ref = !1;
          }
          return {
            construction: JSCompiler_temp_const,
            depType: _ref11,
            isUsedOutsideOfHook: ref
          };
        });
    }
    function getDependency(node) {
      return ("MemberExpression" !== node.parent.type &&
        "OptionalMemberExpression" !== node.parent.type) ||
        node.parent.object !== node ||
        "current" === node.parent.property.name ||
        node.parent.computed ||
        (null != node.parent.parent &&
          ("CallExpression" === node.parent.parent.type ||
            "OptionalCallExpression" === node.parent.parent.type) &&
          node.parent.parent.callee === node.parent)
        ? "MemberExpression" === node.type &&
          node.parent &&
          "AssignmentExpression" === node.parent.type &&
          node.parent.left === node
          ? node.object
          : node
        : getDependency(node.parent);
    }
    function markNode(node, optionalChains, result) {
      optionalChains &&
        (node.optional
          ? optionalChains.has(result) || optionalChains.set(result, !0)
          : optionalChains.set(result, !1));
    }
    function analyzePropertyChain(node, optionalChains) {
      if ("Identifier" === node.type || "JSXIdentifier" === node.type)
        return (
          (node = node.name),
          optionalChains && optionalChains.set(node, !1),
          node
        );
      if ("MemberExpression" !== node.type || node.computed) {
        if ("OptionalMemberExpression" !== node.type || node.computed) {
          if ("ChainExpression" !== node.type || node.computed)
            throw Error("Unsupported node type: " + node.type);
          node = node.expression;
          if ("CallExpression" === node.type)
            throw Error("Unsupported node type: " + node.type);
          var _object2 = analyzePropertyChain(node.object, optionalChains),
            _property2 = analyzePropertyChain(node.property, null);
          _object2 = _object2 + "." + _property2;
          markNode(node, optionalChains, _object2);
          return _object2;
        }
        _object2 = analyzePropertyChain(node.object, optionalChains);
        _property2 = analyzePropertyChain(node.property, null);
        _object2 = _object2 + "." + _property2;
        markNode(node, optionalChains, _object2);
        return _object2;
      }
      _object2 = analyzePropertyChain(node.object, optionalChains);
      _property2 = analyzePropertyChain(node.property, null);
      _object2 = _object2 + "." + _property2;
      markNode(node, optionalChains, _object2);
      return _object2;
    }
    function getNodeWithoutReactNamespace(node) {
      return "MemberExpression" !== node.type ||
        "Identifier" !== node.object.type ||
        "React" !== node.object.name ||
        "Identifier" !== node.property.type ||
        node.computed
        ? node
        : node.property;
    }
    function getReactiveHookCallbackIndex(calleeNode, options) {
      var node = getNodeWithoutReactNamespace(calleeNode);
      if ("Identifier" !== node.type) return -1;
      switch (node.name) {
        case "useEffect":
        case "useLayoutEffect":
        case "useCallback":
        case "useMemo":
          return 0;
        case "useImperativeHandle":
          return 1;
        default:
          if (node === calleeNode && options && options.additionalHooks) {
            try {
              var name = analyzePropertyChain(node, null);
            } catch (error) {
              if (/Unsupported node type/.test(error.message)) return 0;
              throw error;
            }
            return options.additionalHooks.test(name) ? 0 : -1;
          }
          return -1;
      }
    }
    function fastFindReferenceWithParent(start, target) {
      for (var queue = [start], item = null; queue.length; ) {
        item = queue.shift();
        if (
          ("Identifier" === item.type || "JSXIdentifier" === item.type) &&
          item.type === target.type &&
          item.name === target.name &&
          item.range[0] === target.range[0] &&
          item.range[1] === target.range[1]
        )
          return item;
        if (isAncestorNodeOf(item, target)) {
          start = 0;
          for (
            var _Object$entries = Object.entries(item);
            start < _Object$entries.length;
            start++
          ) {
            var _Object$entries$_i = _Object$entries[start],
              value = _Object$entries$_i[1];
            "parent" !== _Object$entries$_i[0] &&
              (isNodeLike(value)
                ? ((value.parent = item), queue.push(value))
                : Array.isArray(value) &&
                  value.forEach(function (val) {
                    isNodeLike(val) && ((val.parent = item), queue.push(val));
                  }));
          }
        }
      }
      return null;
    }
    function joinEnglish(arr) {
      for (var s = "", i = 0; i < arr.length; i++)
        (s += arr[i]),
          0 === i && 2 === arr.length
            ? (s += " and ")
            : i === arr.length - 2 && 2 < arr.length
              ? (s += ", and ")
              : i < arr.length - 1 && (s += ", ");
      return s;
    }
    function isNodeLike(val) {
      return (
        "object" === typeof val &&
        null !== val &&
        !Array.isArray(val) &&
        "string" === typeof val.type
      );
    }
    function isAncestorNodeOf(a, b) {
      return a.range[0] <= b.range[0] && a.range[1] >= b.range[1];
    }
    exports.configs = {
      recommended: {
        plugins: ["react-hooks"],
        rules: {
          "react-hooks/rules-of-hooks": "error",
          "react-hooks/exhaustive-deps": "warn"
        }
      }
    };
    exports.rules = {
      "rules-of-hooks": {
        meta: {
          type: "problem",
          docs: {
            description: "enforces the Rules of Hooks",
            recommended: !0,
            url: "https://reactjs.org/docs/hooks-rules.html"
          }
        },
        create: function (context) {
          function recordAllUseEffectEventFunctions(scope) {
            scope = _createForOfIteratorHelper(scope.references);
            try {
              for (scope.s(); !scope.n().done; );
            } catch (err$0) {
              scope.e(err$0);
            } finally {
              scope.f();
            }
          }
          var lastEffect = null,
            codePathReactHooksMapStack = [],
            codePathSegmentStack = [],
            useEffectEventFunctions = new WeakSet(),
            getSource =
              "function" === typeof context.getSource
                ? function (node) {
                    return context.getSource(node);
                  }
                : function (node) {
                    return context.sourceCode.getText(node);
                  },
            getScope =
              "function" === typeof context.getScope
                ? function () {
                    return context.getScope();
                  }
                : function (node) {
                    return context.sourceCode.getScope(node);
                  };
          return {
            onCodePathSegmentStart: function (segment) {
              return codePathSegmentStack.push(segment);
            },
            onCodePathSegmentEnd: function () {
              return codePathSegmentStack.pop();
            },
            onCodePathStart: function () {
              return codePathReactHooksMapStack.push(new Map());
            },
            onCodePathEnd: function (codePath, codePathNode) {
              function countPathsFromStart(segment, pathHistory) {
                var cache = countPathsFromStart.cache,
                  paths = cache.get(segment.id);
                pathHistory = new Set(pathHistory);
                if (pathHistory.has(segment.id)) {
                  cache = [].concat(pathHistory);
                  segment = cache.slice(cache.indexOf(segment.id) + 1);
                  segment = _createForOfIteratorHelper(segment);
                  var _step3;
                  try {
                    for (segment.s(); !(_step3 = segment.n()).done; )
                      cyclic.add(_step3.value);
                  } catch (err) {
                    segment.e(err);
                  } finally {
                    segment.f();
                  }
                  return BigInt("0");
                }
                pathHistory.add(segment.id);
                if (void 0 !== paths) return paths;
                if (codePath.thrownSegments.includes(segment))
                  paths = BigInt("0");
                else if (0 === segment.prevSegments.length) paths = BigInt("1");
                else {
                  paths = BigInt("0");
                  _step3 = _createForOfIteratorHelper(segment.prevSegments);
                  var _step4;
                  try {
                    for (_step3.s(); !(_step4 = _step3.n()).done; )
                      paths += countPathsFromStart(_step4.value, pathHistory);
                  } catch (err$1) {
                    _step3.e(err$1);
                  } finally {
                    _step3.f();
                  }
                }
                segment.reachable && paths === BigInt("0")
                  ? cache.delete(segment.id)
                  : cache.set(segment.id, paths);
                return paths;
              }
              function countPathsToEnd(segment, pathHistory) {
                var cache = countPathsToEnd.cache,
                  paths = cache.get(segment.id);
                pathHistory = new Set(pathHistory);
                if (pathHistory.has(segment.id)) {
                  cache = Array.from(pathHistory);
                  segment = cache.slice(cache.indexOf(segment.id) - 1);
                  segment = _createForOfIteratorHelper(segment);
                  var _step5;
                  try {
                    for (segment.s(); !(_step5 = segment.n()).done; )
                      cyclic.add(_step5.value);
                  } catch (err) {
                    segment.e(err);
                  } finally {
                    segment.f();
                  }
                  return BigInt("0");
                }
                pathHistory.add(segment.id);
                if (void 0 !== paths) return paths;
                if (codePath.thrownSegments.includes(segment))
                  paths = BigInt("0");
                else if (0 === segment.nextSegments.length) paths = BigInt("1");
                else {
                  paths = BigInt("0");
                  _step5 = _createForOfIteratorHelper(segment.nextSegments);
                  var _step6;
                  try {
                    for (_step5.s(); !(_step6 = _step5.n()).done; )
                      paths += countPathsToEnd(_step6.value, pathHistory);
                  } catch (err$2) {
                    _step5.e(err$2);
                  } finally {
                    _step5.f();
                  }
                }
                cache.set(segment.id, paths);
                return paths;
              }
              function shortestPathLengthToStart(segment) {
                var cache = shortestPathLengthToStart.cache,
                  length = cache.get(segment.id);
                if (null === length) return Infinity;
                if (void 0 !== length) return length;
                cache.set(segment.id, null);
                if (0 === segment.prevSegments.length) length = 1;
                else {
                  length = Infinity;
                  var _iterator7 = _createForOfIteratorHelper(
                      segment.prevSegments
                    ),
                    _step7;
                  try {
                    for (_iterator7.s(); !(_step7 = _iterator7.n()).done; ) {
                      var prevLength = shortestPathLengthToStart(_step7.value);
                      prevLength < length && (length = prevLength);
                    }
                  } catch (err) {
                    _iterator7.e(err);
                  } finally {
                    _iterator7.f();
                  }
                  length += 1;
                }
                cache.set(segment.id, length);
                return length;
              }
              var reactHooksMap = codePathReactHooksMapStack.pop();
              if (0 !== reactHooksMap.size) {
                var cyclic = new Set();
                countPathsFromStart.cache = new Map();
                countPathsToEnd.cache = new Map();
                shortestPathLengthToStart.cache = new Map();
                var allPathsFromStartToEnd = countPathsToEnd(
                    codePath.initialSegment
                  ),
                  codePathFunctionName = getFunctionName(codePathNode),
                  isSomewhereInsideComponentOrHook =
                    isInsideComponentOrHook(codePathNode),
                  isDirectlyInsideComponentOrHook = codePathFunctionName
                    ? isComponentName(codePathFunctionName) ||
                      isHook(codePathFunctionName)
                    : isForwardRefCallback(codePathNode) ||
                      isMemoCallback(codePathNode),
                  shortestFinalPathLength = Infinity,
                  _iterator8 = _createForOfIteratorHelper(
                    codePath.finalSegments
                  ),
                  _step8;
                try {
                  for (_iterator8.s(); !(_step8 = _iterator8.n()).done; ) {
                    var finalSegment = _step8.value;
                    if (finalSegment.reachable) {
                      var length$jscomp$0 =
                        shortestPathLengthToStart(finalSegment);
                      length$jscomp$0 < shortestFinalPathLength &&
                        (shortestFinalPathLength = length$jscomp$0);
                    }
                  }
                } catch (err) {
                  _iterator8.e(err);
                } finally {
                  _iterator8.f();
                }
                reactHooksMap = _createForOfIteratorHelper(reactHooksMap);
                var _step9;
                try {
                  for (
                    reactHooksMap.s();
                    !(_step9 = reactHooksMap.n()).done;

                  ) {
                    var _step9$value = _step9.value,
                      segment$jscomp$0 = _step9$value[0],
                      reactHooks = _step9$value[1];
                    if (segment$jscomp$0.reachable) {
                      var possiblyHasEarlyReturn =
                          0 === segment$jscomp$0.nextSegments.length
                            ? shortestFinalPathLength <=
                              shortestPathLengthToStart(segment$jscomp$0)
                            : shortestFinalPathLength <
                              shortestPathLengthToStart(segment$jscomp$0),
                        pathsFromStartToEnd =
                          countPathsFromStart(segment$jscomp$0) *
                          countPathsToEnd(segment$jscomp$0),
                        cycled = cyclic.has(segment$jscomp$0.id),
                        _iterator10 = _createForOfIteratorHelper(reactHooks),
                        _step10;
                      try {
                        for (
                          _iterator10.s();
                          !(_step10 = _iterator10.n()).done;

                        ) {
                          var hook = _step10.value;
                          cycled &&
                            !isReactFunction(hook, "use") &&
                            context.report({
                              node: hook,
                              message:
                                'React Hook "' +
                                getSource(hook) +
                                '" may be executed more than once. Possibly because it is called in a loop. React Hooks must be called in the exact same order in every component render.'
                            });
                          if (isDirectlyInsideComponentOrHook) {
                            if (
                              (codePathNode.async &&
                                context.report({
                                  node: hook,
                                  message:
                                    'React Hook "' +
                                    getSource(hook) +
                                    '" cannot be called in an async function.'
                                }),
                              !cycled &&
                                pathsFromStartToEnd !==
                                  allPathsFromStartToEnd &&
                                !isReactFunction(hook, "use"))
                            ) {
                              var message =
                                'React Hook "' +
                                getSource(hook) +
                                '" is called conditionally. React Hooks must be called in the exact same order in every component render.' +
                                (possiblyHasEarlyReturn
                                  ? " Did you accidentally call a React Hook after an early return?"
                                  : "");
                              context.report({ node: hook, message: message });
                            }
                          } else if (
                            codePathNode.parent &&
                            ("MethodDefinition" === codePathNode.parent.type ||
                              "ClassProperty" === codePathNode.parent.type) &&
                            codePathNode.parent.value === codePathNode
                          ) {
                            var _message =
                              'React Hook "' +
                              getSource(hook) +
                              '" cannot be called in a class component. React Hooks must be called in a React function component or a custom React Hook function.';
                            context.report({ node: hook, message: _message });
                          } else if (codePathFunctionName) {
                            var _message2 =
                              'React Hook "' +
                              getSource(hook) +
                              '" is called in function "' +
                              (getSource(codePathFunctionName) +
                                '" that is neither a React function component nor a custom React Hook function. React component names must start with an uppercase letter. React Hook names must start with the word "use".');
                            context.report({ node: hook, message: _message2 });
                          } else if ("Program" === codePathNode.type) {
                            var _message3 =
                              'React Hook "' +
                              getSource(hook) +
                              '" cannot be called at the top level. React Hooks must be called in a React function component or a custom React Hook function.';
                            context.report({ node: hook, message: _message3 });
                          } else if (
                            isSomewhereInsideComponentOrHook &&
                            !isReactFunction(hook, "use")
                          ) {
                            var _message4 =
                              'React Hook "' +
                              getSource(hook) +
                              '" cannot be called inside a callback. React Hooks must be called in a React function component or a custom React Hook function.';
                            context.report({ node: hook, message: _message4 });
                          }
                        }
                      } catch (err$3) {
                        _iterator10.e(err$3);
                      } finally {
                        _iterator10.f();
                      }
                    }
                  }
                } catch (err$4) {
                  reactHooksMap.e(err$4);
                } finally {
                  reactHooksMap.f();
                }
              }
            },
            CallExpression: function (node) {
              if (isHook(node.callee)) {
                var reactHooksMap =
                    codePathReactHooksMapStack[
                      codePathReactHooksMapStack.length - 1
                    ],
                  codePathSegment =
                    codePathSegmentStack[codePathSegmentStack.length - 1],
                  reactHooks = reactHooksMap.get(codePathSegment);
                reactHooks ||
                  ((reactHooks = []),
                  reactHooksMap.set(codePathSegment, reactHooks));
                reactHooks.push(node.callee);
              }
              "Identifier" === node.callee.type &&
                "useEffect" === node.callee.name &&
                0 < node.arguments.length &&
                (lastEffect = node);
            },
            Identifier: function (node) {
              null == lastEffect &&
                useEffectEventFunctions.has(node) &&
                "CallExpression" !== node.parent.type &&
                context.report({
                  node: node,
                  message:
                    "`" +
                    getSource(node) +
                    '` is a function created with React Hook "useEffectEvent", and can only be called from the same component. They cannot be assigned to variables or passed down.'
                });
            },
            "CallExpression:exit": function (node) {
              node === lastEffect && (lastEffect = null);
            },
            FunctionDeclaration: function (node) {
              isInsideComponentOrHook(node) &&
                recordAllUseEffectEventFunctions(getScope(node));
            },
            ArrowFunctionExpression: function (node) {
              isInsideComponentOrHook(node) &&
                recordAllUseEffectEventFunctions(getScope(node));
            }
          };
        }
      },
      "exhaustive-deps": {
        meta: {
          type: "suggestion",
          docs: {
            description:
              "verifies the list of dependencies for Hooks like useEffect and similar",
            recommended: !0,
            url: "https://github.com/facebook/react/issues/14920"
          },
          fixable: "code",
          hasSuggestions: !0,
          schema: [
            {
              type: "object",
              additionalProperties: !1,
              enableDangerousAutofixThisMayCauseInfiniteLoops: !1,
              properties: {
                additionalHooks: { type: "string" },
                enableDangerousAutofixThisMayCauseInfiniteLoops: {
                  type: "boolean"
                }
              }
            }
          ]
        },
        create: function (context) {
          function reportProblem(problem) {
            enableDangerousAutofixThisMayCauseInfiniteLoops &&
              Array.isArray(problem.suggest) &&
              0 < problem.suggest.length &&
              (problem.fix = problem.suggest[0].fix);
            context.report(problem);
          }
          function memoizeWithWeakMap(fn, map) {
            return function (arg) {
              if (map.has(arg)) return map.get(arg);
              var result = fn(arg);
              map.set(arg, result);
              return result;
            };
          }
          function visitFunctionWithDependencies(
            node,
            declaredDependenciesNode,
            reactiveHook,
            reactiveHookName,
            isEffect
          ) {
            function gatherDependenciesRecursively(currentScope) {
              var _iterator2 = _createForOfIteratorHelper(
                  currentScope.references
                ),
                _step2;
              try {
                for (_iterator2.s(); !(_step2 = _iterator2.n()).done; ) {
                  var reference = _step2.value;
                  if (
                    reference.resolved &&
                    pureScopes.has(reference.resolved.scope)
                  ) {
                    var referenceNode = fastFindReferenceWithParent(
                        node,
                        reference.identifier
                      ),
                      dependencyNode = getDependency(referenceNode),
                      dependency = analyzePropertyChain(
                        dependencyNode,
                        optionalChains
                      ),
                      JSCompiler_temp;
                    if (
                      (JSCompiler_temp =
                        isEffect &&
                        "Identifier" === dependencyNode.type &&
                        ("MemberExpression" === dependencyNode.parent.type ||
                          "OptionalMemberExpression" ===
                            dependencyNode.parent.type) &&
                        !dependencyNode.parent.computed &&
                        "Identifier" === dependencyNode.parent.property.type &&
                        "current" === dependencyNode.parent.property.name)
                    ) {
                      for (
                        var curScope = reference.from,
                          isInReturnedFunction = !1;
                        curScope.block !== node;

                      )
                        "function" === curScope.type &&
                          (isInReturnedFunction =
                            null != curScope.block.parent &&
                            "ReturnStatement" === curScope.block.parent.type),
                          (curScope = curScope.upper);
                      JSCompiler_temp = isInReturnedFunction;
                    }
                    JSCompiler_temp &&
                      currentRefsInEffectCleanup.set(dependency, {
                        reference: reference,
                        dependencyNode: dependencyNode
                      });
                    if (
                      "TSTypeQuery" !== dependencyNode.parent.type &&
                      "TSTypeReference" !== dependencyNode.parent.type
                    ) {
                      var def = reference.resolved.defs[0];
                      if (
                        null != def &&
                        (null == def.node || def.node.init !== node.parent) &&
                        "TypeParameter" !== def.type
                      )
                        if (dependencies.has(dependency))
                          dependencies
                            .get(dependency)
                            .references.push(reference);
                        else {
                          var resolved = reference.resolved,
                            isStable =
                              memoizedIsStableKnownHookValue(resolved) ||
                              memoizedIsFunctionWithoutCapturedValues(resolved);
                          dependencies.set(dependency, {
                            isStable: isStable,
                            references: [reference]
                          });
                        }
                    }
                  }
                }
              } catch (err) {
                _iterator2.e(err);
              } finally {
                _iterator2.f();
              }
              currentScope = _createForOfIteratorHelper(
                currentScope.childScopes
              );
              var _step3;
              try {
                for (currentScope.s(); !(_step3 = currentScope.n()).done; )
                  gatherDependenciesRecursively(_step3.value);
              } catch (err$5) {
                currentScope.e(err$5);
              } finally {
                currentScope.f();
              }
            }
            function formatDependency(path) {
              path = path.split(".");
              for (var finalPath = "", i = 0; i < path.length; i++) {
                if (0 !== i) {
                  var pathSoFar = path.slice(0, i + 1).join(".");
                  pathSoFar = !0 === optionalChains.get(pathSoFar);
                  finalPath += pathSoFar ? "?." : ".";
                }
                finalPath += path[i];
              }
              return finalPath;
            }
            function getWarningMessage(deps, singlePrefix, label, fixVerb) {
              return 0 === deps.size
                ? null
                : (1 < deps.size ? "" : singlePrefix + " ") +
                    label +
                    " " +
                    (1 < deps.size ? "dependencies" : "dependency") +
                    ": " +
                    joinEnglish(
                      Array.from(deps)
                        .sort()
                        .map(function (name) {
                          return "'" + formatDependency(name) + "'";
                        })
                    ) +
                    (". Either " +
                      fixVerb +
                      " " +
                      (1 < deps.size ? "them" : "it") +
                      " or remove the dependency array.");
            }
            isEffect &&
              node.async &&
              reportProblem({
                node: node,
                message:
                  "Effect callbacks are synchronous to prevent race conditions. Put the async function inside:\n\nuseEffect(() => {\n  async function fetchData() {\n    // You can await here\n    const response = await MyAPI.getData(someId);\n    // ...\n  }\n  fetchData();\n}, [someId]); // Or [] if effect doesn't need props or state\n\nLearn more about data fetching with Hooks: https://react.dev/link/hooks-data-fetching"
              });
            for (
              var scope = scopeManager.acquire(node),
                pureScopes = new Set(),
                componentScope = null,
                currentScope = scope.upper;
              currentScope;

            ) {
              pureScopes.add(currentScope);
              if ("function" === currentScope.type) break;
              currentScope = currentScope.upper;
            }
            if (currentScope) {
              componentScope = currentScope;
              var isArray = Array.isArray,
                memoizedIsStableKnownHookValue = memoizeWithWeakMap(function (
                  resolved
                ) {
                  if (!isArray(resolved.defs)) return !1;
                  var def = resolved.defs[0];
                  if (null == def || "VariableDeclarator" !== def.node.type)
                    return !1;
                  var init = def.node.init;
                  if (null == init) return !1;
                  for (
                    ;
                    "TSAsExpression" === init.type ||
                    "AsExpression" === init.type;

                  )
                    init = init.expression;
                  var declaration = def.node.parent;
                  if (
                    null == declaration &&
                    (fastFindReferenceWithParent(
                      componentScope.block,
                      def.node.id
                    ),
                    (declaration = def.node.parent),
                    null == declaration)
                  )
                    return !1;
                  if (
                    "const" === declaration.kind &&
                    "Literal" === init.type &&
                    ("string" === typeof init.value ||
                      "number" === typeof init.value ||
                      null === init.value)
                  )
                    return !0;
                  if ("CallExpression" !== init.type) return !1;
                  init = init.callee;
                  "MemberExpression" !== init.type ||
                    "React" !== init.object.name ||
                    null == init.property ||
                    init.computed ||
                    (init = init.property);
                  if ("Identifier" !== init.type) return !1;
                  def = def.node.id;
                  init = init.name;
                  if ("useRef" === init && "Identifier" === def.type) return !0;
                  if (
                    "useState" === init ||
                    "useReducer" === init ||
                    "useActionState" === init
                  ) {
                    if (
                      "ArrayPattern" === def.type &&
                      2 === def.elements.length &&
                      isArray(resolved.identifiers)
                    ) {
                      if (def.elements[1] === resolved.identifiers[0]) {
                        if ("useState" === init)
                          for (
                            resolved = resolved.references,
                              declaration = init = 0;
                            declaration < resolved.length;
                            declaration++
                          ) {
                            resolved[declaration].isWrite() && init++;
                            if (1 < init) return !1;
                            setStateCallSites.set(
                              resolved[declaration].identifier,
                              def.elements[0]
                            );
                          }
                        return !0;
                      }
                      if (
                        def.elements[0] === resolved.identifiers[0] &&
                        "useState" === init
                      )
                        for (
                          resolved = resolved.references, def = 0;
                          def < resolved.length;
                          def++
                        )
                          stateVariables.add(resolved[def].identifier);
                    }
                  } else if (
                    "useTransition" === init &&
                    "ArrayPattern" === def.type &&
                    2 === def.elements.length &&
                    Array.isArray(resolved.identifiers) &&
                    def.elements[1] === resolved.identifiers[0]
                  )
                    return !0;
                  return !1;
                }, stableKnownValueCache),
                memoizedIsFunctionWithoutCapturedValues = memoizeWithWeakMap(
                  function (resolved) {
                    if (!isArray(resolved.defs)) return !1;
                    resolved = resolved.defs[0];
                    if (
                      null == resolved ||
                      null == resolved.node ||
                      null == resolved.node.id
                    )
                      return !1;
                    var fnNode = resolved.node,
                      childScopes = componentScope.childScopes;
                    resolved = null;
                    var i;
                    for (i = 0; i < childScopes.length; i++) {
                      var childScope = childScopes[i],
                        childScopeBlock = childScope.block;
                      if (
                        ("FunctionDeclaration" === fnNode.type &&
                          childScopeBlock === fnNode) ||
                        ("VariableDeclarator" === fnNode.type &&
                          childScopeBlock.parent === fnNode)
                      ) {
                        resolved = childScope;
                        break;
                      }
                    }
                    if (null == resolved) return !1;
                    for (i = 0; i < resolved.through.length; i++)
                      if (
                        ((fnNode = resolved.through[i]),
                        null != fnNode.resolved &&
                          pureScopes.has(fnNode.resolved.scope) &&
                          !memoizedIsStableKnownHookValue(fnNode.resolved))
                      )
                        return !1;
                    return !0;
                  },
                  functionWithoutCapturedValueCache
                ),
                currentRefsInEffectCleanup = new Map(),
                dependencies = new Map(),
                optionalChains = new Map();
              gatherDependenciesRecursively(scope);
              currentRefsInEffectCleanup.forEach(function (_ref, dependency) {
                var dependencyNode = _ref.dependencyNode;
                _ref = _ref.reference.resolved.references;
                for (
                  var foundCurrentAssignment = !1, i = 0;
                  i < _ref.length;
                  i++
                ) {
                  var parent = _ref[i].identifier.parent;
                  if (
                    null != parent &&
                    "MemberExpression" === parent.type &&
                    !parent.computed &&
                    "Identifier" === parent.property.type &&
                    "current" === parent.property.name &&
                    "AssignmentExpression" === parent.parent.type &&
                    parent.parent.left === parent
                  ) {
                    foundCurrentAssignment = !0;
                    break;
                  }
                }
                foundCurrentAssignment ||
                  reportProblem({
                    node: dependencyNode.parent.property,
                    message:
                      "The ref value '" +
                      dependency +
                      ".current' will likely have changed by the time this effect cleanup function runs. If this ref points to a node rendered by React, copy '" +
                      (dependency +
                        ".current' to a variable inside the effect, and use that variable in the cleanup function.")
                  });
              });
              var staleAssignments = new Set(),
                stableDependencies = new Set();
              dependencies.forEach(function (_ref2, key) {
                var references = _ref2.references;
                _ref2.isStable && stableDependencies.add(key);
                references.forEach(function (reference) {
                  reference.writeExpr &&
                    ((reference = reference.writeExpr),
                    staleAssignments.has(key) ||
                      (staleAssignments.add(key),
                      reportProblem({
                        node: reference,
                        message:
                          "Assignments to the '" +
                          key +
                          "' variable from inside React Hook " +
                          (getSource(reactiveHook) +
                            " will be lost after each render. To preserve the value over time, store it in a useRef Hook and keep the mutable value in the '.current' property. Otherwise, you can move this variable directly inside ") +
                          (getSource(reactiveHook) + ".")
                      })));
                });
              });
              if (!(0 < staleAssignments.size))
                if (declaredDependenciesNode) {
                  var declaredDependencies = [],
                    externalDependencies = new Set();
                  currentScope =
                    "TSAsExpression" === declaredDependenciesNode.type &&
                    "ArrayExpression" ===
                      declaredDependenciesNode.expression.type;
                  "ArrayExpression" === declaredDependenciesNode.type ||
                  currentScope
                    ? (currentScope
                        ? declaredDependenciesNode.expression
                        : declaredDependenciesNode
                      ).elements.forEach(function (declaredDependencyNode) {
                        if (null !== declaredDependencyNode)
                          if ("SpreadElement" === declaredDependencyNode.type)
                            reportProblem({
                              node: declaredDependencyNode,
                              message:
                                "React Hook " +
                                getSource(reactiveHook) +
                                " has a spread element in its dependency array. This means we can't statically verify whether you've passed the correct dependencies."
                            });
                          else {
                            useEffectEventVariables.has(
                              declaredDependencyNode
                            ) &&
                              reportProblem({
                                node: declaredDependencyNode,
                                message:
                                  "Functions returned from `useEffectEvent` must not be included in the dependency array. Remove `" +
                                  (getSource(declaredDependencyNode) +
                                    "` from the list."),
                                suggest: [
                                  {
                                    desc:
                                      "Remove the dependency `" +
                                      getSource(declaredDependencyNode) +
                                      "`",
                                    fix: function (fixer) {
                                      return fixer.removeRange(
                                        declaredDependencyNode.range
                                      );
                                    }
                                  }
                                ]
                              });
                            try {
                              var declaredDependency = analyzePropertyChain(
                                declaredDependencyNode,
                                null
                              );
                            } catch (error) {
                              if (/Unsupported node type/.test(error.message)) {
                                "Literal" === declaredDependencyNode.type
                                  ? dependencies.has(
                                      declaredDependencyNode.value
                                    )
                                    ? reportProblem({
                                        node: declaredDependencyNode,
                                        message:
                                          "The " +
                                          declaredDependencyNode.raw +
                                          " literal is not a valid dependency because it never changes. Did you mean to include " +
                                          (declaredDependencyNode.value +
                                            " in the array instead?")
                                      })
                                    : reportProblem({
                                        node: declaredDependencyNode,
                                        message:
                                          "The " +
                                          declaredDependencyNode.raw +
                                          " literal is not a valid dependency because it never changes. You can safely remove it."
                                      })
                                  : reportProblem({
                                      node: declaredDependencyNode,
                                      message:
                                        "React Hook " +
                                        getSource(reactiveHook) +
                                        " has a complex expression in the dependency array. Extract it to a separate variable so it can be statically checked."
                                    });
                                return;
                              }
                              throw error;
                            }
                            for (
                              var maybeID = declaredDependencyNode;
                              "MemberExpression" === maybeID.type ||
                              "OptionalMemberExpression" === maybeID.type ||
                              "ChainExpression" === maybeID.type;

                            )
                              maybeID =
                                maybeID.object || maybeID.expression.object;
                            var isDeclaredInComponent =
                              !componentScope.through.some(function (ref) {
                                return ref.identifier === maybeID;
                              });
                            declaredDependencies.push({
                              key: declaredDependency,
                              node: declaredDependencyNode
                            });
                            isDeclaredInComponent ||
                              externalDependencies.add(declaredDependency);
                          }
                      })
                    : reportProblem({
                        node: declaredDependenciesNode,
                        message:
                          "React Hook " +
                          getSource(reactiveHook) +
                          " was passed a dependency list that is not an array literal. This means we can't statically verify whether you've passed the correct dependencies."
                      });
                  var _collectRecommendatio2 = collectRecommendations({
                    dependencies: dependencies,
                    declaredDependencies: declaredDependencies,
                    stableDependencies: stableDependencies,
                    externalDependencies: externalDependencies,
                    isEffect: isEffect
                  });
                  currentScope = _collectRecommendatio2.unnecessaryDependencies;
                  var missingDependencies =
                      _collectRecommendatio2.missingDependencies,
                    duplicateDependencies =
                      _collectRecommendatio2.duplicateDependencies,
                    suggestedDeps =
                      _collectRecommendatio2.suggestedDependencies;
                  if (
                    0 ===
                    duplicateDependencies.size +
                      missingDependencies.size +
                      currentScope.size
                  )
                    scanForConstructions({
                      declaredDependencies: declaredDependencies,
                      declaredDependenciesNode: declaredDependenciesNode,
                      componentScope: componentScope,
                      scope: scope
                    }).forEach(function (_ref4) {
                      var construction = _ref4.construction,
                        isUsedOutsideOfHook = _ref4.isUsedOutsideOfHook;
                      _ref4 = _ref4.depType;
                      var wrapperHook =
                          "function" === _ref4 ? "useCallback" : "useMemo",
                        constructionType =
                          "function" === _ref4
                            ? "definition"
                            : "initialization",
                        defaultAdvice =
                          "wrap the " +
                          constructionType +
                          " of '" +
                          construction.name.name +
                          "' in its own " +
                          wrapperHook +
                          "() Hook.";
                      defaultAdvice =
                        "The '" +
                        construction.name.name +
                        "' " +
                        _ref4 +
                        " " +
                        ("conditional" === _ref4 ||
                        "logical expression" === _ref4
                          ? "could make"
                          : "makes") +
                        " the dependencies of " +
                        (reactiveHookName +
                          " Hook (at line " +
                          declaredDependenciesNode.loc.start.line +
                          ") change on every render. ") +
                        (isUsedOutsideOfHook
                          ? "To fix this, " + defaultAdvice
                          : "Move it inside the " +
                            reactiveHookName +
                            " callback. Alternatively, " +
                            defaultAdvice);
                      var suggest;
                      isUsedOutsideOfHook &&
                        "Variable" === construction.type &&
                        "function" === _ref4 &&
                        (suggest = [
                          {
                            desc:
                              "Wrap the " +
                              constructionType +
                              " of '" +
                              construction.name.name +
                              "' in its own " +
                              wrapperHook +
                              "() Hook.",
                            fix: function (fixer) {
                              var _ref5 =
                                  "useMemo" === wrapperHook
                                    ? ["useMemo(() => { return ", "; })"]
                                    : ["useCallback(", ")"],
                                after = _ref5[1];
                              return [
                                fixer.insertTextBefore(
                                  construction.node.init,
                                  _ref5[0]
                                ),
                                fixer.insertTextAfter(
                                  construction.node.init,
                                  after
                                )
                              ];
                            }
                          }
                        ]);
                      reportProblem({
                        node: construction.node,
                        message: defaultAdvice,
                        suggest: suggest
                      });
                    });
                  else {
                    !isEffect &&
                      0 < missingDependencies.size &&
                      (suggestedDeps = collectRecommendations({
                        dependencies: dependencies,
                        declaredDependencies: [],
                        stableDependencies: stableDependencies,
                        externalDependencies: externalDependencies,
                        isEffect: isEffect
                      }).suggestedDependencies);
                    (function () {
                      if (0 === declaredDependencies.length) return !0;
                      var declaredDepKeys = declaredDependencies.map(
                          function (dep) {
                            return dep.key;
                          }
                        ),
                        sortedDeclaredDepKeys = declaredDepKeys.slice().sort();
                      return (
                        declaredDepKeys.join(",") ===
                        sortedDeclaredDepKeys.join(",")
                      );
                    })() && suggestedDeps.sort();
                    _collectRecommendatio2 = "";
                    if (0 < currentScope.size) {
                      var badRef = null;
                      Array.from(currentScope.keys()).forEach(function (key) {
                        null === badRef &&
                          key.endsWith(".current") &&
                          (badRef = key);
                      });
                      if (null !== badRef)
                        _collectRecommendatio2 =
                          " Mutable values like '" +
                          badRef +
                          "' aren't valid dependencies because mutating them doesn't re-render the component.";
                      else if (0 < externalDependencies.size) {
                        var dep = Array.from(externalDependencies)[0];
                        scope.set.has(dep) ||
                          (_collectRecommendatio2 =
                            " Outer scope values like '" +
                            dep +
                            "' aren't valid dependencies because mutating them doesn't re-render the component.");
                      }
                    }
                    if (
                      !_collectRecommendatio2 &&
                      missingDependencies.has("props")
                    ) {
                      scope = dependencies.get("props");
                      if (null == scope) return;
                      scope = scope.references;
                      if (!Array.isArray(scope)) return;
                      dep = !0;
                      for (
                        var i$jscomp$0 = 0;
                        i$jscomp$0 < scope.length;
                        i$jscomp$0++
                      ) {
                        var id = fastFindReferenceWithParent(
                          componentScope.block,
                          scope[i$jscomp$0].identifier
                        );
                        if (!id) {
                          dep = !1;
                          break;
                        }
                        id = id.parent;
                        if (null == id) {
                          dep = !1;
                          break;
                        }
                        if (
                          "MemberExpression" !== id.type &&
                          "OptionalMemberExpression" !== id.type
                        ) {
                          dep = !1;
                          break;
                        }
                      }
                      dep &&
                        (_collectRecommendatio2 =
                          " However, 'props' will change when *any* prop changes, so the preferred fix is to destructure the 'props' object outside of the " +
                          (reactiveHookName +
                            " call and refer to those specific props inside ") +
                          (getSource(reactiveHook) + "."));
                    }
                    if (
                      !_collectRecommendatio2 &&
                      0 < missingDependencies.size
                    ) {
                      var missingCallbackDep = null;
                      missingDependencies.forEach(function (missingDep) {
                        if (!missingCallbackDep) {
                          var topScopeRef = componentScope.set.get(missingDep),
                            usedDep = dependencies.get(missingDep);
                          if (
                            usedDep.references[0].resolved === topScopeRef &&
                            ((topScopeRef = topScopeRef.defs[0]),
                            null != topScopeRef &&
                              null != topScopeRef.name &&
                              "Parameter" === topScopeRef.type)
                          ) {
                            topScopeRef = !1;
                            for (
                              var id, _i2 = 0;
                              _i2 < usedDep.references.length;
                              _i2++
                            )
                              if (
                                ((id = usedDep.references[_i2].identifier),
                                null != id &&
                                  null != id.parent &&
                                  ("CallExpression" === id.parent.type ||
                                    "OptionalCallExpression" ===
                                      id.parent.type) &&
                                  id.parent.callee === id)
                              ) {
                                topScopeRef = !0;
                                break;
                              }
                            topScopeRef && (missingCallbackDep = missingDep);
                          }
                        }
                      });
                      null !== missingCallbackDep &&
                        (_collectRecommendatio2 =
                          " If '" +
                          missingCallbackDep +
                          "' changes too often, find the parent component that defines it and wrap that definition in useCallback.");
                    }
                    if (
                      !_collectRecommendatio2 &&
                      0 < missingDependencies.size
                    ) {
                      var setStateRecommendation = null;
                      missingDependencies.forEach(function (missingDep) {
                        if (null === setStateRecommendation)
                          for (
                            var references =
                                dependencies.get(missingDep).references,
                              id,
                              maybeCall,
                              _i3 = 0;
                            _i3 < references.length;
                            _i3++
                          ) {
                            id = references[_i3].identifier;
                            for (
                              maybeCall = id.parent;
                              null != maybeCall &&
                              maybeCall !== componentScope.block;

                            ) {
                              if ("CallExpression" === maybeCall.type) {
                                var correspondingStateVariable =
                                  setStateCallSites.get(maybeCall.callee);
                                if (null != correspondingStateVariable) {
                                  correspondingStateVariable.name === missingDep
                                    ? (setStateRecommendation = {
                                        missingDep: missingDep,
                                        setter: maybeCall.callee.name,
                                        form: "updater"
                                      })
                                    : stateVariables.has(id)
                                      ? (setStateRecommendation = {
                                          missingDep: missingDep,
                                          setter: maybeCall.callee.name,
                                          form: "reducer"
                                        })
                                      : ((id = references[_i3].resolved),
                                        null != id &&
                                          ((id = id.defs[0]),
                                          null != id &&
                                            "Parameter" === id.type &&
                                            (setStateRecommendation = {
                                              missingDep: missingDep,
                                              setter: maybeCall.callee.name,
                                              form: "inlineReducer"
                                            })));
                                  break;
                                }
                              }
                              maybeCall = maybeCall.parent;
                            }
                            if (null !== setStateRecommendation) break;
                          }
                      });
                      if (null !== setStateRecommendation)
                        switch (setStateRecommendation.form) {
                          case "reducer":
                            _collectRecommendatio2 =
                              " You can also replace multiple useState variables with useReducer if '" +
                              (setStateRecommendation.setter +
                                "' needs the current value of '") +
                              (setStateRecommendation.missingDep + "'.");
                            break;
                          case "inlineReducer":
                            _collectRecommendatio2 =
                              " If '" +
                              setStateRecommendation.setter +
                              "' needs the current value of '" +
                              (setStateRecommendation.missingDep +
                                "', you can also switch to useReducer instead of useState and read '") +
                              (setStateRecommendation.missingDep +
                                "' in the reducer.");
                            break;
                          case "updater":
                            _collectRecommendatio2 =
                              " You can also do a functional update '" +
                              setStateRecommendation.setter +
                              "(" +
                              setStateRecommendation.missingDep.slice(0, 1) +
                              " => ...)' if you only need '" +
                              setStateRecommendation.missingDep +
                              "' in the '" +
                              (setStateRecommendation.setter + "' call.");
                            break;
                          default:
                            throw Error("Unknown case.");
                        }
                    }
                    reportProblem({
                      node: declaredDependenciesNode,
                      message:
                        "React Hook " +
                        getSource(reactiveHook) +
                        " has " +
                        (getWarningMessage(
                          missingDependencies,
                          "a",
                          "missing",
                          "include"
                        ) ||
                          getWarningMessage(
                            currentScope,
                            "an",
                            "unnecessary",
                            "exclude"
                          ) ||
                          getWarningMessage(
                            duplicateDependencies,
                            "a",
                            "duplicate",
                            "omit"
                          )) +
                        _collectRecommendatio2,
                      suggest: [
                        {
                          desc:
                            "Update the dependencies array to be: [" +
                            suggestedDeps.map(formatDependency).join(", ") +
                            "]",
                          fix: function (fixer) {
                            return fixer.replaceText(
                              declaredDependenciesNode,
                              "[" +
                                suggestedDeps.map(formatDependency).join(", ") +
                                "]"
                            );
                          }
                        }
                      ]
                    });
                  }
                } else {
                  var setStateInsideEffectWithoutDeps = null;
                  dependencies.forEach(function (_ref3, key) {
                    setStateInsideEffectWithoutDeps ||
                      _ref3.references.forEach(function (reference) {
                        if (
                          !setStateInsideEffectWithoutDeps &&
                          setStateCallSites.has(reference.identifier)
                        ) {
                          for (
                            reference = reference.from;
                            "function" !== reference.type;

                          )
                            reference = reference.upper;
                          reference.block === node &&
                            (setStateInsideEffectWithoutDeps = key);
                        }
                      });
                  });
                  if (setStateInsideEffectWithoutDeps) {
                    var _suggestedDependencies = collectRecommendations({
                      dependencies: dependencies,
                      declaredDependencies: [],
                      stableDependencies: stableDependencies,
                      externalDependencies: new Set(),
                      isEffect: !0
                    }).suggestedDependencies;
                    reportProblem({
                      node: reactiveHook,
                      message:
                        "React Hook " +
                        reactiveHookName +
                        " contains a call to '" +
                        setStateInsideEffectWithoutDeps +
                        "'. Without a list of dependencies, this can lead to an infinite chain of updates. To fix this, pass [" +
                        _suggestedDependencies.join(", ") +
                        ("] as a second argument to the " +
                          reactiveHookName +
                          " Hook."),
                      suggest: [
                        {
                          desc:
                            "Add dependencies array: [" +
                            _suggestedDependencies.join(", ") +
                            "]",
                          fix: function (fixer) {
                            return fixer.insertTextAfter(
                              node,
                              ", [" + _suggestedDependencies.join(", ") + "]"
                            );
                          }
                        }
                      ]
                    });
                  }
                }
            }
          }
          var enableDangerousAutofixThisMayCauseInfiniteLoops =
              (context.options &&
                context.options[0] &&
                context.options[0]
                  .enableDangerousAutofixThisMayCauseInfiniteLoops) ||
              !1,
            options = {
              additionalHooks:
                context.options &&
                context.options[0] &&
                context.options[0].additionalHooks
                  ? new RegExp(context.options[0].additionalHooks)
                  : void 0,
              enableDangerousAutofixThisMayCauseInfiniteLoops:
                enableDangerousAutofixThisMayCauseInfiniteLoops
            },
            getSource =
              "function" === typeof context.getSource
                ? function (node) {
                    return context.getSource(node);
                  }
                : function (node) {
                    return context.sourceCode.getText(node);
                  },
            getScope =
              "function" === typeof context.getScope
                ? function () {
                    return context.getScope();
                  }
                : function (node) {
                    return context.sourceCode.getScope(node);
                  },
            scopeManager = context.getSourceCode().scopeManager,
            setStateCallSites = new WeakMap(),
            stateVariables = new WeakSet(),
            stableKnownValueCache = new WeakMap(),
            functionWithoutCapturedValueCache = new WeakMap(),
            useEffectEventVariables = new WeakSet();
          return {
            CallExpression: function (node) {
              var callbackIndex = getReactiveHookCallbackIndex(
                node.callee,
                options
              );
              if (-1 !== callbackIndex) {
                var callback = node.arguments[callbackIndex],
                  reactiveHook = node.callee,
                  reactiveHookName =
                    getNodeWithoutReactNamespace(reactiveHook).name;
                node = node.arguments[callbackIndex + 1];
                var declaredDependenciesNode =
                  !node ||
                  ("Identifier" === node.type && "undefined" === node.name)
                    ? void 0
                    : node;
                node = /Effect($|[^a-z])/g.test(reactiveHookName);
                if (callback)
                  if (declaredDependenciesNode || node) {
                    switch (callback.type) {
                      case "FunctionExpression":
                      case "ArrowFunctionExpression":
                        visitFunctionWithDependencies(
                          callback,
                          declaredDependenciesNode,
                          reactiveHook,
                          reactiveHookName,
                          node
                        );
                        return;
                      case "TSAsExpression":
                        visitFunctionWithDependencies(
                          callback.expression,
                          declaredDependenciesNode,
                          reactiveHook,
                          reactiveHookName,
                          node
                        );
                        return;
                      case "Identifier":
                        if (
                          !declaredDependenciesNode ||
                          (declaredDependenciesNode.elements &&
                            declaredDependenciesNode.elements.some(
                              function (el) {
                                return (
                                  el &&
                                  "Identifier" === el.type &&
                                  el.name === callback.name
                                );
                              }
                            ))
                        )
                          return;
                        callbackIndex = getScope(callback).set.get(
                          callback.name
                        );
                        if (null == callbackIndex || null == callbackIndex.defs)
                          return;
                        callbackIndex = callbackIndex.defs[0];
                        if (!callbackIndex || !callbackIndex.node) break;
                        if (
                          "Variable" !== callbackIndex.type &&
                          "FunctionName" !== callbackIndex.type
                        )
                          break;
                        switch (callbackIndex.node.type) {
                          case "FunctionDeclaration":
                            visitFunctionWithDependencies(
                              callbackIndex.node,
                              declaredDependenciesNode,
                              reactiveHook,
                              reactiveHookName,
                              node
                            );
                            return;
                          case "VariableDeclarator":
                            if ((callbackIndex = callbackIndex.node.init))
                              switch (callbackIndex.type) {
                                case "ArrowFunctionExpression":
                                case "FunctionExpression":
                                  visitFunctionWithDependencies(
                                    callbackIndex,
                                    declaredDependenciesNode,
                                    reactiveHook,
                                    reactiveHookName,
                                    node
                                  );
                                  return;
                              }
                        }
                        break;
                      default:
                        reportProblem({
                          node: reactiveHook,
                          message:
                            "React Hook " +
                            reactiveHookName +
                            " received a function whose dependencies are unknown. Pass an inline function instead."
                        });
                        return;
                    }
                    reportProblem({
                      node: reactiveHook,
                      message:
                        "React Hook " +
                        reactiveHookName +
                        " has a missing dependency: '" +
                        callback.name +
                        "'. Either include it or remove the dependency array.",
                      suggest: [
                        {
                          desc:
                            "Update the dependencies array to be: [" +
                            callback.name +
                            "]",
                          fix: function (fixer) {
                            return fixer.replaceText(
                              declaredDependenciesNode,
                              "[" + callback.name + "]"
                            );
                          }
                        }
                      ]
                    });
                  } else
                    ("useMemo" !== reactiveHookName &&
                      "useCallback" !== reactiveHookName) ||
                      reportProblem({
                        node: reactiveHook,
                        message:
                          "React Hook " +
                          reactiveHookName +
                          " does nothing when called with only one argument. Did you forget to pass an array of dependencies?"
                      });
                else
                  reportProblem({
                    node: reactiveHook,
                    message:
                      "React Hook " +
                      reactiveHookName +
                      " requires an effect callback. Did you forget to pass a callback to the hook?"
                  });
              }
            }
          };
        }
      }
    };
  })();