@storm-software/eslint 0.170.82 → 0.170.84

package/dist/preset.js

@@ -3,6 +3,8 @@ import { getTsConfigPath } from './chunk-STWB44U5.js';
 import { findWorkspaceRoot } from './chunk-2U26IRBT.js';
 import { joinPaths } from './chunk-I72VXUA2.js';
 import { __commonJS, init_esm_shims, __toESM, __require, __filename as __filename$1 } from './chunk-HUL5SEAB.js';
+import * as __import_util from 'util';
+import * as __import_eslintPluginReactNativeGlobals from 'eslint-plugin-react-native-globals';
 import * as __import__microsoft_tsdocConfig from '@microsoft/tsdoc-config';
 import * as __import_path from 'path';
 import * as __import_fs from 'fs';
@@ -56,6 +58,1234 @@ import { globSync } from 'tinyglobby';
 import config4 from 'eslint-plugin-prettier/recommended';
 import { configs as configs$1 } from 'eslint-plugin-regexp';
 
+// ../../node_modules/.pnpm/eslint-plugin-react-native@5.0.0_patch_hash=1320a4c113a7f7ebb367bb0eaf377bd76dd7730f216_b81403553f777f68c7f42f6dd1713653/node_modules/eslint-plugin-react-native/lib/util/Components.js
+var require_Components = __commonJS({
+  "../../node_modules/.pnpm/eslint-plugin-react-native@5.0.0_patch_hash=1320a4c113a7f7ebb367bb0eaf377bd76dd7730f216_b81403553f777f68c7f42f6dd1713653/node_modules/eslint-plugin-react-native/lib/util/Components.js"(exports, module) {
+    init_esm_shims();
+    function Components() {
+      this.list = {};
+      this.getId = function(node2) {
+        return node2 && node2.range.join(":");
+      };
+    }
+    Components.prototype.add = function(node2, confidence) {
+      const id = this.getId(node2);
+      if (this.list[id]) {
+        if (confidence === 0 || this.list[id].confidence === 0) {
+          this.list[id].confidence = 0;
+        } else {
+          this.list[id].confidence = Math.max(this.list[id].confidence, confidence);
+        }
+        return;
+      }
+      this.list[id] = {
+        node: node2,
+        confidence
+      };
+    };
+    Components.prototype.get = function(node2) {
+      const id = this.getId(node2);
+      return this.list[id];
+    };
+    Components.prototype.set = function(node2, props) {
+      let currentNode = node2;
+      while (currentNode && !this.list[this.getId(currentNode)]) {
+        currentNode = node2.parent;
+      }
+      if (!currentNode) {
+        return;
+      }
+      const id = this.getId(currentNode);
+      this.list[id] = { ...this.list[id], ...props };
+    };
+    Components.prototype.all = function() {
+      const list = {};
+      Object.keys(this.list).forEach((i) => {
+        if ({}.hasOwnProperty.call(this.list, i) && this.list[i].confidence >= 2) {
+          list[i] = this.list[i];
+        }
+      });
+      return list;
+    };
+    Components.prototype.length = function() {
+      let length = 0;
+      Object.keys(this.list).forEach((i) => {
+        if ({}.hasOwnProperty.call(this.list, i) && this.list[i].confidence >= 2) {
+          length += 1;
+        }
+      });
+      return length;
+    };
+    function componentRule(rule, context, _node) {
+      const sourceCode = context.sourceCode ?? context.getSourceCode();
+      const components = new Components();
+      const utils = {
+        /**
+         * Check if the node is a React ES5 component
+         *
+         * @param {ASTNode} node The AST node being checked.
+         * @returns {Boolean} True if the node is a React ES5 component, false if not
+         */
+        isES5Component: function(node2) {
+          if (!node2.parent) {
+            return false;
+          }
+          return /^(React\.)?createClass$/.test(sourceCode.getText(node2.parent.callee));
+        },
+        /**
+         * Check if the node is a React ES6 component
+         *
+         * @param {ASTNode} node The AST node being checked.
+         * @returns {Boolean} True if the node is a React ES6 component, false if not
+         */
+        isES6Component: function(node2) {
+          if (!node2.superClass) {
+            return false;
+          }
+          return /^(React\.)?(Pure)?Component$/.test(sourceCode.getText(node2.superClass));
+        },
+        /**
+         * Check if the node is returning JSX
+         *
+         * @param {ASTNode} node The AST node being checked (must be a ReturnStatement).
+         * @returns {Boolean} True if the node is returning JSX, false if not
+         */
+        isReturningJSX: function(node2) {
+          let property;
+          switch (node2.type) {
+            case "ReturnStatement":
+              property = "argument";
+              break;
+            case "ArrowFunctionExpression":
+              property = "body";
+              break;
+            default:
+              return false;
+          }
+          const returnsJSX = node2[property] && (node2[property].type === "JSXElement" || node2[property].type === "JSXFragment");
+          const returnsReactCreateElement = node2[property] && node2[property].callee && node2[property].callee.property && node2[property].callee.property.name === "createElement";
+          return Boolean(returnsJSX || returnsReactCreateElement);
+        },
+        /**
+         * Get the parent component node from the current scope
+         *
+         * @returns {ASTNode} component node, null if we are not in a component
+         */
+        getParentComponent: function(_n) {
+          return utils.getParentES6Component(_n) || utils.getParentES5Component(_n) || utils.getParentStatelessComponent(_n);
+        },
+        /**
+         * Get the parent ES5 component node from the current scope
+         *
+         * @returns {ASTNode} component node, null if we are not in a component
+         */
+        getParentES5Component: function(_n) {
+          let scope = (context.sourceCode || context).getScope(_n);
+          while (scope) {
+            const node2 = scope.block && scope.block.parent && scope.block.parent.parent;
+            if (node2 && utils.isES5Component(node2)) {
+              return node2;
+            }
+            scope = scope.upper;
+          }
+          return null;
+        },
+        /**
+         * Get the parent ES6 component node from the current scope
+         *
+         * @returns {ASTNode} component node, null if we are not in a component
+         */
+        getParentES6Component: function(_n) {
+          let scope = (context.sourceCode || context).getScope(_n);
+          while (scope && scope.type !== "class") {
+            scope = scope.upper;
+          }
+          const node2 = scope && scope.block;
+          if (!node2 || !utils.isES6Component(node2)) {
+            return null;
+          }
+          return node2;
+        },
+        /**
+         * Get the parent stateless component node from the current scope
+         *
+         * @returns {ASTNode} component node, null if we are not in a component
+         */
+        getParentStatelessComponent: function(_n) {
+          let scope = (context.sourceCode || context).getScope(_n);
+          while (scope) {
+            const node2 = scope.block;
+            const isFunction = /Function/.test(node2.type);
+            const isNotMethod = !node2.parent || node2.parent.type !== "MethodDefinition";
+            const isNotArgument = !node2.parent || node2.parent.type !== "CallExpression";
+            if (isFunction && isNotMethod && isNotArgument) {
+              return node2;
+            }
+            scope = scope.upper;
+          }
+          return null;
+        },
+        /**
+         * Get the related component from a node
+         *
+         * @param {ASTNode} node The AST node being checked (must be a MemberExpression).
+         * @returns {ASTNode} component node, null if we cannot find the component
+         */
+        getRelatedComponent: function(node2) {
+          let currentNode = node2;
+          let i;
+          let j;
+          let k;
+          let l;
+          const componentPath = [];
+          while (currentNode) {
+            if (currentNode.property && currentNode.property.type === "Identifier") {
+              componentPath.push(currentNode.property.name);
+            }
+            if (currentNode.object && currentNode.object.type === "Identifier") {
+              componentPath.push(currentNode.object.name);
+            }
+            currentNode = currentNode.object;
+          }
+          componentPath.reverse();
+          const variableName = componentPath.shift();
+          if (!variableName) {
+            return null;
+          }
+          let variableInScope;
+          const { variables } = (context.sourceCode || context).getScope(_node);
+          for (i = 0, j = variables.length; i < j; i++) {
+            if (variables[i].name === variableName) {
+              variableInScope = variables[i];
+              break;
+            }
+          }
+          if (!variableInScope) {
+            return null;
+          }
+          let defInScope;
+          const { defs: defs2 } = variableInScope;
+          for (i = 0, j = defs2.length; i < j; i++) {
+            if (defs2[i].type === "ClassName" || defs2[i].type === "FunctionName" || defs2[i].type === "Variable") {
+              defInScope = defs2[i];
+              break;
+            }
+          }
+          if (!defInScope) {
+            return null;
+          }
+          currentNode = defInScope.node.init || defInScope.node;
+          for (i = 0, j = componentPath.length; i < j; i++) {
+            if (!currentNode.properties) {
+              continue;
+            }
+            for (k = 0, l = currentNode.properties.length; k < l; k++) {
+              if (currentNode.properties[k].key.name === componentPath[i]) {
+                currentNode = currentNode.properties[k];
+                break;
+              }
+            }
+            if (!currentNode) {
+              return null;
+            }
+            currentNode = currentNode.value;
+          }
+          return components.get(currentNode);
+        }
+      };
+      const detectionInstructions = {
+        ClassDeclaration: function(node2) {
+          if (!utils.isES6Component(node2)) {
+            return;
+          }
+          components.add(node2, 2);
+        },
+        ClassProperty: function(_n) {
+          const node2 = utils.getParentComponent(_n);
+          if (!node2) {
+            return;
+          }
+          components.add(node2, 2);
+        },
+        ObjectExpression: function(node2) {
+          if (!utils.isES5Component(node2)) {
+            return;
+          }
+          components.add(node2, 2);
+        },
+        FunctionExpression: function(_n) {
+          const node2 = utils.getParentComponent(_n);
+          if (!node2) {
+            return;
+          }
+          components.add(node2, 1);
+        },
+        FunctionDeclaration: function(_n) {
+          const node2 = utils.getParentComponent(_n);
+          if (!node2) {
+            return;
+          }
+          components.add(node2, 1);
+        },
+        ArrowFunctionExpression: function(_n) {
+          const node2 = utils.getParentComponent(_n);
+          if (!node2) {
+            return;
+          }
+          if (node2.expression && utils.isReturningJSX(node2)) {
+            components.add(node2, 2);
+          } else {
+            components.add(node2, 1);
+          }
+        },
+        ThisExpression: function(_n) {
+          const node2 = utils.getParentComponent(_n);
+          if (!node2 || !/Function/.test(node2.type)) {
+            return;
+          }
+          components.add(node2, 0);
+        },
+        ReturnStatement: function(node2) {
+          if (!utils.isReturningJSX(node2)) {
+            return;
+          }
+          const parentNode = utils.getParentComponent(node2);
+          if (!parentNode) {
+            return;
+          }
+          components.add(parentNode, 2);
+        }
+      };
+      const ruleInstructions = rule(context, components, utils);
+      const updatedRuleInstructions = { ...ruleInstructions };
+      Object.keys(detectionInstructions).forEach((instruction) => {
+        updatedRuleInstructions[instruction] = (node2) => {
+          detectionInstructions[instruction](node2);
+          return ruleInstructions[instruction] ? ruleInstructions[instruction](node2) : void 0;
+        };
+      });
+      return updatedRuleInstructions;
+    }
+    Components.detect = function(rule) {
+      return componentRule.bind(this, rule);
+    };
+    module.exports = Components;
+  }
+});
+
+// ../../node_modules/.pnpm/eslint-plugin-react-native@5.0.0_patch_hash=1320a4c113a7f7ebb367bb0eaf377bd76dd7730f216_b81403553f777f68c7f42f6dd1713653/node_modules/eslint-plugin-react-native/lib/util/stylesheet.js
+var require_stylesheet = __commonJS({
+  "../../node_modules/.pnpm/eslint-plugin-react-native@5.0.0_patch_hash=1320a4c113a7f7ebb367bb0eaf377bd76dd7730f216_b81403553f777f68c7f42f6dd1713653/node_modules/eslint-plugin-react-native/lib/util/stylesheet.js"(exports, module) {
+    init_esm_shims();
+    function StyleSheets() {
+      this.styleSheets = {};
+    }
+    StyleSheets.prototype.add = function(styleSheetName, properties2) {
+      this.styleSheets[styleSheetName] = properties2;
+    };
+    StyleSheets.prototype.markAsUsed = function(fullyQualifiedName) {
+      const nameSplit = fullyQualifiedName.split(".");
+      const styleSheetName = nameSplit[0];
+      const styleSheetProperty = nameSplit[1];
+      if (this.styleSheets[styleSheetName]) {
+        this.styleSheets[styleSheetName] = this.styleSheets[styleSheetName].filter((property) => property.key.name !== styleSheetProperty);
+      }
+    };
+    StyleSheets.prototype.getUnusedReferences = function() {
+      return this.styleSheets;
+    };
+    StyleSheets.prototype.addColorLiterals = function(expressions) {
+      if (!this.colorLiterals) {
+        this.colorLiterals = [];
+      }
+      this.colorLiterals = this.colorLiterals.concat(expressions);
+    };
+    StyleSheets.prototype.getColorLiterals = function() {
+      return this.colorLiterals;
+    };
+    StyleSheets.prototype.addObjectExpressions = function(expressions) {
+      if (!this.objectExpressions) {
+        this.objectExpressions = [];
+      }
+      this.objectExpressions = this.objectExpressions.concat(expressions);
+    };
+    StyleSheets.prototype.getObjectExpressions = function() {
+      return this.objectExpressions;
+    };
+    var currentContent;
+    var getSourceCode = (node2) => currentContent.getSourceCode(node2).getText(node2);
+    var getStyleSheetObjectNames = (settings) => settings["react-native/style-sheet-object-names"] || ["StyleSheet"];
+    var astHelpers = {
+      containsStyleSheetObject: function(node2, objectNames) {
+        return Boolean(
+          node2 && node2.type === "CallExpression" && node2.callee && node2.callee.object && node2.callee.object.name && objectNames.includes(node2.callee.object.name)
+        );
+      },
+      containsCreateCall: function(node2) {
+        return Boolean(
+          node2 && node2.callee && node2.callee.property && node2.callee.property.name === "create"
+        );
+      },
+      isStyleSheetDeclaration: function(node2, settings) {
+        const objectNames = getStyleSheetObjectNames(settings);
+        return Boolean(
+          astHelpers.containsStyleSheetObject(node2, objectNames) && astHelpers.containsCreateCall(node2)
+        );
+      },
+      getStyleSheetName: function(node2) {
+        if (node2 && node2.parent && node2.parent.id) {
+          return node2.parent.id.name;
+        }
+      },
+      getStyleDeclarations: function(node2) {
+        if (node2 && node2.type === "CallExpression" && node2.arguments && node2.arguments[0] && node2.arguments[0].properties) {
+          return node2.arguments[0].properties.filter((property) => property.type === "Property");
+        }
+        return [];
+      },
+      getStyleDeclarationsChunks: function(node2) {
+        if (node2 && node2.type === "CallExpression" && node2.arguments && node2.arguments[0] && node2.arguments[0].properties) {
+          const { properties: properties2 } = node2.arguments[0];
+          const result = [];
+          let chunk = [];
+          for (let i = 0; i < properties2.length; i += 1) {
+            const property = properties2[i];
+            if (property.type === "Property") {
+              chunk.push(property);
+            } else if (chunk.length) {
+              result.push(chunk);
+              chunk = [];
+            }
+          }
+          if (chunk.length) {
+            result.push(chunk);
+          }
+          return result;
+        }
+        return [];
+      },
+      getPropertiesChunks: function(properties2) {
+        const result = [];
+        let chunk = [];
+        for (let i = 0; i < properties2.length; i += 1) {
+          const property = properties2[i];
+          if (property.type === "Property") {
+            chunk.push(property);
+          } else if (chunk.length) {
+            result.push(chunk);
+            chunk = [];
+          }
+        }
+        if (chunk.length) {
+          result.push(chunk);
+        }
+        return result;
+      },
+      getExpressionIdentifier: function(node2) {
+        if (node2) {
+          switch (node2.type) {
+            case "Identifier":
+              return node2.name;
+            case "Literal":
+              return node2.value;
+            case "TemplateLiteral":
+              return node2.quasis.reduce(
+                (result, quasi, index) => result + quasi.value.cooked + astHelpers.getExpressionIdentifier(node2.expressions[index]),
+                ""
+              );
+            default:
+              return "";
+          }
+        }
+        return "";
+      },
+      getStylePropertyIdentifier: function(node2) {
+        if (node2 && node2.key) {
+          return astHelpers.getExpressionIdentifier(node2.key);
+        }
+      },
+      isStyleAttribute: function(node2) {
+        return Boolean(
+          node2.type === "JSXAttribute" && node2.name && node2.name.name && node2.name.name.toLowerCase().includes("style")
+        );
+      },
+      collectStyleObjectExpressions: function(node2, context) {
+        currentContent = context;
+        if (astHelpers.hasArrayOfStyleReferences(node2)) {
+          const styleReferenceContainers = node2.expression.elements;
+          return astHelpers.collectStyleObjectExpressionFromContainers(
+            styleReferenceContainers
+          );
+        }
+        if (node2 && node2.expression) {
+          return astHelpers.getStyleObjectExpressionFromNode(node2.expression);
+        }
+        return [];
+      },
+      collectColorLiterals: function(node2, context) {
+        if (!node2) {
+          return [];
+        }
+        currentContent = context;
+        if (astHelpers.hasArrayOfStyleReferences(node2)) {
+          const styleReferenceContainers = node2.expression.elements;
+          return astHelpers.collectColorLiteralsFromContainers(
+            styleReferenceContainers
+          );
+        }
+        if (node2.type === "ObjectExpression") {
+          return astHelpers.getColorLiteralsFromNode(node2);
+        }
+        return astHelpers.getColorLiteralsFromNode(node2.expression);
+      },
+      collectStyleObjectExpressionFromContainers: function(nodes) {
+        let objectExpressions = [];
+        nodes.forEach((node2) => {
+          objectExpressions = objectExpressions.concat(astHelpers.getStyleObjectExpressionFromNode(node2));
+        });
+        return objectExpressions;
+      },
+      collectColorLiteralsFromContainers: function(nodes) {
+        let colorLiterals = [];
+        nodes.forEach((node2) => {
+          colorLiterals = colorLiterals.concat(astHelpers.getColorLiteralsFromNode(node2));
+        });
+        return colorLiterals;
+      },
+      getStyleReferenceFromNode: function(node2) {
+        let styleReference;
+        let leftStyleReferences;
+        let rightStyleReferences;
+        if (!node2) {
+          return [];
+        }
+        switch (node2.type) {
+          case "MemberExpression":
+            styleReference = astHelpers.getStyleReferenceFromExpression(node2);
+            return [styleReference];
+          case "LogicalExpression":
+            leftStyleReferences = astHelpers.getStyleReferenceFromNode(node2.left);
+            rightStyleReferences = astHelpers.getStyleReferenceFromNode(node2.right);
+            return [].concat(leftStyleReferences).concat(rightStyleReferences);
+          case "ConditionalExpression":
+            leftStyleReferences = astHelpers.getStyleReferenceFromNode(node2.consequent);
+            rightStyleReferences = astHelpers.getStyleReferenceFromNode(node2.alternate);
+            return [].concat(leftStyleReferences).concat(rightStyleReferences);
+          default:
+            return [];
+        }
+      },
+      getStyleObjectExpressionFromNode: function(node2) {
+        let leftStyleObjectExpression;
+        let rightStyleObjectExpression;
+        if (!node2) {
+          return [];
+        }
+        if (node2.type === "ObjectExpression") {
+          return [astHelpers.getStyleObjectFromExpression(node2)];
+        }
+        switch (node2.type) {
+          case "LogicalExpression":
+            leftStyleObjectExpression = astHelpers.getStyleObjectExpressionFromNode(node2.left);
+            rightStyleObjectExpression = astHelpers.getStyleObjectExpressionFromNode(node2.right);
+            return [].concat(leftStyleObjectExpression).concat(rightStyleObjectExpression);
+          case "ConditionalExpression":
+            leftStyleObjectExpression = astHelpers.getStyleObjectExpressionFromNode(node2.consequent);
+            rightStyleObjectExpression = astHelpers.getStyleObjectExpressionFromNode(node2.alternate);
+            return [].concat(leftStyleObjectExpression).concat(rightStyleObjectExpression);
+          default:
+            return [];
+        }
+      },
+      getColorLiteralsFromNode: function(node2) {
+        let leftColorLiterals;
+        let rightColorLiterals;
+        if (!node2) {
+          return [];
+        }
+        if (node2.type === "ObjectExpression") {
+          return [astHelpers.getColorLiteralsFromExpression(node2)];
+        }
+        switch (node2.type) {
+          case "LogicalExpression":
+            leftColorLiterals = astHelpers.getColorLiteralsFromNode(node2.left);
+            rightColorLiterals = astHelpers.getColorLiteralsFromNode(node2.right);
+            return [].concat(leftColorLiterals).concat(rightColorLiterals);
+          case "ConditionalExpression":
+            leftColorLiterals = astHelpers.getColorLiteralsFromNode(node2.consequent);
+            rightColorLiterals = astHelpers.getColorLiteralsFromNode(node2.alternate);
+            return [].concat(leftColorLiterals).concat(rightColorLiterals);
+          default:
+            return [];
+        }
+      },
+      hasArrayOfStyleReferences: function(node2) {
+        return node2 && Boolean(
+          node2.type === "JSXExpressionContainer" && node2.expression && node2.expression.type === "ArrayExpression"
+        );
+      },
+      getStyleReferenceFromExpression: function(node2) {
+        const result = [];
+        const name3 = astHelpers.getObjectName(node2);
+        if (name3) {
+          result.push(name3);
+        }
+        const property = astHelpers.getPropertyName(node2);
+        if (property) {
+          result.push(property);
+        }
+        return result.join(".");
+      },
+      getStyleObjectFromExpression: function(node2) {
+        const obj = {};
+        let invalid = false;
+        if (node2.properties && node2.properties.length) {
+          node2.properties.forEach((p) => {
+            if (!p.value || !p.key) {
+              return;
+            }
+            if (p.value.type === "Literal") {
+              invalid = true;
+              obj[p.key.name] = p.value.value;
+            } else if (p.value.type === "ConditionalExpression") {
+              const innerNode = p.value;
+              if (innerNode.consequent.type === "Literal" || innerNode.alternate.type === "Literal") {
+                invalid = true;
+                obj[p.key.name] = getSourceCode(innerNode);
+              }
+            } else if (p.value.type === "UnaryExpression" && p.value.operator === "-" && p.value.argument.type === "Literal") {
+              invalid = true;
+              obj[p.key.name] = -1 * p.value.argument.value;
+            } else if (p.value.type === "UnaryExpression" && p.value.operator === "+" && p.value.argument.type === "Literal") {
+              invalid = true;
+              obj[p.key.name] = p.value.argument.value;
+            }
+          });
+        }
+        return invalid ? { expression: obj, node: node2 } : void 0;
+      },
+      getColorLiteralsFromExpression: function(node2) {
+        const obj = {};
+        let invalid = false;
+        if (node2.properties && node2.properties.length) {
+          node2.properties.forEach((p) => {
+            if (p.key && p.key.name && p.key.name.toLowerCase().indexOf("color") !== -1) {
+              if (p.value.type === "Literal") {
+                invalid = true;
+                obj[p.key.name] = p.value.value;
+              } else if (p.value.type === "ConditionalExpression") {
+                const innerNode = p.value;
+                if (innerNode.consequent.type === "Literal" || innerNode.alternate.type === "Literal") {
+                  invalid = true;
+                  obj[p.key.name] = getSourceCode(innerNode);
+                }
+              }
+            }
+          });
+        }
+        return invalid ? { expression: obj, node: node2 } : void 0;
+      },
+      getObjectName: function(node2) {
+        if (node2 && node2.object && node2.object.name) {
+          return node2.object.name;
+        }
+      },
+      getPropertyName: function(node2) {
+        if (node2 && node2.property && node2.property.name) {
+          return node2.property.name;
+        }
+      },
+      getPotentialStyleReferenceFromMemberExpression: function(node2) {
+        if (node2 && node2.object && node2.object.type === "Identifier" && node2.object.name && node2.property && node2.property.type === "Identifier" && node2.property.name && node2.parent.type !== "MemberExpression") {
+          return [node2.object.name, node2.property.name].join(".");
+        }
+      },
+      isEitherShortHand: function(property1, property2) {
+        const shorthands = ["margin", "padding", "border", "flex"];
+        if (shorthands.includes(property1)) {
+          return property2.startsWith(property1);
+        }
+        if (shorthands.includes(property2)) {
+          return property1.startsWith(property2);
+        }
+        return false;
+      }
+    };
+    module.exports.astHelpers = astHelpers;
+    module.exports.StyleSheets = StyleSheets;
+  }
+});
+
+// ../../node_modules/.pnpm/eslint-plugin-react-native@5.0.0_patch_hash=1320a4c113a7f7ebb367bb0eaf377bd76dd7730f216_b81403553f777f68c7f42f6dd1713653/node_modules/eslint-plugin-react-native/lib/rules/no-unused-styles.js
+var require_no_unused_styles = __commonJS({
+  "../../node_modules/.pnpm/eslint-plugin-react-native@5.0.0_patch_hash=1320a4c113a7f7ebb367bb0eaf377bd76dd7730f216_b81403553f777f68c7f42f6dd1713653/node_modules/eslint-plugin-react-native/lib/rules/no-unused-styles.js"(exports, module) {
+    init_esm_shims();
+    var __import____util_Components = __toESM(require_Components());
+    var __import____util_stylesheet = __toESM(require_stylesheet());
+    var Components = __import____util_Components;
+    var styleSheet = __import____util_stylesheet;
+    var { StyleSheets } = styleSheet;
+    var { astHelpers } = styleSheet;
+    var create = Components.detect((context, components) => {
+      const styleSheets = new StyleSheets();
+      const styleReferences = /* @__PURE__ */ new Set();
+      function reportUnusedStyles(unusedStyles) {
+        Object.keys(unusedStyles).forEach((key) => {
+          if ({}.hasOwnProperty.call(unusedStyles, key)) {
+            const styles = unusedStyles[key];
+            styles.forEach((node2) => {
+              const message2 = [
+                "Unused style detected: ",
+                key,
+                ".",
+                node2.key.name
+              ].join("");
+              context.report(node2, message2);
+            });
+          }
+        });
+      }
+      return {
+        MemberExpression: function(node2) {
+          const styleRef = astHelpers.getPotentialStyleReferenceFromMemberExpression(node2);
+          if (styleRef) {
+            styleReferences.add(styleRef);
+          }
+        },
+        CallExpression: function(node2) {
+          if (astHelpers.isStyleSheetDeclaration(node2, context.settings)) {
+            const styleSheetName = astHelpers.getStyleSheetName(node2);
+            const styles = astHelpers.getStyleDeclarations(node2);
+            styleSheets.add(styleSheetName, styles);
+          }
+        },
+        "Program:exit": function() {
+          const list = components.all();
+          if (Object.keys(list).length > 0) {
+            styleReferences.forEach((reference) => {
+              styleSheets.markAsUsed(reference);
+            });
+            reportUnusedStyles(styleSheets.getUnusedReferences());
+          }
+        }
+      };
+    });
+    module.exports = {
+      meta: {
+        schema: []
+      },
+      create
+    };
+  }
+});
+var require_no_inline_styles = __commonJS({
+  "../../node_modules/.pnpm/eslint-plugin-react-native@5.0.0_patch_hash=1320a4c113a7f7ebb367bb0eaf377bd76dd7730f216_b81403553f777f68c7f42f6dd1713653/node_modules/eslint-plugin-react-native/lib/rules/no-inline-styles.js"(exports, module) {
+    init_esm_shims();
+    var __import____util_Components = __toESM(require_Components());
+    var __import____util_stylesheet = __toESM(require_stylesheet());
+    var util = __import_util;
+    var Components = __import____util_Components;
+    var styleSheet = __import____util_stylesheet;
+    var { StyleSheets } = styleSheet;
+    var { astHelpers } = styleSheet;
+    var create = Components.detect((context) => {
+      const styleSheets = new StyleSheets();
+      function reportInlineStyles(inlineStyles) {
+        if (inlineStyles) {
+          inlineStyles.forEach((style) => {
+            if (style) {
+              const expression = util.inspect(style.expression);
+              context.report({
+                node: style.node,
+                message: "Inline style: {{expression}}",
+                data: { expression }
+              });
+            }
+          });
+        }
+      }
+      return {
+        JSXAttribute: (node2) => {
+          if (astHelpers.isStyleAttribute(node2)) {
+            const styles = astHelpers.collectStyleObjectExpressions(node2.value, context);
+            styleSheets.addObjectExpressions(styles);
+          }
+        },
+        "Program:exit": () => reportInlineStyles(styleSheets.getObjectExpressions())
+      };
+    });
+    module.exports = {
+      meta: {
+        schema: []
+      },
+      create
+    };
+  }
+});
+var require_no_color_literals = __commonJS({
+  "../../node_modules/.pnpm/eslint-plugin-react-native@5.0.0_patch_hash=1320a4c113a7f7ebb367bb0eaf377bd76dd7730f216_b81403553f777f68c7f42f6dd1713653/node_modules/eslint-plugin-react-native/lib/rules/no-color-literals.js"(exports, module) {
+    init_esm_shims();
+    var __import____util_Components = __toESM(require_Components());
+    var __import____util_stylesheet = __toESM(require_stylesheet());
+    var util = __import_util;
+    var Components = __import____util_Components;
+    var styleSheet = __import____util_stylesheet;
+    var { StyleSheets } = styleSheet;
+    var { astHelpers } = styleSheet;
+    var create = Components.detect((context) => {
+      const styleSheets = new StyleSheets();
+      function reportColorLiterals(colorLiterals) {
+        if (colorLiterals) {
+          colorLiterals.forEach((style) => {
+            if (style) {
+              const expression = util.inspect(style.expression);
+              context.report({
+                node: style.node,
+                message: "Color literal: {{expression}}",
+                data: { expression }
+              });
+            }
+          });
+        }
+      }
+      return {
+        CallExpression: (node2) => {
+          if (astHelpers.isStyleSheetDeclaration(node2, context.settings)) {
+            const styles = astHelpers.getStyleDeclarations(node2);
+            if (styles) {
+              styles.forEach((style) => {
+                const literals = astHelpers.collectColorLiterals(style.value, context);
+                styleSheets.addColorLiterals(literals);
+              });
+            }
+          }
+        },
+        JSXAttribute: (node2) => {
+          if (astHelpers.isStyleAttribute(node2)) {
+            const literals = astHelpers.collectColorLiterals(node2.value, context);
+            styleSheets.addColorLiterals(literals);
+          }
+        },
+        "Program:exit": () => reportColorLiterals(styleSheets.getColorLiterals())
+      };
+    });
+    module.exports = {
+      meta: {
+        schema: []
+      },
+      create
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/eslint-plugin-react-native@5.0.0_patch_hash=1320a4c113a7f7ebb367bb0eaf377bd76dd7730f216_b81403553f777f68c7f42f6dd1713653/node_modules/eslint-plugin-react-native/lib/rules/sort-styles.js
+var require_sort_styles = __commonJS({
+  "../../node_modules/.pnpm/eslint-plugin-react-native@5.0.0_patch_hash=1320a4c113a7f7ebb367bb0eaf377bd76dd7730f216_b81403553f777f68c7f42f6dd1713653/node_modules/eslint-plugin-react-native/lib/rules/sort-styles.js"(exports, module) {
+    init_esm_shims();
+    var __import____util_stylesheet = __toESM(require_stylesheet());
+    var { astHelpers } = __import____util_stylesheet;
+    var {
+      getStyleDeclarationsChunks,
+      getPropertiesChunks,
+      getStylePropertyIdentifier,
+      isStyleSheetDeclaration,
+      isEitherShortHand
+    } = astHelpers;
+    function create(context) {
+      const order = context.options[0] || "asc";
+      const options = context.options[1] || {};
+      const { ignoreClassNames } = options;
+      const { ignoreStyleProperties } = options;
+      const isValidOrder = order === "asc" ? (a, b) => a <= b : (a, b) => a >= b;
+      const sourceCode = context.sourceCode ?? context.getSourceCode();
+      function sort(array2) {
+        return [].concat(array2).sort((a, b) => {
+          const identifierA = getStylePropertyIdentifier(a);
+          const identifierB = getStylePropertyIdentifier(b);
+          let sortOrder = 0;
+          if (isEitherShortHand(identifierA, identifierB)) {
+            return a.range[0] - b.range[0];
+          }
+          if (identifierA < identifierB) {
+            sortOrder = -1;
+          } else if (identifierA > identifierB) {
+            sortOrder = 1;
+          }
+          return sortOrder * (order === "asc" ? 1 : -1);
+        });
+      }
+      function report(array2, type, node2, prev, current) {
+        const currentName = getStylePropertyIdentifier(current);
+        const prevName = getStylePropertyIdentifier(prev);
+        const hasComments = array2.map((prop) => [...sourceCode.getCommentsBefore(prop), ...sourceCode.getCommentsAfter(prop)]).reduce(
+          (hasComment, comment) => hasComment || comment.length > 0,
+          false
+        );
+        context.report({
+          node: node2,
+          message: `Expected ${type} to be in ${order}ending order. '${currentName}' should be before '${prevName}'.`,
+          loc: current.key.loc,
+          fix: hasComments ? void 0 : (fixer) => {
+            const sortedArray = sort(array2);
+            return array2.map((item, i) => {
+              if (item !== sortedArray[i]) {
+                return fixer.replaceText(
+                  item,
+                  sourceCode.getText(sortedArray[i])
+                );
+              }
+              return null;
+            }).filter(Boolean);
+          }
+        });
+      }
+      function checkIsSorted(array2, arrayName, node2) {
+        for (let i = 1; i < array2.length; i += 1) {
+          const previous = array2[i - 1];
+          const current = array2[i];
+          if (previous.type !== "Property" || current.type !== "Property") {
+            return;
+          }
+          const prevName = getStylePropertyIdentifier(previous);
+          const currentName = getStylePropertyIdentifier(current);
+          const oneIsShorthandForTheOther = arrayName === "style properties" && isEitherShortHand(prevName, currentName);
+          if (!oneIsShorthandForTheOther && !isValidOrder(prevName, currentName)) {
+            return report(array2, arrayName, node2, previous, current);
+          }
+        }
+      }
+      return {
+        CallExpression: function(node2) {
+          if (!isStyleSheetDeclaration(node2, context.settings)) {
+            return;
+          }
+          const classDefinitionsChunks = getStyleDeclarationsChunks(node2);
+          if (!ignoreClassNames) {
+            classDefinitionsChunks.forEach((classDefinitions) => {
+              checkIsSorted(classDefinitions, "class names", node2);
+            });
+          }
+          if (ignoreStyleProperties) return;
+          classDefinitionsChunks.forEach((classDefinitions) => {
+            classDefinitions.forEach((classDefinition) => {
+              const styleProperties = classDefinition.value.properties;
+              if (!styleProperties || styleProperties.length < 2) {
+                return;
+              }
+              const stylePropertyChunks = getPropertiesChunks(styleProperties);
+              stylePropertyChunks.forEach((stylePropertyChunk) => {
+                checkIsSorted(stylePropertyChunk, "style properties", node2);
+              });
+            });
+          });
+        }
+      };
+    }
+    module.exports = {
+      meta: {
+        fixable: "code",
+        schema: [
+          {
+            enum: ["asc", "desc"]
+          },
+          {
+            type: "object",
+            properties: {
+              ignoreClassNames: {
+                type: "boolean"
+              },
+              ignoreStyleProperties: {
+                type: "boolean"
+              }
+            },
+            additionalProperties: false
+          }
+        ]
+      },
+      create
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/eslint-plugin-react-native@5.0.0_patch_hash=1320a4c113a7f7ebb367bb0eaf377bd76dd7730f216_b81403553f777f68c7f42f6dd1713653/node_modules/eslint-plugin-react-native/lib/rules/split-platform-components.js
+var require_split_platform_components = __commonJS({
+  "../../node_modules/.pnpm/eslint-plugin-react-native@5.0.0_patch_hash=1320a4c113a7f7ebb367bb0eaf377bd76dd7730f216_b81403553f777f68c7f42f6dd1713653/node_modules/eslint-plugin-react-native/lib/rules/split-platform-components.js"(exports, module) {
+    init_esm_shims();
+    function create(context) {
+      let reactComponents = [];
+      const androidMessage = "Android components should be placed in android files";
+      const iosMessage = "IOS components should be placed in ios files";
+      const conflictMessage = "IOS and Android components can't be mixed";
+      const iosPathRegex = context.options[0] && context.options[0].iosPathRegex ? new RegExp(context.options[0].iosPathRegex) : /\.ios\.[j|t]sx?$/;
+      const androidPathRegex = context.options[0] && context.options[0].androidPathRegex ? new RegExp(context.options[0].androidPathRegex) : /\.android\.[j|t]sx?$/;
+      function getName(node2) {
+        if (node2.type === "Property") {
+          const key = node2.key || node2.argument;
+          return key.type === "Identifier" ? key.name : key.value;
+        }
+        if (node2.type === "Identifier") {
+          return node2.name;
+        }
+      }
+      function hasNodeWithName(nodes, name3) {
+        return nodes.some((node2) => {
+          const nodeName = getName(node2);
+          return nodeName && nodeName.includes(name3);
+        });
+      }
+      function reportErrors(components, filename) {
+        const containsAndroidAndIOS = hasNodeWithName(components, "IOS") && hasNodeWithName(components, "Android");
+        components.forEach((node2) => {
+          const propName = getName(node2);
+          if (propName.includes("IOS") && !filename.match(iosPathRegex)) {
+            context.report(node2, containsAndroidAndIOS ? conflictMessage : iosMessage);
+          }
+          if (propName.includes("Android") && !filename.match(androidPathRegex)) {
+            context.report(node2, containsAndroidAndIOS ? conflictMessage : androidMessage);
+          }
+        });
+      }
+      return {
+        VariableDeclarator: function(node2) {
+          const destructuring = node2.init && node2.id && node2.id.type === "ObjectPattern";
+          const statelessDestructuring = destructuring && node2.init.name === "React";
+          if (destructuring && statelessDestructuring) {
+            reactComponents = reactComponents.concat(node2.id.properties);
+          }
+        },
+        ImportDeclaration: function(node2) {
+          if (node2.source.value === "react-native") {
+            node2.specifiers.forEach((importSpecifier) => {
+              if (importSpecifier.type === "ImportSpecifier") {
+                reactComponents = reactComponents.concat(importSpecifier.imported);
+              }
+            });
+          }
+        },
+        "Program:exit": function() {
+          const filename = context.getFilename();
+          reportErrors(reactComponents, filename);
+        }
+      };
+    }
+    module.exports = {
+      meta: {
+        fixable: "code",
+        schema: [{
+          type: "object",
+          properties: {
+            androidPathRegex: {
+              type: "string"
+            },
+            iosPathRegex: {
+              type: "string"
+            }
+          },
+          additionalProperties: false
+        }]
+      },
+      create
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/eslint-plugin-react-native@5.0.0_patch_hash=1320a4c113a7f7ebb367bb0eaf377bd76dd7730f216_b81403553f777f68c7f42f6dd1713653/node_modules/eslint-plugin-react-native/lib/rules/no-raw-text.js
+var require_no_raw_text = __commonJS({
+  "../../node_modules/.pnpm/eslint-plugin-react-native@5.0.0_patch_hash=1320a4c113a7f7ebb367bb0eaf377bd76dd7730f216_b81403553f777f68c7f42f6dd1713653/node_modules/eslint-plugin-react-native/lib/rules/no-raw-text.js"(exports, module) {
+    init_esm_shims();
+    var elementName = (node2) => {
+      const reversedIdentifiers = [];
+      if (node2.type === "JSXElement" && node2.openingElement.type === "JSXOpeningElement") {
+        let object2 = node2.openingElement.name;
+        while (object2.type === "JSXMemberExpression") {
+          if (object2.property.type === "JSXIdentifier") {
+            reversedIdentifiers.push(object2.property.name);
+          }
+          object2 = object2.object;
+        }
+        if (object2.type === "JSXIdentifier") {
+          reversedIdentifiers.push(object2.name);
+        }
+      }
+      return reversedIdentifiers.reverse().join(".");
+    };
+    var hasAllowedParent = (parent, allowedElements) => {
+      let curNode = parent;
+      while (curNode) {
+        if (curNode.type === "JSXElement") {
+          const name3 = elementName(curNode);
+          if (allowedElements.includes(name3)) {
+            return true;
+          }
+        }
+        curNode = curNode.parent;
+      }
+      return false;
+    };
+    function create(context) {
+      const options = context.options[0] || {};
+      const report = (node2) => {
+        const errorValue = node2.type === "TemplateLiteral" ? `TemplateLiteral: ${node2.expressions[0].name}` : node2.value.trim();
+        const formattedErrorValue = errorValue.length > 0 ? `Raw text (${errorValue})` : "Whitespace(s)";
+        context.report({
+          node: node2,
+          message: `${formattedErrorValue} cannot be used outside of a <Text> tag`
+        });
+      };
+      const skippedElements = options.skip ? options.skip : [];
+      const allowedElements = ["Text", "TSpan", "StyledText", "Animated.Text"].concat(skippedElements);
+      const hasOnlyLineBreak = (value) => /^[\r\n\t\f\v]+$/.test(value.replace(/ /g, ""));
+      const getValidation = (node2) => !hasAllowedParent(node2.parent, allowedElements);
+      return {
+        Literal(node2) {
+          const parentType = node2.parent.type;
+          const onlyFor = ["JSXExpressionContainer", "JSXElement"];
+          if (typeof node2.value !== "string" || hasOnlyLineBreak(node2.value) || !onlyFor.includes(parentType) || node2.parent.parent && node2.parent.parent.type === "JSXAttribute") return;
+          const isStringLiteral = parentType === "JSXExpressionContainer";
+          if (getValidation(isStringLiteral ? node2.parent : node2)) {
+            report(node2);
+          }
+        },
+        JSXText(node2) {
+          if (typeof node2.value !== "string" || hasOnlyLineBreak(node2.value)) return;
+          if (getValidation(node2)) {
+            report(node2);
+          }
+        },
+        TemplateLiteral(node2) {
+          if (node2.parent.type !== "JSXExpressionContainer" || node2.parent.parent && node2.parent.parent.type === "JSXAttribute") return;
+          if (getValidation(node2.parent)) {
+            report(node2);
+          }
+        }
+      };
+    }
+    module.exports = {
+      meta: {
+        schema: [
+          {
+            type: "object",
+            properties: {
+              skip: {
+                type: "array",
+                items: {
+                  type: "string"
+                }
+              }
+            },
+            additionalProperties: false
+          }
+        ]
+      },
+      create
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/eslint-plugin-react-native@5.0.0_patch_hash=1320a4c113a7f7ebb367bb0eaf377bd76dd7730f216_b81403553f777f68c7f42f6dd1713653/node_modules/eslint-plugin-react-native/lib/rules/no-single-element-style-arrays.js
+var require_no_single_element_style_arrays = __commonJS({
+  "../../node_modules/.pnpm/eslint-plugin-react-native@5.0.0_patch_hash=1320a4c113a7f7ebb367bb0eaf377bd76dd7730f216_b81403553f777f68c7f42f6dd1713653/node_modules/eslint-plugin-react-native/lib/rules/no-single-element-style-arrays.js"(exports, module) {
+    init_esm_shims();
+    module.exports = {
+      meta: {
+        docs: {
+          description: "Disallow single element style arrays. These cause unnecessary re-renders as the identity of the array always changes",
+          category: "Stylistic Issues",
+          recommended: false,
+          url: ""
+        },
+        fixable: "code"
+      },
+      create(context) {
+        function reportNode(JSXExpressionNode) {
+          context.report({
+            node: JSXExpressionNode,
+            message: "Single element style arrays are not necessary and cause unnecessary re-renders",
+            fix(fixer) {
+              const realStyleNode = JSXExpressionNode.value.expression.elements[0];
+              const styleSource = (context.sourceCode ?? context.getSourceCode()).getText(realStyleNode);
+              return fixer.replaceText(JSXExpressionNode.value.expression, styleSource);
+            }
+          });
+        }
+        return {
+          JSXAttribute(node2) {
+            if (node2.name.name !== "style") return;
+            if (!node2.value.expression) return;
+            if (node2.value.expression.type !== "ArrayExpression") return;
+            if (node2.value.expression.elements.length === 1) {
+              reportNode(node2);
+            }
+          }
+        };
+      }
+    };
+  }
+});
+var require_eslint_plugin_react_native = __commonJS({
+  "../../node_modules/.pnpm/eslint-plugin-react-native@5.0.0_patch_hash=1320a4c113a7f7ebb367bb0eaf377bd76dd7730f216_b81403553f777f68c7f42f6dd1713653/node_modules/eslint-plugin-react-native/index.js"(exports, module) {
+    init_esm_shims();
+    var __import___lib_rules_noUnusedStyles = __toESM(require_no_unused_styles());
+    var __import___lib_rules_noInlineStyles = __toESM(require_no_inline_styles());
+    var __import___lib_rules_noColorLiterals = __toESM(require_no_color_literals());
+    var __import___lib_rules_sortStyles = __toESM(require_sort_styles());
+    var __import___lib_rules_splitPlatformComponents = __toESM(require_split_platform_components());
+    var __import___lib_rules_noRawText = __toESM(require_no_raw_text());
+    var __import___lib_rules_noSingleElementStyleArrays = __toESM(require_no_single_element_style_arrays());
+    var allRules = {
+      "no-unused-styles": __import___lib_rules_noUnusedStyles,
+      "no-inline-styles": __import___lib_rules_noInlineStyles,
+      "no-color-literals": __import___lib_rules_noColorLiterals,
+      "sort-styles": __import___lib_rules_sortStyles,
+      "split-platform-components": __import___lib_rules_splitPlatformComponents,
+      "no-raw-text": __import___lib_rules_noRawText,
+      "no-single-element-style-arrays": __import___lib_rules_noSingleElementStyleArrays
+    };
+    function configureAsError(rules5) {
+      const result = {};
+      for (const key in rules5) {
+        if (!rules5.hasOwnProperty(key)) {
+          continue;
+        }
+        result["react-native/" + key] = 2;
+      }
+      return result;
+    }
+    var allRulesConfig = configureAsError(allRules);
+    module.exports = {
+      deprecatedRules: {},
+      rules: allRules,
+      rulesConfig: {
+        "no-unused-styles": 0,
+        "no-inline-styles": 0,
+        "no-color-literals": 0,
+        "sort-styles": 0,
+        "split-platform-components": 0,
+        "no-raw-text": 0,
+        "no-single-element-style-arrays": 0
+      },
+      environments: {
+        "react-native": {
+          globals: __import_eslintPluginReactNativeGlobals.environments.all.globals
+        }
+      },
+      configs: {
+        all: {
+          plugins: [
+            "react-native"
+          ],
+          parserOptions: {
+            ecmaFeatures: {
+              jsx: true
+            }
+          },
+          rules: allRulesConfig
+        }
+      }
+    };
+  }
+});
+
 // ../../node_modules/.pnpm/eslint-plugin-tsdoc@0.4.0_patch_hash=11b9fbe0e91a2ce3492e80b89a7502a9ff364683b23b9bdfc2c979d988e1682b/node_modules/eslint-plugin-tsdoc/lib/Debug.js
 var require_Debug = __commonJS({
   "../../node_modules/.pnpm/eslint-plugin-tsdoc@0.4.0_patch_hash=11b9fbe0e91a2ce3492e80b89a7502a9ff364683b23b9bdfc2c979d988e1682b/node_modules/eslint-plugin-tsdoc/lib/Debug.js"(exports) {
@@ -416,7 +1646,7 @@ var require_lib = __commonJS({
     defaultTSDocConfiguration.allTsdocMessageIds.forEach((messageId) => {
       tsdocMessageIds[messageId] = `${messageId}: {{unformattedText}}`;
     });
-    var plugin6 = {
+    var plugin7 = {
       rules: {
         // NOTE: The actual ESLint rule name will be "tsdoc/syntax".  It is calculated by deleting "eslint-plugin-"
         // from the NPM package name, and then appending this string.
@@ -577,7 +1807,7 @@ Please ensure "@storm-software/tsdoc" is installed in the workspace root.`,
         }
       }
     };
-    module.exports = plugin6;
+    module.exports = plugin7;
   }
 });
 
@@ -5482,10 +6712,10 @@ init_esm_shims();
 // src/plugins.ts
 init_esm_shims();
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/index.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/index.js
 init_esm_shims();
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/config/electron.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/config/electron.js
 init_esm_shims();
 var electron_default = {
   settings: {
@@ -5493,7 +6723,7 @@ var electron_default = {
   }
 };
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/config/errors.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/config/errors.js
 init_esm_shims();
 var errors_default = {
   plugins: ["import-x"],
@@ -5506,7 +6736,7 @@ var errors_default = {
   }
 };
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/config/flat/electron.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/config/flat/electron.js
 init_esm_shims();
 var electron_default2 = {
   settings: {
@@ -5514,7 +6744,7 @@ var electron_default2 = {
   }
 };
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/config/flat/errors.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/config/flat/errors.js
 init_esm_shims();
 var errors_default2 = {
   rules: {
@@ -5526,7 +6756,7 @@ var errors_default2 = {
   }
 };
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/config/flat/react-native.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/config/flat/react-native.js
 init_esm_shims();
 var react_native_default = {
   settings: {
@@ -5538,7 +6768,7 @@ var react_native_default = {
   }
 };
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/config/flat/react.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/config/flat/react.js
 init_esm_shims();
 var react_default = {
   settings: {
@@ -5553,7 +6783,7 @@ var react_default = {
   }
 };
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/config/flat/recommended.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/config/flat/recommended.js
 init_esm_shims();
 var recommended_default2 = {
   rules: {
@@ -5568,7 +6798,7 @@ var recommended_default2 = {
   }
 };
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/config/flat/stage-0.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/config/flat/stage-0.js
 init_esm_shims();
 var stage_0_default = {
   rules: {
@@ -5576,7 +6806,7 @@ var stage_0_default = {
   }
 };
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/config/flat/typescript.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/config/flat/typescript.js
 init_esm_shims();
 var typeScriptExtensions = [".ts", ".tsx", ".cts", ".mts"];
 var allExtensions = [
@@ -5602,7 +6832,7 @@ var typescript_default = {
   }
 };
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/config/flat/warnings.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/config/flat/warnings.js
 init_esm_shims();
 var warnings_default = {
   rules: {
@@ -5613,7 +6843,7 @@ var warnings_default = {
   }
 };
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/config/react-native.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/config/react-native.js
 init_esm_shims();
 var react_native_default2 = {
   settings: {
@@ -5625,7 +6855,7 @@ var react_native_default2 = {
   }
 };
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/config/react.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/config/react.js
 init_esm_shims();
 var react_default2 = {
   settings: {
@@ -5638,7 +6868,7 @@ var react_default2 = {
   }
 };
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/config/recommended.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/config/recommended.js
 init_esm_shims();
 var recommended_default3 = {
   plugins: ["import-x"],
@@ -5658,7 +6888,7 @@ var recommended_default3 = {
   }
 };
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/config/stage-0.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/config/stage-0.js
 init_esm_shims();
 var stage_0_default2 = {
   plugins: ["import-x"],
@@ -5667,7 +6897,7 @@ var stage_0_default2 = {
   }
 };
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/config/typescript.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/config/typescript.js
 init_esm_shims();
 var typeScriptExtensions2 = [".ts", ".tsx", ".cts", ".mts"];
 var allExtensions2 = [
@@ -5693,7 +6923,7 @@ var typescript_default2 = {
   }
 };
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/config/warnings.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/config/warnings.js
 init_esm_shims();
 var warnings_default2 = {
   plugins: ["import-x"],
@@ -5705,19 +6935,19 @@ var warnings_default2 = {
   }
 };
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/meta.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/meta.js
 init_esm_shims();
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/require.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/require.js
 init_esm_shims();
 var importMetaUrl = import.meta.url;
 var cjsRequire = importMetaUrl ? createRequire(importMetaUrl) : __require;
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/meta.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/meta.js
 var { name, version: version2 } = cjsRequire("../package.json");
 var meta2 = { name, version: version2 };
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/node-resolver.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/node-resolver.js
 init_esm_shims();
 function createNodeResolver({ extensions = [".mjs", ".cjs", ".js", ".json", ".node"], conditionNames = ["import", "require", "default"], mainFields = ["module", "main"], ...restOptions } = {}) {
   const resolver = new ResolverFactory({
@@ -5745,16 +6975,16 @@ function createNodeResolver({ extensions = [".mjs", ".cjs", ".js", ".json", ".no
   };
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/consistent-type-specifier-style.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/consistent-type-specifier-style.js
 init_esm_shims();
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/index.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/index.js
 init_esm_shims();
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/apply-default.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/apply-default.js
 init_esm_shims();
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/deep-merge.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/deep-merge.js
 init_esm_shims();
 function isObjectNotArray(obj) {
   return typeof obj === "object" && obj != null && !Array.isArray(obj);
@@ -5778,7 +7008,7 @@ function deepMerge(first = {}, second = {}) {
   }));
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/apply-default.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/apply-default.js
 function applyDefault(defaultOptions, userOptions) {
   const options = structuredClone(defaultOptions ?? []);
   if (userOptions == null) {
@@ -5793,19 +7023,19 @@ function applyDefault(defaultOptions, userOptions) {
   return options;
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/arraify.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/arraify.js
 init_esm_shims();
 var arraify = (value) => value ? Array.isArray(value) ? value : [value] : void 0;
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/create-rule.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/create-rule.js
 init_esm_shims();
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/docs-url.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/docs-url.js
 init_esm_shims();
 var repoUrl = "https://github.com/un-ts/eslint-plugin-import-x";
 var docsUrl = (ruleName, commitish = `v${version2}`) => `${repoUrl}/blob/${commitish}/docs/rules/${ruleName}.md`;
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/create-rule.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/create-rule.js
 function RuleCreator2(urlCreator) {
   return function createNamedRule({ meta: meta3, name: name3, ...rule }) {
     return createRule_({
@@ -5832,7 +7062,7 @@ function createRule_({ create, defaultOptions, meta: meta3 }) {
 }
 var createRule2 = RuleCreator2(docsUrl);
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/declared-scope.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/declared-scope.js
 init_esm_shims();
 function declaredScope(context, node2, name3) {
   const references = context.sourceCode.getScope(node2).references;
@@ -5840,10 +7070,10 @@ function declaredScope(context, node2, name3) {
   return reference?.resolved?.scope.type;
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/export-map.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/export-map.js
 init_esm_shims();
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/get-value.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/get-value.js
 init_esm_shims();
 var getValue = (node2) => {
   switch (node2.type) {
@@ -5859,7 +7089,7 @@ var getValue = (node2) => {
   }
 };
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/ignore.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/ignore.js
 init_esm_shims();
 var log = debug("eslint-plugin-import-x:utils:ignore");
 var cachedSet;
@@ -5908,7 +7138,7 @@ function hasValidExtension(filepath, context) {
   return validExtensions(context).has(path16.extname(filepath));
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/lazy-value.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/lazy-value.js
 init_esm_shims();
 var lazy = (cb) => {
   let isCalled = false;
@@ -5942,10 +7172,10 @@ function defineLazyProperty(object2, propertyName, valueGetter) {
   return object2;
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/parse.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/parse.js
 init_esm_shims();
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/module-require.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/module-require.js
 init_esm_shims();
 function createModule(filename) {
   const mod = new Module(filename);
@@ -5971,7 +7201,7 @@ function moduleRequire(p, sourceFile) {
   return cjsRequire(p);
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/parse.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/parse.js
 function withoutProjectParserOptions(opts) {
   const { EXPERIMENTAL_useProjectService, project, projectService, ...rest } = opts;
   return rest;
@@ -6065,16 +7295,16 @@ function getParserOrPath(path23, context) {
   return null;
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/resolve.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/resolve.js
 init_esm_shims();
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/import-type.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/import-type.js
 init_esm_shims();
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/package-path.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/package-path.js
 init_esm_shims();
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/pkg-up.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/pkg-up.js
 init_esm_shims();
 function findUp(filename, cwd) {
   let dir = path16.resolve(cwd || "");
@@ -6095,7 +7325,7 @@ function pkgUp(opts) {
   return findUp("package.json", opts && opts.cwd);
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/read-pkg-up.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/read-pkg-up.js
 init_esm_shims();
 function stripBOM(str) {
   return str.replace(/^\uFEFF/, "");
@@ -6115,7 +7345,7 @@ function readPkgUp(opts) {
   }
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/package-path.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/package-path.js
 function getContextPackagePath(context) {
   return getFilePackagePath(context.physicalFilename);
 }
@@ -6130,7 +7360,7 @@ function getFilePackageName(filename) {
   return null;
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/import-type.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/import-type.js
 function baseModule(name3) {
   if (isScoped(name3)) {
     const [scope, pkg2] = name3.split("/");
@@ -6240,17 +7470,17 @@ function importType(name3, context) {
   return typeTest(name3, context, typeof name3 === "string" ? resolve(name3, context) : null);
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/legacy-resolver-settings.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/legacy-resolver-settings.js
 init_esm_shims();
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/pkg-dir.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/pkg-dir.js
 init_esm_shims();
 function pkgDir(cwd) {
   const fp = pkgUp({ cwd });
   return fp ? path16.dirname(fp) : null;
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/legacy-resolver-settings.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/legacy-resolver-settings.js
 function resolveWithLegacyResolver(resolver, config5, modulePath, sourceFile) {
   if (resolver.interfaceVersion === 2) {
     return resolver.resolve(modulePath, sourceFile, config5);
@@ -6370,7 +7600,7 @@ function getBaseDir(sourceFile) {
   return pkgDir(sourceFile) || process.cwd();
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/module-cache.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/module-cache.js
 init_esm_shims();
 var log3 = debug("eslint-plugin-import-x:utils:ModuleCache");
 var ModuleCache = class {
@@ -6407,7 +7637,7 @@ var ModuleCache = class {
   }
 };
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/resolve.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/resolve.js
 var importMetaUrl2 = import.meta.url;
 var _filename = importMetaUrl2 ? fileURLToPath(importMetaUrl2) : __filename$1;
 var _dirname = path16.dirname(_filename);
@@ -6619,7 +7849,7 @@ function importXResolverCompat(resolver, resolverOptions = {}) {
   };
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/unambiguous.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/unambiguous.js
 init_esm_shims();
 var pattern = /(^|;)\s*(export|import)((\s+\w)|(\s*[*={]))|import\(/m;
 function isMaybeUnambiguousModule(content) {
@@ -6630,7 +7860,7 @@ function isUnambiguousModule(ast) {
   return ast.body && ast.body.some((node2) => unambiguousNodeType.test(node2.type));
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/visit.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/visit.js
 init_esm_shims();
 function visit(node2, keys, visitorSpec) {
   if (!node2 || !keys) {
@@ -6659,7 +7889,7 @@ function visit(node2, keys, visitorSpec) {
   }
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/export-map.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/export-map.js
 var log4 = debug("eslint-plugin-import-x:ExportMap");
 var exportCache = /* @__PURE__ */ new Map();
 var declTypes = /* @__PURE__ */ new Set([
@@ -7345,7 +8575,7 @@ function makeContextCacheKey(context) {
   return hash;
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/import-declaration.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/import-declaration.js
 init_esm_shims();
 var importDeclaration = (context, node2) => {
   if (node2.parent && node2.parent.type === AST_NODE_TYPES.ImportDeclaration) {
@@ -7355,7 +8585,7 @@ var importDeclaration = (context, node2) => {
   return ancestors[ancestors.length - 1];
 };
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/module-visitor.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/module-visitor.js
 init_esm_shims();
 function moduleVisitor(visitor, options) {
   const ignore2 = options?.ignore;
@@ -7498,7 +8728,7 @@ function makeOptionsSchema(additionalProperties) {
 }
 makeOptionsSchema();
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/npm-client.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/npm-client.js
 init_esm_shims();
 var NPM = "npm";
 var NPM_CLIENTS = /* @__PURE__ */ new Set([
@@ -7519,7 +8749,7 @@ var getNpmClient = () => {
 };
 var getNpmInstallCommand = (packageName) => `${getNpmClient()} ${npmClient === NPM ? "i" : "add"} ${npmClient === "deno" ? `${NPM}:` : ""}${packageName}`;
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/parse-path.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/parse-path.js
 init_esm_shims();
 var parsePath = (path23) => {
   const hashIndex = path23.indexOf("#");
@@ -7533,7 +8763,7 @@ var parsePath = (path23) => {
 };
 var stringifyPath = ({ pathname, query, hash }) => pathname + query + hash;
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/source-type.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/source-type.js
 init_esm_shims();
 function sourceType(context) {
   if ("languageOptions" in context && context.languageOptions) {
@@ -7549,13 +8779,13 @@ function sourceType(context) {
   }
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/utils/static-require.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/utils/static-require.js
 init_esm_shims();
 function isStaticRequire(node2) {
   return node2 && node2.callee && node2.callee.type === "Identifier" && node2.callee.name === "require" && node2.arguments.length === 1 && node2.arguments[0].type === "Literal" && typeof node2.arguments[0].value === "string";
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/consistent-type-specifier-style.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/consistent-type-specifier-style.js
 function isComma(token) {
   return token.type === "Punctuator" && token.value === ",";
 }
@@ -7721,7 +8951,7 @@ ${newImports}`)
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/default.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/default.js
 init_esm_shims();
 var default_default = createRule2({
   name: "default",
@@ -7766,7 +8996,7 @@ var default_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/dynamic-import-chunkname.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/dynamic-import-chunkname.js
 init_esm_shims();
 var dynamic_import_chunkname_default = createRule2({
   name: "dynamic-import-chunkname",
@@ -7937,7 +9167,7 @@ var dynamic_import_chunkname_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/export.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/export.js
 init_esm_shims();
 var rootProgram = "root";
 var tsTypePrefix = "type:";
@@ -8090,7 +9320,7 @@ var export_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/exports-last.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/exports-last.js
 init_esm_shims();
 var findLastIndex = (array2, predicate) => {
   let i = array2.length - 1;
@@ -8138,7 +9368,7 @@ var exports_last_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/extensions.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/extensions.js
 init_esm_shims();
 
 // ../../node_modules/.pnpm/minimatch@10.2.5/node_modules/minimatch/dist/esm/index.js
@@ -9740,7 +10970,7 @@ minimatch.Minimatch = Minimatch;
 minimatch.escape = escape;
 minimatch.unescape = unescape;
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/extensions.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/extensions.js
 var modifierValues = ["always", "ignorePackages", "never"];
 var modifierSchema = {
   type: "string",
@@ -10022,7 +11252,7 @@ var extensions_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/first.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/first.js
 init_esm_shims();
 function getImportValue(node2) {
   return node2.type === "ImportDeclaration" ? node2.source.value : "moduleReference" in node2 && "expression" in node2.moduleReference && "value" in node2.moduleReference.expression && node2.moduleReference.expression.value;
@@ -10157,7 +11387,7 @@ ${nodeSourceCode}`;
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/group-exports.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/group-exports.js
 init_esm_shims();
 function accessorChain(node2) {
   const chain = [];
@@ -10272,7 +11502,7 @@ var group_exports_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/imports-first.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/imports-first.js
 init_esm_shims();
 var imports_first_default = createRule2({
   ...first_default,
@@ -10297,7 +11527,7 @@ var imports_first_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/max-dependencies.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/max-dependencies.js
 init_esm_shims();
 var max_dependencies_default = createRule2({
   name: "max-dependencies",
@@ -10350,7 +11580,7 @@ var max_dependencies_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/named.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/named.js
 init_esm_shims();
 var named_default = createRule2({
   name: "named",
@@ -10476,7 +11706,7 @@ var named_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/namespace.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/namespace.js
 init_esm_shims();
 function processBodyStatement(context, namespaces, declaration) {
   if (declaration.type !== "ImportDeclaration") {
@@ -10704,7 +11934,7 @@ var namespace_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/newline-after-import.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/newline-after-import.js
 init_esm_shims();
 var log5 = debug("eslint-plugin-import-x:rules:newline-after-import");
 function containsNodeOrEqual(outerNode, innerNode) {
@@ -10906,7 +12136,7 @@ var newline_after_import_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-absolute-path.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-absolute-path.js
 init_esm_shims();
 var no_absolute_path_default = createRule2({
   name: "no-absolute-path",
@@ -10944,7 +12174,7 @@ var no_absolute_path_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-amd.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-amd.js
 init_esm_shims();
 var no_amd_default = createRule2({
   name: "no-amd",
@@ -10991,7 +12221,7 @@ var no_amd_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-anonymous-default-export.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-anonymous-default-export.js
 init_esm_shims();
 var { hasOwnProperty } = Object.prototype;
 var hasOwn = (object2, key) => hasOwnProperty.call(object2, key);
@@ -11125,7 +12355,7 @@ var no_anonymous_default_export_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-commonjs.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-commonjs.js
 init_esm_shims();
 function normalizeLegacyOptions(options) {
   if (options.includes("allow-primitive-modules")) {
@@ -11248,7 +12478,7 @@ var no_commonjs_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-cycle.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-cycle.js
 init_esm_shims();
 var traversed = /* @__PURE__ */ new Set();
 var no_cycle_default = createRule2({
@@ -11377,7 +12607,7 @@ function routeString(route) {
   return route.map((s) => `${s.value}:${s.loc.start.line}`).join("=>");
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-default-export.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-default-export.js
 init_esm_shims();
 var no_default_export_default = createRule2({
   name: "no-default-export",
@@ -11433,7 +12663,7 @@ var no_default_export_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-deprecated.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-deprecated.js
 init_esm_shims();
 function message(deprecation) {
   if (deprecation.description) {
@@ -11591,7 +12821,7 @@ var no_deprecated_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-duplicates.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-duplicates.js
 init_esm_shims();
 var isTypeScriptVersionSupportPreferInline = lazy(() => {
   let typescriptPkg;
@@ -11864,7 +13094,7 @@ var no_duplicates_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-dynamic-require.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-dynamic-require.js
 init_esm_shims();
 function isRequire(node2) {
   return node2.callee?.type === "Identifier" && node2.callee.name === "require" && node2.arguments.length > 0;
@@ -11933,7 +13163,7 @@ var no_dynamic_require_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-empty-named-blocks.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-empty-named-blocks.js
 init_esm_shims();
 function getEmptyBlockRange(tokens, index) {
   const token = tokens[index];
@@ -12031,7 +13261,7 @@ var no_empty_named_blocks_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-extraneous-dependencies.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-extraneous-dependencies.js
 init_esm_shims();
 var depFieldCache = /* @__PURE__ */ new Map();
 var minimatch2 = minimatch;
@@ -12277,7 +13507,7 @@ var no_extraneous_dependencies_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-import-module-exports.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-import-module-exports.js
 init_esm_shims();
 function getEntryPoint(context) {
   const pkgPath = pkgUp({
@@ -12359,7 +13589,7 @@ var no_import_module_exports_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-internal-modules.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-internal-modules.js
 init_esm_shims();
 function normalizeSep(somePath) {
   return somePath.split("\\").join("/");
@@ -12476,7 +13706,7 @@ var no_internal_modules_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-mutable-exports.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-mutable-exports.js
 init_esm_shims();
 var no_mutable_exports_default = createRule2({
   name: "no-mutable-exports",
@@ -12536,7 +13766,7 @@ var no_mutable_exports_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-named-as-default-member.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-named-as-default-member.js
 init_esm_shims();
 var no_named_as_default_member_default = createRule2({
   name: "no-named-as-default-member",
@@ -12623,7 +13853,7 @@ var no_named_as_default_member_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-named-as-default.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-named-as-default.js
 init_esm_shims();
 var no_named_as_default_default = createRule2({
   name: "no-named-as-default",
@@ -12679,7 +13909,7 @@ var no_named_as_default_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-named-default.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-named-default.js
 init_esm_shims();
 var no_named_default_default = createRule2({
   name: "no-named-default",
@@ -12717,7 +13947,7 @@ var no_named_default_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-named-export.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-named-export.js
 init_esm_shims();
 var no_named_export_default = createRule2({
   name: "no-named-export",
@@ -12754,7 +13984,7 @@ var no_named_export_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-namespace.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-namespace.js
 init_esm_shims();
 var no_namespace_default = createRule2({
   name: "no-namespace",
@@ -12877,7 +14107,7 @@ function generateLocalNames(names, nameConflicts, namespaceName) {
   return localNames;
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-nodejs-modules.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-nodejs-modules.js
 init_esm_shims();
 var no_nodejs_modules_default = createRule2({
   name: "no-nodejs-modules",
@@ -12925,7 +14155,7 @@ var no_nodejs_modules_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-relative-packages.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-relative-packages.js
 init_esm_shims();
 function toPosixPath(filePath) {
   return filePath.replaceAll("\\", "/");
@@ -12985,7 +14215,7 @@ var no_relative_packages_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-relative-parent-imports.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-relative-parent-imports.js
 init_esm_shims();
 var no_relative_parent_imports_default = createRule2({
   name: "no-relative-parent-imports",
@@ -13030,7 +14260,7 @@ var no_relative_parent_imports_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-rename-default.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-rename-default.js
 init_esm_shims();
 var no_rename_default_default = createRule2({
   name: "no-rename-default",
@@ -13270,7 +14500,7 @@ function getDefaultExportNode(exportMap) {
   }
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-restricted-paths.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-restricted-paths.js
 init_esm_shims();
 var containsPath = (filepath, target) => {
   const relative2 = path16.relative(target, filepath);
@@ -13471,7 +14701,7 @@ var no_restricted_paths_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-self-import.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-self-import.js
 init_esm_shims();
 function isImportingSelf(context, node2, requireName) {
   const filename = context.physicalFilename;
@@ -13504,7 +14734,7 @@ var no_self_import_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-unassigned-import.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-unassigned-import.js
 init_esm_shims();
 function testIsAllow(globs, context, source) {
   if (!Array.isArray(globs)) {
@@ -13574,7 +14804,7 @@ var no_unassigned_import_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-unresolved.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-unresolved.js
 init_esm_shims();
 var no_unresolved_default = createRule2({
   name: "no-unresolved",
@@ -13629,7 +14859,7 @@ var no_unresolved_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-unused-modules.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-unused-modules.js
 init_esm_shims();
 function isESLint9UnsupportedApi(input) {
   return typeof input === "object" && input !== null && "shouldUseFlatConfig" in input && "FileEnumerator" in eslintUnsupportedApi;
@@ -14365,7 +15595,7 @@ In the meantime, if you want to keep this rule enabled, you can suppress this wa
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-useless-path-segments.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-useless-path-segments.js
 init_esm_shims();
 function toRelativePath(relativePath) {
   const stripped = relativePath.replaceAll(/\/$/g, "");
@@ -14462,7 +15692,7 @@ var no_useless_path_segments_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/no-webpack-loader-syntax.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/no-webpack-loader-syntax.js
 init_esm_shims();
 var no_webpack_loader_syntax_default = createRule2({
   name: "no-webpack-loader-syntax",
@@ -14493,7 +15723,7 @@ var no_webpack_loader_syntax_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/order.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/order.js
 init_esm_shims();
 var log6 = debug("eslint-plugin-import-x:rules:order");
 var groupBy = (array2, grouper) => array2.reduce((acc, curr, index) => {
@@ -15538,7 +16768,7 @@ var order_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/prefer-default-export.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/prefer-default-export.js
 init_esm_shims();
 var prefer_default_export_default = createRule2({
   name: "prefer-default-export",
@@ -15644,7 +16874,7 @@ var prefer_default_export_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/prefer-namespace-import.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/prefer-namespace-import.js
 init_esm_shims();
 var prefer_namespace_import_default = createRule2({
   name: "prefer-namespace-import",
@@ -15726,7 +16956,7 @@ function toRegExp(string3) {
   return { test: (s) => s === string3 };
 }
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/rules/unambiguous.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/rules/unambiguous.js
 init_esm_shims();
 var unambiguous_default = createRule2({
   name: "unambiguous",
@@ -15759,7 +16989,7 @@ var unambiguous_default = createRule2({
   }
 });
 
-// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_b95cb6c19f81be476d27f00e3e92b785/node_modules/eslint-plugin-import-x/lib/index.js
+// ../../node_modules/.pnpm/eslint-plugin-import-x@4.16.2_patch_hash=2fde63e367ada6ae348459ff5a2b0bbc53a12189dad6a5_edb58aa0c4b578b161dc981f01ae0870/node_modules/eslint-plugin-import-x/lib/index.js
 var rules2 = {
   "no-unresolved": no_unresolved_default,
   named: named_default,
@@ -17364,7 +18594,7 @@ init_esm_shims();
 // ../eslint-plugin-pnpm/src/plugin.ts
 init_esm_shims();
 
-// ../../node_modules/.pnpm/eslint-plugin-pnpm@0.3.0_patch_hash=72dcde755c336eeca3e6170de1106fd85ecb66171e060788f80_9a83dbe288d598de72c3e754ec4675de/node_modules/eslint-plugin-pnpm/dist/index.mjs
+// ../../node_modules/.pnpm/eslint-plugin-pnpm@0.3.0_patch_hash=72dcde755c336eeca3e6170de1106fd85ecb66171e060788f80_f3795df961f0ced0a2358dd7bcde797b/node_modules/eslint-plugin-pnpm/dist/index.mjs
 init_esm_shims();
 var name2 = "eslint-plugin-pnpm";
 var version3 = "0.3.0";
@@ -18245,6 +19475,31 @@ var ReactRouterPackages = [
   "@react-router/serve",
   "@react-router/dev"
 ];
+function renameRules2(config5) {
+  const renamedRules = {};
+  for (const [ruleName, ruleConfig] of Object.entries(config5.rules || {})) {
+    if (ruleName.startsWith("@eslint-react/dom-")) {
+      renamedRules[`react-dom/${ruleName.slice("@eslint-react/dom-".length)}`] = ruleConfig;
+    } else if (ruleName.startsWith("@eslint-react/web-api-")) {
+      renamedRules[`react-web-api/${ruleName.slice("@eslint-react/web-api-".length)}`] = ruleConfig;
+    } else if (ruleName.startsWith("@eslint-react/jsx-")) {
+      renamedRules[`react-jsx/${ruleName.slice("@eslint-react/jsx-".length)}`] = ruleConfig;
+    } else if (ruleName.startsWith("@eslint-react/rsc-")) {
+      renamedRules[`react-rsc/${ruleName.slice("@eslint-react/rsc-".length)}`] = ruleConfig;
+    } else if (ruleName.startsWith("@eslint-react/naming-convention-")) {
+      renamedRules[`react-naming-convention/${ruleName.slice(
+        "@eslint-react/naming-convention-".length
+      )}`] = ruleConfig;
+    } else if (ruleName.startsWith("@eslint-react/x-")) {
+      renamedRules[`react-x/${ruleName.slice("@eslint-react/x-".length)}`] = ruleConfig;
+    } else if (ruleName.startsWith("@eslint-react/")) {
+      renamedRules[`react/${ruleName.slice("@eslint-react/".length)}`] = ruleConfig;
+    } else {
+      renamedRules[ruleName] = ruleConfig;
+    }
+  }
+  return renamedRules;
+}
 async function react(options = {}) {
   const {
     files = [GLOB_SRC],
@@ -18257,22 +19512,36 @@ async function react(options = {}) {
     "@eslint-react/eslint-plugin",
     "eslint-plugin-react-hooks",
     "eslint-plugin-react-refresh",
-    "eslint-plugin-react-compiler"
+    "eslint-plugin-react-compiler",
+    "eslint-plugin-react-dom",
+    "eslint-plugin-react-jsx",
+    "eslint-plugin-react-naming-convention",
+    "eslint-plugin-react-rsc",
+    "eslint-plugin-react-web-api",
+    "eslint-plugin-react-x"
   ]);
-  const isTypeAware = !!tsconfigPath;
-  const typeAwareRules = {
-    "react/no-leaked-conditional-rendering": "warn"
-  };
   const [
     pluginReact,
     pluginReactHooks,
     pluginReactRefresh,
-    pluginReactCompiler
+    pluginReactCompiler,
+    pluginReactDom,
+    pluginReactJsx,
+    pluginReactNamingConvention,
+    pluginReactRsc,
+    pluginReactWebApi,
+    pluginReactX
   ] = await Promise.all([
     interopDefault(import('@eslint-react/eslint-plugin')),
     interopDefault(import('eslint-plugin-react-hooks')),
     interopDefault(import('eslint-plugin-react-refresh')),
-    interopDefault(import('eslint-plugin-react-compiler'))
+    interopDefault(import('eslint-plugin-react-compiler')),
+    interopDefault(import('eslint-plugin-react-dom')),
+    interopDefault(import('eslint-plugin-react-jsx')),
+    interopDefault(import('eslint-plugin-react-naming-convention')),
+    interopDefault(import('eslint-plugin-react-rsc')),
+    interopDefault(import('eslint-plugin-react-web-api')),
+    interopDefault(import('eslint-plugin-react-x'))
   ]);
   const isAllowConstantExport = ReactRefreshAllowConstantExportPackages.some(
     (i) => isPackageExists(i)
@@ -18280,13 +19549,19 @@ async function react(options = {}) {
   const isUsingReactRouter = ReactRouterPackages.some((i) => isPackageExists(i));
   return [
     pluginReactHooks.configs.flat["recommended-latest"],
-    isTypeAware ? pluginReact.configs["recommended-type-checked"] : pluginReact.configs["recommended"],
     {
       name: "storm/react/setup",
       plugins: {
         "react-hooks": pluginReactHooks,
         "react-refresh": pluginReactRefresh,
-        "react-compiler": pluginReactCompiler
+        "react-compiler": pluginReactCompiler,
+        react: pluginReact,
+        "react-dom": pluginReactDom,
+        "react-jsx": pluginReactJsx,
+        "react-naming-convention": pluginReactNamingConvention,
+        "react-rsc": pluginReactRsc,
+        "react-web-api": pluginReactWebApi,
+        "react-x": pluginReactX
       }
     },
     {
@@ -18301,22 +19576,11 @@ async function react(options = {}) {
       },
       name: "storm/react/rules",
       rules: {
-        // recommended rules from @eslint-react/dom
-        "@eslint-react/dom-no-void-elements-with-children": "warn",
-        "@eslint-react/dom-no-dangerously-set-innerhtml": "warn",
-        "@eslint-react/dom-no-dangerously-set-innerhtml-with-children": "error",
-        "@eslint-react/dom-no-find-dom-node": "error",
-        "@eslint-react/dom-no-missing-button-type": "warn",
-        "@eslint-react/dom-no-missing-iframe-sandbox": "warn",
-        "@eslint-react/dom-no-namespace": "error",
-        "@eslint-react/dom-no-render-return-value": "error",
-        "@eslint-react/dom-no-script-url": "warn",
-        "@eslint-react/dom-no-unsafe-iframe-sandbox": "warn",
-        "@eslint-react/dom-no-unsafe-target-blank": "warn",
-        // recommended rules react-hooks
+        ...renameRules2(
+          !!tsconfigPath ? pluginReact.configs["recommended-type-checked"] : pluginReact.configs["recommended"]
+        ),
         "react-hooks/exhaustive-deps": "warn",
         "react-hooks/rules-of-hooks": "error",
-        // react refresh
         "react-refresh/only-export-components": [
           "warn",
           {
@@ -18340,66 +19604,71 @@ async function react(options = {}) {
             )
           }
         ],
-        // recommended rules from @eslint-react/web-api
-        "@eslint-react/web-api-no-leaked-event-listener": "warn",
-        "@eslint-react/web-api-no-leaked-interval": "warn",
-        "@eslint-react/web-api-no-leaked-resize-observer": "warn",
-        "@eslint-react/web-api-no-leaked-timeout": "warn",
-        // recommended rules from @eslint-react
-        "@eslint-react/error-boundaries": "error",
-        "@eslint-react/ensure-forward-ref-using-ref": "warn",
-        "@eslint-react/jsx-no-duplicate-props": "warn",
-        "@eslint-react/jsx-uses-vars": "warn",
-        "@eslint-react/no-access-state-in-setstate": "error",
-        "@eslint-react/no-array-index-key": "warn",
-        "@eslint-react/no-children-count": "warn",
-        "@eslint-react/no-children-for-each": "warn",
-        "@eslint-react/no-children-map": "warn",
-        "@eslint-react/no-children-only": "warn",
-        "@eslint-react/no-children-to-array": "warn",
-        "@eslint-react/no-clone-element": "warn",
-        "@eslint-react/no-comment-textnodes": "warn",
-        "@eslint-react/no-component-will-mount": "error",
-        "@eslint-react/no-component-will-receive-props": "error",
-        "@eslint-react/no-component-will-update": "error",
-        "@eslint-react/no-context-provider": "warn",
-        "@eslint-react/no-create-ref": "error",
-        "@eslint-react/no-default-props": "error",
-        "@eslint-react/no-direct-mutation-state": "error",
-        "@eslint-react/no-duplicate-key": "error",
-        "@eslint-react/no-forward-ref": "warn",
-        "@eslint-react/no-implicit-key": "warn",
-        "@eslint-react/no-missing-key": "error",
-        "@eslint-react/no-nested-components": "error",
-        "@eslint-react/no-prop-types": "error",
-        "@eslint-react/no-redundant-should-component-update": "error",
-        "@eslint-react/no-set-state-in-component-did-mount": "warn",
-        "@eslint-react/no-set-state-in-component-did-update": "warn",
-        "@eslint-react/no-set-state-in-component-will-update": "warn",
-        "@eslint-react/no-string-refs": "error",
-        "@eslint-react/no-unsafe-component-will-mount": "warn",
-        "@eslint-react/no-unsafe-component-will-receive-props": "warn",
-        "@eslint-react/no-unsafe-component-will-update": "warn",
-        "@eslint-react/no-unstable-context-value": "warn",
-        "@eslint-react/no-unstable-default-props": "warn",
-        "@eslint-react/no-unused-class-component-members": "warn",
-        "@eslint-react/no-unused-state": "warn",
-        "@eslint-react/prefer-destructuring-assignment": "warn",
-        "@eslint-react/prefer-shorthand-boolean": "warn",
-        "@eslint-react/prefer-shorthand-fragment": "warn",
-        // recommended rules from eslint-plugin-react-compiler
         "react-compiler/react-compiler": "error",
-        // overrides
+        "react-dom/no-void-elements-with-children": "warn",
+        "react-dom/no-dangerously-set-innerhtml": "warn",
+        "react-dom/no-dangerously-set-innerhtml-with-children": "error",
+        "react-dom/no-find-dom-node": "error",
+        "react-dom/no-missing-button-type": "warn",
+        "react-dom/no-missing-iframe-sandbox": "warn",
+        "react-dom/no-namespace": "error",
+        "react-dom/no-render-return-value": "error",
+        "react-dom/no-script-url": "warn",
+        "react-dom/no-unsafe-iframe-sandbox": "warn",
+        "react-dom/no-unsafe-target-blank": "warn",
+        "react-web-api/no-leaked-event-listener": "warn",
+        "react-web-api/no-leaked-interval": "warn",
+        "react-web-api/no-leaked-resize-observer": "warn",
+        "react-web-api/no-leaked-timeout": "warn",
+        "react-x/error-boundaries": "error",
+        "react/ensure-forward-ref-using-ref": "warn",
+        "react/no-access-state-in-setstate": "error",
+        "react/no-array-index-key": "warn",
+        "react/no-children-count": "warn",
+        "react/no-children-for-each": "warn",
+        "react/no-children-map": "warn",
+        "react/no-children-only": "warn",
+        "react/no-children-to-array": "warn",
+        "react/no-clone-element": "warn",
+        "react/no-comment-textnodes": "warn",
+        "react/no-component-will-mount": "error",
+        "react/no-component-will-receive-props": "error",
+        "react/no-component-will-update": "error",
+        "react/no-context-provider": "warn",
+        "react/no-create-ref": "error",
+        "react/no-default-props": "error",
+        "react/no-direct-mutation-state": "error",
+        "react/no-duplicate-key": "error",
+        "react/no-forward-ref": "warn",
+        "react/no-implicit-key": "warn",
+        "react/no-missing-key": "error",
+        "react/no-nested-components": "error",
+        "react/no-prop-types": "error",
+        "react/no-redundant-should-component-update": "error",
+        "react/no-set-state-in-component-did-mount": "warn",
+        "react/no-set-state-in-component-did-update": "warn",
+        "react/no-set-state-in-component-will-update": "warn",
+        "react/no-string-refs": "error",
+        "react/no-unsafe-component-will-mount": "warn",
+        "react/no-unsafe-component-will-receive-props": "warn",
+        "react/no-unsafe-component-will-update": "warn",
+        "react/no-unstable-context-value": "warn",
+        "react/no-unstable-default-props": "warn",
+        "react/no-unused-class-component-members": "warn",
+        "react/no-unused-state": "warn",
+        "react/prefer-destructuring-assignment": "warn",
+        "react/prefer-shorthand-boolean": "warn",
+        "react/prefer-shorthand-fragment": "warn",
         ...overrides
       }
     },
-    ...isTypeAware ? [
+    ...!!tsconfigPath ? [
       {
         files: filesTypeAware,
         ignores: ignoresTypeAware,
         name: "storm/react/type-aware-rules",
         rules: {
-          ...typeAwareRules
+          "react/no-leaked-conditional-rendering": "warn"
         }
       }
     ] : []
@@ -18408,19 +19677,15 @@ async function react(options = {}) {
 
 // src/configs/react-native.ts
 init_esm_shims();
+var import_eslint_plugin_react_native = __toESM(require_eslint_plugin_react_native(), 1);
 async function reactNative(options = {}) {
   const { overrides = {} } = options;
-  await ensurePackages(["eslint-plugin-react-native"]);
-  const reactNative2 = await interopDefault(
-    // eslint-disable-next-line @nx/enforce-module-boundaries
-    import('eslint-plugin-react-native')
-  );
   return [
     {
       name: "storm/react-native/rules",
-      plugins: { "react-native": reactNative2 },
+      plugins: { "react-native": import_eslint_plugin_react_native.default },
       rules: {
-        ...reactNative2.configs.all.rules,
+        ...import_eslint_plugin_react_native.default.configs.all.rules,
         ...overrides
       }
     }
@@ -18766,10 +20031,10 @@ async function storybook(options = {}) {
 
 // src/configs/test.ts
 init_esm_shims();
-var plugin5;
+var plugin6;
 async function test(options = {}) {
   const { files = GLOB_TESTS, isInEditor = false, overrides = {} } = options;
-  plugin5 = plugin5 || {
+  plugin6 = plugin6 || {
     ...default4,
     rules: {
       ...default4.rules,
@@ -18781,7 +20046,7 @@ async function test(options = {}) {
     {
       name: "storm/test/setup",
       plugins: {
-        test: plugin5
+        test: plugin6
       }
     },
     {