pickier 0.1.15 → 0.1.17

package/dist/bin/cli.js

@@ -353,13 +353,18 @@ function detectQuoteIssues(line, preferred) {
   }
   return indices;
 }
-function hasIndentIssue(leading, indentSize, indentStyle = "spaces") {
+function hasIndentIssue(leading, indentSize, indentStyle = "spaces", lineContent) {
   if (indentStyle === "tabs") {
     return /[^\t]/.test(leading);
   }
   if (/\t/.test(leading))
     return true;
   const spaces = leading.length;
+  if (lineContent && spaces % indentSize === 1) {
+    const trimmed = lineContent.trimStart();
+    if (trimmed.startsWith("* ") || trimmed.startsWith("*/") || trimmed === "*")
+      return false;
+  }
   return spaces % indentSize !== 0;
 }
 function maskStrings(input) {
@@ -6131,7 +6136,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",
@@ -6212,8 +6217,9 @@ async function loadConfigFromPath(pathLike) {
       const { join: join4 } = await import("path");
       const configPath = join4(process13.cwd(), "pickier.config.ts");
       if (existsSync6(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, {});
@@ -15088,6 +15094,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_utils2 = __esm(() => {
+  CODE_EXTS2 = /\.(?:ts|js|tsx|jsx|mts|mjs|cts|cjs)$/;
+});
+
 // src/plugins/eslint.ts
 var eslintPlugin;
 var init_eslint = __esm(() => {
@@ -15156,74 +15183,75 @@ var init_eslint = __esm(() => {
   init_no_with();
   init_prefer_arrow_callback();
   init_require_await();
+  init_utils2();
   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)
     }
   };
 });
@@ -15241,8 +15269,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;
@@ -15486,6 +15514,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) {
@@ -15934,7 +15964,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;
@@ -15962,7 +15992,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;
               }
             }
@@ -16004,7 +16034,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")) {
@@ -16355,11 +16385,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;
@@ -16367,7 +16397,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;
@@ -16539,43 +16569,44 @@ var init_general = __esm(() => {
   init_prefer_template();
   init_use_isnan();
   init_valid_typeof();
+  init_utils2();
   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)
     }
   };
 });
@@ -17157,38 +17188,41 @@ var init_blanks_around_fences = __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 prevLine = i > 0 ? lines[i - 1] : "";
-        const nextLine = i + 1 < lines.length ? lines[i + 1] : "";
-        const isFence = /^(`{3,}|~{3,})/.test(line);
+        const isFence = /^(`{3,}|~{3,})/.test(line.trim());
         if (isFence) {
-          let isOpening = true;
-          for (let j = i - 1;j >= 0; j--) {
-            if (/^(`{3,}|~{3,})/.test(lines[j])) {
-              isOpening = false;
-              break;
+          if (!inFence) {
+            const prevLine = i > 0 ? lines[i - 1] : "";
+            if (i > 0 && prevLine.trim().length > 0) {
+              if (!/^:::/.test(prevLine.trim())) {
+                issues.push({
+                  filePath: ctx.filePath,
+                  line: i + 1,
+                  column: 1,
+                  ruleId: "markdown/blanks-around-fences",
+                  message: "Fenced code blocks should be surrounded by blank lines",
+                  severity: "error"
+                });
+              }
             }
-          }
-          if (isOpening && i > 0 && prevLine.trim().length > 0) {
-            issues.push({
-              filePath: ctx.filePath,
-              line: i + 1,
-              column: 1,
-              ruleId: "markdown/blanks-around-fences",
-              message: "Fenced code blocks should be surrounded by blank lines",
-              severity: "error"
-            });
-          }
-          if (!isOpening && i + 1 < lines.length && nextLine.trim().length > 0) {
-            issues.push({
-              filePath: ctx.filePath,
-              line: i + 1,
-              column: 1,
-              ruleId: "markdown/blanks-around-fences",
-              message: "Fenced code blocks should be surrounded by blank lines",
-              severity: "error"
-            });
+            inFence = true;
+          } else {
+            const nextLine = i + 1 < lines.length ? lines[i + 1] : "";
+            if (i + 1 < lines.length && nextLine.trim().length > 0) {
+              if (!/^:::/.test(nextLine.trim())) {
+                issues.push({
+                  filePath: ctx.filePath,
+                  line: i + 1,
+                  column: 1,
+                  ruleId: "markdown/blanks-around-fences",
+                  message: "Fenced code blocks should be surrounded by blank lines",
+                  severity: "error"
+                });
+              }
+            }
+            inFence = false;
           }
         }
       }
@@ -17201,10 +17235,10 @@ var init_blanks_around_fences = __esm(() => {
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
         const prevLine = i > 0 ? lines[i - 1] : "";
-        const isFence = /^(`{3,}|~{3,})/.test(line);
+        const isFence = /^(`{3,}|~{3,})/.test(line.trim());
         if (isFence) {
           if (!inFence) {
-            if (i > 0 && prevLine.trim().length > 0 && result.length > 0) {
+            if (i > 0 && prevLine.trim().length > 0 && !/^:::/.test(prevLine.trim()) && result.length > 0) {
               result.push("");
             }
             inFence = true;
@@ -17215,7 +17249,7 @@ var init_blanks_around_fences = __esm(() => {
         result.push(line);
         if (isFence && !inFence && i + 1 < lines.length) {
           const nextLine = lines[i + 1];
-          if (nextLine.trim().length > 0) {
+          if (nextLine.trim().length > 0 && !/^:::/.test(nextLine.trim())) {
             result.push("");
           }
         }
@@ -17351,14 +17385,22 @@ var init_blanks_around_lists = __esm(() => {
       const issues = [];
       const lines = text.split(/\r?\n/);
       let inList = false;
-      let listStartLine = -1;
+      let inFence = false;
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
         const prevLine = i > 0 ? lines[i - 1] : "";
+        if (/^(`{3,}|~{3,})/.test(line.trim())) {
+          inFence = !inFence;
+          if (inList)
+            inList = false;
+          continue;
+        }
+        if (inFence)
+          continue;
         const isListItem = /^(\s*)([*\-+]|\d+\.)\s+/.test(line);
+        const isListContinuation = inList && !isListItem && line.trim().length > 0 && /^\s+/.test(line);
         if (isListItem && !inList) {
           inList = true;
-          listStartLine = i;
           if (i > 0 && prevLine.trim().length > 0) {
             issues.push({
               filePath: ctx.filePath,
@@ -17369,7 +17411,7 @@ var init_blanks_around_lists = __esm(() => {
               severity: "error"
             });
           }
-        } else if (!isListItem && inList && line.trim().length > 0) {
+        } else if (!isListItem && !isListContinuation && inList && line.trim().length > 0) {
           inList = false;
           const prevLineIsListItem = /^(\s*)([*\-+]|\d+\.)\s+/.test(prevLine);
           if (prevLineIsListItem) {
@@ -17430,15 +17472,21 @@ var init_blanks_around_tables = __esm(() => {
       const issues = [];
       const lines = text.split(/\r?\n/);
       let inTable = false;
-      let tableStartLine = -1;
+      let inFence = false;
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
         const prevLine = i > 0 ? lines[i - 1] : "";
-        const nextLine = i + 1 < lines.length ? lines[i + 1] : "";
+        if (/^(`{3,}|~{3,})/.test(line.trim())) {
+          inFence = !inFence;
+          if (inTable)
+            inTable = false;
+          continue;
+        }
+        if (inFence)
+          continue;
         const isTableLine = /\|/.test(line) && line.trim().length > 0;
         if (isTableLine && !inTable) {
           inTable = true;
-          tableStartLine = i;
           if (i > 0 && prevLine.trim().length > 0) {
             issues.push({
               filePath: ctx.filePath,
@@ -17920,8 +17968,15 @@ var init_heading_increment = __esm(() => {
       const issues = [];
       const lines = text.split(/\r?\n/);
       let previousLevel = 0;
+      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 atxMatch = line.match(/^(#{1,6})\s/);
         if (atxMatch) {
           const level = atxMatch[1].length;
@@ -17953,8 +18008,15 @@ var init_heading_start_left = __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 match = line.match(/^(\s+)(#{1,6}\s)/);
         if (match) {
           issues.push({
@@ -18249,8 +18311,24 @@ var init_link_image_style = __esm(() => {
       const options = ctx.options || {};
       const style = options.style || "consistent";
       let detectedStyle = null;
+      let inFence = false;
+      let inHtmlComment = 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;
+        if (line.includes("<!--"))
+          inHtmlComment = true;
+        if (line.includes("-->")) {
+          inHtmlComment = false;
+          continue;
+        }
+        if (inHtmlComment)
+          continue;
         if (line.match(/^\[([^\]]+)\]:\s*\S+/)) {
           continue;
         }
@@ -18467,19 +18545,34 @@ var init_no_bare_urls = __esm(() => {
     check: (text, ctx) => {
       const issues = [];
       const lines = text.split(/\r?\n/);
+      let inFence = false;
+      let inHtmlComment = false;
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
-        if (line.trim().startsWith("```") || line.trim().startsWith("~~~")) {
+        if (/^(`{3,}|~{3,})/.test(line.trim())) {
+          inFence = !inFence;
+          continue;
+        }
+        if (inFence)
+          continue;
+        if (line.includes("<!--"))
+          inHtmlComment = true;
+        if (line.includes("-->")) {
+          inHtmlComment = false;
           continue;
         }
-        const urlPattern = /(?<![<`(])https?:\/\/[^\s<>`)\]]+(?![>\])`])/g;
-        const matches = line.matchAll(urlPattern);
+        if (inHtmlComment)
+          continue;
+        if (/^\[([^\]]+)\]:\s*\S+/.test(line))
+          continue;
+        const stripped = line.replace(/`[^`]+`/g, (m) => " ".repeat(m.length));
+        const urlPattern = /(?<![<(="'])https?:\/\/[^\s<>`)\]"']+(?![>\])"'])/g;
+        const matches = stripped.matchAll(urlPattern);
         for (const match of matches) {
-          const column = match.index + 1;
           issues.push({
             filePath: ctx.filePath,
             line: i + 1,
-            column,
+            column: match.index + 1,
             ruleId: "markdown/no-bare-urls",
             message: "Bare URL used. Wrap in angle brackets: <url>",
             severity: "error"
@@ -18490,11 +18583,26 @@ var init_no_bare_urls = __esm(() => {
     },
     fix: (text) => {
       const lines = text.split(/\r?\n/);
+      let inFence = false;
+      let inHtmlComment = false;
       const fixedLines = lines.map((line) => {
-        if (line.trim().startsWith("```") || line.trim().startsWith("~~~")) {
+        if (/^(`{3,}|~{3,})/.test(line.trim())) {
+          inFence = !inFence;
           return line;
         }
-        return line.replace(/(?<![<`(])https?:\/\/[^\s<>`)\]]+(?![>\])`])/g, "<$&>");
+        if (inFence)
+          return line;
+        if (line.includes("<!--"))
+          inHtmlComment = true;
+        if (line.includes("-->")) {
+          inHtmlComment = false;
+          return line;
+        }
+        if (inHtmlComment)
+          return line;
+        if (/^\[([^\]]+)\]:\s*\S+/.test(line))
+          return line;
+        return line.replace(/(?<![<(="'])https?:\/\/[^\s<>`)\]"']+(?![>\])"'])/g, "<$&>");
       });
       return fixedLines.join(`
 `);
@@ -18550,8 +18658,15 @@ var init_no_duplicate_heading = __esm(() => {
       const issues = [];
       const lines = text.split(/\r?\n/);
       const headings = new Map;
+      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 atxMatch = line.match(/^#{1,6}\s+(.+?)(?:\s*#+\s*)?$/);
         if (atxMatch) {
           const content = atxMatch[1].trim();
@@ -18600,10 +18715,17 @@ var init_no_emphasis_as_heading = __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 prevLine = i > 0 ? lines[i - 1] : "";
         const nextLine = i + 1 < lines.length ? lines[i + 1] : "";
+        if (/^(`{3,}|~{3,})/.test(line.trim())) {
+          inFence = !inFence;
+          continue;
+        }
+        if (inFence)
+          continue;
         const isBoldLine = /^\*\*[^*]+\*\*\s*$/.test(line) || /^__[^_]+__\s*$/.test(line);
         const isItalicLine = /^\*[^*]+\*\s*$/.test(line) || /^_[^_]+_\s*$/.test(line);
         const isStandalone = prevLine.trim().length === 0 && nextLine.trim().length === 0;
@@ -18633,9 +18755,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({
@@ -18647,7 +18777,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({
@@ -18675,8 +18805,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({
@@ -18709,9 +18846,17 @@ var init_no_inline_html = __esm(() => {
       const lines = text.split(/\r?\n/);
       const options = ctx.options || {};
       const allowedElements = options.allowed_elements || [];
+      let inFence = false;
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
-        const matches = line.matchAll(/<\/?([a-z][a-z0-9]*)\b[^>]*>/gi);
+        if (/^(`{3,}|~{3,})/.test(line.trim())) {
+          inFence = !inFence;
+          continue;
+        }
+        if (inFence)
+          continue;
+        const stripped = line.replace(/`[^`]+`/g, (m) => " ".repeat(m.length));
+        const matches = stripped.matchAll(/<\/?([a-z][a-z0-9]*)\b[^>]*>/gi);
         for (const match of matches) {
           const tagName = match[1].toLowerCase();
           if (!allowedElements.includes(tagName)) {
@@ -19027,27 +19172,54 @@ var init_no_space_in_code = __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 matches = line.matchAll(/(`+)\s+([^`]+?)\s+\1/g);
-        for (const match of matches) {
-          const column = match.index + 1;
-          issues.push({
-            filePath: ctx.filePath,
-            line: i + 1,
-            column,
-            ruleId: "markdown/no-space-in-code",
-            message: "Spaces inside code span elements",
-            severity: "error"
-          });
+        if (/^(`{3,}|~{3,})/.test(line.trim())) {
+          inFence = !inFence;
+          continue;
+        }
+        if (inFence)
+          continue;
+        const codeSpanPattern = /(`+)([\s\S]*?)\1/g;
+        for (const match of line.matchAll(codeSpanPattern)) {
+          const content = match[2];
+          if (content.startsWith(" ") && content.endsWith(" ") && content.trim().length > 0) {
+            issues.push({
+              filePath: ctx.filePath,
+              line: i + 1,
+              column: match.index + 1,
+              ruleId: "markdown/no-space-in-code",
+              message: "Spaces inside code span elements",
+              severity: "error"
+            });
+          }
         }
       }
       return issues;
     },
     fix: (text) => {
-      return text.replace(/(`+)\s+([^`]+?)\s+\1/g, (match, backticks, content) => {
-        return `${backticks}${content.trim()}${backticks}`;
-      });
+      const lines = text.split(/\r?\n/);
+      let inFence = false;
+      const result = [];
+      for (const line of lines) {
+        if (/^(`{3,}|~{3,})/.test(line.trim())) {
+          inFence = !inFence;
+          result.push(line);
+          continue;
+        }
+        if (inFence) {
+          result.push(line);
+          continue;
+        }
+        result.push(line.replace(/(`+)([\s\S]*?)\1/g, (match, backticks, content) => {
+          if (content.startsWith(" ") && content.endsWith(" ") && content.trim().length > 0)
+            return `${backticks}${content.trim()}${backticks}`;
+          return match;
+        }));
+      }
+      return result.join(`
+`);
     }
   };
 });
@@ -19062,20 +19234,28 @@ var init_no_space_in_emphasis = __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 stripped = line.replace(/`[^`]+`/g, (m) => "\x01".repeat(m.length));
         const patterns = [
-          /(\*\*|\*|__?)\s+/g,
-          /\s+(\*\*|\*|__?)/g
+          /\*\*\s+[^*]+?\*\*/g,
+          /\*\*[^*]+?\s+\*\*/g,
+          /__\s+[^_]+?__/g,
+          /__[^_]+?\s+__/g
         ];
         for (const pattern of patterns) {
-          const matches = line.matchAll(pattern);
-          for (const match of matches) {
-            const column = match.index + 1;
+          for (const match of stripped.matchAll(pattern)) {
             issues.push({
               filePath: ctx.filePath,
               line: i + 1,
-              column,
+              column: match.index + 1,
               ruleId: "markdown/no-space-in-emphasis",
               message: "Spaces inside emphasis markers",
               severity: "error"
@@ -19086,9 +19266,28 @@ var init_no_space_in_emphasis = __esm(() => {
       return issues;
     },
     fix: (text) => {
-      let fixed = text.replace(/(\*\*|\*|__?)\s+/g, "$1");
-      fixed = fixed.replace(/\s+(\*\*|\*|__?)/g, "$1");
-      return fixed;
+      const lines = text.split(/\r?\n/);
+      let inFence = false;
+      const result = [];
+      for (const line of lines) {
+        if (/^(`{3,}|~{3,})/.test(line.trim())) {
+          inFence = !inFence;
+          result.push(line);
+          continue;
+        }
+        if (inFence) {
+          result.push(line);
+          continue;
+        }
+        let fixed = line;
+        fixed = fixed.replace(/\*\*\s+([^*]+?)\*\*/g, "**$1**");
+        fixed = fixed.replace(/\*\*([^*]+?)\s+\*\*/g, "**$1**");
+        fixed = fixed.replace(/__\s+([^_]+?)__/g, "__$1__");
+        fixed = fixed.replace(/__([^_]+?)\s+__/g, "__$1__");
+        result.push(fixed);
+      }
+      return result.join(`
+`);
     }
   };
 });
@@ -19392,20 +19591,37 @@ var init_reference_links_images = __esm(() => {
           definitions.add(defMatch[1].toLowerCase());
         }
       }
+      let inFence = false;
+      let inHtmlComment = false;
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
-        const linkMatches = line.matchAll(/\[([^\]]+)\](?:\[([^\]]+)\])?(?!\()/g);
+        if (/^(`{3,}|~{3,})/.test(line.trim())) {
+          inFence = !inFence;
+          continue;
+        }
+        if (inFence)
+          continue;
+        if (line.includes("<!--"))
+          inHtmlComment = true;
+        if (line.includes("-->")) {
+          inHtmlComment = false;
+          continue;
+        }
+        if (inHtmlComment)
+          continue;
+        if (/^\[([^\]]+)\]:\s*\S+/.test(line))
+          continue;
+        const stripped = line.replace(/`[^`]+`/g, (m) => " ".repeat(m.length));
+        const linkMatches = stripped.matchAll(/\[([^\]]+)\](?:\[([^\]]+)\])?(?!\()/g);
         for (const match of linkMatches) {
           const label = (match[2] || match[1]).toLowerCase();
-          if (line.match(/^\[([^\]]+)\]:\s*\S+/)) {
+          if (/^[xX ]$/.test(label))
             continue;
-          }
           if (!definitions.has(label)) {
-            const column = match.index + 1;
             issues.push({
               filePath: ctx.filePath,
               line: i + 1,
-              column,
+              column: match.index + 1,
               ruleId: "markdown/reference-links-images",
               message: `Reference link '[${label}]' is not defined`,
               severity: "error"
@@ -19748,8 +19964,15 @@ var init_table_pipe_style = __esm(() => {
       const lines = text.split(/\r?\n/);
       const options = ctx.options || {};
       const style = options.style || "leading_and_trailing";
+      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;
         if (/\|/.test(line) && line.trim().length > 0) {
           const hasLeading = line.trim().startsWith("|");
           const hasTrailing = line.trim().endsWith("|");
@@ -19817,8 +20040,15 @@ var init_ul_indent = __esm(() => {
       const lines = text.split(/\r?\n/);
       const options = ctx.options || {};
       const expectedIndent = options.indent || 2;
+      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 match = line.match(/^(\s*)([*\-+])\s+/);
         if (match) {
           const indent = match[1].length;
@@ -19932,18 +20162,49 @@ var init_ul_style = __esm(() => {
 });
 
 // src/plugins/markdown.ts
+function stripFrontmatter(content) {
+  const lines = content.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---")
+    return { text: content, frontmatter: null, frontmatterEndLine: 0 };
+  for (let i = 1;i < lines.length; i++) {
+    if (lines[i].trim() === "---") {
+      const frontmatter = lines.slice(0, i + 1);
+      const blanked = frontmatter.map(() => "");
+      return {
+        text: [...blanked, ...lines.slice(i + 1)].join(`
+`),
+        frontmatter,
+        frontmatterEndLine: i + 1
+      };
+    }
+  }
+  return { text: content, frontmatter: null, frontmatterEndLine: 0 };
+}
+function restoreFrontmatter(content, frontmatter) {
+  if (!frontmatter)
+    return content;
+  const lines = content.split(/\r?\n/);
+  return [...frontmatter, ...lines.slice(frontmatter.length)].join(`
+`);
+}
 function markdownOnly(rule) {
   return {
     meta: rule.meta,
     check: (content, context) => {
       if (!context.filePath.endsWith(".md"))
         return [];
-      return rule.check(content, context);
+      const { text, frontmatterEndLine } = stripFrontmatter(content);
+      const issues = rule.check(text, context);
+      if (frontmatterEndLine > 0)
+        return issues.filter((issue) => issue.line > frontmatterEndLine + 1);
+      return issues;
     },
     fix: rule.fix ? (content, context) => {
       if (!context.filePath.endsWith(".md"))
         return content;
-      return rule.fix(content, context);
+      const { text, frontmatter } = stripFrontmatter(content);
+      const fixed = rule.fix(text, context);
+      return restoreFrontmatter(fixed, frontmatter);
     } : undefined
   };
 }
@@ -20161,11 +20422,12 @@ var nodePlugin;
 var init_node = __esm(() => {
   init_prefer_global_buffer();
   init_prefer_global_process();
+  init_utils2();
   nodePlugin = {
     name: "node",
     rules: {
-      "prefer-global/buffer": preferGlobalBuffer,
-      "prefer-global/process": preferGlobalProcess
+      "prefer-global/buffer": codeOnly(preferGlobalBuffer),
+      "prefer-global/process": codeOnly(preferGlobalProcess)
     }
   };
 });
@@ -20209,10 +20471,11 @@ ${rest}`;
 var perfectionistPlugin;
 var init_perfectionist = __esm(() => {
   init_imports();
+  init_utils2();
   perfectionistPlugin = {
     name: "perfectionist",
     rules: {
-      "sort-imports": sortImportsRule
+      "sort-imports": codeOnly(sortImportsRule)
     }
   };
 });
@@ -21064,24 +21327,25 @@ var init_pickier = __esm(() => {
   init_named_imports();
   init_objects();
   init_top_level_function();
+  init_utils2();
   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)
     }
   };
 });
@@ -21128,48 +21392,49 @@ var init_quality = __esm(() => {
   init_no_with();
   init_prefer_arrow_callback();
   init_require_await();
+  init_utils2();
   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)
     }
   };
 });
@@ -21216,74 +21481,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++;
   }
@@ -21293,7 +21678,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) {
@@ -21355,12 +21740,13 @@ var init_regexp = __esm(() => {
   init_no_super_linear_backtracking();
   init_no_unused_capturing_group();
   init_no_useless_lazy();
+  init_utils2();
   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)
     }
   };
 });
@@ -25561,22 +25947,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();
@@ -25628,17 +25999,17 @@ 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_utils2();
   stylePlugin = {
     name: "style",
     rules: {
-      "brace-style": braceStyle,
-      curly: curlyRule,
-      "max-statements-per-line": maxStatementsPerLineRule,
-      "if-newline": ifNewlineRule,
-      "consistent-chaining": consistentChainingRule,
-      "consistent-list-newline": consistentListNewlineRule,
-      "indent-unindent": indentUnindentRule,
+      "brace-style": codeOnly(braceStyle),
+      curly: codeOnly(curlyRule),
+      "max-statements-per-line": codeOnly(maxStatementsPerLineRule),
+      "if-newline": codeOnly(ifNewlineRule),
+      "consistent-chaining": codeOnly(consistentChainingRule),
+      "consistent-list-newline": codeOnly(consistentListNewlineRule),
+      "indent-unindent": codeOnly(indentUnindentRule),
       "no-multi-spaces": noMultiSpaces,
       "no-multiple-empty-lines": noMultipleEmptyLines,
       "no-trailing-spaces": noTrailingSpaces,
@@ -26223,9 +26594,9 @@ var init_no_top_level_await = __esm(() => {
           }
           if (!escape && ch === "'") {
             inSQ = false;
-            escape = false;
-            continue;
           }
+          escape = false;
+          continue;
         }
         if (inDQ) {
           if (!escape && ch === "\\") {
@@ -26234,9 +26605,9 @@ var init_no_top_level_await = __esm(() => {
           }
           if (!escape && ch === '"') {
             inDQ = false;
-            escape = false;
-            continue;
           }
+          escape = false;
+          continue;
         }
         if (inTQ) {
           if (!escape && ch === "\\") {
@@ -27028,22 +27399,23 @@ var init_ts = __esm(() => {
   init_type_annotation_spacing();
   init_type_generic_spacing();
   init_type_named_tuple_spacing();
+  init_utils2();
   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)
     }
   };
 });
@@ -27052,11 +27424,12 @@ var init_ts = __esm(() => {
 var unusedImportsPlugin;
 var init_unused_imports = __esm(() => {
   init_no_unused_vars();
+  init_utils2();
   unusedImportsPlugin = {
     name: "unused-imports",
     rules: {
-      "no-unused-vars": noUnusedVarsRule,
-      "no-unused-imports": noUnusedVarsRule
+      "no-unused-vars": codeOnly(noUnusedVarsRule),
+      "no-unused-imports": codeOnly(noUnusedVarsRule)
     }
   };
 });
@@ -28052,6 +28425,18 @@ function scanContentOptimized(filePath, content, cfg, suppress, commentLines) {
   const wantNoCondAssign = sevMap(cfg.rules.noCondAssign);
   const consoleCall = /\bconsole\.log\s*\(/;
   const debuggerStmt = /^\s*debugger\b/;
+  const linesInFencedCodeBlock = new Set;
+  if (fileExt === "md") {
+    let inFence = false;
+    for (let li = 0;li < lines.length; li++) {
+      if (/^(`{3,}|~{3,})/.test(lines[li].trim())) {
+        inFence = !inFence;
+        continue;
+      }
+      if (inFence)
+        linesInFencedCodeBlock.add(li + 1);
+    }
+  }
   const linesInTemplate = new Set;
   let inTemplate = false;
   let escaped = false;
@@ -28100,7 +28485,7 @@ function scanContentOptimized(filePath, content, cfg, suppress, commentLines) {
     }
     const leadingMatch = line.match(/^[ \t]*/);
     const leading = leadingMatch ? leadingMatch[0] : "";
-    if (leading.length > 0 && hasIndentIssue(leading, cfg.format.indent, cfg.format.indentStyle)) {
+    if (leading.length > 0 && !linesInFencedCodeBlock.has(lineNo) && hasIndentIssue(leading, cfg.format.indent, cfg.format.indentStyle, line)) {
       if (!isSuppressed("indent", lineNo, suppress))
         issues.push({ filePath, line: lineNo, column: 1, ruleId: "indent", message: "Incorrect indentation detected", severity: "warning", help: `Use ${cfg.format.indentStyle === "spaces" ? `${cfg.format.indent} spaces` : "tabs"} for indentation. Configure with format.indent and format.indentStyle in your config` });
     }
@@ -32446,7 +32831,7 @@ var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "pickier",
     type: "module",
-    version: "0.1.15",
+    version: "0.1.17",
     description: "Format, lint and more in a fraction of seconds.",
     author: "Chris Breuer <chris@stacksjs.org>",
     license: "MIT",