@exbotanical/eslint-config 1.1.2 → 1.1.3

package/dist/index.js

@@ -1,6 +1,794 @@
-import {
-  init_esm_shims
-} from "./chunk-6GNDNAEM.js";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/tsup/assets/esm_shims.js
+import { fileURLToPath } from "url";
+import path from "path";
+var getFilename, getDirname, __dirname;
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+    getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path.dirname(getFilename());
+    __dirname = /* @__PURE__ */ getDirname();
+  }
+});
+
+// node_modules/eslint-plugin-cypress/package.json
+var require_package = __commonJS({
+  "node_modules/eslint-plugin-cypress/package.json"(exports, module) {
+    module.exports = {
+      name: "eslint-plugin-cypress",
+      version: "4.2.0",
+      description: "An ESLint plugin for projects using Cypress",
+      main: "legacy.js",
+      exports: {
+        ".": "./legacy.js",
+        "./flat": "./lib/flat.js"
+      },
+      author: "Cypress-io",
+      license: "MIT",
+      keywords: [
+        "eslint",
+        "eslintplugin",
+        "cypress"
+      ],
+      repository: {
+        type: "git",
+        url: "git+https://github.com/cypress-io/eslint-plugin-cypress.git"
+      },
+      bugs: {
+        url: "https://github.com/cypress-io/eslint-plugin-cypress/issues"
+      },
+      homepage: "https://github.com/cypress-io/eslint-plugin-cypress#readme",
+      peerDependencies: {
+        eslint: ">=9"
+      },
+      dependencies: {
+        globals: "^15.11.0"
+      },
+      devDependencies: {
+        eslint: "^9.13.0",
+        "eslint-plugin-eslint-plugin": "^6.3.1",
+        "eslint-plugin-mocha": "^10.5.0",
+        husky: "^9.1.6",
+        jest: "^29.7.0",
+        "semantic-release": "24.2.0"
+      },
+      scripts: {
+        lint: 'eslint "*.js" "**/**/*.js"',
+        "lint-fix": "npm run lint -- --fix",
+        "semantic-release": "semantic-release",
+        start: "npm run test-watch",
+        test: "jest",
+        "test:legacy": "jest --config jest.config-legacy.js",
+        "test-watch": "jest --watchAll",
+        prepare: "husky"
+      }
+    };
+  }
+});
+
+// node_modules/eslint-plugin-cypress/lib/rules/no-assigning-return-values.js
+var require_no_assigning_return_values = __commonJS({
+  "node_modules/eslint-plugin-cypress/lib/rules/no-assigning-return-values.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    function get(obj, propertyString = "") {
+      const properties = propertyString.split(".");
+      for (let i = 0; i < properties.length; i++) {
+        const value = (obj || {})[properties[i]];
+        if (value == null) return value;
+        obj = value;
+      }
+      return obj;
+    }
+    module.exports = {
+      meta: {
+        type: "problem",
+        docs: {
+          description: "disallow assigning return values of `cy` calls",
+          category: "Possible Errors",
+          recommended: true,
+          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-assigning-return-values.md"
+        },
+        schema: [],
+        messages: {
+          unexpected: "Do not assign the return value of a Cypress command"
+        }
+      },
+      create(context) {
+        return {
+          VariableDeclaration(node2) {
+            if (node2.declarations.some(isCypressCommandDeclaration)) {
+              context.report({ node: node2, messageId: "unexpected" });
+            }
+          }
+        };
+      }
+    };
+    var allowedCommands = {
+      now: true,
+      spy: true,
+      state: true,
+      stub: true
+    };
+    function isCypressCommandDeclaration(declarator) {
+      let object = get(declarator, "init.callee.object");
+      if (!object) return;
+      while (object.callee) {
+        object = object.callee.object;
+        if (!object) return;
+      }
+      const commandName = get(declarator, "init.callee.property.name");
+      const parent = get(object, "parent.property.name") || get(declarator, "id.name");
+      if (commandName && (allowedCommands[commandName] || allowedCommands[parent])) return;
+      return object.name === "cy";
+    }
+  }
+});
+
+// node_modules/eslint-plugin-cypress/lib/rules/unsafe-to-chain-command.js
+var require_unsafe_to_chain_command = __commonJS({
+  "node_modules/eslint-plugin-cypress/lib/rules/unsafe-to-chain-command.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    var { basename } = __require("path");
+    var NAME = basename(__dirname);
+    var DESCRIPTION = "disallow actions within chains";
+    var unsafeToChainActions = [
+      "blur",
+      "clear",
+      "click",
+      "check",
+      "dblclick",
+      "each",
+      "focus",
+      "rightclick",
+      "screenshot",
+      "scrollIntoView",
+      "scrollTo",
+      "select",
+      "selectFile",
+      "spread",
+      "submit",
+      "type",
+      "trigger",
+      "uncheck",
+      "within"
+    ];
+    var schema = {
+      title: NAME,
+      description: DESCRIPTION,
+      type: "object",
+      properties: {
+        methods: {
+          type: "array",
+          description: "An additional list of methods to check for unsafe chaining.",
+          default: []
+        }
+      }
+    };
+    var getDefaultOptions = (context) => {
+      return Object.entries(schema.properties).reduce((acc, [key, value]) => {
+        if (!(value.default in value)) return acc;
+        return {
+          ...acc,
+          [key]: value.default
+        };
+      }, context.options[0] || {});
+    };
+    module.exports = {
+      meta: {
+        type: "problem",
+        docs: {
+          description: DESCRIPTION,
+          category: "Possible Errors",
+          recommended: true,
+          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/unsafe-to-chain-command.md"
+        },
+        schema: [schema],
+        messages: {
+          unexpected: "It is unsafe to chain further commands that rely on the subject after this command. It is best to split the chain, chaining again from `cy.` in a next command line."
+        }
+      },
+      create(context) {
+        const { methods } = getDefaultOptions(context);
+        return {
+          CallExpression(node2) {
+            if (isRootCypress(node2) && isActionUnsafeToChain(node2, methods) && node2.parent.type === "MemberExpression") {
+              context.report({
+                node: node2,
+                messageId: "unexpected"
+              });
+            }
+          }
+        };
+      }
+    };
+    var isRootCypress = (node2) => {
+      if (node2.type !== "CallExpression" || node2.callee.type !== "MemberExpression") {
+        return false;
+      }
+      if (node2.callee.object.type === "Identifier" && node2.callee.object.name === "cy") {
+        return true;
+      }
+      return isRootCypress(node2.callee.object);
+    };
+    var isActionUnsafeToChain = (node2, additionalMethods = []) => {
+      const unsafeActionsRegex = new RegExp([
+        ...unsafeToChainActions.map((action) => `^${action}$`),
+        ...additionalMethods.map((method) => method instanceof RegExp ? method.source : method)
+      ].join("|"));
+      return node2.callee && node2.callee.property && node2.callee.property.type === "Identifier" && unsafeActionsRegex.test(node2.callee.property.name);
+    };
+  }
+});
+
+// node_modules/eslint-plugin-cypress/lib/rules/no-unnecessary-waiting.js
+var require_no_unnecessary_waiting = __commonJS({
+  "node_modules/eslint-plugin-cypress/lib/rules/no-unnecessary-waiting.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    module.exports = {
+      meta: {
+        type: "problem",
+        docs: {
+          description: "disallow waiting for arbitrary time periods",
+          category: "Possible Errors",
+          recommended: true,
+          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-unnecessary-waiting.md"
+        },
+        schema: [],
+        messages: {
+          unexpected: "Do not wait for arbitrary time periods"
+        }
+      },
+      create(context) {
+        const sourceCode = context.sourceCode ?? context.getSourceCode();
+        return {
+          CallExpression(node2) {
+            if (isCallingCyWait(node2)) {
+              const scope = sourceCode.getScope ? sourceCode.getScope(node2) : context.getScope();
+              if (isIdentifierNumberConstArgument(node2, scope) || isNumberArgument(node2)) {
+                context.report({ node: node2, messageId: "unexpected" });
+              }
+            }
+          }
+        };
+      }
+    };
+    function nodeIsCalledByCy(node2) {
+      if (node2.type === "Identifier" && node2.name === "cy") return true;
+      if (typeof node2.callee === "undefined" || typeof node2.callee.object === "undefined") {
+        return false;
+      }
+      return nodeIsCalledByCy(node2.callee.object);
+    }
+    function isCallingCyWait(node2) {
+      return node2.callee.type === "MemberExpression" && nodeIsCalledByCy(node2) && node2.callee.property.type === "Identifier" && node2.callee.property.name === "wait";
+    }
+    function isNumberArgument(node2) {
+      return node2.arguments.length > 0 && node2.arguments[0].type === "Literal" && typeof node2.arguments[0].value === "number";
+    }
+    function isIdentifierNumberConstArgument(node2, scope) {
+      if (node2.arguments.length === 0) return false;
+      if (node2.arguments[0].type !== "Identifier") return false;
+      const identifier = node2.arguments[0];
+      const resolvedIdentifier = scope.references.find((ref) => ref.identifier === identifier).resolved;
+      const definition = resolvedIdentifier.defs[0];
+      const isVariable = definition.type === "Variable";
+      if (isVariable) {
+        if (!definition.node.init) return false;
+        return typeof definition.node.init.value === "number";
+      }
+      if (definition.type === "ImportBinding") return false;
+      const param = definition.node.params[definition.index];
+      if (!param || param.type !== "AssignmentPattern") return false;
+      return typeof param.right.value === "number";
+    }
+  }
+});
+
+// node_modules/eslint-plugin-cypress/lib/rules/no-async-before.js
+var require_no_async_before = __commonJS({
+  "node_modules/eslint-plugin-cypress/lib/rules/no-async-before.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    module.exports = {
+      meta: {
+        type: "problem",
+        docs: {
+          description: "disallow using `async`/`await` in Cypress `before` methods",
+          category: "Possible Errors",
+          recommended: true,
+          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-async-before.md"
+        },
+        schema: [],
+        messages: {
+          unexpected: "Avoid using async functions with Cypress before / beforeEach functions"
+        }
+      },
+      create(context) {
+        function isBeforeBlock(callExpressionNode) {
+          const { type, name } = callExpressionNode.callee;
+          return type === "Identifier" && name === "before" || name === "beforeEach";
+        }
+        function isBeforeAsync(node2) {
+          return node2.arguments && node2.arguments.length >= 2 && node2.arguments[1].async === true;
+        }
+        const sourceCode = context.sourceCode ?? context.getSourceCode();
+        return {
+          Identifier(node2) {
+            if (node2.name === "cy" || node2.name === "Cypress") {
+              const ancestors = sourceCode.getAncestors ? sourceCode.getAncestors(node2) : context.getAncestors();
+              const asyncTestBlocks = ancestors.filter((n) => n.type === "CallExpression").filter(isBeforeBlock).filter(isBeforeAsync);
+              if (asyncTestBlocks.length >= 1) {
+                asyncTestBlocks.forEach((node3) => {
+                  context.report({ node: node3, messageId: "unexpected" });
+                });
+              }
+            }
+          }
+        };
+      }
+    };
+  }
+});
+
+// node_modules/eslint-plugin-cypress/lib/rules/no-async-tests.js
+var require_no_async_tests = __commonJS({
+  "node_modules/eslint-plugin-cypress/lib/rules/no-async-tests.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    module.exports = {
+      meta: {
+        type: "problem",
+        docs: {
+          description: "disallow using `async`/`await` in Cypress test cases",
+          category: "Possible Errors",
+          recommended: true,
+          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-async-tests.md"
+        },
+        schema: [],
+        messages: {
+          unexpected: "Avoid using async functions with Cypress tests"
+        }
+      },
+      create(context) {
+        function isTestBlock(callExpressionNode) {
+          const { type, name } = callExpressionNode.callee;
+          return type === "Identifier" && name === "it" || name === "test";
+        }
+        function isTestAsync(node2) {
+          return node2.arguments && node2.arguments.length >= 2 && node2.arguments[1].async === true;
+        }
+        const sourceCode = context.sourceCode ?? context.getSourceCode();
+        return {
+          Identifier(node2) {
+            if (node2.name === "cy" || node2.name === "Cypress") {
+              const ancestors = sourceCode.getAncestors ? sourceCode.getAncestors(node2) : context.getAncestors();
+              const asyncTestBlocks = ancestors.filter((n) => n.type === "CallExpression").filter(isTestBlock).filter(isTestAsync);
+              if (asyncTestBlocks.length >= 1) {
+                asyncTestBlocks.forEach((node3) => {
+                  context.report({ node: node3, messageId: "unexpected" });
+                });
+              }
+            }
+          }
+        };
+      }
+    };
+  }
+});
+
+// node_modules/eslint-plugin-cypress/lib/rules/assertion-before-screenshot.js
+var require_assertion_before_screenshot = __commonJS({
+  "node_modules/eslint-plugin-cypress/lib/rules/assertion-before-screenshot.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    var assertionCommands = [
+      // assertions
+      "should",
+      "and",
+      "contains",
+      // retries until it gets something
+      "get",
+      // not an assertion, but unlikely to require waiting for render
+      "scrollIntoView",
+      "scrollTo"
+    ];
+    module.exports = {
+      meta: {
+        type: "problem",
+        docs: {
+          description: "require screenshots to be preceded by an assertion",
+          category: "Possible Errors",
+          recommended: false,
+          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/assertion-before-screenshot.md"
+        },
+        schema: [],
+        messages: {
+          unexpected: "Make an assertion on the page state before taking a screenshot"
+        }
+      },
+      create(context) {
+        return {
+          CallExpression(node2) {
+            if (isCallingCyScreenshot(node2) && !isPreviousAnAssertion(node2)) {
+              context.report({ node: node2, messageId: "unexpected" });
+            }
+          }
+        };
+      }
+    };
+    function isRootCypress(node2) {
+      while (node2.type === "CallExpression") {
+        if (node2.callee.type !== "MemberExpression") return false;
+        if (node2.callee.object.type === "Identifier" && node2.callee.object.name === "cy") {
+          return true;
+        }
+        node2 = node2.callee.object;
+      }
+      return false;
+    }
+    function getPreviousInChain(node2) {
+      return node2.type === "CallExpression" && node2.callee.type === "MemberExpression" && node2.callee.object.type === "CallExpression" && node2.callee.object.callee.type === "MemberExpression" && node2.callee.object.callee.property.type === "Identifier" && node2.callee.object.callee.property.name;
+    }
+    function getCallExpressionCypressCommand(node2) {
+      return isRootCypress(node2) && node2.callee.property.type === "Identifier" && node2.callee.property.name;
+    }
+    function isCallingCyScreenshot(node2) {
+      return getCallExpressionCypressCommand(node2) === "screenshot";
+    }
+    function getPreviousCypressCommand(node2) {
+      const previousInChain = getPreviousInChain(node2);
+      if (previousInChain) {
+        return previousInChain;
+      }
+      while (node2.parent && !node2.parent.body) {
+        node2 = node2.parent;
+      }
+      if (!node2.parent || !node2.parent.body) return null;
+      const body = node2.parent.body.type === "BlockStatement" ? node2.parent.body.body : node2.parent.body;
+      const index = body.indexOf(node2);
+      if (index < 0) return null;
+      if (index === 0) return getPreviousCypressCommand(node2.parent);
+      const previousStatement = body[index - 1];
+      if (previousStatement.type !== "ExpressionStatement" || previousStatement.expression.type !== "CallExpression") {
+        return null;
+      }
+      return getCallExpressionCypressCommand(previousStatement.expression);
+    }
+    function isPreviousAnAssertion(node2) {
+      const previousCypressCommand = getPreviousCypressCommand(node2);
+      return assertionCommands.indexOf(previousCypressCommand) >= 0;
+    }
+  }
+});
+
+// node_modules/eslint-plugin-cypress/lib/rules/require-data-selectors.js
+var require_require_data_selectors = __commonJS({
+  "node_modules/eslint-plugin-cypress/lib/rules/require-data-selectors.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    module.exports = {
+      meta: {
+        type: "suggestion",
+        docs: {
+          description: "require `data-*` attribute selectors",
+          category: "Possible Errors",
+          recommended: false,
+          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/require-data-selectors.md"
+        },
+        schema: [],
+        messages: {
+          unexpected: "use data-* attribute selectors instead of classes or tag names"
+        }
+      },
+      create(context) {
+        return {
+          CallExpression(node2) {
+            if (isCallingCyGet(node2) && !isDataArgument(node2)) {
+              context.report({ node: node2, messageId: "unexpected" });
+            }
+          }
+        };
+      }
+    };
+    function isCallingCyGet(node2) {
+      return node2.callee.type === "MemberExpression" && node2.callee.object.type === "Identifier" && node2.callee.object.name === "cy" && node2.callee.property.type === "Identifier" && node2.callee.property.name === "get";
+    }
+    function isDataArgument(node2) {
+      return node2.arguments.length > 0 && (node2.arguments[0].type === "Literal" && isAliasOrDataSelector(String(node2.arguments[0].value)) || node2.arguments[0].type === "TemplateLiteral" && isAliasOrDataSelector(String(node2.arguments[0].quasis[0].value.cooked)));
+    }
+    function isAliasOrDataSelector(selector) {
+      return ["[data-", "@"].some(function(validValue) {
+        return selector.startsWith(validValue);
+      });
+    }
+  }
+});
+
+// node_modules/eslint-plugin-cypress/lib/rules/no-force.js
+var require_no_force = __commonJS({
+  "node_modules/eslint-plugin-cypress/lib/rules/no-force.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    module.exports = {
+      meta: {
+        type: "suggestion",
+        docs: {
+          description: "disallow using `force: true` with action commands",
+          category: "Possible Errors",
+          recommended: false,
+          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-force.md"
+        },
+        fixable: null,
+        // or "code" or "whitespace"
+        schema: [],
+        messages: {
+          unexpected: "Do not use force on click and type calls"
+        }
+      },
+      create(context) {
+        function isCallingClickOrType(node2) {
+          const allowedMethods = ["click", "dblclick", "type", "trigger", "check", "rightclick", "focus", "select"];
+          return node2.property && node2.property.type === "Identifier" && allowedMethods.includes(node2.property.name);
+        }
+        function isCypressCall(node2) {
+          return node2.callee.type === "MemberExpression" && node2.callee.object.type === "Identifier" && node2.callee.object.name === "cy";
+        }
+        function hasOptionForce(node2) {
+          return node2.arguments && node2.arguments.length && node2.arguments.some((arg) => {
+            return arg.type === "ObjectExpression" && arg.properties.some((propNode) => propNode.key && propNode.key.name === "force");
+          });
+        }
+        function deepCheck(node2, checkFunc) {
+          let currentNode = node2;
+          while (currentNode.parent) {
+            if (checkFunc(currentNode.parent)) {
+              return true;
+            }
+            currentNode = currentNode.parent;
+          }
+          return false;
+        }
+        return {
+          CallExpression(node2) {
+            if (isCypressCall(node2) && deepCheck(node2, isCallingClickOrType) && deepCheck(node2, hasOptionForce)) {
+              context.report({ node: node2, messageId: "unexpected" });
+            }
+          }
+        };
+      }
+    };
+  }
+});
+
+// node_modules/eslint-plugin-cypress/lib/rules/no-pause.js
+var require_no_pause = __commonJS({
+  "node_modules/eslint-plugin-cypress/lib/rules/no-pause.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    module.exports = {
+      meta: {
+        type: "suggestion",
+        docs: {
+          description: "disallow using `cy.pause()` calls",
+          category: "Possible Errors",
+          recommended: false,
+          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-pause.md"
+        },
+        fixable: null,
+        // or "code" or "whitespace"
+        schema: [],
+        messages: {
+          unexpected: "Do not use cy.pause command"
+        }
+      },
+      create(context) {
+        function isCallingPause(node2) {
+          return node2.callee && node2.callee.property && node2.callee.property.type === "Identifier" && node2.callee.property.name === "pause";
+        }
+        function isCypressCall(node2) {
+          if (!node2.callee || node2.callee.type !== "MemberExpression") {
+            return false;
+          }
+          if (node2.callee.object.type === "Identifier" && node2.callee.object.name === "cy") {
+            return true;
+          }
+          return isCypressCall(node2.callee.object);
+        }
+        return {
+          CallExpression(node2) {
+            if (isCypressCall(node2) && isCallingPause(node2)) {
+              context.report({ node: node2, messageId: "unexpected" });
+            }
+          }
+        };
+      }
+    };
+  }
+});
+
+// node_modules/eslint-plugin-cypress/lib/rules/no-debug.js
+var require_no_debug = __commonJS({
+  "node_modules/eslint-plugin-cypress/lib/rules/no-debug.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    module.exports = {
+      meta: {
+        type: "suggestion",
+        docs: {
+          description: "disallow using `cy.debug()` calls",
+          category: "Possible Errors",
+          recommended: false,
+          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-debug.md"
+        },
+        fixable: null,
+        // or "code" or "whitespace"
+        schema: [],
+        messages: {
+          unexpected: "Do not use cy.debug command"
+        }
+      },
+      create(context) {
+        function isCallingDebug(node2) {
+          return node2.callee && node2.callee.property && node2.callee.property.type === "Identifier" && node2.callee.property.name === "debug";
+        }
+        function isCypressCall(node2) {
+          if (!node2.callee || node2.callee.type !== "MemberExpression") {
+            return false;
+          }
+          if (node2.callee.object.type === "Identifier" && node2.callee.object.name === "cy") {
+            return true;
+          }
+          return isCypressCall(node2.callee.object);
+        }
+        return {
+          CallExpression(node2) {
+            if (isCypressCall(node2) && isCallingDebug(node2)) {
+              context.report({ node: node2, messageId: "unexpected" });
+            }
+          }
+        };
+      }
+    };
+  }
+});
+
+// node_modules/eslint-plugin-cypress/lib/rules/no-xpath.js
+var require_no_xpath = __commonJS({
+  "node_modules/eslint-plugin-cypress/lib/rules/no-xpath.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    module.exports = {
+      meta: {
+        type: "suggestion",
+        docs: {
+          description: "disallow using `cy.xpath()` calls",
+          recommended: false,
+          url: "https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-xpath.md"
+        },
+        fixable: null,
+        // Or `code` or `whitespace`
+        schema: [],
+        // Add a schema if the rule has options
+        messages: {
+          unexpected: "Avoid using cy.xpath command"
+        }
+      },
+      create(context) {
+        return {
+          CallExpression(node2) {
+            if (isCallingCyXpath(node2)) {
+              context.report({ node: node2, messageId: "unexpected" });
+            }
+          }
+        };
+      }
+    };
+    function isCallingCyXpath(node2) {
+      return node2.callee.type === "MemberExpression" && node2.callee.object.type === "Identifier" && node2.callee.object.name === "cy" && node2.callee.property.type === "Identifier" && node2.callee.property.name === "xpath";
+    }
+  }
+});
+
+// node_modules/eslint-plugin-cypress/lib/flat.js
+var require_flat = __commonJS({
+  "node_modules/eslint-plugin-cypress/lib/flat.js"(exports, module) {
+    "use strict";
+    init_esm_shims();
+    var globals2 = __require("globals");
+    var { name, version } = require_package();
+    var plugin4 = {
+      meta: { name, version },
+      configs: {},
+      rules: {
+        "no-assigning-return-values": require_no_assigning_return_values(),
+        "unsafe-to-chain-command": require_unsafe_to_chain_command(),
+        "no-unnecessary-waiting": require_no_unnecessary_waiting(),
+        "no-async-before": require_no_async_before(),
+        "no-async-tests": require_no_async_tests(),
+        "assertion-before-screenshot": require_assertion_before_screenshot(),
+        "require-data-selectors": require_require_data_selectors(),
+        "no-force": require_no_force(),
+        "no-pause": require_no_pause(),
+        "no-debug": require_no_debug(),
+        "no-xpath": require_no_xpath()
+      }
+    };
+    var commonGlobals = Object.assign({
+      cy: false,
+      Cypress: false,
+      expect: false,
+      assert: false,
+      chai: false
+    }, globals2.browser, globals2.mocha);
+    Object.assign(plugin4.configs, {
+      globals: {
+        name: "cypress/globals",
+        plugins: {
+          cypress: plugin4
+        },
+        languageOptions: {
+          globals: commonGlobals
+        }
+      }
+    });
+    Object.assign(plugin4.configs, {
+      recommended: {
+        name: "cypress/recommended",
+        plugins: {
+          cypress: plugin4
+        },
+        rules: {
+          "cypress/no-assigning-return-values": "error",
+          "cypress/no-unnecessary-waiting": "error",
+          "cypress/no-async-tests": "error",
+          "cypress/unsafe-to-chain-command": "error"
+        },
+        languageOptions: {
+          globals: commonGlobals
+        }
+      }
+    });
+    module.exports = plugin4;
+  }
+});
 
 // src/index.ts
 init_esm_shims();
@@ -139,7 +927,7 @@ init_esm_shims();
 
 // src/utils.ts
 init_esm_shims();
-import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { isPackageExists } from "local-pkg";
 var parserPlain = {
   meta: {
@@ -215,7 +1003,7 @@ var processorPassThrough = {
     return messages[0];
   }
 };
-var scopeUrl = fileURLToPath(new URL(".", import.meta.url));
+var scopeUrl = fileURLToPath2(new URL(".", import.meta.url));
 
 // src/configs/graphql.ts
 async function graphql() {
@@ -878,7 +1666,9 @@ async function unicorn() {
         "unicorn/prefer-top-level-await": "off",
         "unicorn/filename-case": "off",
         "unicorn/no-await-expression-member": "off",
-        "unicorn/throw-new-error": "off"
+        "unicorn/throw-new-error": "off",
+        "unicorn/no-array-callback-reference": "off",
+        "unicorn/no-new-array": "off"
       }
     }
   ];
@@ -1483,6 +2273,7 @@ async function regexpr({
 
 // src/configs/test.ts
 init_esm_shims();
+var import_flat = __toESM(require_flat(), 1);
 var PLUGIN_RUNNER_MAP = {
   tap: [
     "eslint-plugin-tap",
@@ -1506,14 +2297,14 @@ var PLUGIN_RUNNER_MAP = {
   ],
   vitest: [
     "@vitest/eslint-plugin",
-    async () => ({
-      ...(await interopDefault(import("@vitest/eslint-plugin"))).configs.recommended.rules
+    (plugin4) => ({
+      ...plugin4.configs.recommended.rules
     })
   ],
   jest: [
     "eslint-plugin-jest",
-    async () => ({
-      ...(await interopDefault(import("./lib-C4ZW2PPJ.js"))).configs["flat/recommended"].rules
+    (plugin4) => ({
+      ...plugin4.configs["flat/recommended"].rules
     })
   ]
 };
@@ -1532,10 +2323,9 @@ async function test({
   ]);
   const extraConfigs = [];
   if (cypress) {
-    const pluginCypress = await interopDefault(import("./flat-QQMMJZVN.js"));
     extraConfigs.push({
       name: `${NAMESPACE16}/cypress/rules`,
-      ...pluginCypress.configs.recommended,
+      ...import_flat.default.configs.recommended,
       ...typeof cypress === "boolean" ? {} : cypress
     });
   }
@@ -1546,12 +2336,19 @@ async function test({
         test: {
           ...pluginRunner,
           rules: {
-            ...await Promise.resolve(rules()),
-            ...pluginNoOnlyTests.rules
+            ...pluginNoOnlyTests.rules,
+            ...rules(pluginRunner)
           }
         }
       }
     },
+    runner === "jest" ? {
+      name: `${NAMESPACE16}/jest`,
+      ...pluginRunner.configs["flat/recommended"],
+      rules: {
+        ...pluginRunner.configs["flat/recommended"].rules
+      }
+    } : {},
     {
       name: `${NAMESPACE16}/rules`,
       files,