@exbotanical/eslint-config 1.1.0 → 1.1.3

package/dist/index.js

@@ -1,7 +1,807 @@
+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();
+
 // src/factory.ts
+init_esm_shims();
 import { isPackageExists as isPackageExists3 } from "local-pkg";
 
+// src/configs/index.ts
+init_esm_shims();
+
 // src/configs/comments.ts
+init_esm_shims();
 import plugin from "@eslint-community/eslint-plugin-eslint-comments";
 var NAMESPACE = "exbotanical/comments";
 async function comments() {
@@ -23,7 +823,11 @@ async function comments() {
   ];
 }
 
+// src/configs/disables.ts
+init_esm_shims();
+
 // src/filepaths.ts
+init_esm_shims();
 var GLOB_JS = "**/*.?([cm])js";
 var GLOB_JSX = "**/*.?([cm])jsx";
 var GLOB_TS = "**/*.?([cm])ts";
@@ -118,8 +922,12 @@ async function disables() {
   ];
 }
 
+// src/configs/graphql.ts
+init_esm_shims();
+
 // src/utils.ts
-import { fileURLToPath } from "node:url";
+init_esm_shims();
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { isPackageExists } from "local-pkg";
 var parserPlain = {
   meta: {
@@ -195,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() {
@@ -217,14 +1025,16 @@ async function graphql() {
       plugins: {
         "@graphql-eslint": graphqlPlugin
       },
+      // @ts-expect-error weird rule types in gql plugin
       rules
     }
   ];
 }
 
 // src/configs/ignores.ts
+init_esm_shims();
 var NAMESPACE3 = "exbotanical/ignores";
-async function ignores({ files = [] } = {}) {
+async function ignores(files = []) {
   return [
     {
       name: NAMESPACE3,
@@ -234,6 +1044,7 @@ async function ignores({ files = [] } = {}) {
 }
 
 // src/configs/imports.ts
+init_esm_shims();
 import plugin2 from "eslint-plugin-import";
 var NAMESPACE4 = "exbotanical/imports";
 async function imports() {
@@ -301,10 +1112,12 @@ async function imports() {
 }
 
 // src/configs/javascript.ts
+init_esm_shims();
 import pluginUnusedImports from "eslint-plugin-unused-imports";
 import globals from "globals";
 
 // src/common.ts
+init_esm_shims();
 var VAR_IGNORE_PATTERN = "^_";
 
 // src/configs/javascript.ts
@@ -576,6 +1389,7 @@ async function javascript({ overrides = {} } = {}) {
 }
 
 // src/configs/jsdoc.ts
+init_esm_shims();
 var NAMESPACE6 = "exbotanical/jsdoc";
 async function jsdoc() {
   return [
@@ -607,7 +1421,11 @@ async function jsdoc() {
   ];
 }
 
+// src/configs/jsonc.ts
+init_esm_shims();
+
 // src/defaults.ts
+init_esm_shims();
 var STYLE_DEFAULTS = {
   indent: 2,
   jsx: true,
@@ -691,6 +1509,7 @@ async function jsonc({
 }
 
 // src/configs/jsx.ts
+init_esm_shims();
 var NAMESPACE8 = "exbotanical/jsx";
 async function jsx() {
   return [
@@ -709,6 +1528,7 @@ async function jsx() {
 }
 
 // src/configs/markdown.ts
+init_esm_shims();
 var NAMESPACE9 = "exbotanical/markdown";
 async function markdown({
   files = [GLOB_MARKDOWN],
@@ -777,7 +1597,11 @@ async function markdown({
   ];
 }
 
+// src/configs/misc/index.ts
+init_esm_shims();
+
 // src/configs/misc/perfectionist.ts
+init_esm_shims();
 import pluginPerfectionist from "eslint-plugin-perfectionist";
 var NAMESPACE10 = "exbotanical/misc/perfectionist";
 async function perfectionist() {
@@ -825,6 +1649,7 @@ async function perfectionist() {
 }
 
 // src/configs/misc/unicorn.ts
+init_esm_shims();
 import pluginUnicorn from "eslint-plugin-unicorn";
 var NAMESPACE11 = "exbotanical/misc/unicorn";
 async function unicorn() {
@@ -839,13 +1664,18 @@ async function unicorn() {
         "unicorn/prevent-abbreviations": "off",
         "unicorn/no-null": "off",
         "unicorn/prefer-top-level-await": "off",
-        "unicorn/filename-case": "off"
+        "unicorn/filename-case": "off",
+        "unicorn/no-await-expression-member": "off",
+        "unicorn/throw-new-error": "off",
+        "unicorn/no-array-callback-reference": "off",
+        "unicorn/no-new-array": "off"
       }
     }
   ];
 }
 
 // src/configs/node.ts
+init_esm_shims();
 import plugin3 from "eslint-plugin-n";
 var NAMESPACE12 = "exbotanical/node";
 async function node() {
@@ -869,6 +1699,7 @@ async function node() {
 }
 
 // src/configs/package.json.ts
+init_esm_shims();
 var NAMESPACE13 = "exbotanical/package.json";
 async function packageJson() {
   return [
@@ -968,7 +1799,11 @@ async function packageJson() {
   ];
 }
 
+// src/configs/prettier.ts
+init_esm_shims();
+
 // src/vendor/plugins/eslint-config-prettier.ts
+init_esm_shims();
 var specialRule = 0;
 var eslint_config_prettier_default = {
   rules: {
@@ -1264,6 +2099,7 @@ async function prettier() {
 }
 
 // src/configs/react.ts
+init_esm_shims();
 import { isPackageExists as isPackageExists2 } from "local-pkg";
 var REACT_REFRESH_ALLOW_CONSTANT_EXPORT_PACKAGES = ["vite"];
 var REACT_ROUTER_PACKAGES = [
@@ -1407,6 +2243,7 @@ async function react({
 }
 
 // src/configs/regexpr.ts
+init_esm_shims();
 import { configs } from "eslint-plugin-regexp";
 var NAMESPACE15 = "exbotanical/regexpr";
 async function regexpr({
@@ -1435,10 +2272,12 @@ 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",
-    {
+    () => ({
       "tap/assertion-message": ["error", "always"],
       "tap/max-asserts": ["error", 8],
       "tap/no-identical-title": "error",
@@ -1454,19 +2293,25 @@ var PLUGIN_RUNNER_MAP = {
       "tap/use-t-well": "error",
       "tap/use-t": "error",
       "tap/use-tap": "error"
-    }
+    })
   ],
   vitest: [
     "@vitest/eslint-plugin",
-    {
-      // ...vitest.configs.recommended.rules,
-    }
+    (plugin4) => ({
+      ...plugin4.configs.recommended.rules
+    })
   ],
-  jest: ["eslint-plugin-jest", {}]
+  jest: [
+    "eslint-plugin-jest",
+    (plugin4) => ({
+      ...plugin4.configs["flat/recommended"].rules
+    })
+  ]
 };
 var NAMESPACE16 = "exbotanical/test";
 async function test({
   runner = "vitest",
+  cypress = false,
   files = GLOB_TESTS,
   overrides = {}
 }) {
@@ -1476,6 +2321,14 @@ async function test({
     // @ts-expect-error no types
     interopDefault(import("eslint-plugin-no-only-tests"))
   ]);
+  const extraConfigs = [];
+  if (cypress) {
+    extraConfigs.push({
+      name: `${NAMESPACE16}/cypress/rules`,
+      ...import_flat.default.configs.recommended,
+      ...typeof cypress === "boolean" ? {} : cypress
+    });
+  }
   return [
     {
       name: `${NAMESPACE16}/setup`,
@@ -1483,23 +2336,32 @@ async function test({
         test: {
           ...pluginRunner,
           rules: {
-            ...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,
       rules: {
         ...overrides
       }
-    }
+    },
+    ...extraConfigs
   ];
 }
 
 // src/configs/toml.ts
+init_esm_shims();
 var NAMESPACE17 = "exbotanical/toml";
 async function toml({ files = [GLOB_TOML], overrides = {} } = {}, { indent } = STYLE_DEFAULTS) {
   const [plugin4, parser] = await Promise.all([
@@ -1547,6 +2409,7 @@ async function toml({ files = [GLOB_TOML], overrides = {} } = {}, { indent } = S
 }
 
 // src/configs/tsconfig.ts
+init_esm_shims();
 var NAMESPACE18 = "exbotanical/tsconfig";
 async function tsconfig() {
   return [
@@ -1676,6 +2539,7 @@ async function tsconfig() {
 }
 
 // src/configs/typescript.ts
+init_esm_shims();
 var NAMESPACE19 = "exbotanical/typescript";
 async function typescript(options = {}) {
   const {
@@ -1844,6 +2708,7 @@ async function typescript(options = {}) {
 }
 
 // src/configs/vue.ts
+init_esm_shims();
 var NAMESPACE20 = "exbotanical/vue";
 async function vue({
   files = [GLOB_VUE],
@@ -2014,6 +2879,7 @@ async function vue({
 }
 
 // src/configs/yaml.ts
+init_esm_shims();
 var NAMESPACE21 = "exbotanical/yaml";
 async function yaml({ files = [GLOB_YAML], overrides = {} } = {}, { indent, quotes } = STYLE_DEFAULTS) {
   const [plugin4, parser] = await Promise.all([
@@ -2133,7 +2999,7 @@ async function exbotanical({
   if (formatter) {
     configs2.push(prettier());
   }
-  configs2.push(disables(), ignores({ ...optionsIgnore }));
+  configs2.push(disables(), ignores(optionsIgnore));
   if (userConfigs.length > 0) {
     const resolved2 = await Promise.all(userConfigs);
     configs2.push(...resolved2.map((r) => Promise.resolve(Array.isArray(r) ? r : [r])));
@@ -2145,6 +3011,12 @@ function factoryConfig(options) {
   if (!options) return {};
   return typeof options === "boolean" ? {} : options;
 }
+
+// src/options.ts
+init_esm_shims();
+
+// src/types.ts
+init_esm_shims();
 export {
   exbotanical as default
 };