@remotion/eslint-config-flat 4.0.272 → 4.0.273

package/dist/esm/index.mjs

@@ -92590,7 +92590,7 @@ var require_rule_tester = __commonJS((exports, module) => {
   var { Linter, SourceCodeFixer, interpolate } = require_linter2();
   var CodePath = require_code_path();
   var ajv = require_ajv2()({ strictDefaults: true });
-  var espreePath = __require.resolve("espree");
+  var espreePath = __require.resolve("/Users/jonathanburger/remotion/node_modules/.pnpm/espree@9.6.1/node_modules/espree/dist/espree.cjs");
   var parserSymbol = Symbol.for("eslint.RuleTester.parser");
   var { SourceCode } = require_source_code2();
   var testerDefaultConfig = { rules: {} };
@@ -132695,120 +132695,1525 @@ var require_eslint_plugin_react = __commonJS((exports, module) => {
   module.exports = plugin;
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-react-hooks@5.2.0-canary-de1eaa26-20250124_eslint@9.19.0/node_modules/eslint-plugin-react-hooks/cjs/eslint-plugin-react-hooks.production.js
+// ../../node_modules/.pnpm/eslint-plugin-react-hooks@5.2.0_eslint@9.19.0/node_modules/eslint-plugin-react-hooks/cjs/eslint-plugin-react-hooks.production.js
 var require_eslint_plugin_react_hooks_production = __commonJS((exports) => {
-  var assign = Object.assign;
-  function _unsupportedIterableToArray(o, minLen) {
-    if (o) {
-      if (typeof o === "string")
-        return _arrayLikeToArray(o, minLen);
-      var n = Object.prototype.toString.call(o).slice(8, -1);
-      n === "Object" && o.constructor && (n = o.constructor.name);
-      if (n === "Map" || n === "Set")
-        return Array.from(o);
-      if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
-        return _arrayLikeToArray(o, minLen);
-    }
-  }
-  function _arrayLikeToArray(arr, len) {
-    if (len == null || len > arr.length)
-      len = arr.length;
-    for (var i = 0, arr2 = Array(len);i < len; i++)
-      arr2[i] = arr[i];
-    return arr2;
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+  
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+  
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m)
+      return m.call(o);
+    if (o && typeof o.length === "number")
+      return {
+        next: function() {
+          if (o && i >= o.length)
+            o = undefined;
+          return { value: o && o[i++], done: !o };
+        }
+      };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
   }
-  function _createForOfIteratorHelper(o, allowArrayLike) {
-    var it2;
-    if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
-      if (Array.isArray(o) || (it2 = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
-        it2 && (o = it2);
-        var i = 0;
-        allowArrayLike = function() {
-        };
-        return {
-          s: allowArrayLike,
-          n: function() {
-            return i >= o.length ? { done: true } : { done: false, value: o[i++] };
-          },
-          e: function(e) {
-            throw e;
-          },
-          f: allowArrayLike
-        };
+  function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m)
+      return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+      while ((n === undefined || n-- > 0) && !(r = i.next()).done)
+        ar.push(r.value);
+    } catch (error) {
+      e = { error };
+    } finally {
+      try {
+        if (r && !r.done && (m = i["return"]))
+          m.call(i);
+      } finally {
+        if (e)
+          throw e.error;
       }
-      throw new TypeError(`Invalid attempt to iterate non-iterable instance.
-In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
     }
-    var normalCompletion = true, didErr = false, err;
-    return {
-      s: function() {
-        it2 = o[Symbol.iterator]();
-      },
-      n: function() {
-        var step = it2.next();
-        normalCompletion = step.done;
-        return step;
-      },
-      e: function(e) {
-        didErr = true;
-        err = e;
-      },
-      f: function() {
-        try {
-          normalCompletion || it2.return == null || it2.return();
-        } finally {
-          if (didErr)
-            throw err;
+    return ar;
+  }
+  function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2)
+      for (var i = 0, l = from.length, ar;i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar)
+            ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
         }
       }
-    };
+    return to.concat(ar || from);
+  }
+  function isHookName(s) {
+    return s === "use" || /^use[A-Z0-9]/.test(s);
   }
   function isHook(node) {
-    if (node.type === "Identifier")
-      return node = node.name, node === "use" || /^use[A-Z0-9]/.test(node);
-    if (node.type === "MemberExpression" && !node.computed && isHook(node.property)) {
-      node = node.object;
+    if (node.type === "Identifier") {
+      return isHookName(node.name);
+    } else if (node.type === "MemberExpression" && !node.computed && isHook(node.property)) {
+      var obj = node.object;
       var isPascalCaseNameSpace = /^[A-Z].*/;
-      return node.type === "Identifier" && isPascalCaseNameSpace.test(node.name);
+      return obj.type === "Identifier" && isPascalCaseNameSpace.test(obj.name);
+    } else {
+      return false;
     }
-    return false;
   }
   function isComponentName(node) {
     return node.type === "Identifier" && /^[A-Z]/.test(node.name);
   }
   function isReactFunction(node, functionName) {
-    return node.name === functionName || node.type === "MemberExpression" && node.object.name === "React" && node.property.name === functionName;
+    return "name" in node && node.name === functionName || node.type === "MemberExpression" && "name" in node.object && node.object.name === "React" && "name" in node.property && node.property.name === functionName;
   }
   function isForwardRefCallback(node) {
-    return !!(node.parent && node.parent.callee && isReactFunction(node.parent.callee, "forwardRef"));
+    return !!(node.parent && ("callee" in node.parent) && node.parent.callee && isReactFunction(node.parent.callee, "forwardRef"));
   }
   function isMemoCallback(node) {
-    return !!(node.parent && node.parent.callee && isReactFunction(node.parent.callee, "memo"));
+    return !!(node.parent && ("callee" in node.parent) && node.parent.callee && isReactFunction(node.parent.callee, "memo"));
   }
   function isInsideComponentOrHook(node) {
-    for (;node; ) {
+    while (node) {
       var functionName = getFunctionName(node);
-      if (functionName && (isComponentName(functionName) || isHook(functionName)) || isForwardRefCallback(node) || isMemoCallback(node))
+      if (functionName) {
+        if (isComponentName(functionName) || isHook(functionName)) {
+          return true;
+        }
+      }
+      if (isForwardRefCallback(node) || isMemoCallback(node)) {
         return true;
+      }
       node = node.parent;
     }
     return false;
   }
   function isInsideDoWhileLoop(node) {
-    for (;node; ) {
-      if (node.type === "DoWhileStatement")
+    while (node) {
+      if (node.type === "DoWhileStatement") {
         return true;
+      }
       node = node.parent;
     }
     return false;
   }
+  function isUseEffectEventIdentifier$1(node) {
+    return false;
+  }
+  function isUseIdentifier(node) {
+    return isReactFunction(node, "use");
+  }
+  var rule$1 = {
+    meta: {
+      type: "problem",
+      docs: {
+        description: "enforces the Rules of Hooks",
+        recommended: true,
+        url: "https://reactjs.org/docs/hooks-rules.html"
+      }
+    },
+    create: function(context) {
+      var lastEffect = null;
+      var codePathReactHooksMapStack = [];
+      var codePathSegmentStack = [];
+      var useEffectEventFunctions = new WeakSet;
+      function recordAllUseEffectEventFunctions(scope) {
+        var e_1, _a, e_2, _b;
+        try {
+          for (var _c = __values(scope.references), _d = _c.next();!_d.done; _d = _c.next()) {
+            var reference = _d.value;
+            var parent = reference.identifier.parent;
+            if ((parent === null || parent === undefined ? undefined : parent.type) === "VariableDeclarator" && parent.init && parent.init.type === "CallExpression" && parent.init.callee && isUseEffectEventIdentifier$1(parent.init.callee)) {
+              if (reference.resolved === null) {
+                throw new Error("Unexpected null reference.resolved");
+              }
+              try {
+                for (var _e = (e_2 = undefined, __values(reference.resolved.references)), _f = _e.next();!_f.done; _f = _e.next()) {
+                  var ref = _f.value;
+                  if (ref !== reference) {
+                    useEffectEventFunctions.add(ref.identifier);
+                  }
+                }
+              } catch (e_2_1) {
+                e_2 = { error: e_2_1 };
+              } finally {
+                try {
+                  if (_f && !_f.done && (_b = _e.return))
+                    _b.call(_e);
+                } finally {
+                  if (e_2)
+                    throw e_2.error;
+                }
+              }
+            }
+          }
+        } catch (e_1_1) {
+          e_1 = { error: e_1_1 };
+        } finally {
+          try {
+            if (_d && !_d.done && (_a = _c.return))
+              _a.call(_c);
+          } finally {
+            if (e_1)
+              throw e_1.error;
+          }
+        }
+      }
+      var getSourceCode = typeof context.getSourceCode === "function" ? function() {
+        return context.getSourceCode();
+      } : function() {
+        return context.sourceCode;
+      };
+      var getScope = typeof context.getScope === "function" ? function() {
+        return context.getScope();
+      } : function(node) {
+        return getSourceCode().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) {
+          var e_3, _a, e_4, _b, e_5, _c;
+          var reactHooksMap = codePathReactHooksMapStack.pop();
+          if ((reactHooksMap === null || reactHooksMap === undefined ? undefined : reactHooksMap.size) === 0) {
+            return;
+          } else if (typeof reactHooksMap === "undefined") {
+            throw new Error("Unexpected undefined reactHooksMap");
+          }
+          var cyclic = new Set;
+          function countPathsFromStart(segment2, pathHistory) {
+            var e_6, _a2, e_7, _b2;
+            var cache = countPathsFromStart.cache;
+            var paths = cache.get(segment2.id);
+            var pathList = new Set(pathHistory);
+            if (pathList.has(segment2.id)) {
+              var pathArray = __spreadArray([], __read(pathList), false);
+              var cyclicSegments = pathArray.slice(pathArray.indexOf(segment2.id) + 1);
+              try {
+                for (var cyclicSegments_1 = __values(cyclicSegments), cyclicSegments_1_1 = cyclicSegments_1.next();!cyclicSegments_1_1.done; cyclicSegments_1_1 = cyclicSegments_1.next()) {
+                  var cyclicSegment = cyclicSegments_1_1.value;
+                  cyclic.add(cyclicSegment);
+                }
+              } catch (e_6_1) {
+                e_6 = { error: e_6_1 };
+              } finally {
+                try {
+                  if (cyclicSegments_1_1 && !cyclicSegments_1_1.done && (_a2 = cyclicSegments_1.return))
+                    _a2.call(cyclicSegments_1);
+                } finally {
+                  if (e_6)
+                    throw e_6.error;
+                }
+              }
+              return BigInt("0");
+            }
+            pathList.add(segment2.id);
+            if (paths !== undefined) {
+              return paths;
+            }
+            if (codePath.thrownSegments.includes(segment2)) {
+              paths = BigInt("0");
+            } else if (segment2.prevSegments.length === 0) {
+              paths = BigInt("1");
+            } else {
+              paths = BigInt("0");
+              try {
+                for (var _c2 = __values(segment2.prevSegments), _d2 = _c2.next();!_d2.done; _d2 = _c2.next()) {
+                  var prevSegment = _d2.value;
+                  paths += countPathsFromStart(prevSegment, pathList);
+                }
+              } catch (e_7_1) {
+                e_7 = { error: e_7_1 };
+              } finally {
+                try {
+                  if (_d2 && !_d2.done && (_b2 = _c2.return))
+                    _b2.call(_c2);
+                } finally {
+                  if (e_7)
+                    throw e_7.error;
+                }
+              }
+            }
+            if (segment2.reachable && paths === BigInt("0")) {
+              cache.delete(segment2.id);
+            } else {
+              cache.set(segment2.id, paths);
+            }
+            return paths;
+          }
+          function countPathsToEnd(segment2, pathHistory) {
+            var e_8, _a2, e_9, _b2;
+            var cache = countPathsToEnd.cache;
+            var paths = cache.get(segment2.id);
+            var pathList = new Set(pathHistory);
+            if (pathList.has(segment2.id)) {
+              var pathArray = Array.from(pathList);
+              var cyclicSegments = pathArray.slice(pathArray.indexOf(segment2.id) + 1);
+              try {
+                for (var cyclicSegments_2 = __values(cyclicSegments), cyclicSegments_2_1 = cyclicSegments_2.next();!cyclicSegments_2_1.done; cyclicSegments_2_1 = cyclicSegments_2.next()) {
+                  var cyclicSegment = cyclicSegments_2_1.value;
+                  cyclic.add(cyclicSegment);
+                }
+              } catch (e_8_1) {
+                e_8 = { error: e_8_1 };
+              } finally {
+                try {
+                  if (cyclicSegments_2_1 && !cyclicSegments_2_1.done && (_a2 = cyclicSegments_2.return))
+                    _a2.call(cyclicSegments_2);
+                } finally {
+                  if (e_8)
+                    throw e_8.error;
+                }
+              }
+              return BigInt("0");
+            }
+            pathList.add(segment2.id);
+            if (paths !== undefined) {
+              return paths;
+            }
+            if (codePath.thrownSegments.includes(segment2)) {
+              paths = BigInt("0");
+            } else if (segment2.nextSegments.length === 0) {
+              paths = BigInt("1");
+            } else {
+              paths = BigInt("0");
+              try {
+                for (var _c2 = __values(segment2.nextSegments), _d2 = _c2.next();!_d2.done; _d2 = _c2.next()) {
+                  var nextSegment = _d2.value;
+                  paths += countPathsToEnd(nextSegment, pathList);
+                }
+              } catch (e_9_1) {
+                e_9 = { error: e_9_1 };
+              } finally {
+                try {
+                  if (_d2 && !_d2.done && (_b2 = _c2.return))
+                    _b2.call(_c2);
+                } finally {
+                  if (e_9)
+                    throw e_9.error;
+                }
+              }
+            }
+            cache.set(segment2.id, paths);
+            return paths;
+          }
+          function shortestPathLengthToStart(segment2) {
+            var e_10, _a2;
+            var cache = shortestPathLengthToStart.cache;
+            var length2 = cache.get(segment2.id);
+            if (length2 === null) {
+              return Infinity;
+            }
+            if (length2 !== undefined) {
+              return length2;
+            }
+            cache.set(segment2.id, null);
+            if (segment2.prevSegments.length === 0) {
+              length2 = 1;
+            } else {
+              length2 = Infinity;
+              try {
+                for (var _b2 = __values(segment2.prevSegments), _c2 = _b2.next();!_c2.done; _c2 = _b2.next()) {
+                  var prevSegment = _c2.value;
+                  var prevLength = shortestPathLengthToStart(prevSegment);
+                  if (prevLength < length2) {
+                    length2 = prevLength;
+                  }
+                }
+              } catch (e_10_1) {
+                e_10 = { error: e_10_1 };
+              } finally {
+                try {
+                  if (_c2 && !_c2.done && (_a2 = _b2.return))
+                    _a2.call(_b2);
+                } finally {
+                  if (e_10)
+                    throw e_10.error;
+                }
+              }
+              length2 += 1;
+            }
+            cache.set(segment2.id, length2);
+            return length2;
+          }
+          countPathsFromStart.cache = new Map;
+          countPathsToEnd.cache = new Map;
+          shortestPathLengthToStart.cache = new Map;
+          var allPathsFromStartToEnd = countPathsToEnd(codePath.initialSegment);
+          var codePathFunctionName = getFunctionName(codePathNode);
+          var isSomewhereInsideComponentOrHook = isInsideComponentOrHook(codePathNode);
+          var isDirectlyInsideComponentOrHook = codePathFunctionName ? isComponentName(codePathFunctionName) || isHook(codePathFunctionName) : isForwardRefCallback(codePathNode) || isMemoCallback(codePathNode);
+          var shortestFinalPathLength = Infinity;
+          try {
+            for (var _d = __values(codePath.finalSegments), _e = _d.next();!_e.done; _e = _d.next()) {
+              var finalSegment = _e.value;
+              if (!finalSegment.reachable) {
+                continue;
+              }
+              var length = shortestPathLengthToStart(finalSegment);
+              if (length < shortestFinalPathLength) {
+                shortestFinalPathLength = length;
+              }
+            }
+          } catch (e_3_1) {
+            e_3 = { error: e_3_1 };
+          } finally {
+            try {
+              if (_e && !_e.done && (_a = _d.return))
+                _a.call(_d);
+            } finally {
+              if (e_3)
+                throw e_3.error;
+            }
+          }
+          try {
+            for (var reactHooksMap_1 = __values(reactHooksMap), reactHooksMap_1_1 = reactHooksMap_1.next();!reactHooksMap_1_1.done; reactHooksMap_1_1 = reactHooksMap_1.next()) {
+              var _f = __read(reactHooksMap_1_1.value, 2), segment = _f[0], reactHooks = _f[1];
+              if (!segment.reachable) {
+                continue;
+              }
+              var possiblyHasEarlyReturn = segment.nextSegments.length === 0 ? shortestFinalPathLength <= shortestPathLengthToStart(segment) : shortestFinalPathLength < shortestPathLengthToStart(segment);
+              var pathsFromStartToEnd = countPathsFromStart(segment) * countPathsToEnd(segment);
+              var cycled = cyclic.has(segment.id);
+              try {
+                for (var reactHooks_1 = (e_5 = undefined, __values(reactHooks)), reactHooks_1_1 = reactHooks_1.next();!reactHooks_1_1.done; reactHooks_1_1 = reactHooks_1.next()) {
+                  var hook = reactHooks_1_1.value;
+                  if ((cycled || isInsideDoWhileLoop(hook)) && !isUseIdentifier(hook)) {
+                    context.report({
+                      node: hook,
+                      message: 'React Hook "'.concat(getSourceCode().getText(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) {
+                    var isAsyncFunction = codePathNode.async;
+                    if (isAsyncFunction) {
+                      context.report({
+                        node: hook,
+                        message: 'React Hook "'.concat(getSourceCode().getText(hook), '" cannot be ') + "called in an async function."
+                      });
+                    }
+                    if (!cycled && pathsFromStartToEnd !== allPathsFromStartToEnd && !isUseIdentifier(hook) && !isInsideDoWhileLoop(hook)) {
+                      var message = 'React Hook "'.concat(getSourceCode().getText(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 });
+                    }
+                  } else if (codePathNode.parent != null && (codePathNode.parent.type === "MethodDefinition" || codePathNode.parent.type === "ClassProperty" || codePathNode.parent.type === "PropertyDefinition") && codePathNode.parent.value === codePathNode) {
+                    var message = 'React Hook "'.concat(getSourceCode().getText(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 });
+                  } else if (codePathFunctionName) {
+                    var message = 'React Hook "'.concat(getSourceCode().getText(hook), '" is called in ') + 'function "'.concat(getSourceCode().getText(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 });
+                  } else if (codePathNode.type === "Program") {
+                    var message = 'React Hook "'.concat(getSourceCode().getText(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 });
+                  } else {
+                    if (isSomewhereInsideComponentOrHook && !isUseIdentifier(hook)) {
+                      var message = 'React Hook "'.concat(getSourceCode().getText(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 });
+                    }
+                  }
+                }
+              } catch (e_5_1) {
+                e_5 = { error: e_5_1 };
+              } finally {
+                try {
+                  if (reactHooks_1_1 && !reactHooks_1_1.done && (_c = reactHooks_1.return))
+                    _c.call(reactHooks_1);
+                } finally {
+                  if (e_5)
+                    throw e_5.error;
+                }
+              }
+            }
+          } catch (e_4_1) {
+            e_4 = { error: e_4_1 };
+          } finally {
+            try {
+              if (reactHooksMap_1_1 && !reactHooksMap_1_1.done && (_b = reactHooksMap_1.return))
+                _b.call(reactHooksMap_1);
+            } finally {
+              if (e_4)
+                throw e_4.error;
+            }
+          }
+        },
+        CallExpression: function(node) {
+          if (isHook(node.callee)) {
+            var reactHooksMap = last(codePathReactHooksMapStack);
+            var codePathSegment = last(codePathSegmentStack);
+            var reactHooks = reactHooksMap.get(codePathSegment);
+            if (!reactHooks) {
+              reactHooks = [];
+              reactHooksMap.set(codePathSegment, reactHooks);
+            }
+            reactHooks.push(node.callee);
+          }
+          if (node.callee.type === "Identifier" && (node.callee.name === "useEffect" || isUseEffectEventIdentifier$1()) && node.arguments.length > 0) {
+            lastEffect = node;
+          }
+        },
+        Identifier: function(node) {
+          if (lastEffect == null && useEffectEventFunctions.has(node) && node.parent.type !== "CallExpression") {
+            context.report({
+              node,
+              message: "`".concat(getSourceCode().getText(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) {
+          if (node === lastEffect) {
+            lastEffect = null;
+          }
+        },
+        FunctionDeclaration: function(node) {
+          if (isInsideComponentOrHook(node)) {
+            recordAllUseEffectEventFunctions(getScope(node));
+          }
+        },
+        ArrowFunctionExpression: function(node) {
+          if (isInsideComponentOrHook(node)) {
+            recordAllUseEffectEventFunctions(getScope(node));
+          }
+        }
+      };
+    }
+  };
   function getFunctionName(node) {
-    if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" && node.id)
+    var _a, _b, _c, _d;
+    if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" && node.id) {
       return node.id;
-    if (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression")
-      return node.parent.type === "VariableDeclarator" && node.parent.init === node ? node.parent.id : node.parent.type === "AssignmentExpression" && node.parent.right === node && node.parent.operator === "=" ? node.parent.left : node.parent.type !== "Property" || node.parent.value !== node || node.parent.computed ? node.parent.type !== "AssignmentPattern" || node.parent.right !== node || node.parent.computed ? undefined : node.parent.left : node.parent.key;
+    } else if (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+      if (((_a = node.parent) === null || _a === undefined ? undefined : _a.type) === "VariableDeclarator" && node.parent.init === node) {
+        return node.parent.id;
+      } else if (((_b = node.parent) === null || _b === undefined ? undefined : _b.type) === "AssignmentExpression" && node.parent.right === node && node.parent.operator === "=") {
+        return node.parent.left;
+      } else if (((_c = node.parent) === null || _c === undefined ? undefined : _c.type) === "Property" && node.parent.value === node && !node.parent.computed) {
+        return node.parent.key;
+      } else if (((_d = node.parent) === null || _d === undefined ? undefined : _d.type) === "AssignmentPattern" && node.parent.right === node && !node.parent.computed) {
+        return node.parent.left;
+      } else {
+        return;
+      }
+    } else {
+      return;
+    }
+  }
+  function last(array) {
+    return array[array.length - 1];
   }
-  function collectRecommendations(_ref6) {
+  var rule2 = {
+    meta: {
+      type: "suggestion",
+      docs: {
+        description: "verifies the list of dependencies for Hooks like useEffect and similar",
+        recommended: true,
+        url: "https://github.com/facebook/react/issues/14920"
+      },
+      fixable: "code",
+      hasSuggestions: true,
+      schema: [
+        {
+          type: "object",
+          additionalProperties: false,
+          enableDangerousAutofixThisMayCauseInfiniteLoops: false,
+          properties: {
+            additionalHooks: {
+              type: "string"
+            },
+            enableDangerousAutofixThisMayCauseInfiniteLoops: {
+              type: "boolean"
+            }
+          }
+        }
+      ]
+    },
+    create: function(context) {
+      var additionalHooks = context.options && context.options[0] && context.options[0].additionalHooks ? new RegExp(context.options[0].additionalHooks) : undefined;
+      var enableDangerousAutofixThisMayCauseInfiniteLoops = context.options && context.options[0] && context.options[0].enableDangerousAutofixThisMayCauseInfiniteLoops || false;
+      var options = {
+        additionalHooks,
+        enableDangerousAutofixThisMayCauseInfiniteLoops
+      };
+      function reportProblem(problem) {
+        if (enableDangerousAutofixThisMayCauseInfiniteLoops) {
+          if (Array.isArray(problem.suggest) && problem.suggest.length > 0 && problem.suggest[0]) {
+            problem.fix = problem.suggest[0].fix;
+          }
+        }
+        context.report(problem);
+      }
+      var getSourceCode = typeof context.getSourceCode === "function" ? function() {
+        return context.getSourceCode();
+      } : function() {
+        return context.sourceCode;
+      };
+      var getScope = typeof context.getScope === "function" ? function() {
+        return context.getScope();
+      } : function(node) {
+        return context.sourceCode.getScope(node);
+      };
+      var scopeManager = getSourceCode().scopeManager;
+      var setStateCallSites = new WeakMap;
+      var stateVariables = new WeakSet;
+      var stableKnownValueCache = new WeakMap;
+      var functionWithoutCapturedValueCache = new WeakMap;
+      var useEffectEventVariables = new WeakSet;
+      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) {
+        var e_1, _a, e_2, _b, e_3, _c;
+        if (isEffect && node.async) {
+          reportProblem({
+            node,
+            message: "Effect callbacks are synchronous to prevent race conditions. " + `Put the async function inside:
+
+` + `useEffect(() => {
+` + `  async function fetchData() {
+` + `    // You can await here
+` + `    const response = await MyAPI.getData(someId);
+` + `    // ...
+` + `  }
+` + `  fetchData();
+` + `}, [someId]); // Or [] if effect doesn't need props or state
+
+` + "Learn more about data fetching with Hooks: https://react.dev/link/hooks-data-fetching"
+          });
+        }
+        var scope = scopeManager.acquire(node);
+        if (!scope) {
+          throw new Error("Unable to acquire scope for the current node. This is a bug in eslint-plugin-react-hooks, please file an issue.");
+        }
+        var pureScopes = new Set;
+        var componentScope = null;
+        {
+          var currentScope = scope.upper;
+          while (currentScope) {
+            pureScopes.add(currentScope);
+            if (currentScope.type === "function") {
+              break;
+            }
+            currentScope = currentScope.upper;
+          }
+          if (!currentScope) {
+            return;
+          }
+          componentScope = currentScope;
+        }
+        var isArray = Array.isArray;
+        function isStableKnownHookValue(resolved2) {
+          var e_4, _a2, e_5, _b2, e_6, _c2;
+          if (!isArray(resolved2.defs)) {
+            return false;
+          }
+          var def2 = resolved2.defs[0];
+          if (def2 == null) {
+            return false;
+          }
+          var defNode = def2.node;
+          if (defNode.type !== "VariableDeclarator") {
+            return false;
+          }
+          var init = defNode.init;
+          if (init == null) {
+            return false;
+          }
+          while (init.type === "TSAsExpression" || init.type === "AsExpression") {
+            init = init.expression;
+          }
+          var declaration = defNode.parent;
+          if (declaration == null && componentScope != null) {
+            fastFindReferenceWithParent(componentScope.block, def2.node.id);
+            declaration = def2.node.parent;
+            if (declaration == null) {
+              return false;
+            }
+          }
+          if (declaration != null && "kind" in declaration && declaration.kind === "const" && init.type === "Literal" && (typeof init.value === "string" || typeof init.value === "number" || init.value === null)) {
+            return true;
+          }
+          if (init.type !== "CallExpression") {
+            return false;
+          }
+          var callee = init.callee;
+          if (callee.type === "MemberExpression" && "name" in callee.object && callee.object.name === "React" && callee.property != null && !callee.computed) {
+            callee = callee.property;
+          }
+          if (callee.type !== "Identifier") {
+            return false;
+          }
+          var definitionNode = def2.node;
+          var id2 = definitionNode.id;
+          var name = callee.name;
+          if (name === "useRef" && id2.type === "Identifier") {
+            return true;
+          } else if (isUseEffectEventIdentifier() && id2.type === "Identifier") {
+            try {
+              for (var _d2 = __values(resolved2.references), _e = _d2.next();!_e.done; _e = _d2.next()) {
+                var ref2 = _e.value;
+                if (ref2 !== id2) {
+                  useEffectEventVariables.add(ref2.identifier);
+                }
+              }
+            } catch (e_4_1) {
+              e_4 = { error: e_4_1 };
+            } finally {
+              try {
+                if (_e && !_e.done && (_a2 = _d2.return))
+                  _a2.call(_d2);
+              } finally {
+                if (e_4)
+                  throw e_4.error;
+              }
+            }
+            return true;
+          } else if (name === "useState" || name === "useReducer" || name === "useActionState") {
+            if (id2.type === "ArrayPattern" && id2.elements.length === 2 && isArray(resolved2.identifiers)) {
+              if (id2.elements[1] === resolved2.identifiers[0]) {
+                if (name === "useState") {
+                  var references2 = resolved2.references;
+                  var writeCount = 0;
+                  try {
+                    for (var references_2 = __values(references2), references_2_1 = references_2.next();!references_2_1.done; references_2_1 = references_2.next()) {
+                      var reference2 = references_2_1.value;
+                      if (reference2.isWrite()) {
+                        writeCount++;
+                      }
+                      if (writeCount > 1) {
+                        return false;
+                      }
+                      setStateCallSites.set(reference2.identifier, id2.elements[0]);
+                    }
+                  } catch (e_5_1) {
+                    e_5 = { error: e_5_1 };
+                  } finally {
+                    try {
+                      if (references_2_1 && !references_2_1.done && (_b2 = references_2.return))
+                        _b2.call(references_2);
+                    } finally {
+                      if (e_5)
+                        throw e_5.error;
+                    }
+                  }
+                }
+                return true;
+              } else if (id2.elements[0] === resolved2.identifiers[0]) {
+                if (name === "useState") {
+                  var references2 = resolved2.references;
+                  try {
+                    for (var references_3 = __values(references2), references_3_1 = references_3.next();!references_3_1.done; references_3_1 = references_3.next()) {
+                      var reference2 = references_3_1.value;
+                      stateVariables.add(reference2.identifier);
+                    }
+                  } catch (e_6_1) {
+                    e_6 = { error: e_6_1 };
+                  } finally {
+                    try {
+                      if (references_3_1 && !references_3_1.done && (_c2 = references_3.return))
+                        _c2.call(references_3);
+                    } finally {
+                      if (e_6)
+                        throw e_6.error;
+                    }
+                  }
+                }
+                return false;
+              }
+            }
+          } else if (name === "useTransition") {
+            if (id2.type === "ArrayPattern" && id2.elements.length === 2 && Array.isArray(resolved2.identifiers)) {
+              if (id2.elements[1] === resolved2.identifiers[0]) {
+                return true;
+              }
+            }
+          }
+          return false;
+        }
+        function isFunctionWithoutCapturedValues(resolved2) {
+          var e_7, _a2, e_8, _b2;
+          if (!isArray(resolved2.defs)) {
+            return false;
+          }
+          var def2 = resolved2.defs[0];
+          if (def2 == null) {
+            return false;
+          }
+          if (def2.node == null || def2.node.id == null) {
+            return false;
+          }
+          var fnNode = def2.node;
+          var childScopes = (componentScope === null || componentScope === undefined ? undefined : componentScope.childScopes) || [];
+          var fnScope = null;
+          try {
+            for (var childScopes_1 = __values(childScopes), childScopes_1_1 = childScopes_1.next();!childScopes_1_1.done; childScopes_1_1 = childScopes_1.next()) {
+              var childScope = childScopes_1_1.value;
+              var childScopeBlock = childScope.block;
+              if (fnNode.type === "FunctionDeclaration" && childScopeBlock === fnNode || fnNode.type === "VariableDeclarator" && childScopeBlock.parent === fnNode) {
+                fnScope = childScope;
+                break;
+              }
+            }
+          } catch (e_7_1) {
+            e_7 = { error: e_7_1 };
+          } finally {
+            try {
+              if (childScopes_1_1 && !childScopes_1_1.done && (_a2 = childScopes_1.return))
+                _a2.call(childScopes_1);
+            } finally {
+              if (e_7)
+                throw e_7.error;
+            }
+          }
+          if (fnScope == null) {
+            return false;
+          }
+          try {
+            for (var _c2 = __values(fnScope.through), _d2 = _c2.next();!_d2.done; _d2 = _c2.next()) {
+              var ref2 = _d2.value;
+              if (ref2.resolved == null) {
+                continue;
+              }
+              if (pureScopes.has(ref2.resolved.scope) && !memoizedIsStableKnownHookValue(ref2.resolved)) {
+                return false;
+              }
+            }
+          } catch (e_8_1) {
+            e_8 = { error: e_8_1 };
+          } finally {
+            try {
+              if (_d2 && !_d2.done && (_b2 = _c2.return))
+                _b2.call(_c2);
+            } finally {
+              if (e_8)
+                throw e_8.error;
+            }
+          }
+          return true;
+        }
+        var memoizedIsStableKnownHookValue = memoizeWithWeakMap(isStableKnownHookValue, stableKnownValueCache);
+        var memoizedIsFunctionWithoutCapturedValues = memoizeWithWeakMap(isFunctionWithoutCapturedValues, functionWithoutCapturedValueCache);
+        var currentRefsInEffectCleanup = new Map;
+        function isInsideEffectCleanup(reference2) {
+          var curScope = reference2.from;
+          var isInReturnedFunction = false;
+          while (curScope != null && curScope.block !== node) {
+            if (curScope.type === "function") {
+              isInReturnedFunction = curScope.block.parent != null && curScope.block.parent.type === "ReturnStatement";
+            }
+            curScope = curScope.upper;
+          }
+          return isInReturnedFunction;
+        }
+        var dependencies = new Map;
+        var optionalChains = new Map;
+        gatherDependenciesRecursively(scope);
+        function gatherDependenciesRecursively(currentScope2) {
+          var e_9, _a2, e_10, _b2;
+          var _c2, _d2, _e, _f, _g;
+          try {
+            for (var _h = __values(currentScope2.references), _j = _h.next();!_j.done; _j = _h.next()) {
+              var reference2 = _j.value;
+              if (!reference2.resolved) {
+                continue;
+              }
+              if (!pureScopes.has(reference2.resolved.scope)) {
+                continue;
+              }
+              var referenceNode = fastFindReferenceWithParent(node, reference2.identifier);
+              if (referenceNode == null) {
+                continue;
+              }
+              var dependencyNode = getDependency(referenceNode);
+              var dependency = analyzePropertyChain(dependencyNode, optionalChains);
+              if (isEffect && dependencyNode.type === "Identifier" && (((_c2 = dependencyNode.parent) === null || _c2 === undefined ? undefined : _c2.type) === "MemberExpression" || ((_d2 = dependencyNode.parent) === null || _d2 === undefined ? undefined : _d2.type) === "OptionalMemberExpression") && !dependencyNode.parent.computed && dependencyNode.parent.property.type === "Identifier" && dependencyNode.parent.property.name === "current" && isInsideEffectCleanup(reference2)) {
+                currentRefsInEffectCleanup.set(dependency, {
+                  reference: reference2,
+                  dependencyNode
+                });
+              }
+              if (((_e = dependencyNode.parent) === null || _e === undefined ? undefined : _e.type) === "TSTypeQuery" || ((_f = dependencyNode.parent) === null || _f === undefined ? undefined : _f.type) === "TSTypeReference") {
+                continue;
+              }
+              var def2 = reference2.resolved.defs[0];
+              if (def2 == null) {
+                continue;
+              }
+              if (def2.node != null && def2.node.init === node.parent) {
+                continue;
+              }
+              if (def2.type === "TypeParameter") {
+                continue;
+              }
+              if (!dependencies.has(dependency)) {
+                var resolved2 = reference2.resolved;
+                var isStable = memoizedIsStableKnownHookValue(resolved2) || memoizedIsFunctionWithoutCapturedValues(resolved2);
+                dependencies.set(dependency, {
+                  isStable,
+                  references: [reference2]
+                });
+              } else {
+                (_g = dependencies.get(dependency)) === null || _g === undefined || _g.references.push(reference2);
+              }
+            }
+          } catch (e_9_1) {
+            e_9 = { error: e_9_1 };
+          } finally {
+            try {
+              if (_j && !_j.done && (_a2 = _h.return))
+                _a2.call(_h);
+            } finally {
+              if (e_9)
+                throw e_9.error;
+            }
+          }
+          try {
+            for (var _k = __values(currentScope2.childScopes), _l = _k.next();!_l.done; _l = _k.next()) {
+              var childScope = _l.value;
+              gatherDependenciesRecursively(childScope);
+            }
+          } catch (e_10_1) {
+            e_10 = { error: e_10_1 };
+          } finally {
+            try {
+              if (_l && !_l.done && (_b2 = _k.return))
+                _b2.call(_k);
+            } finally {
+              if (e_10)
+                throw e_10.error;
+            }
+          }
+        }
+        currentRefsInEffectCleanup.forEach(function(_a2, dependency) {
+          var e_11, _b2;
+          var _c2, _d2;
+          var { reference: reference2, dependencyNode } = _a2;
+          var references2 = ((_c2 = reference2.resolved) === null || _c2 === undefined ? undefined : _c2.references) || [];
+          var foundCurrentAssignment = false;
+          try {
+            for (var references_4 = __values(references2), references_4_1 = references_4.next();!references_4_1.done; references_4_1 = references_4.next()) {
+              var ref2 = references_4_1.value;
+              var identifier = ref2.identifier;
+              var parent2 = identifier.parent;
+              if (parent2 != null && parent2.type === "MemberExpression" && !parent2.computed && parent2.property.type === "Identifier" && parent2.property.name === "current" && ((_d2 = parent2.parent) === null || _d2 === undefined ? undefined : _d2.type) === "AssignmentExpression" && parent2.parent.left === parent2) {
+                foundCurrentAssignment = true;
+                break;
+              }
+            }
+          } catch (e_11_1) {
+            e_11 = { error: e_11_1 };
+          } finally {
+            try {
+              if (references_4_1 && !references_4_1.done && (_b2 = references_4.return))
+                _b2.call(references_4);
+            } finally {
+              if (e_11)
+                throw e_11.error;
+            }
+          }
+          if (foundCurrentAssignment) {
+            return;
+          }
+          reportProblem({
+            node: dependencyNode.parent.property,
+            message: "The ref value '".concat(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 " + "'".concat(dependency, ".current' to a variable inside the effect, and ") + "use that variable in the cleanup function."
+          });
+        });
+        var staleAssignments = new Set;
+        function reportStaleAssignment(writeExpr, key) {
+          if (staleAssignments.has(key)) {
+            return;
+          }
+          staleAssignments.add(key);
+          reportProblem({
+            node: writeExpr,
+            message: "Assignments to the '".concat(key, "' variable from inside React Hook ") + "".concat(getSourceCode().getText(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 " + "".concat(getSourceCode().getText(reactiveHook), ".")
+          });
+        }
+        var stableDependencies = new Set;
+        dependencies.forEach(function(_a2, key) {
+          var { isStable, references: references2 } = _a2;
+          if (isStable) {
+            stableDependencies.add(key);
+          }
+          references2.forEach(function(reference2) {
+            if (reference2.writeExpr) {
+              reportStaleAssignment(reference2.writeExpr, key);
+            }
+          });
+        });
+        if (staleAssignments.size > 0) {
+          return;
+        }
+        if (!declaredDependenciesNode) {
+          var setStateInsideEffectWithoutDeps_1 = null;
+          dependencies.forEach(function(_a2, key) {
+            var references2 = _a2.references;
+            if (setStateInsideEffectWithoutDeps_1) {
+              return;
+            }
+            references2.forEach(function(reference2) {
+              if (setStateInsideEffectWithoutDeps_1) {
+                return;
+              }
+              var id2 = reference2.identifier;
+              var isSetState = setStateCallSites.has(id2);
+              if (!isSetState) {
+                return;
+              }
+              var fnScope = reference2.from;
+              while (fnScope != null && fnScope.type !== "function") {
+                fnScope = fnScope.upper;
+              }
+              var isDirectlyInsideEffect = (fnScope === null || fnScope === undefined ? undefined : fnScope.block) === node;
+              if (isDirectlyInsideEffect) {
+                setStateInsideEffectWithoutDeps_1 = key;
+              }
+            });
+          });
+          if (setStateInsideEffectWithoutDeps_1) {
+            var suggestedDependencies_1 = collectRecommendations({
+              dependencies,
+              declaredDependencies: [],
+              stableDependencies,
+              externalDependencies: new Set,
+              isEffect: true
+            }).suggestedDependencies;
+            reportProblem({
+              node: reactiveHook,
+              message: "React Hook ".concat(reactiveHookName, " contains a call to '").concat(setStateInsideEffectWithoutDeps_1, "'. ") + "Without a list of dependencies, this can lead to an infinite chain of updates. " + "To fix this, pass [" + suggestedDependencies_1.join(", ") + "] as a second argument to the ".concat(reactiveHookName, " Hook."),
+              suggest: [
+                {
+                  desc: "Add dependencies array: [".concat(suggestedDependencies_1.join(", "), "]"),
+                  fix: function(fixer) {
+                    return fixer.insertTextAfter(node, ", [".concat(suggestedDependencies_1.join(", "), "]"));
+                  }
+                }
+              ]
+            });
+          }
+          return;
+        }
+        var declaredDependencies = [];
+        var externalDependencies = new Set;
+        var isArrayExpression = declaredDependenciesNode.type === "ArrayExpression";
+        var isTSAsArrayExpression = declaredDependenciesNode.type === "TSAsExpression" && declaredDependenciesNode.expression.type === "ArrayExpression";
+        if (!isArrayExpression && !isTSAsArrayExpression) {
+          reportProblem({
+            node: declaredDependenciesNode,
+            message: "React Hook ".concat(getSourceCode().getText(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."
+          });
+        } else {
+          var arrayExpression = isTSAsArrayExpression ? declaredDependenciesNode.expression : declaredDependenciesNode;
+          arrayExpression.elements.forEach(function(declaredDependencyNode) {
+            if (declaredDependencyNode === null) {
+              return;
+            }
+            if (declaredDependencyNode.type === "SpreadElement") {
+              reportProblem({
+                node: declaredDependencyNode,
+                message: "React Hook ".concat(getSourceCode().getText(reactiveHook), " has a spread ") + "element in its dependency array. This means we can't " + "statically verify whether you've passed the " + "correct dependencies."
+              });
+              return;
+            }
+            if (useEffectEventVariables.has(declaredDependencyNode)) {
+              reportProblem({
+                node: declaredDependencyNode,
+                message: "Functions returned from `useEffectEvent` must not be included in the dependency array. " + "Remove `".concat(getSourceCode().getText(declaredDependencyNode), "` from the list."),
+                suggest: [
+                  {
+                    desc: "Remove the dependency `".concat(getSourceCode().getText(declaredDependencyNode), "`"),
+                    fix: function(fixer) {
+                      return fixer.removeRange(declaredDependencyNode.range);
+                    }
+                  }
+                ]
+              });
+            }
+            var declaredDependency;
+            try {
+              declaredDependency = analyzePropertyChain(declaredDependencyNode, null);
+            } catch (error) {
+              if (error instanceof Error && /Unsupported node type/.test(error.message)) {
+                if (declaredDependencyNode.type === "Literal") {
+                  if (declaredDependencyNode.value && dependencies.has(declaredDependencyNode.value)) {
+                    reportProblem({
+                      node: declaredDependencyNode,
+                      message: "The ".concat(declaredDependencyNode.raw, " literal is not a valid dependency ") + "because it never changes. " + "Did you mean to include ".concat(declaredDependencyNode.value, " in the array instead?")
+                    });
+                  } else {
+                    reportProblem({
+                      node: declaredDependencyNode,
+                      message: "The ".concat(declaredDependencyNode.raw, " literal is not a valid dependency ") + "because it never changes. You can safely remove it."
+                    });
+                  }
+                } else {
+                  reportProblem({
+                    node: declaredDependencyNode,
+                    message: "React Hook ".concat(getSourceCode().getText(reactiveHook), " has a ") + "complex expression in the dependency array. " + "Extract it to a separate variable so it can be statically checked."
+                  });
+                }
+                return;
+              } else {
+                throw error;
+              }
+            }
+            var maybeID = declaredDependencyNode;
+            while (maybeID.type === "MemberExpression" || maybeID.type === "OptionalMemberExpression" || maybeID.type === "ChainExpression") {
+              maybeID = maybeID.object || maybeID.expression.object;
+            }
+            var isDeclaredInComponent = !componentScope.through.some(function(ref2) {
+              return ref2.identifier === maybeID;
+            });
+            declaredDependencies.push({
+              key: declaredDependency,
+              node: declaredDependencyNode
+            });
+            if (!isDeclaredInComponent) {
+              externalDependencies.add(declaredDependency);
+            }
+          });
+        }
+        var _d = collectRecommendations({
+          dependencies,
+          declaredDependencies,
+          stableDependencies,
+          externalDependencies,
+          isEffect
+        }), suggestedDependencies = _d.suggestedDependencies, unnecessaryDependencies = _d.unnecessaryDependencies, missingDependencies = _d.missingDependencies, duplicateDependencies = _d.duplicateDependencies;
+        var suggestedDeps = suggestedDependencies;
+        var problemCount = duplicateDependencies.size + missingDependencies.size + unnecessaryDependencies.size;
+        if (problemCount === 0) {
+          var constructions = scanForConstructions({
+            declaredDependencies,
+            declaredDependenciesNode,
+            componentScope,
+            scope
+          });
+          constructions.forEach(function(_a2) {
+            var _b2;
+            var { construction, isUsedOutsideOfHook, depType } = _a2;
+            var wrapperHook = depType === "function" ? "useCallback" : "useMemo";
+            var constructionType = depType === "function" ? "definition" : "initialization";
+            var defaultAdvice = "wrap the ".concat(constructionType, " of '").concat(construction.name.name, "' in its own ").concat(wrapperHook, "() Hook.");
+            var advice = isUsedOutsideOfHook ? "To fix this, ".concat(defaultAdvice) : "Move it inside the ".concat(reactiveHookName, " callback. Alternatively, ").concat(defaultAdvice);
+            var causation = depType === "conditional" || depType === "logical expression" ? "could make" : "makes";
+            var message = "The '".concat(construction.name.name, "' ").concat(depType, " ").concat(causation, " the dependencies of ") + "".concat(reactiveHookName, " Hook (at line ").concat((_b2 = declaredDependenciesNode.loc) === null || _b2 === undefined ? undefined : _b2.start.line, ") ") + "change on every render. ".concat(advice);
+            var suggest;
+            if (isUsedOutsideOfHook && construction.type === "Variable" && depType === "function") {
+              suggest = [
+                {
+                  desc: "Wrap the ".concat(constructionType, " of '").concat(construction.name.name, "' in its own ").concat(wrapperHook, "() Hook."),
+                  fix: function(fixer) {
+                    var _a3 = __read(wrapperHook === "useMemo" ? ["useMemo(() => { return ", "; })"] : ["useCallback(", ")"], 2), before = _a3[0], after = _a3[1];
+                    return [
+                      fixer.insertTextBefore(construction.node.init, before),
+                      fixer.insertTextAfter(construction.node.init, after)
+                    ];
+                  }
+                }
+              ];
+            }
+            reportProblem({
+              node: construction.node,
+              message,
+              suggest
+            });
+          });
+          return;
+        }
+        if (!isEffect && missingDependencies.size > 0) {
+          suggestedDeps = collectRecommendations({
+            dependencies,
+            declaredDependencies: [],
+            stableDependencies,
+            externalDependencies,
+            isEffect
+          }).suggestedDependencies;
+        }
+        function areDeclaredDepsAlphabetized() {
+          if (declaredDependencies.length === 0) {
+            return true;
+          }
+          var declaredDepKeys = declaredDependencies.map(function(dep2) {
+            return dep2.key;
+          });
+          var sortedDeclaredDepKeys = declaredDepKeys.slice().sort();
+          return declaredDepKeys.join(",") === sortedDeclaredDepKeys.join(",");
+        }
+        if (areDeclaredDepsAlphabetized()) {
+          suggestedDeps.sort();
+        }
+        function formatDependency(path) {
+          var members = path.split(".");
+          var finalPath = "";
+          for (var i = 0;i < members.length; i++) {
+            if (i !== 0) {
+              var pathSoFar = members.slice(0, i + 1).join(".");
+              var isOptional = optionalChains.get(pathSoFar) === true;
+              finalPath += isOptional ? "?." : ".";
+            }
+            finalPath += members[i];
+          }
+          return finalPath;
+        }
+        function getWarningMessage(deps, singlePrefix, label, fixVerb) {
+          if (deps.size === 0) {
+            return null;
+          }
+          return (deps.size > 1 ? "" : singlePrefix + " ") + label + " " + (deps.size > 1 ? "dependencies" : "dependency") + ": " + joinEnglish(Array.from(deps).sort().map(function(name) {
+            return "'" + formatDependency(name) + "'";
+          })) + ". Either ".concat(fixVerb, " ").concat(deps.size > 1 ? "them" : "it", " or remove the dependency array.");
+        }
+        var extraWarning = "";
+        if (unnecessaryDependencies.size > 0) {
+          var badRef_1 = null;
+          Array.from(unnecessaryDependencies.keys()).forEach(function(key) {
+            if (badRef_1 !== null) {
+              return;
+            }
+            if (key.endsWith(".current")) {
+              badRef_1 = key;
+            }
+          });
+          if (badRef_1 !== null) {
+            extraWarning = " Mutable values like '".concat(badRef_1, "' aren't valid dependencies ") + "because mutating them doesn't re-render the component.";
+          } else if (externalDependencies.size > 0) {
+            var dep = Array.from(externalDependencies)[0];
+            if (!scope.set.has(dep)) {
+              extraWarning = " Outer scope values like '".concat(dep, "' aren't valid dependencies ") + "because mutating them doesn't re-render the component.";
+            }
+          }
+        }
+        if (!extraWarning && missingDependencies.has("props")) {
+          var propDep = dependencies.get("props");
+          if (propDep == null) {
+            return;
+          }
+          var refs = propDep.references;
+          if (!Array.isArray(refs)) {
+            return;
+          }
+          var isPropsOnlyUsedInMembers = true;
+          try {
+            for (var refs_1 = __values(refs), refs_1_1 = refs_1.next();!refs_1_1.done; refs_1_1 = refs_1.next()) {
+              var ref = refs_1_1.value;
+              var id = fastFindReferenceWithParent(componentScope.block, ref.identifier);
+              if (!id) {
+                isPropsOnlyUsedInMembers = false;
+                break;
+              }
+              var parent = id.parent;
+              if (parent == null) {
+                isPropsOnlyUsedInMembers = false;
+                break;
+              }
+              if (parent.type !== "MemberExpression" && parent.type !== "OptionalMemberExpression") {
+                isPropsOnlyUsedInMembers = false;
+                break;
+              }
+            }
+          } catch (e_1_1) {
+            e_1 = { error: e_1_1 };
+          } finally {
+            try {
+              if (refs_1_1 && !refs_1_1.done && (_a = refs_1.return))
+                _a.call(refs_1);
+            } finally {
+              if (e_1)
+                throw e_1.error;
+            }
+          }
+          if (isPropsOnlyUsedInMembers) {
+            extraWarning = " However, 'props' will change when *any* prop changes, so the " + "preferred fix is to destructure the 'props' object outside of " + "the ".concat(reactiveHookName, " call and refer to those specific props ") + "inside ".concat(getSourceCode().getText(reactiveHook), ".");
+          }
+        }
+        if (!extraWarning && missingDependencies.size > 0) {
+          var missingCallbackDep_1 = null;
+          missingDependencies.forEach(function(missingDep2) {
+            var e_12, _a2;
+            var _b2;
+            if (missingCallbackDep_1) {
+              return;
+            }
+            var topScopeRef = componentScope.set.get(missingDep2);
+            var usedDep2 = dependencies.get(missingDep2);
+            if (!(usedDep2 === null || usedDep2 === undefined ? undefined : usedDep2.references) || ((_b2 = usedDep2 === null || usedDep2 === undefined ? undefined : usedDep2.references[0]) === null || _b2 === undefined ? undefined : _b2.resolved) !== topScopeRef) {
+              return;
+            }
+            var def2 = topScopeRef === null || topScopeRef === undefined ? undefined : topScopeRef.defs[0];
+            if (def2 == null || def2.name == null || def2.type !== "Parameter") {
+              return;
+            }
+            var isFunctionCall = false;
+            var id2;
+            try {
+              for (var _c2 = __values(usedDep2.references), _d2 = _c2.next();!_d2.done; _d2 = _c2.next()) {
+                var reference2 = _d2.value;
+                id2 = reference2.identifier;
+                if (id2 != null && id2.parent != null && (id2.parent.type === "CallExpression" || id2.parent.type === "OptionalCallExpression") && id2.parent.callee === id2) {
+                  isFunctionCall = true;
+                  break;
+                }
+              }
+            } catch (e_12_1) {
+              e_12 = { error: e_12_1 };
+            } finally {
+              try {
+                if (_d2 && !_d2.done && (_a2 = _c2.return))
+                  _a2.call(_c2);
+              } finally {
+                if (e_12)
+                  throw e_12.error;
+              }
+            }
+            if (!isFunctionCall) {
+              return;
+            }
+            missingCallbackDep_1 = missingDep2;
+          });
+          if (missingCallbackDep_1 !== null) {
+            extraWarning = " If '".concat(missingCallbackDep_1, "' changes too often, ") + "find the parent component that defines it " + "and wrap that definition in useCallback.";
+          }
+        }
+        if (!extraWarning && missingDependencies.size > 0) {
+          var setStateRecommendation = null;
+          try {
+            for (var missingDependencies_1 = __values(missingDependencies), missingDependencies_1_1 = missingDependencies_1.next();!missingDependencies_1_1.done; missingDependencies_1_1 = missingDependencies_1.next()) {
+              var missingDep = missingDependencies_1_1.value;
+              if (setStateRecommendation !== null) {
+                break;
+              }
+              var usedDep = dependencies.get(missingDep);
+              var references = usedDep.references;
+              var id = undefined;
+              var maybeCall = undefined;
+              try {
+                for (var references_1 = (e_3 = undefined, __values(references)), references_1_1 = references_1.next();!references_1_1.done; references_1_1 = references_1.next()) {
+                  var reference = references_1_1.value;
+                  id = reference.identifier;
+                  maybeCall = id.parent;
+                  while (maybeCall != null && maybeCall !== componentScope.block) {
+                    if (maybeCall.type === "CallExpression") {
+                      var correspondingStateVariable = setStateCallSites.get(maybeCall.callee);
+                      if (correspondingStateVariable != null) {
+                        if ("name" in correspondingStateVariable && correspondingStateVariable.name === missingDep) {
+                          setStateRecommendation = {
+                            missingDep,
+                            setter: "name" in maybeCall.callee ? maybeCall.callee.name : "",
+                            form: "updater"
+                          };
+                        } else if (stateVariables.has(id)) {
+                          setStateRecommendation = {
+                            missingDep,
+                            setter: "name" in maybeCall.callee ? maybeCall.callee.name : "",
+                            form: "reducer"
+                          };
+                        } else {
+                          var resolved = reference.resolved;
+                          if (resolved != null) {
+                            var def = resolved.defs[0];
+                            if (def != null && def.type === "Parameter") {
+                              setStateRecommendation = {
+                                missingDep,
+                                setter: "name" in maybeCall.callee ? maybeCall.callee.name : "",
+                                form: "inlineReducer"
+                              };
+                            }
+                          }
+                        }
+                        break;
+                      }
+                    }
+                    maybeCall = maybeCall.parent;
+                  }
+                  if (setStateRecommendation !== null) {
+                    break;
+                  }
+                }
+              } catch (e_3_1) {
+                e_3 = { error: e_3_1 };
+              } finally {
+                try {
+                  if (references_1_1 && !references_1_1.done && (_c = references_1.return))
+                    _c.call(references_1);
+                } finally {
+                  if (e_3)
+                    throw e_3.error;
+                }
+              }
+            }
+          } catch (e_2_1) {
+            e_2 = { error: e_2_1 };
+          } finally {
+            try {
+              if (missingDependencies_1_1 && !missingDependencies_1_1.done && (_b = missingDependencies_1.return))
+                _b.call(missingDependencies_1);
+            } finally {
+              if (e_2)
+                throw e_2.error;
+            }
+          }
+          if (setStateRecommendation !== null) {
+            switch (setStateRecommendation.form) {
+              case "reducer":
+                extraWarning = " You can also replace multiple useState variables with useReducer " + "if '".concat(setStateRecommendation.setter, "' needs the ") + "current value of '".concat(setStateRecommendation.missingDep, "'.");
+                break;
+              case "inlineReducer":
+                extraWarning = " If '".concat(setStateRecommendation.setter, "' needs the ") + "current value of '".concat(setStateRecommendation.missingDep, "', ") + "you can also switch to useReducer instead of useState and " + "read '".concat(setStateRecommendation.missingDep, "' in the reducer.");
+                break;
+              case "updater":
+                extraWarning = " You can also do a functional update '".concat(setStateRecommendation.setter, "(").concat(setStateRecommendation.missingDep.slice(0, 1), " => ...)' if you only need '").concat(setStateRecommendation.missingDep, "'") + " in the '".concat(setStateRecommendation.setter, "' call.");
+                break;
+              default:
+                throw new Error("Unknown case.");
+            }
+          }
+        }
+        reportProblem({
+          node: declaredDependenciesNode,
+          message: "React Hook ".concat(getSourceCode().getText(reactiveHook), " has ") + (getWarningMessage(missingDependencies, "a", "missing", "include") || getWarningMessage(unnecessaryDependencies, "an", "unnecessary", "exclude") || getWarningMessage(duplicateDependencies, "a", "duplicate", "omit")) + extraWarning,
+          suggest: [
+            {
+              desc: "Update the dependencies array to be: [".concat(suggestedDeps.map(formatDependency).join(", "), "]"),
+              fix: function(fixer) {
+                return fixer.replaceText(declaredDependenciesNode, "[".concat(suggestedDeps.map(formatDependency).join(", "), "]"));
+              }
+            }
+          ]
+        });
+      }
+      function visitCallExpression(node) {
+        var callbackIndex = getReactiveHookCallbackIndex(node.callee, options);
+        if (callbackIndex === -1) {
+          return;
+        }
+        var callback = node.arguments[callbackIndex];
+        var reactiveHook = node.callee;
+        var nodeWithoutNamespace = getNodeWithoutReactNamespace(reactiveHook);
+        var reactiveHookName = "name" in nodeWithoutNamespace ? nodeWithoutNamespace.name : "";
+        var maybeNode = node.arguments[callbackIndex + 1];
+        var declaredDependenciesNode = maybeNode && !(maybeNode.type === "Identifier" && maybeNode.name === "undefined") ? maybeNode : undefined;
+        var isEffect = /Effect($|[^a-z])/g.test(reactiveHookName);
+        if (!callback) {
+          reportProblem({
+            node: reactiveHook,
+            message: "React Hook ".concat(reactiveHookName, " requires an effect callback. ") + "Did you forget to pass a callback to the hook?"
+          });
+          return;
+        }
+        if (!declaredDependenciesNode && !isEffect) {
+          if (reactiveHookName === "useMemo" || reactiveHookName === "useCallback") {
+            reportProblem({
+              node: reactiveHook,
+              message: "React Hook ".concat(reactiveHookName, " does nothing when called with ") + "only one argument. Did you forget to pass an array of " + "dependencies?"
+            });
+          }
+          return;
+        }
+        while (callback.type === "TSAsExpression" || callback.type === "AsExpression") {
+          callback = callback.expression;
+        }
+        switch (callback.type) {
+          case "FunctionExpression":
+          case "ArrowFunctionExpression":
+            visitFunctionWithDependencies(callback, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect);
+            return;
+          case "Identifier":
+            if (!declaredDependenciesNode) {
+              return;
+            }
+            if ("elements" in declaredDependenciesNode && declaredDependenciesNode.elements && declaredDependenciesNode.elements.some(function(el) {
+              return el && el.type === "Identifier" && el.name === callback.name;
+            })) {
+              return;
+            }
+            var variable = getScope(callback).set.get(callback.name);
+            if (variable == null || variable.defs == null) {
+              return;
+            }
+            var def = variable.defs[0];
+            if (!def || !def.node) {
+              break;
+            }
+            if (def.type === "Parameter") {
+              reportProblem({
+                node: reactiveHook,
+                message: getUnknownDependenciesMessage(reactiveHookName)
+              });
+              return;
+            }
+            if (def.type !== "Variable" && def.type !== "FunctionName") {
+              break;
+            }
+            switch (def.node.type) {
+              case "FunctionDeclaration":
+                visitFunctionWithDependencies(def.node, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect);
+                return;
+              case "VariableDeclarator":
+                var init = def.node.init;
+                if (!init) {
+                  break;
+                }
+                switch (init.type) {
+                  case "ArrowFunctionExpression":
+                  case "FunctionExpression":
+                    visitFunctionWithDependencies(init, declaredDependenciesNode, reactiveHook, reactiveHookName, isEffect);
+                    return;
+                }
+                break;
+            }
+            break;
+          default:
+            reportProblem({
+              node: reactiveHook,
+              message: getUnknownDependenciesMessage(reactiveHookName)
+            });
+            return;
+        }
+        reportProblem({
+          node: reactiveHook,
+          message: "React Hook ".concat(reactiveHookName, " has a missing dependency: '").concat(callback.name, "'. ") + "Either include it or remove the dependency array.",
+          suggest: [
+            {
+              desc: "Update the dependencies array to be: [".concat(callback.name, "]"),
+              fix: function(fixer) {
+                return fixer.replaceText(declaredDependenciesNode, "[".concat(callback.name, "]"));
+              }
+            }
+          ]
+        });
+      }
+      return {
+        CallExpression: visitCallExpression
+      };
+    }
+  };
+  function collectRecommendations(_a) {
+    var { dependencies, declaredDependencies, stableDependencies, externalDependencies, isEffect } = _a;
+    var depTree = createDepTree();
     function createDepTree() {
       return {
         isUsed: false,
@@ -132817,80 +134222,127 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
         children: new Map
       };
     }
+    dependencies.forEach(function(_, key) {
+      var node = getOrCreateNodeByPath(depTree, key);
+      node.isUsed = true;
+      markAllParentsByPath(depTree, key, function(parent) {
+        parent.isSubtreeUsed = true;
+      });
+    });
+    declaredDependencies.forEach(function(_a2) {
+      var key = _a2.key;
+      var node = getOrCreateNodeByPath(depTree, key);
+      node.isSatisfiedRecursively = true;
+    });
+    stableDependencies.forEach(function(key) {
+      var node = getOrCreateNodeByPath(depTree, key);
+      node.isSatisfiedRecursively = true;
+    });
     function getOrCreateNodeByPath(rootNode, path) {
-      path = path.split(".");
-      path = _createForOfIteratorHelper(path);
-      var _step4;
+      var e_13, _a2;
+      var keys = path.split(".");
+      var node = rootNode;
       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;
+        for (var keys_1 = __values(keys), keys_1_1 = keys_1.next();!keys_1_1.done; keys_1_1 = keys_1.next()) {
+          var key = keys_1_1.value;
+          var child = node.children.get(key);
+          if (!child) {
+            child = createDepTree();
+            node.children.set(key, child);
+          }
+          node = child;
         }
-      } catch (err) {
-        path.e(err);
+      } catch (e_13_1) {
+        e_13 = { error: e_13_1 };
       } finally {
-        path.f();
+        try {
+          if (keys_1_1 && !keys_1_1.done && (_a2 = keys_1.return))
+            _a2.call(keys_1);
+        } finally {
+          if (e_13)
+            throw e_13.error;
+        }
       }
-      return rootNode;
+      return node;
     }
     function markAllParentsByPath(rootNode, path, fn) {
-      path = path.split(".");
-      path = _createForOfIteratorHelper(path);
-      var _step5;
+      var e_14, _a2;
+      var keys = path.split(".");
+      var node = rootNode;
       try {
-        for (path.s();!(_step5 = path.n()).done; ) {
-          var child = rootNode.children.get(_step5.value);
-          if (!child)
-            break;
+        for (var keys_2 = __values(keys), keys_2_1 = keys_2.next();!keys_2_1.done; keys_2_1 = keys_2.next()) {
+          var key = keys_2_1.value;
+          var child = node.children.get(key);
+          if (!child) {
+            return;
+          }
           fn(child);
-          rootNode = child;
+          node = child;
         }
-      } catch (err) {
-        path.e(err);
+      } catch (e_14_1) {
+        e_14 = { error: e_14_1 };
       } finally {
-        path.f();
+        try {
+          if (keys_2_1 && !keys_2_1.done && (_a2 = keys_2.return))
+            _a2.call(keys_2);
+        } finally {
+          if (e_14)
+            throw e_14.error;
+        }
       }
     }
+    var missingDependencies = new Set;
+    var satisfyingDependencies = new Set;
+    scanTreeRecursively(depTree, missingDependencies, satisfyingDependencies, function(key) {
+      return key;
+    });
     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) {
+        if (child.isSatisfiedRecursively) {
+          if (child.isSubtreeUsed) {
+            satisfyingPaths.add(path);
+          }
+          return;
+        }
+        if (child.isUsed) {
+          missingPaths.add(path);
+          return;
+        }
+        scanTreeRecursively(child, missingPaths, satisfyingPaths, function(childKey) {
           return path + "." + childKey;
         });
       });
     }
-    var { dependencies, declaredDependencies, stableDependencies, externalDependencies, isEffect } = _ref6, depTree = createDepTree();
-    dependencies.forEach(function(_, key) {
-      getOrCreateNodeByPath(depTree, key).isUsed = true;
-      markAllParentsByPath(depTree, key, function(parent) {
-        parent.isSubtreeUsed = true;
-      });
-    });
-    declaredDependencies.forEach(function(_ref7) {
-      getOrCreateNodeByPath(depTree, _ref7.key).isSatisfiedRecursively = true;
-    });
-    stableDependencies.forEach(function(key) {
-      getOrCreateNodeByPath(depTree, key).isSatisfiedRecursively = true;
-    });
-    _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) ? suggestedDependencies.indexOf(_ref8) === -1 ? suggestedDependencies.push(_ref8) : duplicateDependencies.add(_ref8) : !isEffect || _ref8.endsWith(".current") || externalDependencies.has(_ref8) ? unnecessaryDependencies.add(_ref8) : suggestedDependencies.indexOf(_ref8) === -1 && suggestedDependencies.push(_ref8);
+    var suggestedDependencies = [];
+    var unnecessaryDependencies = new Set;
+    var duplicateDependencies = new Set;
+    declaredDependencies.forEach(function(_a2) {
+      var key = _a2.key;
+      if (satisfyingDependencies.has(key)) {
+        if (suggestedDependencies.indexOf(key) === -1) {
+          suggestedDependencies.push(key);
+        } else {
+          duplicateDependencies.add(key);
+        }
+      } else {
+        if (isEffect && !key.endsWith(".current") && !externalDependencies.has(key)) {
+          if (suggestedDependencies.indexOf(key) === -1) {
+            suggestedDependencies.push(key);
+          }
+        } else {
+          unnecessaryDependencies.add(key);
+        }
+      }
     });
-    _ref6.forEach(function(key) {
+    missingDependencies.forEach(function(key) {
       suggestedDependencies.push(key);
     });
     return {
       suggestedDependencies,
       unnecessaryDependencies,
       duplicateDependencies,
-      missingDependencies: _ref6
+      missingDependencies
     };
   }
   function getConstructionExpressionType(node) {
@@ -132905,27 +134357,31 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
       case "ClassExpression":
         return "class";
       case "ConditionalExpression":
-        if (getConstructionExpressionType(node.consequent) != null || getConstructionExpressionType(node.alternate) != null)
+        if (getConstructionExpressionType(node.consequent) != null || getConstructionExpressionType(node.alternate) != null) {
           return "conditional";
-        break;
+        }
+        return null;
       case "LogicalExpression":
-        if (getConstructionExpressionType(node.left) != null || getConstructionExpressionType(node.right) != null)
+        if (getConstructionExpressionType(node.left) != null || getConstructionExpressionType(node.right) != null) {
           return "logical expression";
-        break;
+        }
+        return null;
       case "JSXFragment":
         return "JSX fragment";
       case "JSXElement":
         return "JSX element";
       case "AssignmentExpression":
-        if (getConstructionExpressionType(node.right) != null)
+        if (getConstructionExpressionType(node.right) != null) {
           return "assignment expression";
-        break;
+        }
+        return null;
       case "NewExpression":
         return "object construction";
       case "Literal":
-        if (node.value instanceof RegExp)
+        if (node.value instanceof RegExp) {
           return "regular expression";
-        break;
+        }
+        return null;
       case "TypeCastExpression":
       case "AsExpression":
       case "TSAsExpression":
@@ -132933,95 +134389,144 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
     }
     return null;
   }
-  function scanForConstructions(_ref9) {
-    var { declaredDependenciesNode, componentScope, scope } = _ref9;
-    return _ref9.declaredDependencies.map(function(_ref10) {
-      var key = _ref10.key;
-      _ref10 = componentScope.variables.find(function(v) {
+  function scanForConstructions(_a) {
+    var { declaredDependencies, declaredDependenciesNode, componentScope, scope } = _a;
+    var constructions = declaredDependencies.map(function(_a2) {
+      var key = _a2.key;
+      var ref = componentScope.variables.find(function(v) {
         return v.name === key;
       });
-      if (_ref10 == null)
+      if (ref == null) {
         return null;
-      var node = _ref10.defs[0];
-      if (node == null)
+      }
+      var node = ref.defs[0];
+      if (node == null) {
         return null;
+      }
       if (node.type === "Variable" && node.node.type === "VariableDeclarator" && node.node.id.type === "Identifier" && node.node.init != null) {
         var constantExpressionType = getConstructionExpressionType(node.node.init);
-        if (constantExpressionType != null)
-          return [_ref10, constantExpressionType];
-      }
-      return node.type === "FunctionName" && node.node.type === "FunctionDeclaration" ? [_ref10, "function"] : node.type === "ClassName" && node.node.type === "ClassDeclaration" ? [_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 = false, i = 0;i < ref.references.length; i++) {
-          var reference = ref.references[i];
-          if (reference.writeExpr)
+        if (constantExpressionType) {
+          return [ref, constantExpressionType];
+        }
+      }
+      if (node.type === "FunctionName" && node.node.type === "FunctionDeclaration") {
+        return [ref, "function"];
+      }
+      if (node.type === "ClassName" && node.node.type === "ClassDeclaration") {
+        return [ref, "class"];
+      }
+      return null;
+    }).filter(Boolean);
+    function isUsedOutsideOfHook(ref) {
+      var e_15, _a2;
+      var foundWriteExpr = false;
+      try {
+        for (var _b = __values(ref.references), _c = _b.next();!_c.done; _c = _b.next()) {
+          var reference = _c.value;
+          if (reference.writeExpr) {
             if (foundWriteExpr) {
-              ref = true;
-              break a;
+              return true;
             } else {
               foundWriteExpr = true;
               continue;
             }
-          for (var currentScope = reference.from;currentScope !== scope && currentScope != null; )
+          }
+          var currentScope = reference.from;
+          while (currentScope !== scope && currentScope != null) {
             currentScope = currentScope.upper;
-          if (currentScope !== scope && !isAncestorNodeOf(declaredDependenciesNode, reference.identifier)) {
-            ref = true;
-            break a;
+          }
+          if (currentScope !== scope) {
+            if (!isAncestorNodeOf(declaredDependenciesNode, reference.identifier)) {
+              return true;
+            }
           }
         }
-        ref = false;
+      } catch (e_15_1) {
+        e_15 = { error: e_15_1 };
+      } finally {
+        try {
+          if (_c && !_c.done && (_a2 = _b.return))
+            _a2.call(_b);
+        } finally {
+          if (e_15)
+            throw e_15.error;
+        }
       }
+      return false;
+    }
+    return constructions.map(function(_a2) {
+      var _b = __read(_a2, 2), ref = _b[0], depType = _b[1];
       return {
-        construction: JSCompiler_temp_const,
-        depType: _ref11,
-        isUsedOutsideOfHook: ref
+        construction: ref.defs[0],
+        depType,
+        isUsedOutsideOfHook: isUsedOutsideOfHook(ref)
       };
     });
   }
   function getDependency(node) {
-    return node.parent.type !== "MemberExpression" && node.parent.type !== "OptionalMemberExpression" || node.parent.object !== node || node.parent.property.name === "current" || node.parent.computed || node.parent.parent != null && (node.parent.parent.type === "CallExpression" || node.parent.parent.type === "OptionalCallExpression") && node.parent.parent.callee === node.parent ? node.type === "MemberExpression" && node.parent && node.parent.type === "AssignmentExpression" && node.parent.left === node ? node.object : node : getDependency(node.parent);
+    if (node.parent && (node.parent.type === "MemberExpression" || node.parent.type === "OptionalMemberExpression") && node.parent.object === node && "name" in node.parent.property && node.parent.property.name !== "current" && !node.parent.computed && !(node.parent.parent != null && (node.parent.parent.type === "CallExpression" || node.parent.parent.type === "OptionalCallExpression") && node.parent.parent.callee === node.parent)) {
+      return getDependency(node.parent);
+    } else if (node.type === "MemberExpression" && node.parent && node.parent.type === "AssignmentExpression" && node.parent.left === node) {
+      return node.object;
+    } else {
+      return node;
+    }
   }
   function markNode(node, optionalChains, result) {
-    optionalChains && (node.optional ? optionalChains.has(result) || optionalChains.set(result, true) : optionalChains.set(result, false));
+    if (optionalChains) {
+      if ("optional" in node && node.optional) {
+        if (!optionalChains.has(result)) {
+          optionalChains.set(result, true);
+        }
+      } else {
+        optionalChains.set(result, false);
+      }
+    }
   }
   function analyzePropertyChain(node, optionalChains) {
-    if (node.type === "Identifier" || node.type === "JSXIdentifier")
-      return node = node.name, optionalChains && optionalChains.set(node, false), node;
-    if (node.type !== "MemberExpression" || node.computed) {
-      if (node.type !== "OptionalMemberExpression" || node.computed) {
-        if (node.type !== "ChainExpression" || node.computed)
-          throw Error("Unsupported node type: " + node.type);
-        node = node.expression;
-        if (node.type === "CallExpression")
-          throw Error("Unsupported node type: " + node.type);
-        var object$20 = analyzePropertyChain(node.object, optionalChains), property$21 = analyzePropertyChain(node.property, null);
-        object$20 = object$20 + "." + property$21;
-        markNode(node, optionalChains, object$20);
-        return object$20;
-      }
-      object$20 = analyzePropertyChain(node.object, optionalChains);
-      property$21 = analyzePropertyChain(node.property, null);
-      object$20 = object$20 + "." + property$21;
-      markNode(node, optionalChains, object$20);
-      return object$20;
-    }
-    object$20 = analyzePropertyChain(node.object, optionalChains);
-    property$21 = analyzePropertyChain(node.property, null);
-    object$20 = object$20 + "." + property$21;
-    markNode(node, optionalChains, object$20);
-    return object$20;
+    if (node.type === "Identifier" || node.type === "JSXIdentifier") {
+      var result = node.name;
+      if (optionalChains) {
+        optionalChains.set(result, false);
+      }
+      return result;
+    } else if (node.type === "MemberExpression" && !node.computed) {
+      var object = analyzePropertyChain(node.object, optionalChains);
+      var property = analyzePropertyChain(node.property, null);
+      var result = "".concat(object, ".").concat(property);
+      markNode(node, optionalChains, result);
+      return result;
+    } else if (node.type === "OptionalMemberExpression" && !node.computed) {
+      var object = analyzePropertyChain(node.object, optionalChains);
+      var property = analyzePropertyChain(node.property, null);
+      var result = "".concat(object, ".").concat(property);
+      markNode(node, optionalChains, result);
+      return result;
+    } else if (node.type === "ChainExpression" && (!("computed" in node) || !node.computed)) {
+      var expression = node.expression;
+      if (expression.type === "CallExpression") {
+        throw new Error("Unsupported node type: ".concat(expression.type));
+      }
+      var object = analyzePropertyChain(expression.object, optionalChains);
+      var property = analyzePropertyChain(expression.property, null);
+      var result = "".concat(object, ".").concat(property);
+      markNode(expression, optionalChains, result);
+      return result;
+    } else {
+      throw new Error("Unsupported node type: ".concat(node.type));
+    }
   }
   function getNodeWithoutReactNamespace(node) {
-    return node.type !== "MemberExpression" || node.object.type !== "Identifier" || node.object.name !== "React" || node.property.type !== "Identifier" || node.computed ? node : node.property;
+    if (node.type === "MemberExpression" && node.object.type === "Identifier" && node.object.name === "React" && node.property.type === "Identifier" && !node.computed) {
+      return node.property;
+    }
+    return node;
   }
   function getReactiveHookCallbackIndex(calleeNode, options) {
     var node = getNodeWithoutReactNamespace(calleeNode);
-    if (node.type !== "Identifier")
+    if (node.type !== "Identifier") {
       return -1;
+    }
     switch (node.name) {
       case "useEffect":
       case "useLayoutEffect":
@@ -133032,893 +134537,132 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
         return 1;
       default:
         if (node === calleeNode && options && options.additionalHooks) {
+          var name = undefined;
           try {
-            var name = analyzePropertyChain(node, null);
+            name = analyzePropertyChain(node, null);
           } catch (error) {
-            if (/Unsupported node type/.test(error.message))
+            if (error instanceof Error && /Unsupported node type/.test(error.message)) {
               return 0;
-            throw error;
+            } else {
+              throw error;
+            }
           }
           return options.additionalHooks.test(name) ? 0 : -1;
+        } else {
+          return -1;
         }
-        return -1;
     }
   }
   function fastFindReferenceWithParent(start, target) {
-    for (var queue = [start], item = null;queue.length; ) {
+    var e_16, _a;
+    var queue = [start];
+    var item;
+    while (queue.length) {
       item = queue.shift();
-      if ((item.type === "Identifier" || item.type === "JSXIdentifier") && item.type === target.type && item.name === target.name && item.range[0] === target.range[0] && item.range[1] === target.range[1])
+      if (isSameIdentifier(item, target)) {
         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], value2 = _Object$entries$_i[1];
-          _Object$entries$_i[0] !== "parent" && (isNodeLike(value2) ? (value2.parent = item, queue.push(value2)) : Array.isArray(value2) && value2.forEach(function(val) {
-            isNodeLike(val) && (val.parent = item, queue.push(val));
-          }));
+      }
+      if (!isAncestorNodeOf(item, target)) {
+        continue;
+      }
+      try {
+        for (var _b = (e_16 = undefined, __values(Object.entries(item))), _c = _b.next();!_c.done; _c = _b.next()) {
+          var _d = __read(_c.value, 2), key = _d[0], value2 = _d[1];
+          if (key === "parent") {
+            continue;
+          }
+          if (isNodeLike(value2)) {
+            value2.parent = item;
+            queue.push(value2);
+          } else if (Array.isArray(value2)) {
+            value2.forEach(function(val) {
+              if (isNodeLike(val)) {
+                val.parent = item;
+                queue.push(val);
+              }
+            });
+          }
+        }
+      } catch (e_16_1) {
+        e_16 = { error: e_16_1 };
+      } finally {
+        try {
+          if (_c && !_c.done && (_a = _b.return))
+            _a.call(_b);
+        } finally {
+          if (e_16)
+            throw e_16.error;
         }
       }
     }
     return null;
   }
   function joinEnglish(arr) {
-    for (var s = "", i = 0;i < arr.length; i++)
-      s += arr[i], i === 0 && arr.length === 2 ? s += " and " : i === arr.length - 2 && 2 < arr.length ? s += ", and " : i < arr.length - 1 && (s += ", ");
+    var s = "";
+    for (var i = 0;i < arr.length; i++) {
+      s += arr[i];
+      if (i === 0 && arr.length === 2) {
+        s += " and ";
+      } else if (i === arr.length - 2 && arr.length > 2) {
+        s += ", and ";
+      } else if (i < arr.length - 1) {
+        s += ", ";
+      }
+    }
     return s;
   }
   function isNodeLike(val) {
-    return typeof val === "object" && val !== null && !Array.isArray(val) && typeof val.type === "string";
+    return typeof val === "object" && val !== null && !Array.isArray(val) && "type" in val && typeof val.type === "string";
+  }
+  function isSameIdentifier(a, b) {
+    return (a.type === "Identifier" || a.type === "JSXIdentifier") && a.type === b.type && a.name === b.name && !!a.range && !!b.range && a.range[0] === b.range[0] && a.range[1] === b.range[1];
   }
   function isAncestorNodeOf(a, b) {
-    return a.range[0] <= b.range[0] && a.range[1] >= b.range[1];
+    return !!a.range && !!b.range && a.range[0] <= b.range[0] && a.range[1] >= b.range[1];
+  }
+  function isUseEffectEventIdentifier(node) {
+    return false;
   }
   function getUnknownDependenciesMessage(reactiveHookName) {
-    return "React Hook " + reactiveHookName + " received a function whose dependencies are unknown. Pass an inline function instead.";
+    return "React Hook ".concat(reactiveHookName, " received a function whose dependencies ") + "are unknown. Pass an inline function instead.";
   }
   var rules = {
-    "rules-of-hooks": {
-      meta: {
-        type: "problem",
-        docs: {
-          description: "enforces the Rules of Hooks",
-          recommended: true,
-          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$1) {
-            scope.e(err$1);
-          } finally {
-            scope.f();
-          }
-        }
-        var lastEffect = null, codePathReactHooksMapStack = [], codePathSegmentStack = [], useEffectEventFunctions = new WeakSet, getSource = typeof context.getSource === "function" ? function(node) {
-          return context.getSource(node);
-        } : function(node) {
-          return context.sourceCode.getText(node);
-        }, getScope = typeof context.getScope === "function" ? function() {
-          return context.getScope();
-        } : function(node) {
-          return context.sourceCode.getScope(node);
-        }, $jscomp$compprop0 = {};
-        return $jscomp$compprop0.onCodePathSegmentStart = function(segment) {
-          return codePathSegmentStack.push(segment);
-        }, $jscomp$compprop0.onCodePathSegmentEnd = function() {
-          return codePathSegmentStack.pop();
-        }, $jscomp$compprop0.onCodePathStart = function() {
-          return codePathReactHooksMapStack.push(new Map);
-        }, $jscomp$compprop0.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 (paths !== undefined)
-              return paths;
-            if (codePath.thrownSegments.includes(segment))
-              paths = BigInt("0");
-            else if (segment.prevSegments.length === 0)
-              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$2) {
-                _step3.e(err$2);
-              } 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 (paths !== undefined)
-              return paths;
-            if (codePath.thrownSegments.includes(segment))
-              paths = BigInt("0");
-            else if (segment.nextSegments.length === 0)
-              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$3) {
-                _step5.e(err$3);
-              } finally {
-                _step5.f();
-              }
-            }
-            cache.set(segment.id, paths);
-            return paths;
-          }
-          function shortestPathLengthToStart(segment) {
-            var cache = shortestPathLengthToStart.cache, length = cache.get(segment.id);
-            if (length === null)
-              return Infinity;
-            if (length !== undefined)
-              return length;
-            cache.set(segment.id, null);
-            if (segment.prevSegments.length === 0)
-              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 (reactHooksMap.size !== 0) {
-            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 = segment$jscomp$0.nextSegments.length === 0 ? 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 && !isInsideDoWhileLoop(hook) || 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") && !isInsideDoWhileLoop(hook)) {
-                          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 });
-                        }
-                      } else if (codePathNode.parent && (codePathNode.parent.type === "MethodDefinition" || codePathNode.parent.type === "ClassProperty" || codePathNode.parent.type === "PropertyDefinition") && codePathNode.parent.value === codePathNode) {
-                        var message$4 = '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$4 });
-                      } else if (codePathFunctionName) {
-                        var message$5 = '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: message$5 });
-                      } else if (codePathNode.type === "Program") {
-                        var message$6 = '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: message$6 });
-                      } else if (isSomewhereInsideComponentOrHook && !isReactFunction(hook, "use")) {
-                        var message$7 = '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: message$7 });
-                      }
-                    }
-                  } catch (err$8) {
-                    _iterator10.e(err$8);
-                  } finally {
-                    _iterator10.f();
-                  }
-                }
-              }
-            } catch (err$9) {
-              reactHooksMap.e(err$9);
-            } finally {
-              reactHooksMap.f();
-            }
-          }
-        }, $jscomp$compprop0.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);
-          }
-          node.callee.type === "Identifier" && node.callee.name === "useEffect" && 0 < node.arguments.length && (lastEffect = node);
-        }, $jscomp$compprop0.Identifier = function(node) {
-          lastEffect == null && useEffectEventFunctions.has(node) && node.parent.type !== "CallExpression" && context.report({
-            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.'
-          });
-        }, $jscomp$compprop0["CallExpression:exit"] = function(node) {
-          node === lastEffect && (lastEffect = null);
-        }, $jscomp$compprop0.FunctionDeclaration = function(node) {
-          isInsideComponentOrHook(node) && recordAllUseEffectEventFunctions(getScope(node));
-        }, $jscomp$compprop0.ArrowFunctionExpression = function(node) {
-          isInsideComponentOrHook(node) && recordAllUseEffectEventFunctions(getScope(node));
-        }, $jscomp$compprop0;
-      }
-    },
-    "exhaustive-deps": {
-      meta: {
-        type: "suggestion",
-        docs: {
-          description: "verifies the list of dependencies for Hooks like useEffect and similar",
-          recommended: true,
-          url: "https://github.com/facebook/react/issues/14920"
-        },
-        fixable: "code",
-        hasSuggestions: true,
-        schema: [
-          {
-            type: "object",
-            additionalProperties: false,
-            enableDangerousAutofixThisMayCauseInfiniteLoops: false,
-            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(currentScope2) {
-            var _iterator2 = _createForOfIteratorHelper(currentScope2.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 && dependencyNode.type === "Identifier" && (dependencyNode.parent.type === "MemberExpression" || dependencyNode.parent.type === "OptionalMemberExpression") && !dependencyNode.parent.computed && dependencyNode.parent.property.type === "Identifier" && dependencyNode.parent.property.name === "current") {
-                    for (var curScope = reference.from, isInReturnedFunction = false;curScope.block !== node; )
-                      curScope.type === "function" && (isInReturnedFunction = curScope.block.parent != null && curScope.block.parent.type === "ReturnStatement"), curScope = curScope.upper;
-                    JSCompiler_temp = isInReturnedFunction;
-                  }
-                  JSCompiler_temp && currentRefsInEffectCleanup.set(dependency, {
-                    reference,
-                    dependencyNode
-                  });
-                  if (dependencyNode.parent.type !== "TSTypeQuery" && dependencyNode.parent.type !== "TSTypeReference") {
-                    var def = reference.resolved.defs[0];
-                    if (def != null && (def.node == null || def.node.init !== node.parent) && def.type !== "TypeParameter")
-                      if (dependencies.has(dependency))
-                        dependencies.get(dependency).references.push(reference);
-                      else {
-                        var resolved = reference.resolved, isStable = memoizedIsStableKnownHookValue(resolved) || memoizedIsFunctionWithoutCapturedValues(resolved);
-                        dependencies.set(dependency, {
-                          isStable,
-                          references: [reference]
-                        });
-                      }
-                  }
-                }
-              }
-            } catch (err) {
-              _iterator2.e(err);
-            } finally {
-              _iterator2.f();
-            }
-            currentScope2 = _createForOfIteratorHelper(currentScope2.childScopes);
-            var _step3;
-            try {
-              for (currentScope2.s();!(_step3 = currentScope2.n()).done; )
-                gatherDependenciesRecursively(_step3.value);
-            } catch (err$12) {
-              currentScope2.e(err$12);
-            } finally {
-              currentScope2.f();
-            }
-          }
-          function formatDependency(path) {
-            path = path.split(".");
-            for (var finalPath = "", i = 0;i < path.length; i++) {
-              if (i !== 0) {
-                var pathSoFar = path.slice(0, i + 1).join(".");
-                pathSoFar = optionalChains.get(pathSoFar) === true;
-                finalPath += pathSoFar ? "?." : ".";
-              }
-              finalPath += path[i];
-            }
-            return finalPath;
-          }
-          function getWarningMessage(deps, singlePrefix, label, fixVerb) {
-            return deps.size === 0 ? 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,
-            message: `Effect callbacks are synchronous to prevent race conditions. Put the async function inside:
-
-useEffect(() => {
-  async function fetchData() {
-    // You can await here
-    const response = await MyAPI.getData(someId);
-    // ...
-  }
-  fetchData();
-}, [someId]); // Or [] if effect doesn't need props or state
-
-Learn 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 (currentScope.type === "function")
-              break;
-            currentScope = currentScope.upper;
-          }
-          if (currentScope) {
-            componentScope = currentScope;
-            var isArray = Array.isArray, memoizedIsStableKnownHookValue = memoizeWithWeakMap(function(resolved) {
-              if (!isArray(resolved.defs))
-                return false;
-              var def = resolved.defs[0];
-              if (def == null || def.node.type !== "VariableDeclarator")
-                return false;
-              var init = def.node.init;
-              if (init == null)
-                return false;
-              for (;init.type === "TSAsExpression" || init.type === "AsExpression"; )
-                init = init.expression;
-              var declaration = def.node.parent;
-              if (declaration == null && (fastFindReferenceWithParent(componentScope.block, def.node.id), declaration = def.node.parent, declaration == null))
-                return false;
-              if (declaration.kind === "const" && init.type === "Literal" && (typeof init.value === "string" || typeof init.value === "number" || init.value === null))
-                return true;
-              if (init.type !== "CallExpression")
-                return false;
-              init = init.callee;
-              init.type !== "MemberExpression" || init.object.name !== "React" || init.property == null || init.computed || (init = init.property);
-              if (init.type !== "Identifier")
-                return false;
-              def = def.node.id;
-              init = init.name;
-              if (init === "useRef" && def.type === "Identifier")
-                return true;
-              if (init === "useState" || init === "useReducer" || init === "useActionState") {
-                if (def.type === "ArrayPattern" && def.elements.length === 2 && isArray(resolved.identifiers)) {
-                  if (def.elements[1] === resolved.identifiers[0]) {
-                    if (init === "useState")
-                      for (resolved = resolved.references, declaration = init = 0;declaration < resolved.length; declaration++) {
-                        resolved[declaration].isWrite() && init++;
-                        if (1 < init)
-                          return false;
-                        setStateCallSites.set(resolved[declaration].identifier, def.elements[0]);
-                      }
-                    return true;
-                  }
-                  if (def.elements[0] === resolved.identifiers[0] && init === "useState")
-                    for (resolved = resolved.references, def = 0;def < resolved.length; def++)
-                      stateVariables.add(resolved[def].identifier);
-                }
-              } else if (init === "useTransition" && def.type === "ArrayPattern" && def.elements.length === 2 && Array.isArray(resolved.identifiers) && def.elements[1] === resolved.identifiers[0])
-                return true;
-              return false;
-            }, stableKnownValueCache), memoizedIsFunctionWithoutCapturedValues = memoizeWithWeakMap(function(resolved) {
-              if (!isArray(resolved.defs))
-                return false;
-              resolved = resolved.defs[0];
-              if (resolved == null || resolved.node == null || resolved.node.id == null)
-                return false;
-              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 (fnNode.type === "FunctionDeclaration" && childScopeBlock === fnNode || fnNode.type === "VariableDeclarator" && childScopeBlock.parent === fnNode) {
-                  resolved = childScope;
-                  break;
-                }
-              }
-              if (resolved == null)
-                return false;
-              for (i = 0;i < resolved.through.length; i++)
-                if (fnNode = resolved.through[i], fnNode.resolved != null && pureScopes.has(fnNode.resolved.scope) && !memoizedIsStableKnownHookValue(fnNode.resolved))
-                  return false;
-              return true;
-            }, 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 = false, i = 0;i < _ref.length; i++) {
-                var parent = _ref[i].identifier.parent;
-                if (parent != null && parent.type === "MemberExpression" && !parent.computed && parent.property.type === "Identifier" && parent.property.name === "current" && parent.parent.type === "AssignmentExpression" && parent.parent.left === parent) {
-                  foundCurrentAssignment = true;
-                  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 = declaredDependenciesNode.type === "TSAsExpression" && declaredDependenciesNode.expression.type === "ArrayExpression";
-                declaredDependenciesNode.type === "ArrayExpression" || currentScope ? (currentScope ? declaredDependenciesNode.expression : declaredDependenciesNode).elements.forEach(function(declaredDependencyNode) {
-                  if (declaredDependencyNode !== null)
-                    if (declaredDependencyNode.type === "SpreadElement")
-                      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)) {
-                          declaredDependencyNode.type === "Literal" ? 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;maybeID.type === "MemberExpression" || maybeID.type === "OptionalMemberExpression" || maybeID.type === "ChainExpression"; )
-                        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,
-                  declaredDependencies,
-                  stableDependencies,
-                  externalDependencies,
-                  isEffect
-                });
-                currentScope = _collectRecommendatio2.unnecessaryDependencies;
-                var { missingDependencies, duplicateDependencies, suggestedDependencies: suggestedDeps } = _collectRecommendatio2;
-                if (duplicateDependencies.size + missingDependencies.size + currentScope.size === 0)
-                  scanForConstructions({
-                    declaredDependencies,
-                    declaredDependenciesNode,
-                    componentScope,
-                    scope
-                  }).forEach(function(_ref4) {
-                    var { construction, isUsedOutsideOfHook } = _ref4;
-                    _ref4 = _ref4.depType;
-                    var wrapperHook = _ref4 === "function" ? "useCallback" : "useMemo", constructionType = _ref4 === "function" ? "definition" : "initialization", defaultAdvice = "wrap the " + constructionType + " of '" + construction.name.name + "' in its own " + wrapperHook + "() Hook.";
-                    defaultAdvice = "The '" + construction.name.name + "' " + _ref4 + " " + (_ref4 === "conditional" || _ref4 === "logical expression" ? "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 && construction.type === "Variable" && _ref4 === "function" && (suggest = [
-                      {
-                        desc: "Wrap the " + constructionType + " of '" + construction.name.name + "' in its own " + wrapperHook + "() Hook.",
-                        fix: function(fixer) {
-                          var _ref5 = wrapperHook === "useMemo" ? ["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
-                    });
-                  });
-                else {
-                  !isEffect && 0 < missingDependencies.size && (suggestedDeps = collectRecommendations({
-                    dependencies,
-                    declaredDependencies: [],
-                    stableDependencies,
-                    externalDependencies,
-                    isEffect
-                  }).suggestedDependencies);
-                  (function() {
-                    if (declaredDependencies.length === 0)
-                      return true;
-                    var declaredDepKeys = declaredDependencies.map(function(dep2) {
-                      return dep2.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) {
-                      badRef === null && key.endsWith(".current") && (badRef = key);
-                    });
-                    if (badRef !== null)
-                      _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 (scope == null)
-                      return;
-                    scope = scope.references;
-                    if (!Array.isArray(scope))
-                      return;
-                    dep = true;
-                    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 = false;
-                        break;
-                      }
-                      id = id.parent;
-                      if (id == null) {
-                        dep = false;
-                        break;
-                      }
-                      if (id.type !== "MemberExpression" && id.type !== "OptionalMemberExpression") {
-                        dep = false;
-                        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], topScopeRef != null && topScopeRef.name != null && topScopeRef.type === "Parameter")) {
-                          topScopeRef = false;
-                          for (var id2, i$14 = 0;i$14 < usedDep.references.length; i$14++)
-                            if (id2 = usedDep.references[i$14].identifier, id2 != null && id2.parent != null && (id2.parent.type === "CallExpression" || id2.parent.type === "OptionalCallExpression") && id2.parent.callee === id2) {
-                              topScopeRef = true;
-                              break;
-                            }
-                          topScopeRef && (missingCallbackDep = missingDep);
-                        }
-                      }
-                    });
-                    missingCallbackDep !== null && (_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 (setStateRecommendation === null)
-                        for (var references = dependencies.get(missingDep).references, id2, maybeCall, i$15 = 0;i$15 < references.length; i$15++) {
-                          id2 = references[i$15].identifier;
-                          for (maybeCall = id2.parent;maybeCall != null && maybeCall !== componentScope.block; ) {
-                            if (maybeCall.type === "CallExpression") {
-                              var correspondingStateVariable = setStateCallSites.get(maybeCall.callee);
-                              if (correspondingStateVariable != null) {
-                                correspondingStateVariable.name === missingDep ? setStateRecommendation = {
-                                  missingDep,
-                                  setter: maybeCall.callee.name,
-                                  form: "updater"
-                                } : stateVariables.has(id2) ? setStateRecommendation = {
-                                  missingDep,
-                                  setter: maybeCall.callee.name,
-                                  form: "reducer"
-                                } : (id2 = references[i$15].resolved, id2 != null && (id2 = id2.defs[0], id2 != null && id2.type === "Parameter" && (setStateRecommendation = {
-                                  missingDep,
-                                  setter: maybeCall.callee.name,
-                                  form: "inlineReducer"
-                                })));
-                                break;
-                              }
-                            }
-                            maybeCall = maybeCall.parent;
-                          }
-                          if (setStateRecommendation !== null)
-                            break;
-                        }
-                    });
-                    if (setStateRecommendation !== null)
-                      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;reference.type !== "function"; )
-                        reference = reference.upper;
-                      reference.block === node && (setStateInsideEffectWithoutDeps = key);
-                    }
-                  });
-                });
-                if (setStateInsideEffectWithoutDeps) {
-                  var suggestedDependencies$13 = collectRecommendations({
-                    dependencies,
-                    declaredDependencies: [],
-                    stableDependencies,
-                    externalDependencies: new Set,
-                    isEffect: true
-                  }).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$13.join(", ") + ("] as a second argument to the " + reactiveHookName + " Hook."),
-                    suggest: [
-                      {
-                        desc: "Add dependencies array: [" + suggestedDependencies$13.join(", ") + "]",
-                        fix: function(fixer) {
-                          return fixer.insertTextAfter(node, ", [" + suggestedDependencies$13.join(", ") + "]");
-                        }
-                      }
-                    ]
-                  });
-                }
-              }
-          }
-        }
-        var enableDangerousAutofixThisMayCauseInfiniteLoops = context.options && context.options[0] && context.options[0].enableDangerousAutofixThisMayCauseInfiniteLoops || false, options = {
-          additionalHooks: context.options && context.options[0] && context.options[0].additionalHooks ? new RegExp(context.options[0].additionalHooks) : undefined,
-          enableDangerousAutofixThisMayCauseInfiniteLoops
-        }, getSource = typeof context.getSource === "function" ? function(node) {
-          return context.getSource(node);
-        } : function(node) {
-          return context.sourceCode.getText(node);
-        }, getScope = typeof context.getScope === "function" ? 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 (callbackIndex !== -1) {
-              var callback = node.arguments[callbackIndex], reactiveHook = node.callee, reactiveHookName = getNodeWithoutReactNamespace(reactiveHook).name;
-              node = node.arguments[callbackIndex + 1];
-              var declaredDependenciesNode = !node || node.type === "Identifier" && node.name === "undefined" ? undefined : node;
-              node = /Effect($|[^a-z])/g.test(reactiveHookName);
-              if (callback)
-                if (declaredDependenciesNode || node) {
-                  for (;callback.type === "TSAsExpression" || callback.type === "AsExpression"; )
-                    callback = callback.expression;
-                  switch (callback.type) {
-                    case "FunctionExpression":
-                    case "ArrowFunctionExpression":
-                      visitFunctionWithDependencies(callback, declaredDependenciesNode, reactiveHook, reactiveHookName, node);
-                      return;
-                    case "Identifier":
-                      if (!declaredDependenciesNode || declaredDependenciesNode.elements && declaredDependenciesNode.elements.some(function(el) {
-                        return el && el.type === "Identifier" && el.name === callback.name;
-                      }))
-                        return;
-                      callbackIndex = getScope(callback).set.get(callback.name);
-                      if (callbackIndex == null || callbackIndex.defs == null)
-                        return;
-                      callbackIndex = callbackIndex.defs[0];
-                      if (!callbackIndex || !callbackIndex.node)
-                        break;
-                      if (callbackIndex.type === "Parameter") {
-                        reportProblem({
-                          node: reactiveHook,
-                          message: getUnknownDependenciesMessage(reactiveHookName)
-                        });
-                        return;
-                      }
-                      if (callbackIndex.type !== "Variable" && callbackIndex.type !== "FunctionName")
-                        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: getUnknownDependenciesMessage(reactiveHookName)
-                      });
-                      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
-                  reactiveHookName !== "useMemo" && reactiveHookName !== "useCallback" || 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?"
-                });
-            }
-          }
-        };
-      }
-    }
+    "rules-of-hooks": rule$1,
+    "exhaustive-deps": rule2
   };
   var configRules = {
     "react-hooks/rules-of-hooks": "error",
     "react-hooks/exhaustive-deps": "warn"
   };
-  var legacyRecommendedConfig = { plugins: ["react-hooks"], rules: configRules };
-  var reactHooksPlugin = {
-    meta: { name: "eslint-plugin-react-hooks" },
-    rules
+  var legacyRecommendedConfig = {
+    plugins: ["react-hooks"],
+    rules: configRules
   };
-  var configs = {
-    "recommended-legacy": legacyRecommendedConfig,
-    "recommended-latest": {
-      name: "react-hooks/recommended",
-      plugins: { "react-hooks": reactHooksPlugin },
-      rules: configRules
-    },
-    recommended: legacyRecommendedConfig
+  var plugin = {
+    meta: { name: "eslint-plugin-react-hooks" },
+    rules,
+    configs: {
+      "recommended-legacy": legacyRecommendedConfig,
+      recommended: legacyRecommendedConfig,
+      "recommended-latest": {
+        name: "react-hooks/recommended",
+        plugins: {
+          get "react-hooks"() {
+            return plugin;
+          }
+        },
+        rules: configRules
+      }
+    }
   };
-  assign({}, reactHooksPlugin, { configs });
+  var configs = plugin.configs;
+  var meta = plugin.meta;
   exports.configs = configs;
+  exports.meta = meta;
   exports.rules = rules;
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-react-hooks@5.2.0-canary-de1eaa26-20250124_eslint@9.19.0/node_modules/eslint-plugin-react-hooks/index.js
+// ../../node_modules/.pnpm/eslint-plugin-react-hooks@5.2.0_eslint@9.19.0/node_modules/eslint-plugin-react-hooks/index.js
 var require_eslint_plugin_react_hooks = __commonJS((exports, module) => {
   if (true) {
     module.exports = require_eslint_plugin_react_hooks_production();
@@ -403575,7 +404319,7 @@ var require_getWrappingFixer = __commonJS((exports) => {
   }
 });
 
-// ../../node_modules/.pnpm/ts-api-utils@2.0.0_typescript@5.5.4/node_modules/ts-api-utils/lib/index.cjs
+// ../../node_modules/.pnpm/ts-api-utils@2.0.1_typescript@5.5.4/node_modules/ts-api-utils/lib/index.cjs
 var require_lib15 = __commonJS((exports) => {
   var ts9 = require_typescript();
   function _interopDefault(e) {
@@ -404441,8 +405185,8 @@ var require_lib15 = __commonJS((exports) => {
       if (!prop.name.startsWith(prefix)) {
         continue;
       }
-      const declaration = prop.valueDeclaration ?? prop.getDeclarations()[0];
-      if (!isNamedDeclarationWithName(declaration) || declaration.name === undefined || !ts9__default.default.isComputedPropertyName(declaration.name)) {
+      const declaration = prop.valueDeclaration ?? prop.getDeclarations()?.[0];
+      if (!declaration || !isNamedDeclarationWithName(declaration) || declaration.name === undefined || !ts9__default.default.isComputedPropertyName(declaration.name)) {
         continue;
       }
       const globalSymbol = typeChecker.getApparentType(typeChecker.getTypeAtLocation(declaration.name.expression)).symbol;
@@ -448268,7 +449012,7 @@ var makeConfig = ({
     "remotion.config.ts",
     "remotion.config.js"
   ]
-}, import_js.default.configs.recommended, import_typescript_eslint.default.configs.recommended, {
+}, import_js.default.configs.recommended, import_typescript_eslint.default.configs.eslintRecommended, import_typescript_eslint.default.configs.recommended, {
   plugins: {
     react: import_eslint_plugin_react.default,
     "react-hooks": import_eslint_plugin_react_hooks.default
@@ -448277,7 +449021,7 @@ var makeConfig = ({
     ...import_eslint_plugin_react.default.configs.flat.recommended.languageOptions,
     parser: import_typescript_eslint.default.parser,
     parserOptions: {
-      projectService: true
+      projectService: false
     }
   },
   rules: {
@@ -448300,9 +449044,6 @@ var makeConfig = ({
   },
   rules: esm_default.configs.recommended.rules,
   ...remotionDir ? { files: [remotionDir] } : {}
-}, {
-  files: ["**/*.js"],
-  extends: [import_typescript_eslint.default.configs.disableTypeChecked]
 });
 var config = makeConfig({
   remotionDir: undefined