pickier 0.1.16 → 0.1.18

package/dist/src/index.js

@@ -5255,7 +5255,7 @@ var init_config = __esm(async () => {
       "markdown/proper-names": "off",
       "markdown/no-alt-text": "warn",
       "markdown/table-pipe-style": "warn",
-      "markdown/table-column-count": "error",
+      "markdown/table-column-count": "warn",
       "markdown/table-column-style": "warn",
       "lockfile/validate-host": ["warn", { allowedHosts: ["npm", "yarn"] }],
       "lockfile/validate-https": "error",
@@ -14742,6 +14742,27 @@ var init_require_await = __esm(() => {
   };
 });
 
+// src/plugins/utils.ts
+function codeOnly(rule) {
+  return {
+    meta: rule.meta,
+    check: (content, context) => {
+      if (!CODE_EXTS2.test(context.filePath))
+        return [];
+      return rule.check(content, context);
+    },
+    fix: rule.fix ? (content, context) => {
+      if (!CODE_EXTS2.test(context.filePath))
+        return content;
+      return rule.fix(content, context);
+    } : undefined
+  };
+}
+var CODE_EXTS2;
+var init_utils = __esm(() => {
+  CODE_EXTS2 = /\.(?:ts|js|tsx|jsx|mts|mjs|cts|cjs)$/;
+});
+
 // src/plugins/eslint.ts
 var eslintPlugin;
 var init_eslint = __esm(() => {
@@ -14810,74 +14831,75 @@ var init_eslint = __esm(() => {
   init_no_with();
   init_prefer_arrow_callback();
   init_require_await();
+  init_utils();
   eslintPlugin = {
     name: "eslint",
     rules: {
-      "array-callback-return": arrayCallbackReturnRule,
-      "constructor-super": constructorSuperRule,
-      "for-direction": forDirectionRule,
-      "getter-return": getterReturnRule,
-      "no-async-promise-executor": noAsyncPromiseExecutorRule,
-      "no-compare-neg-zero": noCompareNegZeroRule,
-      "no-cond-assign": noCondAssignRule,
-      "no-constant-condition": noConstantConditionRule,
-      "no-const-assign": noConstAssignRule,
-      "no-dupe-class-members": noDupeClassMembersRule,
-      "no-dupe-keys": noDupeKeysRule,
-      "no-duplicate-case": noDuplicateCaseRule,
-      "no-empty-pattern": noEmptyPatternRule,
-      "no-fallthrough": noFallthroughRule,
-      "no-loss-of-precision": noLossOfPrecisionRule,
-      "no-promise-executor-return": noPromiseExecutorReturnRule,
-      "no-redeclare": noRedeclareRule,
-      "no-self-assign": noSelfAssignRule,
-      "no-self-compare": noSelfCompareRule,
-      "no-sparse-arrays": noSparseArraysRule,
-      "no-undef": noUndefRule,
-      "no-unsafe-negation": noUnsafeNegationRule,
-      "no-unreachable": noUnreachableRule,
-      "no-useless-catch": noUselessCatchRule,
-      "use-isnan": useIsNaNRule,
-      "valid-typeof": validTypeofRule,
-      "default-case": defaultCaseRule,
-      eqeqeq: eqeqeqRule,
-      "no-alert": noAlertRule,
-      "no-await-in-loop": noAwaitInLoopRule,
-      "no-caller": noCallerRule,
-      "no-case-declarations": noCaseDeclarationsRule,
-      "no-else-return": noElseReturnRule,
-      "no-empty": noEmptyRule,
-      "no-empty-function": noEmptyFunctionRule,
-      "no-eval": noEvalRule,
-      "no-extend-native": noExtendNativeRule,
-      "no-global-assign": noGlobalAssignRule,
-      "no-implied-eval": noImpliedEvalRule,
-      "no-iterator": noIteratorRule,
-      "no-new": noNewRule,
-      "no-new-func": noNewFuncRule,
-      "no-new-wrappers": noNewWrappersRule,
-      "no-octal": noOctalRule,
-      "no-param-reassign": noParamReassignRule,
-      "no-proto": noProtoRule,
-      "no-return-assign": noReturnAssignRule,
-      "no-shadow": noShadowRule,
-      "no-throw-literal": noThrowLiteralRule,
-      "no-use-before-define": noUseBeforeDefineRule,
-      "no-useless-call": noUselessCallRule,
-      "no-with": noWithRule,
-      "require-await": requireAwaitRule,
-      complexity: complexityRule,
-      "max-depth": maxDepthRule,
-      "max-lines-per-function": maxLinesPerFunctionRule,
-      "no-extra-boolean-cast": noExtraBooleanCastRule,
-      "no-lonely-if": noLonelyIfRule,
-      "no-sequences": noSequencesRule,
-      "no-useless-concat": noUselessConcatRule,
-      "no-useless-escape": noUselessEscapeRule,
-      "no-useless-rename": noUselessRenameRule,
-      "no-useless-return": noUselessReturnRule,
-      "no-var": noVarRule,
-      "prefer-arrow-callback": preferArrowCallbackRule
+      "array-callback-return": codeOnly(arrayCallbackReturnRule),
+      "constructor-super": codeOnly(constructorSuperRule),
+      "for-direction": codeOnly(forDirectionRule),
+      "getter-return": codeOnly(getterReturnRule),
+      "no-async-promise-executor": codeOnly(noAsyncPromiseExecutorRule),
+      "no-compare-neg-zero": codeOnly(noCompareNegZeroRule),
+      "no-cond-assign": codeOnly(noCondAssignRule),
+      "no-constant-condition": codeOnly(noConstantConditionRule),
+      "no-const-assign": codeOnly(noConstAssignRule),
+      "no-dupe-class-members": codeOnly(noDupeClassMembersRule),
+      "no-dupe-keys": codeOnly(noDupeKeysRule),
+      "no-duplicate-case": codeOnly(noDuplicateCaseRule),
+      "no-empty-pattern": codeOnly(noEmptyPatternRule),
+      "no-fallthrough": codeOnly(noFallthroughRule),
+      "no-loss-of-precision": codeOnly(noLossOfPrecisionRule),
+      "no-promise-executor-return": codeOnly(noPromiseExecutorReturnRule),
+      "no-redeclare": codeOnly(noRedeclareRule),
+      "no-self-assign": codeOnly(noSelfAssignRule),
+      "no-self-compare": codeOnly(noSelfCompareRule),
+      "no-sparse-arrays": codeOnly(noSparseArraysRule),
+      "no-undef": codeOnly(noUndefRule),
+      "no-unsafe-negation": codeOnly(noUnsafeNegationRule),
+      "no-unreachable": codeOnly(noUnreachableRule),
+      "no-useless-catch": codeOnly(noUselessCatchRule),
+      "use-isnan": codeOnly(useIsNaNRule),
+      "valid-typeof": codeOnly(validTypeofRule),
+      "default-case": codeOnly(defaultCaseRule),
+      eqeqeq: codeOnly(eqeqeqRule),
+      "no-alert": codeOnly(noAlertRule),
+      "no-await-in-loop": codeOnly(noAwaitInLoopRule),
+      "no-caller": codeOnly(noCallerRule),
+      "no-case-declarations": codeOnly(noCaseDeclarationsRule),
+      "no-else-return": codeOnly(noElseReturnRule),
+      "no-empty": codeOnly(noEmptyRule),
+      "no-empty-function": codeOnly(noEmptyFunctionRule),
+      "no-eval": codeOnly(noEvalRule),
+      "no-extend-native": codeOnly(noExtendNativeRule),
+      "no-global-assign": codeOnly(noGlobalAssignRule),
+      "no-implied-eval": codeOnly(noImpliedEvalRule),
+      "no-iterator": codeOnly(noIteratorRule),
+      "no-new": codeOnly(noNewRule),
+      "no-new-func": codeOnly(noNewFuncRule),
+      "no-new-wrappers": codeOnly(noNewWrappersRule),
+      "no-octal": codeOnly(noOctalRule),
+      "no-param-reassign": codeOnly(noParamReassignRule),
+      "no-proto": codeOnly(noProtoRule),
+      "no-return-assign": codeOnly(noReturnAssignRule),
+      "no-shadow": codeOnly(noShadowRule),
+      "no-throw-literal": codeOnly(noThrowLiteralRule),
+      "no-use-before-define": codeOnly(noUseBeforeDefineRule),
+      "no-useless-call": codeOnly(noUselessCallRule),
+      "no-with": codeOnly(noWithRule),
+      "require-await": codeOnly(requireAwaitRule),
+      complexity: codeOnly(complexityRule),
+      "max-depth": codeOnly(maxDepthRule),
+      "max-lines-per-function": codeOnly(maxLinesPerFunctionRule),
+      "no-extra-boolean-cast": codeOnly(noExtraBooleanCastRule),
+      "no-lonely-if": codeOnly(noLonelyIfRule),
+      "no-sequences": codeOnly(noSequencesRule),
+      "no-useless-concat": codeOnly(noUselessConcatRule),
+      "no-useless-escape": codeOnly(noUselessEscapeRule),
+      "no-useless-rename": codeOnly(noUselessRenameRule),
+      "no-useless-return": codeOnly(noUselessReturnRule),
+      "no-var": codeOnly(noVarRule),
+      "prefer-arrow-callback": codeOnly(preferArrowCallbackRule)
     }
   };
 });
@@ -14895,8 +14917,8 @@ var init_no_constructor_return = __esm(() => {
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
         const commentIdx = line.indexOf("//");
-        const codeOnly = commentIdx >= 0 ? line.slice(0, commentIdx) : line;
-        const constructorMatch = codeOnly.match(/\bconstructor\s*\(/);
+        const codeOnly2 = commentIdx >= 0 ? line.slice(0, commentIdx) : line;
+        const constructorMatch = codeOnly2.match(/\bconstructor\s*\(/);
         if (!constructorMatch)
           continue;
         let braceDepth = 0;
@@ -15140,6 +15162,8 @@ var init_no_regex_spaces = __esm(() => {
       const lines = content.split(/\r?\n/);
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
+        if (/^\s*\/\//.test(line))
+          continue;
         const regexLiteralPattern = /\/(?![*/])((?:\\.|[^/\\])+)\/[gimsuvy]*/g;
         let match;
         while ((match = regexLiteralPattern.exec(line)) !== null) {
@@ -15588,7 +15612,7 @@ var init_no_unused_vars = __esm(() => {
         const line = lines[i];
         if (/^\s*\/\//.test(line))
           continue;
-        let codeOnly = line;
+        let codeOnly2 = line;
         let inStr = null;
         let inRegex = false;
         let escaped = false;
@@ -15616,7 +15640,7 @@ var init_no_unused_vars = __esm(() => {
               if (/[=([{,:;!?]/.test(prevChar) || prev2Chars === "&&" || prev2Chars === "||" || /^\s*$/.test(line.slice(0, idx))) {
                 inRegex = true;
               } else if (next === "/") {
-                codeOnly = line.slice(0, idx);
+                codeOnly2 = line.slice(0, idx);
                 break;
               }
             }
@@ -15658,7 +15682,7 @@ var init_no_unused_vars = __esm(() => {
           }
           return result;
         };
-        const codeNoRegex = stripRegex(codeOnly);
+        const codeNoRegex = stripRegex(codeOnly2);
         const m = codeNoRegex.match(/\bfunction\b/);
         if (m) {
           if (line.includes("function scanContent") || line.includes("function findMatching")) {
@@ -16009,11 +16033,11 @@ var init_prefer_object_spread = __esm(() => {
         if (/^\s*\/\//.test(line))
           continue;
         const commentIdx = line.indexOf("//");
-        const codeOnly = commentIdx >= 0 ? line.slice(0, commentIdx) : line;
-        const assignMatches = codeOnly.matchAll(/\bObject\.assign\s*\(/g);
+        const codeOnly2 = commentIdx >= 0 ? line.slice(0, commentIdx) : line;
+        const assignMatches = codeOnly2.matchAll(/\bObject\.assign\s*\(/g);
         for (const match of assignMatches) {
           const startIdx = match.index;
-          const beforeAssign = codeOnly.slice(0, startIdx);
+          const beforeAssign = codeOnly2.slice(0, startIdx);
           const singleQuotes = (beforeAssign.match(/'/g) || []).length;
           const doubleQuotes = (beforeAssign.match(/"/g) || []).length;
           const backticks = (beforeAssign.match(/`/g) || []).length;
@@ -16021,7 +16045,7 @@ var init_prefer_object_spread = __esm(() => {
             continue;
           }
           const openParenIdx = startIdx + "Object.assign".length;
-          const restOfLine = codeOnly.slice(openParenIdx);
+          const restOfLine = codeOnly2.slice(openParenIdx);
           let firstArgEnd = -1;
           let parenDepth = 1;
           let braceDepth = 0;
@@ -16193,43 +16217,44 @@ var init_general = __esm(() => {
   init_prefer_template();
   init_use_isnan();
   init_valid_typeof();
+  init_utils();
   generalPlugin = {
     name: "general",
     rules: {
-      "array-callback-return": arrayCallbackReturnRule,
-      "constructor-super": constructorSuperRule,
-      "for-direction": forDirectionRule,
-      "getter-return": getterReturnRule,
-      "no-async-promise-executor": noAsyncPromiseExecutorRule,
-      "no-compare-neg-zero": noCompareNegZeroRule,
-      "no-cond-assign": noCondAssignRule,
-      "no-const-assign": noConstAssignRule,
-      "no-constant-condition": noConstantConditionRule,
-      "no-constructor-return": noConstructorReturnRule,
-      "no-dupe-class-members": noDupeClassMembersRule,
-      "no-dupe-keys": noDupeKeysRule,
-      "no-duplicate-case": noDuplicateCaseRule,
-      "no-empty-pattern": noEmptyPatternRule,
-      "no-fallthrough": noFallthroughRule,
-      "no-irregular-whitespace": noIrregularWhitespaceRule,
-      "no-loss-of-precision": noLossOfPrecisionRule,
-      "no-new": noNew,
-      "no-regex-spaces": noRegexSpaces,
-      "no-promise-executor-return": noPromiseExecutorReturnRule,
-      "no-redeclare": noRedeclareRule,
-      "no-self-assign": noSelfAssignRule,
-      "no-self-compare": noSelfCompareRule,
-      "no-sparse-arrays": noSparseArraysRule,
-      "no-undef": noUndefRule,
-      "no-unsafe-negation": noUnsafeNegationRule,
-      "no-unreachable": noUnreachableRule,
-      "no-unused-vars": noUnusedVarsRule,
-      "no-useless-catch": noUselessCatchRule,
-      "prefer-const": preferConstRule,
-      "prefer-object-spread": preferObjectSpreadRule,
-      "prefer-template": preferTemplate,
-      "use-isnan": useIsNaNRule,
-      "valid-typeof": validTypeofRule
+      "array-callback-return": codeOnly(arrayCallbackReturnRule),
+      "constructor-super": codeOnly(constructorSuperRule),
+      "for-direction": codeOnly(forDirectionRule),
+      "getter-return": codeOnly(getterReturnRule),
+      "no-async-promise-executor": codeOnly(noAsyncPromiseExecutorRule),
+      "no-compare-neg-zero": codeOnly(noCompareNegZeroRule),
+      "no-cond-assign": codeOnly(noCondAssignRule),
+      "no-const-assign": codeOnly(noConstAssignRule),
+      "no-constant-condition": codeOnly(noConstantConditionRule),
+      "no-constructor-return": codeOnly(noConstructorReturnRule),
+      "no-dupe-class-members": codeOnly(noDupeClassMembersRule),
+      "no-dupe-keys": codeOnly(noDupeKeysRule),
+      "no-duplicate-case": codeOnly(noDuplicateCaseRule),
+      "no-empty-pattern": codeOnly(noEmptyPatternRule),
+      "no-fallthrough": codeOnly(noFallthroughRule),
+      "no-irregular-whitespace": codeOnly(noIrregularWhitespaceRule),
+      "no-loss-of-precision": codeOnly(noLossOfPrecisionRule),
+      "no-new": codeOnly(noNew),
+      "no-regex-spaces": codeOnly(noRegexSpaces),
+      "no-promise-executor-return": codeOnly(noPromiseExecutorReturnRule),
+      "no-redeclare": codeOnly(noRedeclareRule),
+      "no-self-assign": codeOnly(noSelfAssignRule),
+      "no-self-compare": codeOnly(noSelfCompareRule),
+      "no-sparse-arrays": codeOnly(noSparseArraysRule),
+      "no-undef": codeOnly(noUndefRule),
+      "no-unsafe-negation": codeOnly(noUnsafeNegationRule),
+      "no-unreachable": codeOnly(noUnreachableRule),
+      "no-unused-vars": codeOnly(noUnusedVarsRule),
+      "no-useless-catch": codeOnly(noUselessCatchRule),
+      "prefer-const": codeOnly(preferConstRule),
+      "prefer-object-spread": codeOnly(preferObjectSpreadRule),
+      "prefer-template": codeOnly(preferTemplate),
+      "use-isnan": codeOnly(useIsNaNRule),
+      "valid-typeof": codeOnly(validTypeofRule)
     }
   };
 });
@@ -18378,9 +18403,17 @@ var init_no_empty_links = __esm(() => {
     check: (text, ctx) => {
       const issues = [];
       const lines = text.split(/\r?\n/);
+      let inFence = false;
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
-        const emptyUrlMatches = line.matchAll(/\[[^\]]+\]\(\s*\)/g);
+        if (/^(`{3,}|~{3,})/.test(line.trim())) {
+          inFence = !inFence;
+          continue;
+        }
+        if (inFence)
+          continue;
+        const stripped = line.replace(/`[^`]+`/g, (m) => "x".repeat(m.length));
+        const emptyUrlMatches = stripped.matchAll(/\[[^\]]+\]\(\s*\)/g);
         for (const match of emptyUrlMatches) {
           const column = match.index + 1;
           issues.push({
@@ -18392,7 +18425,7 @@ var init_no_empty_links = __esm(() => {
             severity: "error"
           });
         }
-        const emptyTextMatches = line.matchAll(/\[\s*\]\([^)]+\)/g);
+        const emptyTextMatches = stripped.matchAll(/\[\s*\]\([^)]+\)/g);
         for (const match of emptyTextMatches) {
           const column = match.index + 1;
           issues.push({
@@ -18420,8 +18453,15 @@ var init_no_hard_tabs = __esm(() => {
     check: (text, ctx) => {
       const issues = [];
       const lines = text.split(/\r?\n/);
+      let inFence = false;
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
+        if (/^(`{3,}|~{3,})/.test(line.trim())) {
+          inFence = !inFence;
+          continue;
+        }
+        if (inFence)
+          continue;
         const tabIndex = line.indexOf("\t");
         if (tabIndex !== -1) {
           issues.push({
@@ -20030,11 +20070,12 @@ var nodePlugin;
 var init_node = __esm(() => {
   init_prefer_global_buffer();
   init_prefer_global_process();
+  init_utils();
   nodePlugin = {
     name: "node",
     rules: {
-      "prefer-global/buffer": preferGlobalBuffer,
-      "prefer-global/process": preferGlobalProcess
+      "prefer-global/buffer": codeOnly(preferGlobalBuffer),
+      "prefer-global/process": codeOnly(preferGlobalProcess)
     }
   };
 });
@@ -20078,10 +20119,11 @@ ${rest}`;
 var perfectionistPlugin;
 var init_perfectionist = __esm(() => {
   init_imports();
+  init_utils();
   perfectionistPlugin = {
     name: "perfectionist",
     rules: {
-      "sort-imports": sortImportsRule
+      "sort-imports": codeOnly(sortImportsRule)
     }
   };
 });
@@ -20933,24 +20975,25 @@ var init_pickier = __esm(() => {
   init_named_imports();
   init_objects();
   init_top_level_function();
+  init_utils();
   pickierPlugin = {
     name: "pickier",
     rules: {
-      "sort-exports": sortExportsRule,
-      "sort-objects": sortObjectsRule,
-      "sort-imports": sortImportsRule,
-      "sort-named-imports": sortNamedImportsRule,
-      "sort-heritage-clauses": sortHeritageClausesRule,
-      "sort-keys": sortKeysRule,
-      "import-dedupe": importDedupeRule,
-      "import-first": firstRule,
-      "import-named": namedRule,
-      "import-no-cycle": noCycleRule,
-      "import-no-unresolved": noUnresolvedRule,
-      "no-import-dist": noImportDistRule,
-      "no-import-node-modules-by-path": noImportNodeModulesByPathRule,
-      "no-duplicate-imports": noDuplicateImportsRule,
-      "top-level-function": topLevelFunctionRule
+      "sort-exports": codeOnly(sortExportsRule),
+      "sort-objects": codeOnly(sortObjectsRule),
+      "sort-imports": codeOnly(sortImportsRule),
+      "sort-named-imports": codeOnly(sortNamedImportsRule),
+      "sort-heritage-clauses": codeOnly(sortHeritageClausesRule),
+      "sort-keys": codeOnly(sortKeysRule),
+      "import-dedupe": codeOnly(importDedupeRule),
+      "import-first": codeOnly(firstRule),
+      "import-named": codeOnly(namedRule),
+      "import-no-cycle": codeOnly(noCycleRule),
+      "import-no-unresolved": codeOnly(noUnresolvedRule),
+      "no-import-dist": codeOnly(noImportDistRule),
+      "no-import-node-modules-by-path": codeOnly(noImportNodeModulesByPathRule),
+      "no-duplicate-imports": codeOnly(noDuplicateImportsRule),
+      "top-level-function": codeOnly(topLevelFunctionRule)
     }
   };
 });
@@ -20997,48 +21040,49 @@ var init_quality = __esm(() => {
   init_no_with();
   init_prefer_arrow_callback();
   init_require_await();
+  init_utils();
   qualityPlugin = {
     name: "quality",
     rules: {
-      "default-case": defaultCaseRule,
-      eqeqeq: eqeqeqRule,
-      "no-alert": noAlertRule,
-      "no-await-in-loop": noAwaitInLoopRule,
-      "no-caller": noCallerRule,
-      "no-case-declarations": noCaseDeclarationsRule,
-      "no-else-return": noElseReturnRule,
-      "no-empty": noEmptyRule,
-      "no-empty-function": noEmptyFunctionRule,
-      "no-eval": noEvalRule,
-      "no-extend-native": noExtendNativeRule,
-      "no-global-assign": noGlobalAssignRule,
-      "no-implied-eval": noImpliedEvalRule,
-      "no-iterator": noIteratorRule,
-      "no-new": noNewRule,
-      "no-new-func": noNewFuncRule,
-      "no-new-wrappers": noNewWrappersRule,
-      "no-octal": noOctalRule,
-      "no-param-reassign": noParamReassignRule,
-      "no-proto": noProtoRule,
-      "no-return-assign": noReturnAssignRule,
-      "no-shadow": noShadowRule,
-      "no-throw-literal": noThrowLiteralRule,
-      "no-use-before-define": noUseBeforeDefineRule,
-      "no-useless-call": noUselessCallRule,
-      "no-with": noWithRule,
-      "require-await": requireAwaitRule,
-      complexity: complexityRule,
-      "max-depth": maxDepthRule,
-      "max-lines-per-function": maxLinesPerFunctionRule,
-      "no-extra-boolean-cast": noExtraBooleanCastRule,
-      "no-lonely-if": noLonelyIfRule,
-      "no-sequences": noSequencesRule,
-      "no-useless-concat": noUselessConcatRule,
-      "no-useless-escape": noUselessEscapeRule,
-      "no-useless-rename": noUselessRenameRule,
-      "no-useless-return": noUselessReturnRule,
-      "no-var": noVarRule,
-      "prefer-arrow-callback": preferArrowCallbackRule
+      "default-case": codeOnly(defaultCaseRule),
+      eqeqeq: codeOnly(eqeqeqRule),
+      "no-alert": codeOnly(noAlertRule),
+      "no-await-in-loop": codeOnly(noAwaitInLoopRule),
+      "no-caller": codeOnly(noCallerRule),
+      "no-case-declarations": codeOnly(noCaseDeclarationsRule),
+      "no-else-return": codeOnly(noElseReturnRule),
+      "no-empty": codeOnly(noEmptyRule),
+      "no-empty-function": codeOnly(noEmptyFunctionRule),
+      "no-eval": codeOnly(noEvalRule),
+      "no-extend-native": codeOnly(noExtendNativeRule),
+      "no-global-assign": codeOnly(noGlobalAssignRule),
+      "no-implied-eval": codeOnly(noImpliedEvalRule),
+      "no-iterator": codeOnly(noIteratorRule),
+      "no-new": codeOnly(noNewRule),
+      "no-new-func": codeOnly(noNewFuncRule),
+      "no-new-wrappers": codeOnly(noNewWrappersRule),
+      "no-octal": codeOnly(noOctalRule),
+      "no-param-reassign": codeOnly(noParamReassignRule),
+      "no-proto": codeOnly(noProtoRule),
+      "no-return-assign": codeOnly(noReturnAssignRule),
+      "no-shadow": codeOnly(noShadowRule),
+      "no-throw-literal": codeOnly(noThrowLiteralRule),
+      "no-use-before-define": codeOnly(noUseBeforeDefineRule),
+      "no-useless-call": codeOnly(noUselessCallRule),
+      "no-with": codeOnly(noWithRule),
+      "require-await": codeOnly(requireAwaitRule),
+      complexity: codeOnly(complexityRule),
+      "max-depth": codeOnly(maxDepthRule),
+      "max-lines-per-function": codeOnly(maxLinesPerFunctionRule),
+      "no-extra-boolean-cast": codeOnly(noExtraBooleanCastRule),
+      "no-lonely-if": codeOnly(noLonelyIfRule),
+      "no-sequences": codeOnly(noSequencesRule),
+      "no-useless-concat": codeOnly(noUselessConcatRule),
+      "no-useless-escape": codeOnly(noUselessEscapeRule),
+      "no-useless-rename": codeOnly(noUselessRenameRule),
+      "no-useless-return": codeOnly(noUselessReturnRule),
+      "no-var": codeOnly(noVarRule),
+      "prefer-arrow-callback": codeOnly(preferArrowCallbackRule)
     }
   };
 });
@@ -21085,74 +21129,194 @@ var init_no_super_linear_backtracking = __esm(() => {
 });
 
 // src/rules/regexp/no-unused-capturing-group.ts
+function parseRegexLiteral(content, idx) {
+  let prevIdx = idx - 1;
+  while (prevIdx >= 0 && (content[prevIdx] === " " || content[prevIdx] === "\t"))
+    prevIdx--;
+  const prevChar = prevIdx >= 0 ? content[prevIdx] : "";
+  const regexPrecedes = "=(<>!&|?:;,{[+(~^%*/";
+  const isRegex = prevIdx < 0 || regexPrecedes.includes(prevChar) || /\b(?:return|typeof|void|delete|throw|new|in|of|case)\s*$/.test(content.slice(Math.max(0, prevIdx - 5), prevIdx + 1));
+  if (!isRegex)
+    return null;
+  let i = idx + 1;
+  let inClass = false;
+  let escaped = false;
+  let closedAt = -1;
+  while (i < content.length) {
+    const c = content[i];
+    if (escaped) {
+      escaped = false;
+    } else if (c === "\\") {
+      escaped = true;
+    } else if (c === "[") {
+      if (!inClass)
+        inClass = true;
+    } else if (c === "]") {
+      if (inClass)
+        inClass = false;
+    } else if (c === "/" && !inClass) {
+      closedAt = i;
+      break;
+    } else if (c === `
+`) {
+      break;
+    }
+    i++;
+  }
+  if (closedAt <= idx)
+    return null;
+  const pattern = content.slice(idx + 1, closedAt);
+  let flagEnd = closedAt + 1;
+  while (flagEnd < content.length && /[gimsuy]/.test(content[flagEnd]))
+    flagEnd++;
+  if (/\\[1-9]/.test(pattern))
+    return null;
+  let capCount = 0;
+  let firstCapOffset = -1;
+  let inCharClass = false;
+  for (let j = 0;j < pattern.length; j++) {
+    if (pattern[j] === "\\") {
+      j++;
+      continue;
+    }
+    if (pattern[j] === "[" && !inCharClass) {
+      inCharClass = true;
+      continue;
+    }
+    if (pattern[j] === "]" && inCharClass) {
+      inCharClass = false;
+      continue;
+    }
+    if (inCharClass)
+      continue;
+    if (pattern[j] === "(" && pattern.slice(j + 1, j + 3) !== "?:" && pattern.slice(j + 1, j + 3) !== "?=" && pattern.slice(j + 1, j + 3) !== "?!" && pattern.slice(j + 1, j + 4) !== "?<=" && pattern.slice(j + 1, j + 4) !== "?<!") {
+      if (firstCapOffset < 0)
+        firstCapOffset = j;
+      capCount++;
+    }
+  }
+  if (capCount === 0)
+    return null;
+  return { patternStart: idx, patternEnd: flagEnd, pattern, capCount, firstCapOffset };
+}
+function areCapturesUsed(content, regexStart, regexEnd) {
+  let afterIdx = regexEnd;
+  while (afterIdx < content.length && (content[afterIdx] === " " || content[afterIdx] === "\t"))
+    afterIdx++;
+  if (content[afterIdx] === ".") {
+    const rest = content.slice(afterIdx + 1, afterIdx + 20);
+    if (/^test\s*\(/.test(rest))
+      return false;
+    if (/^exec\s*\(/.test(rest))
+      return true;
+  }
+  let beforeIdx = regexStart - 1;
+  while (beforeIdx >= 0 && (content[beforeIdx] === " " || content[beforeIdx] === "\t"))
+    beforeIdx--;
+  if (content[beforeIdx] === "(") {
+    let methodEnd = beforeIdx;
+    let methodStart = methodEnd - 1;
+    while (methodStart >= 0 && (content[methodStart] === " " || content[methodStart] === "\t"))
+      methodStart--;
+    const slice = content.slice(Math.max(0, methodStart - 20), methodStart + 1);
+    if (/\.match\s*$/.test(slice))
+      return true;
+    if (/\.matchAll\s*$/.test(slice))
+      return true;
+    if (/\.exec\s*$/.test(slice))
+      return true;
+    if (/\.replace\s*$/.test(slice))
+      return true;
+    if (/\.replaceAll\s*$/.test(slice))
+      return true;
+    if (/\.split\s*$/.test(slice))
+      return true;
+    if (/\.search\s*$/.test(slice))
+      return false;
+    if (/\.test\s*$/.test(slice))
+      return false;
+  }
+  const lineStart = content.lastIndexOf(`
+`, regexStart) + 1;
+  const beforeRegex = content.slice(lineStart, regexStart).trim();
+  const assignMatch = beforeRegex.match(/(?:const|let|var)\s+(\w+)\s*=\s*$/);
+  if (assignMatch) {
+    const varName = assignMatch[1];
+    const afterContent = content.slice(regexEnd);
+    const execPattern = new RegExp(`\\b${varName}\\.exec\\s*\\(`);
+    const testPattern = new RegExp(`\\b${varName}\\.test\\s*\\(`);
+    const matchPattern = new RegExp(`\\.match(?:All)?\\s*\\(\\s*${varName}\\s*\\)`);
+    const replacePattern = new RegExp(`\\.replace(?:All)?\\s*\\(\\s*${varName}`);
+    const hasExec = execPattern.test(afterContent);
+    const hasMatch = matchPattern.test(afterContent);
+    const hasReplace = replacePattern.test(afterContent);
+    const hasTest = testPattern.test(afterContent);
+    if (hasExec || hasMatch || hasReplace)
+      return true;
+    if (hasTest)
+      return false;
+    return true;
+  }
+  return true;
+}
 function findIssues(content, ctx) {
   const issues = [];
   const filePath = ctx.filePath;
-  const _re = /(^|[^\\\w])/g;
   let idx = 0;
   while (idx < content.length) {
     const ch = content[idx];
-    if (ch === "/") {
-      let i = idx + 1;
-      let inClass = false;
-      let escaped = false;
-      let closedAt = -1;
-      while (i < content.length) {
-        const c = content[i];
-        if (escaped) {
-          escaped = false;
-        } else if (c === "\\") {
-          escaped = true;
-        } else if (c === "[") {
-          if (!inClass)
-            inClass = true;
-        } else if (c === "]") {
-          if (inClass)
-            inClass = false;
-        } else if (c === "/" && !inClass) {
-          closedAt = i;
+    if (ch === "/" && content[idx + 1] === "/") {
+      while (idx < content.length && content[idx] !== `
+`)
+        idx++;
+      continue;
+    }
+    if (ch === "/" && content[idx + 1] === "*") {
+      idx += 2;
+      while (idx < content.length - 1 && !(content[idx] === "*" && content[idx + 1] === "/"))
+        idx++;
+      idx += 2;
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      const quote = ch;
+      idx++;
+      while (idx < content.length) {
+        if (content[idx] === "\\") {
+          idx += 2;
+          continue;
+        }
+        if (content[idx] === quote) {
+          idx++;
           break;
         }
-        i++;
+        idx++;
       }
-      if (closedAt > idx) {
-        const pattern = content.slice(idx + 1, closedAt);
-        if (/\\[1-9]/.test(pattern)) {
-          idx = closedAt + 1;
-          continue;
-        }
-        let capCount = 0;
-        for (let j = 0;j < pattern.length; j++) {
-          const c = pattern[j];
-          if (c === "(") {
-            const prev = pattern[j - 1];
-            const isEscaped = prev === "\\";
-            if (!isEscaped) {
-              const next2 = pattern.slice(j + 1, j + 3);
-              if (next2 !== "?:")
-                capCount++;
-            }
-          }
-        }
-        if (capCount > 0) {
-          const rel = pattern.indexOf("(");
-          const reportPos = idx + 1 + (rel >= 0 ? rel : 0);
-          const prefix = content.slice(0, reportPos);
-          const line = (prefix.match(/\r?\n/g) || []).length + 1;
-          const col = reportPos - (prefix.lastIndexOf(`
-`) + 1) + 1;
-          issues.push({
-            filePath,
-            line,
-            column: col,
-            ruleId: "regexp/no-unused-capturing-group",
-            message: "Unused capturing group in regular expression",
-            severity: "error"
-          });
-        }
-        idx = closedAt + 1;
+      continue;
+    }
+    if (ch === "/") {
+      const info = parseRegexLiteral(content, idx);
+      if (!info) {
+        idx++;
         continue;
       }
+      if (!areCapturesUsed(content, info.patternStart, info.patternEnd)) {
+        const reportPos = info.patternStart + 1 + (info.firstCapOffset >= 0 ? info.firstCapOffset : 0);
+        const prefix = content.slice(0, reportPos);
+        const line = (prefix.match(/\r?\n/g) || []).length + 1;
+        const col = reportPos - (prefix.lastIndexOf(`
+`) + 1) + 1;
+        issues.push({
+          filePath,
+          line,
+          column: col,
+          ruleId: "regexp/no-unused-capturing-group",
+          message: "Unused capturing group in regular expression; use non-capturing group (?:...) instead",
+          severity: "error"
+        });
+      }
+      idx = info.patternEnd;
+      continue;
     }
     idx++;
   }
@@ -21162,7 +21326,7 @@ var noUnusedCapturingGroupRule;
 var init_no_unused_capturing_group = __esm(() => {
   noUnusedCapturingGroupRule = {
     meta: {
-      docs: "Flags regex literals with capturing groups when there is no numeric backreference present",
+      docs: "Flags regex literals with unused capturing groups (context-aware)",
       recommended: false
     },
     check(content, ctx) {
@@ -21224,12 +21388,13 @@ var init_regexp = __esm(() => {
   init_no_super_linear_backtracking();
   init_no_unused_capturing_group();
   init_no_useless_lazy();
+  init_utils();
   regexpPlugin = {
     name: "regexp",
     rules: {
-      "no-super-linear-backtracking": noSuperLinearBacktrackingRule,
-      "no-unused-capturing-group": noUnusedCapturingGroupRule,
-      "no-useless-lazy": noUselessLazy
+      "no-super-linear-backtracking": codeOnly(noSuperLinearBacktrackingRule),
+      "no-unused-capturing-group": codeOnly(noUnusedCapturingGroupRule),
+      "no-useless-lazy": codeOnly(noUselessLazy)
     }
   };
 });
@@ -25430,22 +25595,7 @@ var init_yield_star_spacing = __esm(() => {
 });
 
 // src/plugins/style.ts
-function codeOnly(rule) {
-  return {
-    meta: rule.meta,
-    check: (content, context) => {
-      if (!CODE_EXTS2.test(context.filePath))
-        return [];
-      return rule.check(content, context);
-    },
-    fix: rule.fix ? (content, context) => {
-      if (!CODE_EXTS2.test(context.filePath))
-        return content;
-      return rule.fix(content, context);
-    } : undefined
-  };
-}
-var CODE_EXTS2, stylePlugin;
+var stylePlugin;
 var init_style = __esm(() => {
   init_array_bracket_spacing();
   init_arrow_parens();
@@ -25497,7 +25647,7 @@ var init_style = __esm(() => {
   init_template_tag_spacing();
   init_wrap_iife();
   init_yield_star_spacing();
-  CODE_EXTS2 = /\.(ts|js|tsx|jsx|mts|mjs|cts|cjs)$/;
+  init_utils();
   stylePlugin = {
     name: "style",
     rules: {
@@ -26092,9 +26242,9 @@ var init_no_top_level_await = __esm(() => {
           }
           if (!escape && ch === "'") {
             inSQ = false;
-            escape = false;
-            continue;
           }
+          escape = false;
+          continue;
         }
         if (inDQ) {
           if (!escape && ch === "\\") {
@@ -26103,9 +26253,9 @@ var init_no_top_level_await = __esm(() => {
           }
           if (!escape && ch === '"') {
             inDQ = false;
-            escape = false;
-            continue;
           }
+          escape = false;
+          continue;
         }
         if (inTQ) {
           if (!escape && ch === "\\") {
@@ -26897,22 +27047,23 @@ var init_ts = __esm(() => {
   init_type_annotation_spacing();
   init_type_generic_spacing();
   init_type_named_tuple_spacing();
+  init_utils();
   tsPlugin = {
     name: "ts",
     rules: {
-      "no-require-imports": noRequireImportsRule,
-      "no-top-level-await": noTopLevelAwaitRule,
-      "no-ts-export-equal": noTsExportEqualRule,
-      "no-explicit-any": noExplicitAnyRule,
-      "prefer-nullish-coalescing": preferNullishCoalescingRule,
-      "prefer-optional-chain": preferOptionalChainRule,
-      "no-floating-promises": noFloatingPromisesRule,
-      "no-misused-promises": noMisusedPromisesRule,
-      "no-unsafe-assignment": noUnsafeAssignmentRule,
-      "member-delimiter-style": memberDelimiterStyleRule,
-      "type-annotation-spacing": typeAnnotationSpacingRule,
-      "type-generic-spacing": typeGenericSpacingRule,
-      "type-named-tuple-spacing": typeNamedTupleSpacingRule
+      "no-require-imports": codeOnly(noRequireImportsRule),
+      "no-top-level-await": codeOnly(noTopLevelAwaitRule),
+      "no-ts-export-equal": codeOnly(noTsExportEqualRule),
+      "no-explicit-any": codeOnly(noExplicitAnyRule),
+      "prefer-nullish-coalescing": codeOnly(preferNullishCoalescingRule),
+      "prefer-optional-chain": codeOnly(preferOptionalChainRule),
+      "no-floating-promises": codeOnly(noFloatingPromisesRule),
+      "no-misused-promises": codeOnly(noMisusedPromisesRule),
+      "no-unsafe-assignment": codeOnly(noUnsafeAssignmentRule),
+      "member-delimiter-style": codeOnly(memberDelimiterStyleRule),
+      "type-annotation-spacing": codeOnly(typeAnnotationSpacingRule),
+      "type-generic-spacing": codeOnly(typeGenericSpacingRule),
+      "type-named-tuple-spacing": codeOnly(typeNamedTupleSpacingRule)
     }
   };
 });
@@ -26921,11 +27072,12 @@ var init_ts = __esm(() => {
 var unusedImportsPlugin;
 var init_unused_imports = __esm(() => {
   init_no_unused_vars();
+  init_utils();
   unusedImportsPlugin = {
     name: "unused-imports",
     rules: {
-      "no-unused-vars": noUnusedVarsRule,
-      "no-unused-imports": noUnusedVarsRule
+      "no-unused-vars": codeOnly(noUnusedVarsRule),
+      "no-unused-imports": codeOnly(noUnusedVarsRule)
     }
   };
 });
@@ -27026,13 +27178,9 @@ async function loadConfigFromPath(pathLike) {
       return _cachedDefaultConfig;
     }
     try {
-      const { existsSync: existsSync10 } = await import("fs");
-      const { join: join7 } = await import("path");
-      const configPath = join7(process15.cwd(), "pickier.config.ts");
-      if (existsSync10(configPath)) {
-        const { config: config4 } = await init_config().then(() => exports_config);
-        return mergeConfig(config4, {});
-      }
+      const { getConfig: getConfig2 } = await init_config().then(() => exports_config);
+      const cfg = await getConfig2();
+      return mergeConfig(defaultConfig3, cfg);
     } catch {}
     return mergeConfig(defaultConfig3, {});
   }
@@ -27097,7 +27245,7 @@ function shouldIgnorePath(absPath, ignoreGlobs) {
   return false;
 }
 var MAX_FIXER_PASSES = 5, ENV, UNIVERSAL_IGNORES, colors, _cachedDefaultConfig = null;
-var init_utils = __esm(async () => {
+var init_utils2 = __esm(async () => {
   await init_config();
   ENV = {
     get TRACE() {
@@ -27390,7 +27538,7 @@ var init_formatter = __esm(async () => {
   init_plugins();
   await __promiseAll([
     init_src(),
-    init_utils()
+    init_utils2()
   ]);
 });
 
@@ -28816,7 +28964,7 @@ var init_linter = __esm(async () => {
   await __promiseAll([
     init_src(),
     init_formatter(),
-    init_utils()
+    init_utils2()
   ]);
 });
 
@@ -28871,7 +29019,7 @@ async function runUnified(globs, options) {
 }
 var init_run = __esm(async () => {
   init_format();
-  await init_utils();
+  await init_utils2();
 });
 
 // src/index.ts
@@ -28882,7 +29030,7 @@ await __promiseAll([
   init_run()
 ]);
 init_format();
-init_utils();
+init_utils2();
 export {
   yellow5 as yellow,
   shouldIgnorePath,