eslint-plugin-playwright 2.4.1 → 2.5.0

package/dist/index.cjs

@@ -119,10 +119,9 @@ var Chain = class {
   }
 };
 var resolvePossibleAliasedGlobal = (context, global) => {
-  const globalAliases = context.settings.playwright?.globalAliases ?? {};
-  const alias = Object.entries(globalAliases).find(
-    ([, aliases]) => aliases.includes(global)
-  );
+  const settings = context.settings;
+  const globalAliases = settings?.playwright?.globalAliases ?? {};
+  const alias = Object.entries(globalAliases).find(([, aliases]) => aliases.includes(global));
   return alias?.[0] ?? null;
 };
 var resolveToPlaywrightFn = (context, accessor) => {
@@ -135,16 +134,11 @@ var resolveToPlaywrightFn = (context, accessor) => {
   };
 };
 function determinePlaywrightFnGroup(name) {
-  if (name === "step")
-    return "step";
-  if (name === "expect")
-    return "expect";
-  if (name === "describe")
-    return "describe";
-  if (name === "test")
-    return "test";
-  if (testHooks.has(name))
-    return "hook";
+  if (name === "step") return "step";
+  if (name === "expect") return "expect";
+  if (name === "describe") return "describe";
+  if (name === "test") return "test";
+  if (testHooks.has(name)) return "hook";
   return "unknown";
 }
 var modifiers = /* @__PURE__ */ new Set(["not", "resolves", "rejects"]);
@@ -186,11 +180,7 @@ function getExpectArguments(call) {
   return findParent(call.head.node, "CallExpression")?.arguments ?? [];
 }
 var parseExpectCall = (chain, call, stage) => {
-  const modifiersAndMatcher = findModifiersAndMatcher(
-    chain,
-    call.members,
-    stage
-  );
+  const modifiersAndMatcher = findModifiersAndMatcher(chain, call.members, stage);
   if (!modifiersAndMatcher) {
     return null;
   }
@@ -207,31 +197,29 @@ var parseExpectCall = (chain, call, stage) => {
 };
 var findTopMostCallExpression = (node) => {
   let top = node;
-  let parent = getParent(node);
+  let parent = node.parent;
   let child = node;
   while (parent) {
     if (parent.type === "CallExpression" && parent.callee === child) {
       top = parent;
       node = parent;
-      parent = getParent(parent);
+      parent = parent.parent;
       continue;
     }
     if (parent.type !== "MemberExpression") {
       break;
     }
     child = parent;
-    parent = getParent(parent);
+    parent = parent.parent;
   }
   return top;
 };
 function parse(context, node) {
   const chain = new Chain(node);
-  if (!chain.nodes?.length)
-    return null;
+  if (!chain.nodes?.length) return null;
   const [first, ...rest] = chain.nodes;
   const resolved = resolveToPlaywrightFn(context, first);
-  if (!resolved)
-    return null;
+  if (!resolved) return null;
   let name = resolved.original ?? resolved.local;
   const links = [name, ...rest.map((link) => getStringValue(link))];
   if (name === "test" && links.length > 1) {
@@ -259,22 +247,21 @@ function parse(context, node) {
       parsedFnCall.members.shift();
     }
     const result = parseExpectCall(chain, parsedFnCall, stage);
-    if (!result)
-      return null;
+    if (!result) return null;
     if (typeof result === "string" && findTopMostCallExpression(node) !== node) {
       return null;
     }
     if (result === "matcher-not-found") {
-      if (getParent(node)?.type === "MemberExpression") {
+      if (node.parent?.type === "MemberExpression") {
         return "matcher-not-called";
       }
     }
     return result;
   }
-  if (chain.nodes.slice(0, chain.nodes.length - 1).some((n) => getParent(n)?.type !== "MemberExpression")) {
+  if (chain.nodes.slice(0, chain.nodes.length - 1).some((n) => n.parent?.type !== "MemberExpression")) {
     return null;
   }
-  const parent = getParent(node);
+  const parent = node.parent;
   if (parent?.type === "CallExpression" || parent?.type === "MemberExpression") {
     return null;
   }
@@ -308,8 +295,7 @@ var isTypeOfFnCall = (context, node, types) => {
 
 // src/utils/ast.ts
 function getStringValue(node) {
-  if (!node)
-    return "";
+  if (!node) return "";
   return node.type === "Identifier" ? node.name : node.type === "TemplateLiteral" ? node.quasis[0].value.raw : node.type === "Literal" && typeof node.value === "string" ? node.value : "";
 }
 function getRawValue(node) {
@@ -336,13 +322,9 @@ function isPropertyAccessor(node, name) {
   const value = getStringValue(node.property);
   return typeof name === "string" ? value === name : name.test(value);
 }
-function getParent(node) {
-  return node.parent;
-}
 function findParent(node, type) {
   const parent = node.parent;
-  if (!parent)
-    return;
+  if (!parent) return;
   return parent.type === type ? parent : findParent(parent, type);
 }
 function dig(node, identifier) {
@@ -371,8 +353,8 @@ function getNodeName(node) {
   }
   return null;
 }
-var isVariableDeclarator = (node) => node.type === "VariableDeclarator";
-var isAssignmentExpression = (node) => node.type === "AssignmentExpression";
+var isVariableDeclarator = (node) => node?.type === "VariableDeclarator";
+var isAssignmentExpression = (node) => node?.type === "AssignmentExpression";
 function isNodeLastAssignment(node, assignment) {
   if (node.range && assignment.range && node.range[0] < assignment.range[1]) {
     return false;
@@ -389,6 +371,30 @@ function dereference(context, node) {
   const expr = parents.filter(isAssignmentExpression).reverse().find((assignment) => isNodeLastAssignment(node, assignment));
   return expr?.right ?? decl?.init;
 }
+var getActualLastToken = (sourceCode, node) => {
+  const semiToken = sourceCode.getLastToken(node);
+  const prevToken = sourceCode.getTokenBefore(semiToken);
+  const nextToken = sourceCode.getTokenAfter(semiToken);
+  const isSemicolonLessStyle = !!prevToken && !!nextToken && prevToken.range[0] >= node.range[0] && semiToken.type === "Punctuator" && semiToken.value === ";" && semiToken.loc.start.line !== prevToken.loc.end.line && semiToken.loc.end.line === nextToken.loc.start.line;
+  return isSemicolonLessStyle ? prevToken : semiToken;
+};
+var getPaddingLineSequences = (prevNode, nextNode, sourceCode) => {
+  const pairs = [];
+  let prevToken = getActualLastToken(sourceCode, prevNode);
+  if (nextNode.loc.start.line - prevToken.loc.end.line >= 2) {
+    do {
+      const token = sourceCode.getTokenAfter(prevToken, {
+        includeComments: true
+      });
+      if (token.loc.start.line - prevToken.loc.end.line >= 2) {
+        pairs.push([prevToken, token]);
+      }
+      prevToken = token;
+    } while (prevToken.range[0] < nextNode.range[0]);
+  }
+  return pairs;
+};
+var areTokensOnSameLine = (left, right) => left.loc.end.line === right.loc.start.line;
 
 // src/utils/createRule.ts
 function interpolate(str, data) {
@@ -406,7 +412,10 @@ function createRule(rule) {
           const { data, messageId: messageId2, ...rest } = options;
           const message = messages?.[messageId2];
           return context.report(
-            message ? { ...rest, message: interpolate(message, data) } : options
+            message ? {
+              ...rest,
+              message: interpolate(message, data)
+            } : options
           );
         }
         return context.report(options);
@@ -430,6 +439,154 @@ function createRule(rule) {
   };
 }
 
+// src/utils/scope.ts
+function createScopeInfo() {
+  let scope = null;
+  return {
+    enter() {
+      scope = { prevNode: null, upper: scope };
+    },
+    exit() {
+      scope = scope.upper;
+    },
+    get prevNode() {
+      return scope.prevNode;
+    },
+    set prevNode(node) {
+      scope.prevNode = node;
+    }
+  };
+}
+
+// src/rules/consistent-spacing-between-blocks.ts
+var STATEMENT_LIST_PARENTS = /* @__PURE__ */ new Set([
+  "Program",
+  "BlockStatement",
+  "SwitchCase",
+  "SwitchStatement"
+]);
+function isValidParent(parentType) {
+  return STATEMENT_LIST_PARENTS.has(parentType);
+}
+function fixPadding(prevNode, nextNode, ctx) {
+  const { ruleContext, sourceCode } = ctx;
+  const paddingLines = getPaddingLineSequences(prevNode, nextNode, sourceCode);
+  if (paddingLines.length > 0) {
+    return;
+  }
+  ruleContext.report({
+    fix(fixer) {
+      let prevToken = getActualLastToken(sourceCode, prevNode);
+      const nextToken = sourceCode.getFirstTokenBetween(prevToken, nextNode, {
+        /**
+         * Skip the trailing comments of the previous node. This inserts a blank
+         * line after the last trailing comment.
+         *
+         * For example:
+         *
+         *     foo() // trailing comment.
+         *     // comment.
+         *     bar()
+         *
+         * Get fixed to:
+         *
+         *     foo() // trailing comment.
+         *
+         *     // comment.
+         *     bar()
+         */
+        filter(token) {
+          if (areTokensOnSameLine(prevToken, token)) {
+            prevToken = token;
+            return false;
+          }
+          return true;
+        },
+        includeComments: true
+      }) || nextNode;
+      const insertText = areTokensOnSameLine(prevToken, nextToken) ? "\n\n" : "\n";
+      return fixer.insertTextAfter(prevToken, insertText);
+    },
+    messageId: "missingWhitespace",
+    node: nextNode
+  });
+}
+function isTestNode(node, ctx) {
+  let curNode = node;
+  if (curNode.type === "ExpressionStatement") {
+    curNode = curNode.expression;
+  } else if (curNode.type === "VariableDeclaration") {
+    const decl = curNode.declarations.at(-1);
+    if (decl.init == null) {
+      return false;
+    }
+    curNode = decl.init;
+  }
+  if (curNode.type === "AwaitExpression") {
+    curNode = curNode.argument;
+  }
+  if (curNode.type !== "CallExpression") {
+    return false;
+  }
+  return isTypeOfFnCall(ctx.ruleContext, curNode, ["describe", "test", "step", "hook"]);
+}
+function testPadding(prevNode, nextNode, ctx) {
+  while (nextNode.type === "LabeledStatement") {
+    nextNode = nextNode.body;
+  }
+  if (isTestNode(prevNode, ctx) || isTestNode(nextNode, ctx)) {
+    fixPadding(prevNode, nextNode, ctx);
+    return;
+  }
+}
+function verifyNode(node, ctx) {
+  const { scopeInfo } = ctx;
+  if (!isValidParent(node.parent.type)) {
+    return;
+  }
+  if (scopeInfo.prevNode) {
+    testPadding(scopeInfo.prevNode, node, ctx);
+  }
+  scopeInfo.prevNode = node;
+}
+var consistent_spacing_between_blocks_default = createRule({
+  create(context) {
+    const scopeInfo = createScopeInfo();
+    const ctx = {
+      ruleContext: context,
+      scopeInfo,
+      sourceCode: context.sourceCode
+    };
+    return {
+      ":statement": (node) => verifyNode(node, ctx),
+      "BlockStatement": scopeInfo.enter,
+      "BlockStatement:exit": scopeInfo.exit,
+      "Program": scopeInfo.enter,
+      "Program:exit": scopeInfo.enter,
+      "SwitchCase"(node) {
+        verifyNode(node, ctx);
+        scopeInfo.enter();
+      },
+      "SwitchCase:exit": scopeInfo.exit,
+      "SwitchStatement": scopeInfo.enter,
+      "SwitchStatement:exit": scopeInfo.exit
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforces a blank line between Playwright test blocks (e.g., test, test.step, test.beforeEach, etc.).",
+      recommended: true,
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/consistent-spacing-between-blocks.md"
+    },
+    fixable: "whitespace",
+    messages: {
+      missingWhitespace: "Expected blank line before this statement."
+    },
+    schema: [],
+    type: "layout"
+  }
+});
+
 // src/rules/expect-expect.ts
 var expect_expect_default = createRule({
   create(context) {
@@ -438,9 +595,7 @@ var expect_expect_default = createRule({
       assertFunctionPatterns: [],
       ...context.options?.[0] ?? {}
     };
-    const patterns = options.assertFunctionPatterns.map(
-      (pattern) => new RegExp(pattern)
-    );
+    const patterns = options.assertFunctionPatterns.map((pattern) => new RegExp(pattern));
     const unchecked = [];
     function checkExpressions(nodes) {
       for (const node of nodes) {
@@ -461,7 +616,7 @@ var expect_expect_default = createRule({
       return false;
     }
     return {
-      CallExpression(node) {
+      "CallExpression"(node) {
         const call = parseFnCall(context, node);
         if (call?.type === "test") {
           unchecked.push(node);
@@ -482,7 +637,7 @@ var expect_expect_default = createRule({
       category: "Best Practices",
       description: "Enforce assertion to be made in a test body",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/expect-expect.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/expect-expect.md"
     },
     messages: {
       noAssertions: "Test has no assertions"
@@ -516,18 +671,18 @@ var max_expects_default = createRule({
     };
     let count = 0;
     const maybeResetCount = (node) => {
-      const parent = getParent(node);
+      const parent = node.parent;
       const isTestFn = parent?.type !== "CallExpression" || isTypeOfFnCall(context, parent, ["test"]);
       if (isTestFn) {
         count = 0;
       }
     };
     return {
-      ArrowFunctionExpression: maybeResetCount,
+      "ArrowFunctionExpression": maybeResetCount,
       "ArrowFunctionExpression:exit": maybeResetCount,
-      CallExpression(node) {
+      "CallExpression"(node) {
         const call = parseFnCall(context, node);
-        if (call?.type !== "expect" || getParent(call.head.node)?.type === "MemberExpression") {
+        if (call?.type !== "expect" || call.head.node.parent?.type === "MemberExpression") {
           return;
         }
         count += 1;
@@ -542,7 +697,7 @@ var max_expects_default = createRule({
           });
         }
       },
-      FunctionExpression: maybeResetCount,
+      "FunctionExpression": maybeResetCount,
       "FunctionExpression:exit": maybeResetCount
     };
   },
@@ -551,7 +706,7 @@ var max_expects_default = createRule({
       category: "Best Practices",
       description: "Enforces a maximum number assertion calls in a test body",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/max-expects.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/max-expects.md"
     },
     messages: {
       exceededMaxAssertion: "Too many assertion calls ({{ count }}) - maximum allowed is {{ max }}"
@@ -579,7 +734,7 @@ var max_nested_describe_default = createRule({
     const max = options[0]?.max ?? 5;
     const describes = [];
     return {
-      CallExpression(node) {
+      "CallExpression"(node) {
         if (isTypeOfFnCall(context, node, ["describe"])) {
           describes.unshift(node);
           if (describes.length > max) {
@@ -606,7 +761,7 @@ var max_nested_describe_default = createRule({
       category: "Best Practices",
       description: "Enforces a maximum depth to nested describe calls",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/max-nested-describe.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/max-nested-describe.md"
     },
     messages: {
       exceededMaxDepth: "Maximum describe call depth exceeded ({{ depth }}). Maximum allowed is {{ max }}."
@@ -628,11 +783,7 @@ var max_nested_describe_default = createRule({
 });
 
 // src/rules/missing-playwright-await.ts
-var validTypes = /* @__PURE__ */ new Set([
-  "AwaitExpression",
-  "ReturnStatement",
-  "ArrowFunctionExpression"
-]);
+var validTypes = /* @__PURE__ */ new Set(["AwaitExpression", "ReturnStatement", "ArrowFunctionExpression"]);
 var expectPlaywrightMatchers = [
   "toBeChecked",
   "toBeDisabled",
@@ -683,7 +834,7 @@ var playwrightTestMatchers = [
   "toContainClass"
 ];
 function getReportNode(node) {
-  const parent = getParent(node);
+  const parent = node.parent;
   return parent?.type === "MemberExpression" ? parent : node;
 }
 function getCallType(call, awaitableMatchers) {
@@ -711,14 +862,11 @@ var missing_playwright_await_default = createRule({
       ...options.customMatchers || []
     ]);
     function checkValidity(node, visited) {
-      const parent = getParent(node);
-      if (!parent)
-        return false;
-      if (visited.has(parent))
-        return false;
+      const parent = node.parent;
+      if (!parent) return false;
+      if (visited.has(parent)) return false;
       visited.add(parent);
-      if (validTypes.has(parent.type))
-        return true;
+      if (validTypes.has(parent.type)) return true;
       if (parent.type === "ArrayExpression") {
         return checkValidity(parent, visited);
       }
@@ -729,12 +877,9 @@ var missing_playwright_await_default = createRule({
         const scope = context.sourceCode.getScope(parent.parent);
         for (const ref of scope.references) {
           const refParent = ref.identifier.parent;
-          if (visited.has(refParent))
-            continue;
-          if (validTypes.has(refParent.type))
-            return true;
-          if (checkValidity(refParent, visited))
-            return true;
+          if (visited.has(refParent)) continue;
+          if (validTypes.has(refParent.type)) return true;
+          if (checkValidity(refParent, visited)) return true;
         }
       }
       return false;
@@ -742,8 +887,7 @@ var missing_playwright_await_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (call?.type !== "step" && call?.type !== "expect")
-          return;
+        if (call?.type !== "step" && call?.type !== "expect") return;
         const result = getCallType(call, awaitableMatchers);
         const isValid = result ? checkValidity(node, /* @__PURE__ */ new Set()) : false;
         if (result && !isValid) {
@@ -762,7 +906,7 @@ var missing_playwright_await_default = createRule({
       category: "Possible Errors",
       description: `Identify false positives when async Playwright APIs are not properly awaited.`,
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/missing-playwright-await.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/missing-playwright-await.md"
     },
     fixable: "code",
     messages: {
@@ -788,23 +932,20 @@ var missing_playwright_await_default = createRule({
 
 // src/rules/no-commented-out-tests.ts
 function getTestNames(context) {
-  const aliases = context.settings.playwright?.globalAliases?.test ?? [];
+  const settings = context.settings;
+  const aliases = settings?.playwright?.globalAliases?.test ?? [];
   return ["test", ...aliases];
 }
 function hasTests(context, node) {
   const testNames = getTestNames(context);
   const names = testNames.join("|");
-  const regex = new RegExp(
-    `^\\s*(${names}|describe)(\\.\\w+|\\[['"]\\w+['"]\\])?\\s*\\(`,
-    "mu"
-  );
+  const regex = new RegExp(`^\\s*(${names}|describe)(\\.\\w+|\\[['"]\\w+['"]\\])?\\s*\\(`, "mu");
   return regex.test(node.value);
 }
 var no_commented_out_tests_default = createRule({
   create(context) {
     function checkNode(node) {
-      if (!hasTests(context, node))
-        return;
+      if (!hasTests(context, node)) return;
       context.report({
         messageId: "commentedTests",
         node
@@ -821,7 +962,7 @@ var no_commented_out_tests_default = createRule({
       category: "Best Practices",
       description: "Disallow commented out tests",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-commented-out-tests.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-commented-out-tests.md"
     },
     messages: {
       commentedTests: "Some tests seem to be commented"
@@ -836,7 +977,7 @@ var getTestCallExpressionsFromDeclaredVariables = (context, declaredVariables) =
   return declaredVariables.reduce(
     (acc, { references }) => [
       ...acc,
-      ...references.map(({ identifier }) => getParent(identifier)).filter(
+      ...references.map(({ identifier }) => identifier.parent).filter(
         // ESLint types are infurating
         (node) => node?.type === "CallExpression" && isTypeOfFnCall(context, node, ["test"])
       )
@@ -852,7 +993,7 @@ var no_conditional_expect_default = createRule({
     const increaseConditionalDepth = () => inTestCase && conditionalDepth++;
     const decreaseConditionalDepth = () => inTestCase && conditionalDepth--;
     return {
-      CallExpression(node) {
+      "CallExpression"(node) {
         const call = parseFnCall(context, node);
         if (call?.type === "test") {
           inTestCase = true;
@@ -881,11 +1022,11 @@ var no_conditional_expect_default = createRule({
           inPromiseCatch = false;
         }
       },
-      CatchClause: increaseConditionalDepth,
+      "CatchClause": increaseConditionalDepth,
       "CatchClause:exit": decreaseConditionalDepth,
-      ConditionalExpression: increaseConditionalDepth,
+      "ConditionalExpression": increaseConditionalDepth,
       "ConditionalExpression:exit": decreaseConditionalDepth,
-      FunctionDeclaration(node) {
+      "FunctionDeclaration"(node) {
         const declaredVariables = context.sourceCode.getDeclaredVariables(node);
         const testCallExpressions = getTestCallExpressionsFromDeclaredVariables(
           context,
@@ -895,11 +1036,11 @@ var no_conditional_expect_default = createRule({
           inTestCase = true;
         }
       },
-      IfStatement: increaseConditionalDepth,
+      "IfStatement": increaseConditionalDepth,
       "IfStatement:exit": decreaseConditionalDepth,
-      LogicalExpression: increaseConditionalDepth,
+      "LogicalExpression": increaseConditionalDepth,
       "LogicalExpression:exit": decreaseConditionalDepth,
-      SwitchStatement: increaseConditionalDepth,
+      "SwitchStatement": increaseConditionalDepth,
       "SwitchStatement:exit": decreaseConditionalDepth
     };
   },
@@ -908,10 +1049,10 @@ var no_conditional_expect_default = createRule({
       category: "Best Practices",
       description: "Disallow calling `expect` conditionally",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-conditional-expect.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-conditional-expect.md"
     },
     messages: {
-      conditionalExpect: "Avoid calling `expect` conditionally`"
+      conditionalExpect: "Avoid calling `expect` conditionally"
     },
     type: "problem"
   }
@@ -925,13 +1066,11 @@ var no_conditional_in_test_default = createRule({
         return;
       }
       const call = findParent(node, "CallExpression");
-      if (!call)
-        return;
+      if (!call) return;
       if (isTypeOfFnCall(context, call, ["test", "step"])) {
         const testFunction = call.arguments[call.arguments.length - 1];
         const functionBody = findParent(node, "BlockStatement");
-        if (!functionBody)
-          return;
+        if (!functionBody) return;
         let currentParent = functionBody.parent;
         while (currentParent && currentParent !== testFunction) {
           currentParent = currentParent.parent;
@@ -953,7 +1092,7 @@ var no_conditional_in_test_default = createRule({
       category: "Best Practices",
       description: "Disallow conditional logic in tests",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-conditional-in-test.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-conditional-in-test.md"
     },
     messages: {
       conditionalInTest: "Avoid having conditionals in tests"
@@ -968,10 +1107,9 @@ var no_duplicate_hooks_default = createRule({
   create(context) {
     const hookContexts = [{}];
     return {
-      CallExpression(node) {
+      "CallExpression"(node) {
         const call = parseFnCall(context, node);
-        if (!call)
-          return;
+        if (!call) return;
         if (call.type === "describe") {
           hookContexts.push({});
         }
@@ -1002,7 +1140,7 @@ var no_duplicate_hooks_default = createRule({
       category: "Best Practices",
       description: "Disallow duplicate setup and teardown hooks",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-duplicate-hooks.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-duplicate-hooks.md"
     },
     messages: {
       noDuplicateHook: "Duplicate {{ hook }} in describe block"
@@ -1027,19 +1165,9 @@ var no_element_handle_default = createRule({
               {
                 fix: (fixer) => {
                   const { property } = node.callee;
-                  const fixes = [
-                    fixer.replaceTextRange(
-                      getPropertyRange(property),
-                      "locator"
-                    )
-                  ];
+                  const fixes = [fixer.replaceTextRange(getPropertyRange(property), "locator")];
                   if (node.parent.type === "AwaitExpression") {
-                    fixes.push(
-                      fixer.removeRange([
-                        node.parent.range[0],
-                        node.range[0]
-                      ])
-                    );
+                    fixes.push(fixer.removeRange([node.parent.range[0], node.range[0]]));
                   }
                   return fixes;
                 },
@@ -1056,7 +1184,7 @@ var no_element_handle_default = createRule({
       category: "Possible Errors",
       description: "The use of ElementHandle is discouraged, use Locator instead",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-element-handle.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-element-handle.md"
     },
     hasSuggestions: true,
     messages: {
@@ -1088,7 +1216,7 @@ var no_eval_default = createRule({
       category: "Possible Errors",
       description: "The use of `page.$eval` and `page.$$eval` are discouraged, use `locator.evaluate` or `locator.evaluateAll` instead",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-eval.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-eval.md"
     },
     messages: {
       noEval: "Unexpected use of page.$eval().",
@@ -1108,8 +1236,7 @@ var no_focused_test_default = createRule({
           return;
         }
         const onlyNode = call.members.find((s) => getStringValue(s) === "only");
-        if (!onlyNode)
-          return;
+        if (!onlyNode) return;
         context.report({
           messageId: "noFocusedTest",
           node: onlyNode,
@@ -1133,7 +1260,7 @@ var no_focused_test_default = createRule({
       category: "Possible Errors",
       description: "Prevent usage of `.only()` focus test annotation",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-focused-test.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-focused-test.md"
     },
     hasSuggestions: true,
     messages: {
@@ -1182,7 +1309,7 @@ var no_force_option_default = createRule({
       category: "Best Practices",
       description: "Prevent usage of `{ force: true }` option.",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-force-option.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-force-option.md"
     },
     messages: {
       noForceOption: "Unexpected use of { force: true } option."
@@ -1207,7 +1334,7 @@ var no_get_by_title_default = createRule({
       category: "Best Practices",
       description: "Disallows the usage of getByTitle()",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-get-by-title.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-get-by-title.md"
     },
     messages: {
       noGetByTitle: "The HTML title attribute is not an accessible name. Prefer getByRole() or getByLabelText() instead."
@@ -1226,8 +1353,7 @@ var no_hooks_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (!call)
-          return;
+        if (!call) return;
         if (call.type === "hook" && !options.allow.includes(call.name)) {
           context.report({
             data: { hookName: call.name },
@@ -1243,7 +1369,7 @@ var no_hooks_default = createRule({
       category: "Best Practices",
       description: "Disallow setup and teardown hooks",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-hooks.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-hooks.md"
     },
     messages: {
       unexpectedHook: "Unexpected '{{ hookName }}' hook"
@@ -1269,27 +1395,28 @@ var no_nested_step_default = createRule({
   create(context) {
     const stack = [];
     function pushStepCallback(node) {
-      if (node.parent.type !== "CallExpression" || !isTypeOfFnCall(context, node.parent, ["step"])) {
+      const { parent } = node;
+      if (parent?.type !== "CallExpression" || !isTypeOfFnCall(context, parent, ["step"])) {
         return;
       }
       stack.push(0);
       if (stack.length > 1) {
         context.report({
           messageId: "noNestedStep",
-          node: node.parent.callee
+          node: parent.callee
         });
       }
     }
     function popStepCallback(node) {
       const { parent } = node;
-      if (parent.type === "CallExpression" && isTypeOfFnCall(context, parent, ["step"])) {
+      if (parent?.type === "CallExpression" && isTypeOfFnCall(context, parent, ["step"])) {
         stack.pop();
       }
     }
     return {
-      ArrowFunctionExpression: pushStepCallback,
+      "ArrowFunctionExpression": pushStepCallback,
       "ArrowFunctionExpression:exit": popStepCallback,
-      FunctionExpression: pushStepCallback,
+      "FunctionExpression": pushStepCallback,
       "FunctionExpression:exit": popStepCallback
     };
   },
@@ -1298,7 +1425,7 @@ var no_nested_step_default = createRule({
       category: "Best Practices",
       description: "Disallow nested `test.step()` methods",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-nested-step.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-nested-step.md"
     },
     messages: {
       noNestedStep: "Do not nest `test.step()` methods."
@@ -1323,11 +1450,9 @@ var no_networkidle_default = createRule({
   create(context) {
     return {
       CallExpression(node) {
-        if (node.callee.type !== "MemberExpression")
-          return;
+        if (node.callee.type !== "MemberExpression") return;
         const methodName = getStringValue(node.callee.property);
-        if (!methods.has(methodName))
-          return;
+        if (!methods.has(methodName)) return;
         if (methodName === "waitForLoadState") {
           const arg = node.arguments[0];
           if (arg && isStringLiteral(arg, "networkidle")) {
@@ -1337,8 +1462,7 @@ var no_networkidle_default = createRule({
         }
         if (node.arguments.length >= 2) {
           const [_, arg] = node.arguments;
-          if (arg.type !== "ObjectExpression")
-            return;
+          if (arg.type !== "ObjectExpression") return;
           const property = arg.properties.filter((p) => p.type === "Property").find((p) => isStringLiteral(p.value, "networkidle"));
           if (property) {
             context.report({ messageId, node: property.value });
@@ -1352,7 +1476,7 @@ var no_networkidle_default = createRule({
       category: "Possible Errors",
       description: "Prevent usage of the networkidle option",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-networkidle.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-networkidle.md"
     },
     messages: {
       noNetworkidle: "Unexpected use of networkidle."
@@ -1367,11 +1491,9 @@ var no_nth_methods_default = createRule({
   create(context) {
     return {
       CallExpression(node) {
-        if (node.callee.type !== "MemberExpression")
-          return;
+        if (node.callee.type !== "MemberExpression") return;
         const method = getStringValue(node.callee.property);
-        if (!methods2.has(method))
-          return;
+        if (!methods2.has(method)) return;
         context.report({
           data: { method },
           loc: {
@@ -1388,7 +1510,7 @@ var no_nth_methods_default = createRule({
       category: "Best Practices",
       description: "Disallow usage of nth methods",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-nth-methods.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-nth-methods.md"
     },
     messages: {
       noNthMethod: "Unexpected use of {{method}}()"
@@ -1413,7 +1535,7 @@ var no_page_pause_default = createRule({
       category: "Possible Errors",
       description: "Prevent usage of page.pause()",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-page-pause.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-page-pause.md"
     },
     messages: {
       noPagePause: "Unexpected use of page.pause()."
@@ -1454,7 +1576,7 @@ var no_raw_locators_default = createRule({
       category: "Best Practices",
       description: "Disallows the usage of raw locators",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-raw-locators.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-raw-locators.md"
     },
     messages: {
       noRawLocator: "Usage of raw locator detected. Use methods like .getByRole() or .getByText() instead of raw locators."
@@ -1475,6 +1597,78 @@ var no_raw_locators_default = createRule({
   }
 });
 
+// src/rules/no-restricted-locators.ts
+var no_restricted_locators_default = createRule({
+  create(context) {
+    const options = context.options?.[0] ?? [];
+    const restrictions = options.map((option) => {
+      if (typeof option === "string") {
+        return { message: null, type: option };
+      }
+      return {
+        message: option.message ?? null,
+        type: option.type
+      };
+    });
+    const restrictionMap = /* @__PURE__ */ new Map();
+    for (const restriction of restrictions) {
+      restrictionMap.set(restriction.type, restriction.message);
+    }
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== "MemberExpression") {
+          return;
+        }
+        for (const [restrictedType, message] of restrictionMap.entries()) {
+          if (isPageMethod(node, restrictedType)) {
+            context.report({
+              data: {
+                message: message ?? "",
+                method: restrictedType
+              },
+              messageId: message ? "restrictedWithMessage" : "restricted",
+              node
+            });
+            break;
+          }
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      category: "Best Practices",
+      description: "Disallows the usage of specific locator methods",
+      recommended: false,
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-restricted-locators.md"
+    },
+    messages: {
+      restricted: "Usage of `{{method}}` is disallowed",
+      restrictedWithMessage: "{{message}}"
+    },
+    schema: [
+      {
+        items: {
+          oneOf: [
+            { type: "string" },
+            {
+              additionalProperties: false,
+              properties: {
+                message: { type: "string" },
+                type: { type: "string" }
+              },
+              required: ["type"],
+              type: "object"
+            }
+          ]
+        },
+        type: "array"
+      }
+    ],
+    type: "suggestion"
+  }
+});
+
 // src/rules/no-restricted-matchers.ts
 var no_restricted_matchers_default = createRule({
   create(context) {
@@ -1482,8 +1676,7 @@ var no_restricted_matchers_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (call?.type !== "expect")
-          return;
+        if (call?.type !== "expect") return;
         Object.entries(restrictedChains).map(([restriction, message]) => {
           const chain = call.members;
           const restrictionLinks = restriction.split(".").length;
@@ -1516,7 +1709,7 @@ var no_restricted_matchers_default = createRule({
       category: "Best Practices",
       description: "Disallow specific matchers & modifiers",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-restricted-matchers.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-restricted-matchers.md"
     },
     messages: {
       restricted: "Use of `{{restriction}}` is disallowed",
@@ -1546,8 +1739,7 @@ var no_skipped_test_default = createRule({
           return;
         }
         const skipNode = call.members.find((s) => getStringValue(s) === "skip");
-        if (!skipNode)
-          return;
+        if (!skipNode) return;
         const isStandalone = call.type === "config";
         if (isStandalone && allowConditional && (node.arguments.length !== 0 || findParent(node, "BlockStatement")?.parent?.type === "IfStatement")) {
           return;
@@ -1575,7 +1767,7 @@ var no_skipped_test_default = createRule({
       category: "Best Practices",
       description: "Prevent usage of the `.skip()` skip test annotation.",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-skipped-test.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-skipped-test.md"
     },
     hasSuggestions: true,
     messages: {
@@ -1610,8 +1802,7 @@ var no_slowed_test_default = createRule({
           return;
         }
         const slowNode = call.members.find((s) => getStringValue(s) === "slow");
-        if (!slowNode)
-          return;
+        if (!slowNode) return;
         const isStandalone = call.type === "config";
         if (isStandalone && allowConditional && (node.arguments.length !== 0 || findParent(node, "BlockStatement")?.parent?.type === "IfStatement")) {
           return;
@@ -1639,7 +1830,7 @@ var no_slowed_test_default = createRule({
       category: "Best Practices",
       description: "Prevent usage of the `.slow()` slow test annotation.",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-slowed-test.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-slowed-test.md"
     },
     hasSuggestions: true,
     messages: {
@@ -1664,10 +1855,10 @@ var no_slowed_test_default = createRule({
 
 // src/rules/no-standalone-expect.ts
 var getBlockType = (context, statement) => {
-  const func = getParent(statement);
+  const func = statement.parent;
   if (!func) {
     throw new Error(
-      `Unexpected BlockStatement. No parent defined. - please file a github issue at https://github.com/playwright-community/eslint-plugin-playwright`
+      `Unexpected BlockStatement. No parent defined. - please file a github issue at https://github.com/mskelton/eslint-plugin-playwright`
     );
   }
   if (func.type === "FunctionDeclaration") {
@@ -1688,7 +1879,7 @@ var no_standalone_expect_default = createRule({
   create(context) {
     const callStack = [];
     return {
-      ArrowFunctionExpression(node) {
+      "ArrowFunctionExpression"(node) {
         if (node.parent?.type !== "CallExpression") {
           callStack.push("arrow");
         }
@@ -1698,7 +1889,7 @@ var no_standalone_expect_default = createRule({
           callStack.pop();
         }
       },
-      BlockStatement(statement) {
+      "BlockStatement"(statement) {
         const blockType = getBlockType(context, statement);
         if (blockType) {
           callStack.push(blockType);
@@ -1709,10 +1900,10 @@ var no_standalone_expect_default = createRule({
           callStack.pop();
         }
       },
-      CallExpression(node) {
+      "CallExpression"(node) {
         const call = parseFnCall(context, node);
         if (call?.type === "expect") {
-          if (getParent(call.head.node)?.type === "MemberExpression" && call.members.length === 1) {
+          if (call.head.node.parent?.type === "MemberExpression" && call.members.length === 1) {
             return;
           }
           const parent = callStack.at(-1);
@@ -1747,7 +1938,7 @@ var no_standalone_expect_default = createRule({
       category: "Best Practices",
       description: "Disallow using `expect` outside of `test` blocks",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-standalone-expect.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-standalone-expect.md"
     },
     fixable: "code",
     messages: {
@@ -1766,22 +1957,16 @@ var truthy = Boolean;
 
 // src/rules/no-unsafe-references.ts
 function collectVariables(scope) {
-  if (!scope || scope.type === "global")
-    return [];
-  return [
-    ...collectVariables(scope.upper),
-    ...scope.variables.map((ref) => ref.name)
-  ];
+  if (!scope || scope.type === "global") return [];
+  return [...collectVariables(scope.upper), ...scope.variables.map((ref) => ref.name)];
 }
 function addArgument(fixer, node, refs) {
-  if (!node.arguments.length)
-    return;
+  if (!node.arguments.length) return;
   if (node.arguments.length === 1) {
     return fixer.insertTextAfter(node.arguments[0], `, [${refs}]`);
   }
   const arg = node.arguments.at(-1);
-  if (!arg)
-    return;
+  if (!arg) return;
   if (arg.type !== "ArrayExpression") {
     return fixer.replaceText(arg, `[${getStringValue(arg)}, ${refs}]`);
   }
@@ -1807,15 +1992,13 @@ var no_unsafe_references_default = createRule({
   create(context) {
     return {
       CallExpression(node) {
-        if (!isPageMethod(node, "evaluate") && !isPageMethod(node, "addInitScript"))
-          return;
+        if (!isPageMethod(node, "evaluate") && !isPageMethod(node, "addInitScript")) return;
         const [fn] = node.arguments;
-        if (!fn || !isFunction(fn))
-          return;
+        if (!fn || !isFunction(fn)) return;
         const { through, upper } = context.sourceCode.getScope(fn.body);
         const allRefs = new Set(collectVariables(upper));
         through.filter((ref) => {
-          const parent = getParent(ref.identifier);
+          const parent = ref.identifier.parent;
           return parent?.type !== "TSTypeReference";
         }).filter((ref) => allRefs.has(ref.identifier.name)).forEach((ref, i, arr) => {
           const methodName = isPageMethod(node, "evaluate") ? "evaluate" : "addInitScript";
@@ -1832,10 +2015,9 @@ var no_unsafe_references_default = createRule({
             ...descriptor,
             fix(fixer) {
               const refs = arr.map((ref2) => ref2.identifier.name).join(", ");
-              return [
-                addArgument(fixer, node, refs),
-                addParam(context, fixer, fn, refs)
-              ].filter(truthy);
+              return [addArgument(fixer, node, refs), addParam(context, fixer, fn, refs)].filter(
+                truthy
+              );
             }
           });
         });
@@ -1847,7 +2029,7 @@ var no_unsafe_references_default = createRule({
       category: "Possible Errors",
       description: "Prevent unsafe variable references in page.evaluate() and page.addInitScript()",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-unsafe-references.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-unsafe-references.md"
     },
     fixable: "code",
     messages: {
@@ -1877,7 +2059,7 @@ var no_unused_locators_default = createRule({
       category: "Possible Errors",
       description: `Disallow usage of page locators that are not used`,
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-unused-locators.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-unused-locators.md"
     },
     messages: {
       noUnusedLocator: "Unused locator"
@@ -1947,8 +2129,7 @@ var expectMatchers = /* @__PURE__ */ new Set([
   "toThrowError"
 ]);
 function isSupportedMethod(node) {
-  if (node.callee.type !== "MemberExpression")
-    return false;
+  if (node.callee.type !== "MemberExpression") return false;
   const name = getStringValue(node.callee.property);
   return locatorMethods.has(name) || pageMethods.has(name) && isPageMethod(node, name);
 }
@@ -1975,9 +2156,7 @@ var no_useless_await_default = createRule({
           return fix(node.parent);
         }
         const call = parseFnCall(context, node);
-        if (call?.type === "expect" && !call.modifiers.some(
-          (modifier) => isIdentifier(modifier, /^(resolves|rejects)$/)
-        ) && !call.members.some((member) => isIdentifier(member, "poll")) && expectMatchers.has(call.matcherName)) {
+        if (call?.type === "expect" && !call.modifiers.some((modifier) => isIdentifier(modifier, /^(resolves|rejects)$/)) && !call.members.some((member) => isIdentifier(member, "poll")) && expectMatchers.has(call.matcherName)) {
           return fix(node.parent);
         }
       }
@@ -1988,7 +2167,7 @@ var no_useless_await_default = createRule({
       category: "Possible Errors",
       description: "Disallow unnecessary awaits for Playwright methods",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-useless-await.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-useless-await.md"
     },
     fixable: "code",
     messages: {
@@ -2002,15 +2181,11 @@ var no_useless_await_default = createRule({
 var getRangeOffset = (node) => node.type === "Identifier" ? 0 : 1;
 function replaceAccessorFixer(fixer, node, text) {
   const [start, end] = node.range;
-  return fixer.replaceTextRange(
-    [start + getRangeOffset(node), end - getRangeOffset(node)],
-    text
-  );
+  return fixer.replaceTextRange([start + getRangeOffset(node), end - getRangeOffset(node)], text);
 }
 function removePropertyFixer(fixer, property) {
-  const parent = getParent(property);
-  if (parent?.type !== "ObjectExpression")
-    return;
+  const parent = property.parent;
+  if (parent?.type !== "ObjectExpression") return;
   if (parent.properties.length === 1) {
     return fixer.remove(parent);
   }
@@ -2034,8 +2209,7 @@ var matcherConfig = {
 };
 function getOptions(call, name) {
   const [arg] = call.matcherArgs;
-  if (arg?.type !== "ObjectExpression")
-    return;
+  if (arg?.type !== "ObjectExpression") return;
   const property = arg.properties.find(
     (p) => p.type === "Property" && getStringValue(p.key) === name && isBooleanLiteral(p.value)
   );
@@ -2050,19 +2224,13 @@ var no_useless_not_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (call?.type !== "expect")
-          return;
+        if (call?.type !== "expect") return;
         const config = matcherConfig[call.matcherName];
-        if (!config)
-          return;
+        if (!config) return;
         const options = config.argName ? getOptions(call, config.argName) : void 0;
-        if (options?.arg && options.value === void 0)
-          return;
-        const notModifier = call.modifiers.find(
-          (mod) => getStringValue(mod) === "not"
-        );
-        if (!notModifier && !options?.property)
-          return;
+        if (options?.arg && options.value === void 0) return;
+        const notModifier = call.modifiers.find((mod) => getStringValue(mod) === "not");
+        if (!notModifier && !options?.property) return;
         const isInverted = !!notModifier !== (options?.value === false);
         const newMatcherName = isInverted ? config.inverse : call.matcherName;
         context.report({
@@ -2095,7 +2263,7 @@ var no_useless_not_default = createRule({
       category: "Best Practices",
       description: `Disallow usage of 'not' matchers when a more specific matcher exists`,
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-useless-not.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-useless-not.md"
     },
     fixable: "code",
     messages: {
@@ -2134,7 +2302,7 @@ var no_wait_for_navigation_default = createRule({
       category: "Possible Errors",
       description: "Prevent usage of page.waitForNavigation()",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-wait-for-navigation.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-wait-for-navigation.md"
     },
     hasSuggestions: true,
     messages: {
@@ -2172,7 +2340,7 @@ var no_wait_for_selector_default = createRule({
       category: "Best Practices",
       description: "Prevent usage of page.waitForSelector()",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-wait-for-selector.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-wait-for-selector.md"
     },
     hasSuggestions: true,
     messages: {
@@ -2210,7 +2378,7 @@ var no_wait_for_timeout_default = createRule({
       category: "Best Practices",
       description: "Prevent usage of page.waitForTimeout()",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-wait-for-timeout.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/no-wait-for-timeout.md"
     },
     hasSuggestions: true,
     messages: {
@@ -2249,20 +2417,16 @@ var prefer_comparison_matcher_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (call?.type !== "expect" || call.matcherArgs.length === 0)
-          return;
-        const expect = getParent(call.head.node);
-        if (expect?.type !== "CallExpression")
-          return;
+        if (call?.type !== "expect" || call.matcherArgs.length === 0) return;
+        const expect = call.head.node.parent;
+        if (expect?.type !== "CallExpression") return;
         const [comparison] = expect.arguments;
         const expectCallEnd = expect.range[1];
         const [matcherArg] = call.matcherArgs;
         if (comparison?.type !== "BinaryExpression" || isComparingToString(comparison) || !equalityMatchers.has(call.matcherName) || !isBooleanLiteral(matcherArg)) {
           return;
         }
-        const hasNot = call.modifiers.some(
-          (node2) => getStringValue(node2) === "not"
-        );
+        const hasNot = call.modifiers.some((node2) => getStringValue(node2) === "not");
         const preferredMatcher = determineMatcher(
           comparison.operator,
           getRawValue(matcherArg) === hasNot.toString()
@@ -2277,20 +2441,14 @@ var prefer_comparison_matcher_default = createRule({
             const modifierText = modifier && getStringValue(modifier) !== "not" ? `.${getStringValue(modifier)}` : "";
             return [
               // Replace the comparison argument with the left-hand side of the comparison
-              fixer.replaceText(
-                comparison,
-                context.sourceCode.getText(comparison.left)
-              ),
+              fixer.replaceText(comparison, context.sourceCode.getText(comparison.left)),
               // Replace the current matcher & modifier with the preferred matcher
               fixer.replaceTextRange(
-                [expectCallEnd, getParent(call.matcher).range[1]],
+                [expectCallEnd, call.matcher.parent.range[1]],
                 `${modifierText}.${preferredMatcher}`
               ),
               // Replace the matcher argument with the right-hand side of the comparison
-              fixer.replaceText(
-                matcherArg,
-                context.sourceCode.getText(comparison.right)
-              )
+              fixer.replaceText(matcherArg, context.sourceCode.getText(comparison.right))
             ];
           },
           messageId: "useToBeComparison",
@@ -2304,7 +2462,7 @@ var prefer_comparison_matcher_default = createRule({
       category: "Best Practices",
       description: "Suggest using the built-in comparison matchers",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-comparison-matcher.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-comparison-matcher.md"
     },
     fixable: "code",
     messages: {
@@ -2320,11 +2478,9 @@ var prefer_equality_matcher_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (call?.type !== "expect" || call.matcherArgs.length === 0)
-          return;
-        const expect = getParent(call.head.node);
-        if (expect?.type !== "CallExpression")
-          return;
+        if (call?.type !== "expect" || call.matcherArgs.length === 0) return;
+        const expect = call.head.node.parent;
+        if (expect?.type !== "CallExpression") return;
         const [comparison] = expect.arguments;
         const expectCallEnd = expect.range[1];
         const [matcherArg] = call.matcherArgs;
@@ -2333,9 +2489,7 @@ var prefer_equality_matcher_default = createRule({
         }
         const matcherValue = getRawValue(matcherArg) === "true";
         const [modifier] = call.modifiers;
-        const hasNot = call.modifiers.some(
-          (node2) => getStringValue(node2) === "not"
-        );
+        const hasNot = call.modifiers.some((node2) => getStringValue(node2) === "not");
         const addNotModifier = (comparison.operator === "!==" ? !matcherValue : matcherValue) === hasNot;
         context.report({
           messageId: "useEqualityMatcher",
@@ -2349,20 +2503,14 @@ var prefer_equality_matcher_default = createRule({
               }
               return [
                 // replace the comparison argument with the left-hand side of the comparison
-                fixer.replaceText(
-                  comparison,
-                  context.sourceCode.getText(comparison.left)
-                ),
+                fixer.replaceText(comparison, context.sourceCode.getText(comparison.left)),
                 // replace the current matcher & modifier with the preferred matcher
                 fixer.replaceTextRange(
-                  [expectCallEnd, getParent(call.matcher).range[1]],
+                  [expectCallEnd, call.matcher.parent.range[1]],
                   `${modifierText}.${equalityMatcher}`
                 ),
                 // replace the matcher argument with the right-hand side of the comparison
-                fixer.replaceText(
-                  matcherArg,
-                  context.sourceCode.getText(comparison.right)
-                )
+                fixer.replaceText(matcherArg, context.sourceCode.getText(comparison.right))
               ];
             },
             messageId: "suggestEqualityMatcher"
@@ -2376,7 +2524,7 @@ var prefer_equality_matcher_default = createRule({
       category: "Best Practices",
       description: "Suggest using the built-in equality matchers",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-equality-matcher.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-equality-matcher.md"
     },
     hasSuggestions: true,
     messages: {
@@ -2394,9 +2542,8 @@ var prefer_hooks_in_order_default = createRule({
     let previousHookIndex = -1;
     let inHook = false;
     return {
-      CallExpression(node) {
-        if (inHook)
-          return;
+      "CallExpression"(node) {
+        if (inHook) return;
         const call = parseFnCall(context, node);
         if (call?.type !== "hook") {
           previousHookIndex = -1;
@@ -2423,8 +2570,7 @@ var prefer_hooks_in_order_default = createRule({
           inHook = false;
           return;
         }
-        if (inHook)
-          return;
+        if (inHook) return;
         previousHookIndex = -1;
       }
     };
@@ -2434,7 +2580,7 @@ var prefer_hooks_in_order_default = createRule({
       category: "Best Practices",
       description: "Prefer having hooks in a consistent order",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-hooks-in-order.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-hooks-in-order.md"
     },
     messages: {
       reorderHooks: "`{{ currentHook }}` hooks should be before any `{{ previousHook }}` hooks"
@@ -2448,7 +2594,7 @@ var prefer_hooks_on_top_default = createRule({
   create(context) {
     const stack = [false];
     return {
-      CallExpression(node) {
+      "CallExpression"(node) {
         if (isTypeOfFnCall(context, node, ["test"])) {
           stack[stack.length - 1] = true;
         }
@@ -2467,7 +2613,7 @@ var prefer_hooks_on_top_default = createRule({
       category: "Best Practices",
       description: "Suggest having hooks before any test cases",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-hooks-on-top.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-hooks-on-top.md"
     },
     messages: {
       noHookOnTop: "Hooks should come before test cases"
@@ -2503,8 +2649,7 @@ var pageMethods2 = /* @__PURE__ */ new Set([
   "uncheck"
 ]);
 function isSupportedMethod2(node) {
-  if (node.callee.type !== "MemberExpression")
-    return false;
+  if (node.callee.type !== "MemberExpression") return false;
   const name = getStringValue(node.callee.property);
   return pageMethods2.has(name) && isPageMethod(node, name);
 }
@@ -2512,8 +2657,7 @@ var prefer_locator_default = createRule({
   create(context) {
     return {
       CallExpression(node) {
-        if (!isSupportedMethod2(node))
-          return;
+        if (!isSupportedMethod2(node)) return;
         context.report({
           messageId: "preferLocator",
           node
@@ -2526,7 +2670,7 @@ var prefer_locator_default = createRule({
       category: "Best Practices",
       description: "Suggest locators over page methods",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-locator.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-locator.md"
     },
     messages: {
       preferLocator: "Prefer locator methods instead of page methods"
@@ -2547,7 +2691,7 @@ var prefer_lowercase_title_default = createRule({
     };
     let describeCount = 0;
     return {
-      CallExpression(node) {
+      "CallExpression"(node) {
         const call = parseFnCall(context, node);
         if (call?.type !== "describe" && call?.type !== "test") {
           return;
@@ -2574,10 +2718,7 @@ var prefer_lowercase_title_default = createRule({
         context.report({
           data: { method },
           fix(fixer) {
-            const rangeIgnoringQuotes = [
-              title.range[0] + 1,
-              title.range[1] - 1
-            ];
+            const rangeIgnoringQuotes = [title.range[0] + 1, title.range[1] - 1];
             const newDescription = description.substring(0, 1).toLowerCase() + description.substring(1);
             return fixer.replaceTextRange(rangeIgnoringQuotes, newDescription);
           },
@@ -2597,7 +2738,7 @@ var prefer_lowercase_title_default = createRule({
       category: "Best Practices",
       description: "Enforce lowercase test names",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-lowercase-title.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-lowercase-title.md"
     },
     fixable: "code",
     messages: {
@@ -2632,9 +2773,7 @@ var prefer_lowercase_title_default = createRule({
 });
 
 // src/rules/prefer-native-locators.ts
-var compilePatterns = ({
-  testIdAttribute
-}) => {
+var compilePatterns = ({ testIdAttribute }) => {
   const patterns = [
     {
       attribute: "aria-label",
@@ -2681,11 +2820,9 @@ var prefer_native_locators_default = createRule({
     const patterns = compilePatterns({ testIdAttribute });
     return {
       CallExpression(node) {
-        if (node.callee.type !== "MemberExpression")
-          return;
+        if (node.callee.type !== "MemberExpression") return;
         const query = getStringValue(node.arguments[0]);
-        if (!isPageMethod(node, "locator"))
-          return;
+        if (!isPageMethod(node, "locator")) return;
         for (const pattern of patterns) {
           const match = query.match(pattern.pattern);
           if (match) {
@@ -2711,7 +2848,7 @@ var prefer_native_locators_default = createRule({
       category: "Best Practices",
       description: "Prefer native locator functions",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-native-locators.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-native-locators.md"
     },
     fixable: "code",
     messages: {
@@ -2744,8 +2881,7 @@ var prefer_strict_equal_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (call?.type !== "expect")
-          return;
+        if (call?.type !== "expect") return;
         if (call.matcherName === "toEqual") {
           context.report({
             messageId: "useToStrictEqual",
@@ -2753,11 +2889,7 @@ var prefer_strict_equal_default = createRule({
             suggest: [
               {
                 fix: (fixer) => {
-                  return replaceAccessorFixer(
-                    fixer,
-                    call.matcher,
-                    "toStrictEqual"
-                  );
+                  return replaceAccessorFixer(fixer, call.matcher, "toStrictEqual");
                 },
                 messageId: "suggestReplaceWithStrictEqual"
               }
@@ -2772,7 +2904,7 @@ var prefer_strict_equal_default = createRule({
       category: "Best Practices",
       description: "Suggest using `toStrictEqual()`",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-strict-equal.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-strict-equal.md"
     },
     fixable: "code",
     hasSuggestions: true,
@@ -2799,9 +2931,7 @@ function shouldUseToBe(call) {
 function reportPreferToBe(context, call, whatToBe, notModifier) {
   context.report({
     fix(fixer) {
-      const fixes = [
-        replaceAccessorFixer(fixer, call.matcher, `toBe${whatToBe}`)
-      ];
+      const fixes = [replaceAccessorFixer(fixer, call.matcher, `toBe${whatToBe}`)];
       if (call.matcherArgs?.length && whatToBe !== "") {
         fixes.push(fixer.remove(call.matcherArgs[0]));
       }
@@ -2820,12 +2950,9 @@ var prefer_to_be_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (call?.type !== "expect")
-          return;
+        if (call?.type !== "expect") return;
         const notMatchers = ["toBeUndefined", "toBeDefined"];
-        const notModifier = call.modifiers.find(
-          (node2) => getStringValue(node2) === "not"
-        );
+        const notModifier = call.modifiers.find((node2) => getStringValue(node2) === "not");
         if (notModifier && notMatchers.includes(call.matcherName)) {
           return reportPreferToBe(
             context,
@@ -2859,7 +2986,7 @@ var prefer_to_be_default = createRule({
       category: "Best Practices",
       description: "Suggest using `toBe()` for primitive literals",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-be.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-be.md"
     },
     fixable: "code",
     messages: {
@@ -2881,20 +3008,16 @@ var prefer_to_contain_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (call?.type !== "expect" || call.matcherArgs.length === 0)
-          return;
-        const expect = getParent(call.head.node);
-        if (expect?.type !== "CallExpression")
-          return;
+        if (call?.type !== "expect" || call.matcherArgs.length === 0) return;
+        const expect = call.head.node.parent;
+        if (expect?.type !== "CallExpression") return;
         const [includesCall] = expect.arguments;
         const { matcher } = call;
         const [matcherArg] = call.matcherArgs;
         if (!includesCall || matcherArg.type === "SpreadElement" || !equalityMatchers.has(getStringValue(matcher)) || !isBooleanLiteral(matcherArg) || !isFixableIncludesCallExpression(includesCall)) {
           return;
         }
-        const notModifier = call.modifiers.find(
-          (node2) => getStringValue(node2) === "not"
-        );
+        const notModifier = call.modifiers.find((node2) => getStringValue(node2) === "not");
         context.report({
           fix(fixer) {
             const addNotModifier = matcherArg.type === "Literal" && matcherArg.value === !!notModifier;
@@ -2905,10 +3028,7 @@ var prefer_to_contain_default = createRule({
                 includesCall.range[1]
               ]),
               // replace the current matcher with "toContain", adding "not" if needed
-              fixer.replaceText(
-                matcher,
-                addNotModifier ? "not.toContain" : "toContain"
-              ),
+              fixer.replaceText(matcher, addNotModifier ? "not.toContain" : "toContain"),
               // replace the matcher argument with the value from the "includes"
               fixer.replaceText(
                 call.matcherArgs[0],
@@ -2916,12 +3036,7 @@ var prefer_to_contain_default = createRule({
               )
             ];
             if (notModifier) {
-              fixes.push(
-                fixer.removeRange([
-                  notModifier.range[0],
-                  notModifier.range[1] + 1
-                ])
-              );
+              fixes.push(fixer.removeRange([notModifier.range[0], notModifier.range[1] + 1]));
             }
             return fixes;
           },
@@ -2936,7 +3051,7 @@ var prefer_to_contain_default = createRule({
       category: "Best Practices",
       description: "Suggest using toContain()",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-contain.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-contain.md"
     },
     fixable: "code",
     messages: {
@@ -2966,15 +3081,9 @@ var prefer_to_have_count_default = createRule({
           fix(fixer) {
             return [
               // remove the "await" expression
-              fixer.removeRange([
-                argument.range[0],
-                argument.range[0] + "await".length + 1
-              ]),
+              fixer.removeRange([argument.range[0], argument.range[0] + "await".length + 1]),
               // remove the "count()" method accessor
-              fixer.removeRange([
-                callee.property.range[0] - 1,
-                argument.argument.range[1]
-              ]),
+              fixer.removeRange([callee.property.range[0] - 1, argument.argument.range[1]]),
               // replace the current matcher with "toHaveCount"
               replaceAccessorFixer(fixer, call.matcher, "toHaveCount"),
               // insert "await" to before "expect()"
@@ -2992,7 +3101,7 @@ var prefer_to_have_count_default = createRule({
       category: "Best Practices",
       description: "Suggest using `toHaveCount()`",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-have-count.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-have-count.md"
     },
     fixable: "code",
     messages: {
@@ -3020,10 +3129,7 @@ var prefer_to_have_length_default = createRule({
           fix(fixer) {
             return [
               // remove the "length" property accessor
-              fixer.removeRange([
-                argument.property.range[0] - 1,
-                argument.range[1]
-              ]),
+              fixer.removeRange([argument.property.range[0] - 1, argument.range[1]]),
               // replace the current matcher with "toHaveLength"
               replaceAccessorFixer(fixer, call.matcher, "toHaveLength")
             ];
@@ -3039,7 +3145,7 @@ var prefer_to_have_length_default = createRule({
       category: "Best Practices",
       description: "Suggest using `toHaveLength()`",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-have-length.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-to-have-length.md"
     },
     fixable: "code",
     messages: {
@@ -3052,6 +3158,16 @@ var prefer_to_have_length_default = createRule({
 
 // src/rules/prefer-web-first-assertions.ts
 var methods3 = {
+  allInnerTexts: {
+    fixable: false,
+    matcher: "toHaveText",
+    type: "string"
+  },
+  allTextContents: {
+    fixable: false,
+    matcher: "toHaveText",
+    type: "string"
+  },
   getAttribute: {
     matcher: "toHaveAttribute",
     type: "string"
@@ -3086,41 +3202,37 @@ var methods3 = {
   },
   textContent: { matcher: "toHaveText", type: "string" }
 };
-var supportedMatchers = /* @__PURE__ */ new Set([
-  "toBe",
-  "toEqual",
-  "toBeTruthy",
-  "toBeFalsy"
-]);
+var supportedMatchers = /* @__PURE__ */ new Set(["toBe", "toEqual", "toBeTruthy", "toBeFalsy"]);
 var prefer_web_first_assertions_default = createRule({
   create(context) {
     return {
       CallExpression(node) {
         const fnCall = parseFnCall(context, node);
-        if (fnCall?.type !== "expect")
-          return;
+        if (fnCall?.type !== "expect") return;
         const expect = findParent(fnCall.head.node, "CallExpression");
-        if (!expect)
-          return;
+        if (!expect) return;
         const arg = dereference(context, fnCall.args[0]);
-        if (!arg)
-          return;
+        if (!arg) return;
         const call = arg.type === "AwaitExpression" ? arg.argument : arg;
         if (call.type !== "CallExpression" || call.callee.type !== "MemberExpression") {
           return;
         }
-        if (!supportedMatchers.has(fnCall.matcherName))
-          return;
+        if (!supportedMatchers.has(fnCall.matcherName)) return;
         const method = getStringValue(call.callee.property);
         const methodConfig = methods3[method];
-        if (!Object.hasOwn(methods3, method))
-          return;
-        const notModifier = fnCall.modifiers.find(
-          (mod) => getStringValue(mod) === "not"
-        );
+        if (!Object.hasOwn(methods3, method)) return;
+        const notModifier = fnCall.modifiers.find((mod) => getStringValue(mod) === "not");
         const isFalsy = methodConfig.type === "boolean" && (!!fnCall.matcherArgs.length && isBooleanLiteral(fnCall.matcherArgs[0], false) || fnCall.matcherName === "toBeFalsy");
         const isInverse = methodConfig.inverse ? notModifier || isFalsy : notModifier && isFalsy;
         const newMatcher = +!!notModifier ^ +isFalsy && methodConfig.inverse || methodConfig.matcher;
+        if (methodConfig.fixable === false) {
+          context.report({
+            data: { matcher: methodConfig.matcher, method },
+            messageId: "useWebFirstAssertion",
+            node: call.callee.property
+          });
+          return;
+        }
         const { callee } = call;
         context.report({
           data: {
@@ -3136,10 +3248,7 @@ var prefer_web_first_assertions_default = createRule({
               // Remove the await keyword
               fixer.replaceTextRange([arg.range[0], call.range[0]], ""),
               // Remove the old Playwright method and any arguments
-              fixer.replaceTextRange(
-                [callee.property.range[0] - 1, methodEnd],
-                ""
-              )
+              fixer.replaceTextRange([callee.property.range[0] - 1, methodEnd], "")
             ];
             if (isInverse && notModifier) {
               const notRange = notModifier.range;
@@ -3158,18 +3267,11 @@ var prefer_web_first_assertions_default = createRule({
               const args = `{ ${propArg}: ${variable} }`;
               fixes.push(fixer.replaceText(matcherArg, args));
             }
-            const hasOtherArgs = !!methodArgs.filter(
-              (arg2) => !isBooleanLiteral(arg2)
-            ).length;
+            const hasOtherArgs = !!methodArgs.filter((arg2) => !isBooleanLiteral(arg2)).length;
             if (methodArgs) {
               const range = fnCall.matcher.range;
               const stringArgs = methodArgs.map((arg2) => getRawValue(arg2)).concat(hasOtherArgs ? "" : []).join(", ");
-              fixes.push(
-                fixer.insertTextAfterRange(
-                  [range[0], range[1] + 1],
-                  stringArgs
-                )
-              );
+              fixes.push(fixer.insertTextAfterRange([range[0], range[1] + 1], stringArgs));
             }
             return fixes;
           },
@@ -3184,7 +3286,7 @@ var prefer_web_first_assertions_default = createRule({
       category: "Best Practices",
       description: "Prefer web first assertions",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-web-first-assertions.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/prefer-web-first-assertions.md"
     },
     fixable: "code",
     messages: {
@@ -3208,9 +3310,7 @@ var shouldBeInHook = (context, node, allowedFunctionCalls = []) => {
       if (node.kind === "const") {
         return false;
       }
-      return node.declarations.some(
-        ({ init }) => init != null && !isNullOrUndefined(init)
-      );
+      return node.declarations.some(({ init }) => init != null && !isNullOrUndefined(init));
     }
     default:
       return false;
@@ -3253,7 +3353,7 @@ var require_hook_default = createRule({
       category: "Best Practices",
       description: "Require setup and teardown code to be within a hook",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/require-hook.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/require-hook.md"
     },
     messages: {
       useHook: "This should be done within a hook"
@@ -3298,7 +3398,7 @@ var require_soft_assertions_default = createRule({
     docs: {
       description: "Require all assertions to use `expect.soft`",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/require-soft-assertions.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/require-soft-assertions.md"
     },
     fixable: "code",
     messages: {
@@ -3315,8 +3415,7 @@ var require_to_throw_message_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (call?.type !== "expect")
-          return;
+        if (call?.type !== "expect") return;
         if (call.matcherArgs.length === 0 && ["toThrow", "toThrowError"].includes(call.matcherName) && !call.modifiers.some((nod) => getStringValue(nod) === "not")) {
           context.report({
             data: { matcherName: call.matcherName },
@@ -3332,7 +3431,7 @@ var require_to_throw_message_default = createRule({
       category: "Best Practices",
       description: "Require a message for `toThrow()`",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/require-to-throw-message.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/require-to-throw-message.md"
     },
     messages: {
       addErrorMessage: "Add an error message to {{ matcherName }}()"
@@ -3352,10 +3451,9 @@ var require_top_level_describe_default = createRule({
     let topLevelDescribeCount = 0;
     let describeCount = 0;
     return {
-      CallExpression(node) {
+      "CallExpression"(node) {
         const call = parseFnCall(context, node);
-        if (!call)
-          return;
+        if (!call) return;
         if (call.type === "describe") {
           describeCount++;
           if (describeCount === 1) {
@@ -3388,7 +3486,7 @@ var require_top_level_describe_default = createRule({
       category: "Best Practices",
       description: "Require test cases and hooks to be inside a `test.describe` block",
       recommended: false,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/require-top-level-describe.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/require-top-level-describe.md"
     },
     messages: {
       tooManyDescribes: "There should not be more than {{amount}} describe{{s}} at the top level",
@@ -3425,8 +3523,7 @@ var valid_describe_callback_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (call?.group !== "describe")
-          return;
+        if (call?.group !== "describe") return;
         if (call.members.some((s) => getStringValue(s) === "configure")) {
           return;
         }
@@ -3485,7 +3582,7 @@ var valid_describe_callback_default = createRule({
       category: "Possible Errors",
       description: "Enforce valid `describe()` callback",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/valid-describe-callback.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/valid-describe-callback.md"
     },
     messages: {
       invalidCallback: "Callback argument must be a function",
@@ -3499,132 +3596,6 @@ var valid_describe_callback_default = createRule({
   }
 });
 
-// src/rules/valid-expect.ts
-var findTopMostMemberExpression = (node) => {
-  let topMostMemberExpression = node;
-  let parent = getParent(node);
-  while (parent) {
-    if (parent.type !== "MemberExpression") {
-      break;
-    }
-    topMostMemberExpression = parent;
-    parent = parent.parent;
-  }
-  return topMostMemberExpression;
-};
-var valid_expect_default = createRule({
-  create(context) {
-    const options = {
-      maxArgs: 2,
-      minArgs: 1,
-      ...context.options?.[0] ?? {}
-    };
-    const minArgs = Math.min(options.minArgs, options.maxArgs);
-    const maxArgs = Math.max(options.minArgs, options.maxArgs);
-    return {
-      CallExpression(node) {
-        const call = parseFnCallWithReason(context, node);
-        if (typeof call === "string") {
-          const reportingNode = node.parent?.type === "MemberExpression" ? findTopMostMemberExpression(node.parent).property : node;
-          if (call === "matcher-not-found") {
-            context.report({
-              messageId: "matcherNotFound",
-              node: reportingNode
-            });
-            return;
-          }
-          if (call === "matcher-not-called") {
-            context.report({
-              messageId: isSupportedAccessor(reportingNode) && modifiers.has(getStringValue(reportingNode)) ? "matcherNotFound" : "matcherNotCalled",
-              node: reportingNode
-            });
-          }
-          if (call === "modifier-unknown") {
-            context.report({
-              messageId: "modifierUnknown",
-              node: reportingNode
-            });
-            return;
-          }
-          return;
-        } else if (call?.type !== "expect") {
-          return;
-        }
-        const expect = getParent(call.head.node);
-        if (expect?.type !== "CallExpression")
-          return;
-        if (expect.arguments.length < minArgs) {
-          const expectLength = getStringValue(call.head.node).length;
-          const loc = {
-            end: {
-              column: expect.loc.start.column + expectLength + 1,
-              line: expect.loc.start.line
-            },
-            start: {
-              column: expect.loc.start.column + expectLength,
-              line: expect.loc.start.line
-            }
-          };
-          context.report({
-            data: getAmountData(minArgs),
-            loc,
-            messageId: "notEnoughArgs",
-            node: expect
-          });
-        }
-        if (expect.arguments.length > maxArgs) {
-          const { start } = expect.arguments[maxArgs].loc;
-          const { end } = expect.arguments.at(-1).loc;
-          const loc = {
-            end: {
-              column: end.column,
-              line: end.line
-            },
-            start
-          };
-          context.report({
-            data: getAmountData(maxArgs),
-            loc,
-            messageId: "tooManyArgs",
-            node: expect
-          });
-        }
-      }
-    };
-  },
-  meta: {
-    docs: {
-      category: "Possible Errors",
-      description: "Enforce valid `expect()` usage",
-      recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/valid-expect.md"
-    },
-    messages: {
-      matcherNotCalled: "Matchers must be called to assert.",
-      matcherNotFound: "Expect must have a corresponding matcher call.",
-      notEnoughArgs: "Expect requires at least {{amount}} argument{{s}}.",
-      tooManyArgs: "Expect takes at most {{amount}} argument{{s}}."
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          maxArgs: {
-            minimum: 1,
-            type: "number"
-          },
-          minArgs: {
-            minimum: 1,
-            type: "number"
-          }
-        },
-        type: "object"
-      }
-    ],
-    type: "problem"
-  }
-});
-
 // src/rules/valid-expect-in-promise.ts
 var isPromiseChainCall = (node) => {
   if (node.type === "CallExpression" && node.callee.type === "MemberExpression" && isSupportedAccessor(node.callee.property)) {
@@ -3646,9 +3617,7 @@ var isTestCaseCallWithCallbackArg = (context, node) => {
   if (jestCallFn?.type !== "test") {
     return false;
   }
-  const isJestEach = jestCallFn.members.some(
-    (s) => getStringValue(s) === "each"
-  );
+  const isJestEach = jestCallFn.members.some((s) => getStringValue(s) === "each");
   if (isJestEach && node.callee.type !== "TaggedTemplateExpression") {
     return true;
   }
@@ -3658,8 +3627,7 @@ var isTestCaseCallWithCallbackArg = (context, node) => {
 };
 var isPromiseMethodThatUsesValue = (node, identifier) => {
   const name = getStringValue(identifier);
-  if (node.argument == null)
-    return false;
+  if (node.argument == null) return false;
   if (node.argument.type === "CallExpression" && node.argument.arguments.length > 0) {
     const nodeName = getNodeName(node.argument);
     if (["Promise.all", "Promise.allSettled"].includes(nodeName)) {
@@ -3763,10 +3731,10 @@ var findFirstBlockBodyUp = (node) => {
     if (parent.type === "BlockStatement") {
       return parent.body;
     }
-    parent = getParent(parent);
+    parent = parent.parent;
   }
   throw new Error(
-    `Could not find BlockStatement - please file a github issue at https://github.com/playwright-community/eslint-plugin-playwright`
+    `Could not find BlockStatement - please file a github issue at https://github.com/mskelton/eslint-plugin-playwright`
   );
 };
 var isDirectlyWithinTestCaseCall = (context, node) => {
@@ -3776,7 +3744,7 @@ var isDirectlyWithinTestCaseCall = (context, node) => {
       parent = parent.parent;
       return parent?.type === "CallExpression" && isTypeOfFnCall(context, parent, ["test"]);
     }
-    parent = getParent(parent);
+    parent = parent.parent;
   }
   return false;
 };
@@ -3792,7 +3760,7 @@ var valid_expect_in_promise_default = createRule({
     let inTestCaseWithDoneCallback = false;
     const chains = [];
     return {
-      CallExpression(node) {
+      "CallExpression"(node) {
         if (isTestCaseCallWithCallbackArg(context, node)) {
           inTestCaseWithDoneCallback = true;
           return;
@@ -3831,11 +3799,7 @@ var valid_expect_in_promise_default = createRule({
             break;
           }
           case "AssignmentExpression": {
-            if (parent.left.type === "Identifier" && isValueAwaitedOrReturned(
-              context,
-              parent.left,
-              findFirstBlockBodyUp(parent)
-            )) {
+            if (parent.left.type === "Identifier" && isValueAwaitedOrReturned(context, parent.left, findFirstBlockBodyUp(parent))) {
               return;
             }
             break;
@@ -3859,7 +3823,7 @@ var valid_expect_in_promise_default = createRule({
       category: "Best Practices",
       description: "Require promises that have expectations in their chain to be valid",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/valid-expect-in-promise.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/valid-expect-in-promise.md"
     },
     messages: {
       expectInFloatingPromise: "This promise should either be returned or awaited to ensure the expects in its chain are called"
@@ -3869,6 +3833,131 @@ var valid_expect_in_promise_default = createRule({
   }
 });
 
+// src/rules/valid-expect.ts
+var findTopMostMemberExpression = (node) => {
+  let topMostMemberExpression = node;
+  let parent = node.parent;
+  while (parent) {
+    if (parent.type !== "MemberExpression") {
+      break;
+    }
+    topMostMemberExpression = parent;
+    parent = parent.parent;
+  }
+  return topMostMemberExpression;
+};
+var valid_expect_default = createRule({
+  create(context) {
+    const options = {
+      maxArgs: 2,
+      minArgs: 1,
+      ...context.options?.[0] ?? {}
+    };
+    const minArgs = Math.min(options.minArgs, options.maxArgs);
+    const maxArgs = Math.max(options.minArgs, options.maxArgs);
+    return {
+      CallExpression(node) {
+        const call = parseFnCallWithReason(context, node);
+        if (typeof call === "string") {
+          const reportingNode = node.parent?.type === "MemberExpression" ? findTopMostMemberExpression(node.parent).property : node;
+          if (call === "matcher-not-found") {
+            context.report({
+              messageId: "matcherNotFound",
+              node: reportingNode
+            });
+            return;
+          }
+          if (call === "matcher-not-called") {
+            context.report({
+              messageId: isSupportedAccessor(reportingNode) && modifiers.has(getStringValue(reportingNode)) ? "matcherNotFound" : "matcherNotCalled",
+              node: reportingNode
+            });
+          }
+          if (call === "modifier-unknown") {
+            context.report({
+              messageId: "modifierUnknown",
+              node: reportingNode
+            });
+            return;
+          }
+          return;
+        } else if (call?.type !== "expect") {
+          return;
+        }
+        const { parent: expect } = call.head.node;
+        if (expect?.type !== "CallExpression") return;
+        if (expect.arguments.length < minArgs) {
+          const expectLength = getStringValue(call.head.node).length;
+          const loc = {
+            end: {
+              column: expect.loc.start.column + expectLength + 1,
+              line: expect.loc.start.line
+            },
+            start: {
+              column: expect.loc.start.column + expectLength,
+              line: expect.loc.start.line
+            }
+          };
+          context.report({
+            data: getAmountData(minArgs),
+            loc,
+            messageId: "notEnoughArgs",
+            node: expect
+          });
+        }
+        if (expect.arguments.length > maxArgs) {
+          const { start } = expect.arguments[maxArgs].loc;
+          const { end } = expect.arguments.at(-1).loc;
+          const loc = {
+            end: {
+              column: end.column,
+              line: end.line
+            },
+            start
+          };
+          context.report({
+            data: getAmountData(maxArgs),
+            loc,
+            messageId: "tooManyArgs",
+            node: expect
+          });
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      category: "Possible Errors",
+      description: "Enforce valid `expect()` usage",
+      recommended: true,
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/valid-expect.md"
+    },
+    messages: {
+      matcherNotCalled: "Matchers must be called to assert.",
+      matcherNotFound: "Expect must have a corresponding matcher call.",
+      notEnoughArgs: "Expect requires at least {{amount}} argument{{s}}.",
+      tooManyArgs: "Expect takes at most {{amount}} argument{{s}}."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          maxArgs: {
+            minimum: 1,
+            type: "number"
+          },
+          minArgs: {
+            minimum: 1,
+            type: "number"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  }
+});
+
 // src/rules/valid-test-tags.ts
 var valid_test_tags_default = createRule({
   create(context) {
@@ -3876,15 +3965,11 @@ var valid_test_tags_default = createRule({
     const allowedTags = options.allowedTags || [];
     const disallowedTags = options.disallowedTags || [];
     if (allowedTags.length > 0 && disallowedTags.length > 0) {
-      throw new Error(
-        "The allowedTags and disallowedTags options cannot be used together"
-      );
+      throw new Error("The allowedTags and disallowedTags options cannot be used together");
     }
     for (const tag of [...allowedTags, ...disallowedTags]) {
       if (typeof tag === "string" && !tag.startsWith("@")) {
-        throw new Error(
-          `Invalid tag "${tag}" in configuration: tags must start with @`
-        );
+        throw new Error(`Invalid tag "${tag}" in configuration: tags must start with @`);
       }
     }
     const extractTagsFromTitle = (title) => {
@@ -3927,11 +4012,9 @@ var valid_test_tags_default = createRule({
     return {
       CallExpression(node) {
         const call = parseFnCall(context, node);
-        if (!call)
-          return;
+        if (!call) return;
         const { type } = call;
-        if (type !== "test" && type !== "describe" && type !== "step")
-          return;
+        if (type !== "test" && type !== "describe" && type !== "step") return;
         if (node.arguments.length > 0) {
           const titleArg = node.arguments[0];
           if (titleArg && titleArg.type === "Literal" && typeof titleArg.value === "string") {
@@ -3941,17 +4024,14 @@ var valid_test_tags_default = createRule({
             }
           }
         }
-        if (node.arguments.length < 2)
-          return;
+        if (node.arguments.length < 2) return;
         const optionsArg = node.arguments[1];
-        if (!optionsArg || optionsArg.type !== "ObjectExpression")
-          return;
+        if (!optionsArg || optionsArg.type !== "ObjectExpression") return;
         const tagProperty = optionsArg.properties.find(
           (prop) => prop.type === "Property" && !("argument" in prop) && // Ensure it's not a spread element
           prop.key.type === "Identifier" && prop.key.name === "tag"
         );
-        if (!tagProperty)
-          return;
+        if (!tagProperty) return;
         const tagValue = tagProperty.value;
         if (tagValue.type === "Literal") {
           if (typeof tagValue.value !== "string") {
@@ -4076,10 +4156,7 @@ var valid_title_default = createRule({
       mustMatch,
       mustNotMatch
     } = opts;
-    const disallowedWordsRegexp = new RegExp(
-      `\\b(${disallowedWords.join("|")})\\b`,
-      "iu"
-    );
+    const disallowedWordsRegexp = new RegExp(`\\b(${disallowedWords.join("|")})\\b`, "iu");
     const mustNotMatchPatterns = compileMatcherPatterns(mustNotMatch ?? {});
     const mustMatchPatterns = compileMatcherPatterns(mustMatch ?? {});
     return {
@@ -4090,8 +4167,7 @@ var valid_title_default = createRule({
         }
         const [argument] = node.arguments;
         const title = dereference(context, argument) ?? argument;
-        if (!title)
-          return;
+        if (!title) return;
         if (!isStringNode(title)) {
           if (title.type === "BinaryExpression" && doesBinaryExpressionContainStringNode(title)) {
             return;
@@ -4184,7 +4260,7 @@ var valid_title_default = createRule({
       category: "Best Practices",
       description: "Enforce valid titles",
       recommended: true,
-      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/valid-title.md"
+      url: "https://github.com/mskelton/eslint-plugin-playwright/tree/main/docs/rules/valid-title.md"
     },
     fixable: "code",
     messages: {
@@ -4249,6 +4325,7 @@ var valid_title_default = createRule({
 var index = {
   configs: {},
   rules: {
+    "consistent-spacing-between-blocks": consistent_spacing_between_blocks_default,
     "expect-expect": expect_expect_default,
     "max-expects": max_expects_default,
     "max-nested-describe": max_nested_describe_default,
@@ -4268,6 +4345,7 @@ var index = {
     "no-nth-methods": no_nth_methods_default,
     "no-page-pause": no_page_pause_default,
     "no-raw-locators": no_raw_locators_default,
+    "no-restricted-locators": no_restricted_locators_default,
     "no-restricted-matchers": no_restricted_matchers_default,
     "no-skipped-test": no_skipped_test_default,
     "no-slowed-test": no_slowed_test_default,
@@ -4306,6 +4384,7 @@ var index = {
 var sharedConfig = {
   rules: {
     "no-empty-pattern": "off",
+    "playwright/consistent-spacing-between-blocks": "warn",
     "playwright/expect-expect": "warn",
     "playwright/max-nested-describe": "warn",
     "playwright/missing-playwright-await": "error",
@@ -4356,6 +4435,6 @@ module.exports = {
   configs: {
     "flat/recommended": flatConfig,
     "playwright-test": legacyConfig,
-    recommended: legacyConfig
+    "recommended": legacyConfig
   }
 };