eslint-plugin-playwright 2.1.0 → 2.2.1

package/README.md

@@ -139,10 +139,12 @@ CLI option\
 | [no-raw-locators](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-raw-locators.md)                         | Disallow using raw locators                                        |     |     |     |
 | [no-restricted-matchers](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-restricted-matchers.md)           | Disallow specific matchers & modifiers                             |     |     |     |
 | [no-skipped-test](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-skipped-test.md)                         | Disallow usage of the `.skip` annotation                           | ✅  |     | 💡  |
+| [no-slowed-test](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-slowed-test.md)                           | Disallow usage of the `.slow` annotation                           |     |     | 💡  |
 | [no-standalone-expect](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-standalone-expect.md)               | Disallow using expect outside of `test` blocks                     | ✅  |     |     |
 | [no-unsafe-references](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-unsafe-references.md)               | Prevent unsafe variable references in `page.evaluate()`            | ✅  | 🔧  |     |
 | [no-useless-await](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-useless-await.md)                       | Disallow unnecessary `await`s for Playwright methods               | ✅  | 🔧  |     |
 | [no-useless-not](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-useless-not.md)                           | Disallow usage of `not` matchers when a specific matcher exists    | ✅  | 🔧  |     |
+| [no-wait-for-navigation](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-wait-for-navigation.md)           | Disallow usage of `page.waitForNavigation()`                       | ✅  |     | 💡  |
 | [no-wait-for-selector](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-wait-for-selector.md)               | Disallow usage of `page.waitForSelector()`                         | ✅  |     | 💡  |
 | [no-wait-for-timeout](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/no-wait-for-timeout.md)                 | Disallow usage of `page.waitForTimeout()`                          | ✅  |     | 💡  |
 | [prefer-comparison-matcher](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-comparison-matcher.md)     | Suggest using the built-in comparison matchers                     |     | 🔧  |     |
@@ -166,3 +168,4 @@ CLI option\
 | [valid-expect-in-promise](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/valid-expect-in-promise.md)         | Require promises that have expectations in their chain to be valid | ✅  |     |     |
 | [valid-expect](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/valid-expect.md)                               | Enforce valid `expect()` usage                                     | ✅  |     |     |
 | [valid-title](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/valid-title.md)                                 | Enforce valid titles                                               | ✅  | 🔧  |     |
+| [valid-test-tags](https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/valid-test-tags.md)                         | Enforce valid tag format in test blocks                            | ✅  |     |     |

package/dist/index.cjs

@@ -100,6 +100,7 @@ var VALID_CHAINS = /* @__PURE__ */ new Set([
   "test.only",
   "test.skip",
   "test.step",
+  "test.step.skip",
   "test.slow",
   "test.use"
 ]);
@@ -485,7 +486,7 @@ var expect_expect_default = createRule({
       },
       "Program:exit"() {
         unchecked.forEach((node) => {
-          context.report({ messageId: "noAssertions", node });
+          context.report({ messageId: "noAssertions", node: node.callee });
         });
       }
     };
@@ -664,6 +665,7 @@ var expectPlaywrightMatchers = [
   "toPass"
 ];
 var playwrightTestMatchers = [
+  "toBeAttached",
   "toBeChecked",
   "toBeDisabled",
   "toBeEditable",
@@ -671,23 +673,24 @@ var playwrightTestMatchers = [
   "toBeEnabled",
   "toBeFocused",
   "toBeHidden",
+  "toBeInViewport",
+  "toBeOK",
   "toBeVisible",
   "toContainText",
+  "toHaveAccessibleErrorMessage",
   "toHaveAttribute",
+  "toHaveCSS",
   "toHaveClass",
   "toHaveCount",
-  "toHaveCSS",
   "toHaveId",
   "toHaveJSProperty",
-  "toBeOK",
   "toHaveScreenshot",
   "toHaveText",
   "toHaveTitle",
   "toHaveURL",
   "toHaveValue",
   "toHaveValues",
-  "toBeAttached",
-  "toBeInViewport"
+  "toContainClass"
 ];
 function getReportNode(node) {
   const parent = getParent(node);
@@ -927,7 +930,17 @@ var no_conditional_in_test_default = createRule({
       if (!call)
         return;
       if (isTypeOfFnCall(context, call, ["test", "step"])) {
-        context.report({ messageId: "conditionalInTest", node });
+        const testFunction = call.arguments[call.arguments.length - 1];
+        const functionBody = findParent(node, "BlockStatement");
+        if (!functionBody)
+          return;
+        let currentParent = functionBody.parent;
+        while (currentParent && currentParent !== testFunction) {
+          currentParent = currentParent.parent;
+        }
+        if (currentParent === testFunction) {
+          context.report({ messageId: "conditionalInTest", node });
+        }
       }
     }
     return {
@@ -1254,18 +1267,11 @@ var no_hooks_default = createRule({
 });
 
 // src/rules/no-nested-step.ts
-function isStepCall(node) {
-  const inner = node.type === "CallExpression" ? node.callee : node;
-  if (inner.type !== "MemberExpression") {
-    return false;
-  }
-  return isPropertyAccessor(inner, "step");
-}
 var no_nested_step_default = createRule({
   create(context) {
     const stack = [];
     function pushStepCallback(node) {
-      if (node.parent.type !== "CallExpression" || !isStepCall(node.parent)) {
+      if (node.parent.type !== "CallExpression" || !isTypeOfFnCall(context, node.parent, ["step"])) {
         return;
       }
       stack.push(0);
@@ -1278,7 +1284,7 @@ var no_nested_step_default = createRule({
     }
     function popStepCallback(node) {
       const { parent } = node;
-      if (parent.type === "CallExpression" && isStepCall(parent)) {
+      if (parent.type === "CallExpression" && isTypeOfFnCall(context, parent, ["step"])) {
         stack.pop();
       }
     }
@@ -1434,7 +1440,7 @@ var no_raw_locators_default = createRule({
     }
     return {
       CallExpression(node) {
-        if (node.callee.type !== "MemberExpression")
+        if (node.callee.type !== "MemberExpression" || node.arguments[0]?.type === "Identifier")
           return;
         const method = getStringValue(node.callee.property);
         const arg = getStringValue(node.arguments[0]);
@@ -1538,14 +1544,14 @@ var no_skipped_test_default = createRule({
         const options = context.options[0] || {};
         const allowConditional = !!options.allowConditional;
         const call = parseFnCall(context, node);
-        if (call?.group !== "test" && call?.group !== "describe") {
+        if (call?.group !== "test" && call?.group !== "describe" && call?.group !== "step") {
           return;
         }
         const skipNode = call.members.find((s) => getStringValue(s) === "skip");
         if (!skipNode)
           return;
         const isStandalone = call.type === "config";
-        if (isStandalone && allowConditional) {
+        if (isStandalone && allowConditional && (node.arguments.length !== 0 || findParent(node, "BlockStatement")?.parent?.type === "IfStatement")) {
           return;
         }
         context.report({
@@ -1594,6 +1600,70 @@ var no_skipped_test_default = createRule({
   }
 });
 
+// src/rules/no-slowed-test.ts
+var no_slowed_test_default = createRule({
+  create(context) {
+    return {
+      CallExpression(node) {
+        const options = context.options[0] || {};
+        const allowConditional = !!options.allowConditional;
+        const call = parseFnCall(context, node);
+        if (call?.group !== "test") {
+          return;
+        }
+        const slowNode = call.members.find((s) => getStringValue(s) === "slow");
+        if (!slowNode)
+          return;
+        const isStandalone = call.type === "config";
+        if (isStandalone && allowConditional && (node.arguments.length !== 0 || findParent(node, "BlockStatement")?.parent?.type === "IfStatement")) {
+          return;
+        }
+        context.report({
+          messageId: "noSlowedTest",
+          node: isStandalone ? node : slowNode,
+          suggest: [
+            {
+              fix: (fixer) => {
+                return isStandalone ? fixer.remove(node.parent) : fixer.removeRange([
+                  slowNode.range[0] - 1,
+                  slowNode.range[1] + Number(slowNode.type !== "Identifier")
+                ]);
+              },
+              messageId: "removeSlowedTestAnnotation"
+            }
+          ]
+        });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      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"
+    },
+    hasSuggestions: true,
+    messages: {
+      noSlowedTest: "Unexpected use of the `.slow()` annotation.",
+      removeSlowedTestAnnotation: "Remove the `.slow()` annotation."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowConditional: {
+            default: false,
+            type: "boolean"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "suggestion"
+  }
+});
+
 // src/rules/no-standalone-expect.ts
 var getBlockType = (context, statement) => {
   const func = getParent(statement);
@@ -1736,7 +1806,7 @@ var no_unsafe_references_default = createRule({
   create(context) {
     return {
       CallExpression(node) {
-        if (!isPageMethod(node, "evaluate"))
+        if (!isPageMethod(node, "evaluate") && !isPageMethod(node, "addInitScript"))
           return;
         const [fn] = node.arguments;
         if (!fn || !isFunction(fn))
@@ -1747,8 +1817,9 @@ var no_unsafe_references_default = createRule({
           const parent = getParent(ref.identifier);
           return parent?.type !== "TSTypeReference";
         }).filter((ref) => allRefs.has(ref.identifier.name)).forEach((ref, i, arr) => {
+          const methodName = isPageMethod(node, "evaluate") ? "evaluate" : "addInitScript";
           const descriptor = {
-            data: { variable: ref.identifier.name },
+            data: { method: methodName, variable: ref.identifier.name },
             messageId: "noUnsafeReference",
             node: ref.identifier
           };
@@ -1773,13 +1844,13 @@ var no_unsafe_references_default = createRule({
   meta: {
     docs: {
       category: "Possible Errors",
-      description: "Prevent unsafe variable references in page.evaluate()",
+      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"
     },
     fixable: "code",
     messages: {
-      noUnsafeReference: 'Unsafe reference to variable "{{ variable }}" in page.evaluate()'
+      noUnsafeReference: 'Unsafe reference to variable "{{ variable }}" in page.{{ method }}()'
     },
     type: "problem"
   }
@@ -2006,6 +2077,44 @@ var no_useless_not_default = createRule({
   }
 });
 
+// src/rules/no-wait-for-navigation.ts
+var no_wait_for_navigation_default = createRule({
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (isPageMethod(node, "waitForNavigation")) {
+          context.report({
+            messageId: "noWaitForNavigation",
+            node,
+            suggest: [
+              {
+                fix: (fixer) => fixer.remove(
+                  node.parent && node.parent.type !== "AwaitExpression" && node.parent.type !== "VariableDeclarator" ? node.parent : node.parent.parent
+                ),
+                messageId: "removeWaitForNavigation"
+              }
+            ]
+          });
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      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"
+    },
+    hasSuggestions: true,
+    messages: {
+      noWaitForNavigation: "Unexpected use of page.waitForNavigation().",
+      removeWaitForNavigation: "Remove the page.waitForNavigation() method."
+    },
+    type: "suggestion"
+  }
+});
+
 // src/rules/no-wait-for-selector.ts
 var no_wait_for_selector_default = createRule({
   create(context) {
@@ -2165,7 +2274,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-comparision-matcher.md"
+      url: "https://github.com/playwright-community/eslint-plugin-playwright/tree/main/docs/rules/prefer-comparison-matcher.md"
     },
     fixable: "code",
     messages: {
@@ -2957,45 +3066,45 @@ var prefer_web_first_assertions_default = createRule({
   create(context) {
     return {
       CallExpression(node) {
-        const call = parseFnCall(context, node);
-        if (call?.type !== "expect")
+        const fnCall = parseFnCall(context, node);
+        if (fnCall?.type !== "expect")
           return;
-        const expect = findParent(call.head.node, "CallExpression");
+        const expect = findParent(fnCall.head.node, "CallExpression");
         if (!expect)
           return;
-        const arg = dereference(context, call.args[0]);
-        if (!arg || arg.type !== "AwaitExpression" || arg.argument.type !== "CallExpression" || arg.argument.callee.type !== "MemberExpression") {
+        const arg = dereference(context, fnCall.args[0]);
+        if (!arg)
+          return;
+        const call = arg.type === "AwaitExpression" ? arg.argument : arg;
+        if (call.type !== "CallExpression" || call.callee.type !== "MemberExpression") {
           return;
         }
-        if (!supportedMatchers.has(call.matcherName))
+        if (!supportedMatchers.has(fnCall.matcherName))
           return;
-        const method = getStringValue(arg.argument.callee.property);
+        const method = getStringValue(call.callee.property);
         const methodConfig = methods3[method];
         if (!methodConfig)
           return;
-        const notModifier = call.modifiers.find(
+        const notModifier = fnCall.modifiers.find(
           (mod) => getStringValue(mod) === "not"
         );
-        const isFalsy = methodConfig.type === "boolean" && (!!call.matcherArgs.length && isBooleanLiteral(call.matcherArgs[0], false) || call.matcherName === "toBeFalsy");
+        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;
-        const { callee } = arg.argument;
+        const { callee } = call;
         context.report({
           data: {
             matcher: newMatcher,
             method
           },
           fix: (fixer) => {
-            const methodArgs = arg.argument.type === "CallExpression" ? arg.argument.arguments : [];
+            const methodArgs = call.type === "CallExpression" ? call.arguments : [];
             const methodEnd = methodArgs.length ? methodArgs.at(-1).range[1] + 1 : callee.property.range[1] + 2;
             const fixes = [
               // Add await to the expect call
               fixer.insertTextBefore(expect, "await "),
               // Remove the await keyword
-              fixer.replaceTextRange(
-                [arg.range[0], arg.argument.range[0]],
-                ""
-              ),
+              fixer.replaceTextRange([arg.range[0], call.range[0]], ""),
               // Remove the old Playwright method and any arguments
               fixer.replaceTextRange(
                 [callee.property.range[0] - 1, methodEnd],
@@ -3007,10 +3116,10 @@ var prefer_web_first_assertions_default = createRule({
               fixes.push(fixer.removeRange([notRange[0], notRange[1] + 1]));
             }
             if (!methodConfig.inverse && !notModifier && isFalsy) {
-              fixes.push(fixer.insertTextBefore(call.matcher, "not."));
+              fixes.push(fixer.insertTextBefore(fnCall.matcher, "not."));
             }
-            fixes.push(fixer.replaceText(call.matcher, newMatcher));
-            const [matcherArg] = call.matcherArgs ?? [];
+            fixes.push(fixer.replaceText(fnCall.matcher, newMatcher));
+            const [matcherArg] = fnCall.matcherArgs ?? [];
             if (matcherArg && isBooleanLiteral(matcherArg)) {
               fixes.push(fixer.remove(matcherArg));
             } else if (methodConfig.prop && matcherArg) {
@@ -3023,7 +3132,7 @@ var prefer_web_first_assertions_default = createRule({
               (arg2) => !isBooleanLiteral(arg2)
             ).length;
             if (methodArgs) {
-              const range = call.matcher.range;
+              const range = fnCall.matcher.range;
               const stringArgs = methodArgs.map((arg2) => getRawValue(arg2)).concat(hasOtherArgs ? "" : []).join(", ");
               fixes.push(
                 fixer.insertTextAfterRange(
@@ -3730,6 +3839,144 @@ var valid_expect_in_promise_default = createRule({
   }
 });
 
+// src/rules/valid-test-tags.ts
+var valid_test_tags_default = createRule({
+  create(context) {
+    const options = context.options[0] || {};
+    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"
+      );
+    }
+    for (const tag of [...allowedTags, ...disallowedTags]) {
+      if (typeof tag === "string" && !tag.startsWith("@")) {
+        throw new Error(
+          `Invalid tag "${tag}" in configuration: tags must start with @`
+        );
+      }
+    }
+    const validateTag = (tag, node) => {
+      if (!tag.startsWith("@")) {
+        context.report({
+          messageId: "invalidTagFormat",
+          node
+        });
+        return;
+      }
+      if (allowedTags.length > 0) {
+        const isAllowed = allowedTags.some(
+          (pattern) => pattern instanceof RegExp ? pattern.test(tag) : pattern === tag
+        );
+        if (!isAllowed) {
+          context.report({
+            data: { tag },
+            messageId: "unknownTag",
+            node
+          });
+          return;
+        }
+      }
+      if (disallowedTags.length > 0) {
+        const isDisallowed = disallowedTags.some(
+          (pattern) => pattern instanceof RegExp ? pattern.test(tag) : pattern === tag
+        );
+        if (isDisallowed) {
+          context.report({
+            data: { tag },
+            messageId: "disallowedTag",
+            node
+          });
+        }
+      }
+    };
+    return {
+      CallExpression(node) {
+        const call = parseFnCall(context, node);
+        if (!call)
+          return;
+        const { type } = call;
+        if (type !== "test" && type !== "describe" && type !== "step")
+          return;
+        if (node.arguments.length < 2)
+          return;
+        const optionsArg = node.arguments[1];
+        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;
+        const tagValue = tagProperty.value;
+        if (tagValue.type === "Literal") {
+          if (typeof tagValue.value !== "string") {
+            context.report({
+              messageId: "invalidTagValue",
+              node
+            });
+            return;
+          }
+          validateTag(tagValue.value, node);
+        } else if (tagValue.type === "ArrayExpression") {
+          for (const element of tagValue.elements) {
+            if (!element || element.type !== "Literal" || typeof element.value !== "string") {
+              return;
+            }
+            validateTag(element.value, node);
+          }
+        } else {
+          context.report({
+            messageId: "invalidTagValue",
+            node
+          });
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Enforce valid tag format in Playwright test blocks",
+      recommended: true
+    },
+    messages: {
+      disallowedTag: 'Tag "{{tag}}" is not allowed',
+      invalidTagFormat: "Tag must start with @",
+      invalidTagValue: "Tag must be a string or array of strings",
+      unknownTag: 'Unknown tag "{{tag}}"'
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowedTags: {
+            items: {
+              oneOf: [
+                { type: "string" },
+                { properties: { source: { type: "string" } }, type: "object" }
+              ]
+            },
+            type: "array"
+          },
+          disallowedTags: {
+            items: {
+              oneOf: [
+                { type: "string" },
+                { properties: { source: { type: "string" } }, type: "object" }
+              ]
+            },
+            type: "array"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  }
+});
+
 // src/rules/valid-title.ts
 var doesBinaryExpressionContainStringNode = (binaryExp) => {
   if (isStringNode(binaryExp.right)) {
@@ -3973,10 +4220,12 @@ var index = {
     "no-raw-locators": no_raw_locators_default,
     "no-restricted-matchers": no_restricted_matchers_default,
     "no-skipped-test": no_skipped_test_default,
+    "no-slowed-test": no_slowed_test_default,
     "no-standalone-expect": no_standalone_expect_default,
     "no-unsafe-references": no_unsafe_references_default,
     "no-useless-await": no_useless_await_default,
     "no-useless-not": no_useless_not_default,
+    "no-wait-for-navigation": no_wait_for_navigation_default,
     "no-wait-for-selector": no_wait_for_selector_default,
     "no-wait-for-timeout": no_wait_for_timeout_default,
     "prefer-comparison-matcher": prefer_comparison_matcher_default,
@@ -3999,6 +4248,7 @@ var index = {
     "valid-describe-callback": valid_describe_callback_default,
     "valid-expect": valid_expect_default,
     "valid-expect-in-promise": valid_expect_in_promise_default,
+    "valid-test-tags": valid_test_tags_default,
     "valid-title": valid_title_default
   }
 };
@@ -4022,6 +4272,7 @@ var sharedConfig = {
     "playwright/no-unsafe-references": "error",
     "playwright/no-useless-await": "warn",
     "playwright/no-useless-not": "warn",
+    "playwright/no-wait-for-navigation": "error",
     "playwright/no-wait-for-selector": "warn",
     "playwright/no-wait-for-timeout": "warn",
     "playwright/prefer-web-first-assertions": "error",

package/package.json

@@ -1,17 +1,13 @@
 {
   "name": "eslint-plugin-playwright",
   "description": "ESLint plugin for Playwright testing.",
-  "version": "2.1.0",
+  "version": "2.2.1",
   "repository": "https://github.com/playwright-community/eslint-plugin-playwright",
   "author": "Mark Skelton <mark@mskelton.dev>",
-  "packageManager": "pnpm@8.12.0",
   "contributors": [
     "Max Schmitt <max@schmitt.mx>"
   ],
   "license": "MIT",
-  "workspaces": [
-    "examples"
-  ],
   "engines": {
     "node": ">=16.6.0"
   },
@@ -30,34 +26,10 @@
     "index.cjs",
     "index.d.ts"
   ],
-  "scripts": {
-    "build": "tsup src/index.ts --format cjs --out-dir dist",
-    "lint": "eslint .",
-    "fmt": "prettier --write .",
-    "fmt:check": "prettier --check .",
-    "test": "vitest",
-    "test:watch": "vitest --reporter=dot",
-    "ts": "tsc --noEmit"
-  },
   "peerDependencies": {
     "eslint": ">=8.40.0"
   },
   "dependencies": {
     "globals": "^13.23.0"
-  },
-  "devDependencies": {
-    "@mskelton/eslint-config": "^9.0.1",
-    "@mskelton/semantic-release-config": "^1.0.1",
-    "@types/estree": "^1.0.6",
-    "@types/node": "^20.11.17",
-    "@typescript-eslint/parser": "^8.11.0",
-    "dedent": "^1.5.1",
-    "eslint": "^9.13.0",
-    "prettier": "^3.0.3",
-    "prettier-plugin-jsdoc": "^1.3.0",
-    "semantic-release": "^23.0.2",
-    "tsup": "^8.0.1",
-    "typescript": "^5.2.2",
-    "vitest": "^1.3.1"
   }
 }