pickier 0.1.34 → 0.1.36

package/dist/bin/cli.js

@@ -48,6 +48,37 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // src/format.ts
+function isHangingControlLine(code) {
+  const m = RE_CONTROL_OPEN.exec(code);
+  if (!m)
+    return /^(?:else|do)\s*$/.test(code);
+  let depth = 0;
+  let inStr = null;
+  for (let i = m[0].length - 1;i < code.length; i++) {
+    const ch = code[i];
+    if (inStr) {
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === inStr)
+        inStr = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      inStr = ch;
+      continue;
+    }
+    if (ch === "(") {
+      depth++;
+    } else if (ch === ")") {
+      depth--;
+      if (depth === 0)
+        return code.slice(i + 1).trim().length === 0;
+    }
+  }
+  return false;
+}
 function getFileExt(filePath) {
   const idx = filePath.lastIndexOf(".");
   return idx >= 0 ? filePath.slice(idx) : "";
@@ -198,6 +229,25 @@ function fixQuotesLine(line, preferred) {
   while (i < line.length) {
     const ch = line[i];
     if (inString === 0) {
+      if (ch === "/") {
+        const nxt = line[i + 1];
+        if (nxt === "/")
+          break;
+        if (nxt === "*") {
+          const end = line.indexOf("*/", i + 2);
+          i = end === -1 ? line.length : end + 2;
+          continue;
+        }
+        if (isRegexStart(line, i)) {
+          const end = scanRegexEnd(line, i);
+          if (end !== -1) {
+            i = end;
+            continue;
+          }
+        }
+        i++;
+        continue;
+      }
       if (ch === '"') {
         inString = 2;
         stringStart = i;
@@ -265,6 +315,8 @@ function normalizeSpacingLine(line) {
     const c = line[firstNonSpace];
     if (c === "/" && (line[firstNonSpace + 1] === "/" || line[firstNonSpace + 1] === "*"))
       return line;
+    if (c === "*")
+      return line;
   }
   let hasSpacingChar = false;
   for (let j = firstNonSpace;j < line.length; j++) {
@@ -377,6 +429,49 @@ function advanceTemplateState(line, stack) {
   }
   return -1;
 }
+function blockCommentStateAfter(line, startsIn) {
+  let inBlock = startsIn;
+  let inStr = null;
+  let i = 0;
+  while (i < line.length) {
+    const ch = line[i];
+    if (inBlock) {
+      if (ch === "*" && line[i + 1] === "/") {
+        inBlock = false;
+        i += 2;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (inStr) {
+      if (ch === "\\") {
+        i += 2;
+        continue;
+      }
+      if (ch === inStr)
+        inStr = null;
+      i++;
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      inStr = ch;
+      i++;
+      continue;
+    }
+    if (ch === "/") {
+      if (line[i + 1] === "/")
+        break;
+      if (line[i + 1] === "*") {
+        inBlock = true;
+        i += 2;
+        continue;
+      }
+    }
+    i++;
+  }
+  return inBlock;
+}
 function processCodeLinesFused(content, cfg) {
   const lines = content.split(`
 `);
@@ -385,9 +480,16 @@ function processCodeLinesFused(content, cfg) {
   const preferred = cfg.format.quotes;
   const doSemiRemoval = cfg.format.semi === true;
   let indentLevel = 0;
+  let hangDepth = 0;
+  let inBlockComment = false;
   const tmplStack = [];
   for (let idx = 0;idx < len; idx++) {
     let line = lines[idx];
+    if (inBlockComment) {
+      inBlockComment = blockCommentStateAfter(line, true);
+      result[idx] = line;
+      continue;
+    }
     const protectedLine = inTemplateText(tmplStack);
     let splitIdx = -1;
     if (tmplStack.length > 0 || line.indexOf("`") !== -1)
@@ -396,6 +498,8 @@ function processCodeLinesFused(content, cfg) {
       result[idx] = line;
       continue;
     }
+    if (splitIdx < 0 && tmplStack.length === 0)
+      inBlockComment = blockCommentStateAfter(line, false);
     let tmplTail = "";
     let prefixEndedWithSpace = false;
     if (splitIdx >= 0) {
@@ -419,9 +523,15 @@ function processCodeLinesFused(content, cfg) {
     const trimmed = line.slice(wsEnd).trimEnd();
     if (RE_CLOSING_BRACE.test(trimmed))
       indentLevel = Math.max(0, indentLevel - 1);
-    line = makeIndent(indentLevel, cfg) + trimmed;
-    if (RE_OPENING_BRACE.test(trimmed))
+    const continuationBump = RE_CONTINUATION_LINE.test(trimmed) ? 1 : 0;
+    line = makeIndent(indentLevel + hangDepth + continuationBump, cfg) + trimmed;
+    if (RE_OPENING_BRACE.test(trimmed)) {
       indentLevel += 1;
+      hangDepth = 0;
+    } else if (!trimmed.startsWith("//") && !trimmed.startsWith("*") && !trimmed.startsWith("/*")) {
+      const code = trimmed.replace(RE_TRAILING_LINE_COMMENT, "");
+      hangDepth = isHangingControlLine(code) ? hangDepth + 1 : 0;
+    }
     line = normalizeSpacingLine(line);
     if (doSemiRemoval) {
       if (!RE_FOR_LOOP.test(line)) {
@@ -653,8 +763,48 @@ function skipTemplate(input, start) {
   }
   return i;
 }
+function isRegexStart(input, slashIdx) {
+  let j = slashIdx - 1;
+  while (j >= 0 && (input[j] === " " || input[j] === "\t"))
+    j--;
+  if (j < 0)
+    return true;
+  const prev = input[j];
+  if ("(,=:[!&|?;{}<>+-*%^~".includes(prev))
+    return true;
+  if (/[\w$]/.test(prev)) {
+    let k = j;
+    while (k >= 0 && /[\w$]/.test(input[k]))
+      k--;
+    return REGEX_PRECEDING_KEYWORDS.has(input.slice(k + 1, j + 1));
+  }
+  return false;
+}
+function scanRegexEnd(input, start) {
+  let i = start + 1;
+  let inClass = false;
+  while (i < input.length) {
+    const c = input[i];
+    if (c === "\\") {
+      i += 2;
+      continue;
+    }
+    if (c === "[") {
+      inClass = true;
+    } else if (c === "]") {
+      inClass = false;
+    } else if (c === "/" && !inClass) {
+      i++;
+      while (i < input.length && /[a-z]/i.test(input[i]))
+        i++;
+      return i;
+    }
+    i++;
+  }
+  return -1;
+}
 function maskStrings(input) {
-  if (!input.includes("'") && !input.includes('"') && !input.includes("`"))
+  if (!input.includes("'") && !input.includes('"') && !input.includes("`") && !input.includes("/"))
     return { text: input, strings: [] };
   const strings = [];
   const parts = [];
@@ -662,6 +812,42 @@ function maskStrings(input) {
   let segStart = 0;
   while (i < input.length) {
     const ch = input[i];
+    if (ch === "/") {
+      const next = input[i + 1];
+      if (next === "/") {
+        if (i > segStart)
+          parts.push(input.slice(segStart, i));
+        strings.push(input.slice(i));
+        parts.push(`@@S${strings.length - 1}@@`);
+        segStart = input.length;
+        break;
+      }
+      if (next === "*") {
+        const end = input.indexOf("*/", i + 2);
+        const stop = end === -1 ? input.length : end + 2;
+        if (i > segStart)
+          parts.push(input.slice(segStart, i));
+        strings.push(input.slice(i, stop));
+        parts.push(`@@S${strings.length - 1}@@`);
+        i = stop;
+        segStart = i;
+        continue;
+      }
+      if (isRegexStart(input, i)) {
+        const end = scanRegexEnd(input, i);
+        if (end !== -1) {
+          if (i > segStart)
+            parts.push(input.slice(segStart, i));
+          strings.push(input.slice(i, end));
+          parts.push(`@@S${strings.length - 1}@@`);
+          i = end;
+          segStart = i;
+          continue;
+        }
+      }
+      i++;
+      continue;
+    }
     if (ch === "'" || ch === '"' || ch === "`") {
       if (i > segStart)
         parts.push(input.slice(segStart, i));
@@ -717,24 +903,65 @@ function formatImports(source) {
   const lines = source.split(`
 `);
   const imports = [];
+  const preamble = [];
+  const interleaved = [];
   let idx = 0;
+  let lastEnd = 0;
+  let pendingStart = -1;
+  let sawImport = false;
   while (idx < lines.length) {
     const line = lines[idx];
-    if (RE_BLANK_LINE.test(line) || RE_LINE_COMMENT.test(line) || RE_BLOCK_COMMENT.test(line)) {
+    if (RE_BLANK_LINE.test(line)) {
       idx++;
       continue;
     }
+    if (RE_LINE_COMMENT.test(line) || RE_BLOCK_COMMENT.test(line)) {
+      const start = idx;
+      if (RE_BLOCK_COMMENT.test(line)) {
+        while (idx < lines.length && !lines[idx].includes("*/"))
+          idx++;
+        idx++;
+      } else {
+        idx++;
+      }
+      if (!sawImport) {
+        for (let k = start;k < idx && k < lines.length; k++)
+          preamble.push(lines[k]);
+        lastEnd = idx;
+      } else if (pendingStart < 0) {
+        pendingStart = start;
+      }
+      continue;
+    }
     if (!RE_IMPORT_STMT.test(line))
       break;
-    const stmt = line.trim();
+    let stmt = line.trim();
+    let stmtEnd = idx + 1;
+    while (!RE_IMPORT_COMPLETE.test(stmt) && stmtEnd < lines.length && stmtEnd - idx < 50) {
+      stmt += ` ${lines[stmtEnd].trim()}`;
+      stmtEnd++;
+    }
+    if (!RE_IMPORT_COMPLETE.test(stmt))
+      return source;
     const parsed = parseImportStatement(stmt);
-    if (parsed)
-      imports.push(parsed);
-    idx++;
+    if (!parsed)
+      return source;
+    if (pendingStart >= 0) {
+      for (let k = pendingStart;k < idx; k++) {
+        if (!RE_BLANK_LINE.test(lines[k]))
+          interleaved.push(lines[k]);
+      }
+      pendingStart = -1;
+    }
+    imports.push(parsed);
+    idx = stmtEnd;
+    lastEnd = idx;
+    sawImport = true;
   }
   if (imports.length === 0)
     return source;
-  const rest = lines.slice(idx).join(`
+  const restStart = pendingStart >= 0 ? pendingStart : lastEnd;
+  const rest = lines.slice(restStart).join(`
 `);
   const usedIdentifiers = collectIdentifierSet(rest);
   const used = (name) => usedIdentifiers.has(name);
@@ -855,17 +1082,29 @@ function formatImports(source) {
     }
     return a.source.localeCompare(b.source);
   });
+  const head = preamble.length > 0 ? `${preamble.join(`
+`)}
+` : "";
   if (entries.length === 0) {
-    return rest.replace(/^\n+/, "");
+    const restClean2 = rest.replace(/^\n+/, "");
+    const kept = [...interleaved];
+    if (head || kept.length > 0)
+      return `${head}${kept.length > 0 ? `${kept.join(`
+`)}
+` : ""}${restClean2}`;
+    return restClean2;
   }
   const rendered = entries.map(renderImport).join(`
 `);
-  const sep = rest.length > 0 && !rest.startsWith(`
-`) ? `
+  const mid = interleaved.length > 0 ? `
+${interleaved.join(`
+`)}` : "";
+  const restClean = rest.replace(/^\n+/, "");
+  const sep = restClean.length > 0 ? `
 
 ` : `
 `;
-  return `${rendered}${sep}${rest.replace(/^\n+/, "")}`;
+  return `${head}${rendered}${mid}${sep}${restClean}`;
 }
 function renderImport(imp) {
   if (imp.kind === "side-effect")
@@ -1168,39 +1407,44 @@ function sortTsconfigContent(text) {
   }
   return JSON.stringify(outTop, null, 2);
 }
-var CODE_EXTS, JSON_EXTS, YAML_EXTS, SHELL_EXTS, SHELL_SHEBANG_RE, RE_CLOSING_BRACE, RE_OPENING_BRACE, RE_FOR_LOOP, RE_EMPTY_SEMI, RE_DUP_SEMI, RE_SPACE_BEFORE_BRACE, RE_SPACE_AFTER_BRACE_KW, RE_COMMA_SPACE, RE_EQUALS_SPACE, RE_PLUS_OP, RE_MINUS_OP, RE_STAR_OP, RE_SLASH_OP, RE_SEMI_SPACE, RE_LT_OP, RE_GT_OP, RE_MULTI_SPACE, RE_BLANK_LINE, RE_LINE_COMMENT, RE_BLOCK_COMMENT, RE_IMPORT_STMT, RE_PACKAGE_JSON, RE_TSCONFIG_JSON, RE_TRAILING_WS, RE_LEADING_BLANKS, SPACING_CHARS;
+var CODE_EXTS, JSON_EXTS, YAML_EXTS, SHELL_EXTS, SHELL_SHEBANG_RE, RE_CLOSING_BRACE, RE_OPENING_BRACE, RE_TRAILING_LINE_COMMENT, RE_CONTROL_OPEN, RE_CONTINUATION_LINE, RE_FOR_LOOP, RE_EMPTY_SEMI, RE_DUP_SEMI, RE_SPACE_BEFORE_BRACE, RE_SPACE_AFTER_BRACE_KW, RE_COMMA_SPACE, RE_EQUALS_SPACE, RE_PLUS_OP, RE_MINUS_OP, RE_STAR_OP, RE_SLASH_OP, RE_SEMI_SPACE, RE_LT_OP, RE_GT_OP, RE_MULTI_SPACE, RE_BLANK_LINE, RE_LINE_COMMENT, RE_BLOCK_COMMENT, RE_IMPORT_STMT, RE_IMPORT_COMPLETE, RE_PACKAGE_JSON, RE_TSCONFIG_JSON, RE_TRAILING_WS, RE_LEADING_BLANKS, SPACING_CHARS, REGEX_PRECEDING_KEYWORDS;
 var init_format = __esm(() => {
   CODE_EXTS = new Set([".ts", ".js"]);
   JSON_EXTS = new Set([".json", ".jsonc"]);
   YAML_EXTS = new Set([".yaml", ".yml"]);
   SHELL_EXTS = new Set([".sh", ".bash", ".zsh", ".ksh", ".dash"]);
   SHELL_SHEBANG_RE = /^#!\s*(?:\/usr\/bin\/env\s+)?(?:ba|z|k|da)?sh\b/;
-  RE_CLOSING_BRACE = /^\}/;
-  RE_OPENING_BRACE = /\{\s*$/;
+  RE_CLOSING_BRACE = /^[}\])]/;
+  RE_OPENING_BRACE = /[{[(]\s*$/;
+  RE_TRAILING_LINE_COMMENT = /\s*\/\/.*$/;
+  RE_CONTROL_OPEN = /^(?:if|else\s+if|for|while)\s*\(/;
+  RE_CONTINUATION_LINE = /^(?:\.[\w$[]|\?[\s.:]|:\s|&&|\|\|)/;
   RE_FOR_LOOP = /^\s*for\s*\(/;
   RE_EMPTY_SEMI = new RegExp("^\\s*" + ";" + "\\s*$");
   RE_DUP_SEMI = new RegExp(";" + "{2,}\\s*$");
-  RE_SPACE_BEFORE_BRACE = /(\S)\{/g;
+  RE_SPACE_BEFORE_BRACE = /([\w)])\{/g;
   RE_SPACE_AFTER_BRACE_KW = /\{(return|if|for|while|switch|const|let|var|function)\b/g;
   RE_COMMA_SPACE = /,(\S)/g;
-  RE_EQUALS_SPACE = /(?<![=!<>])=(?![=><])/g;
+  RE_EQUALS_SPACE = /(?<![=!<>+\-*/%&|^?])=(?![=><])/g;
   RE_PLUS_OP = /(\w)\+(\w)/g;
   RE_MINUS_OP = /(\w)-(\w)/g;
   RE_STAR_OP = /(\w)\*(\w)/g;
   RE_SLASH_OP = /(\w)\/(\w)/g;
-  RE_SEMI_SPACE = new RegExp(";" + "([^\\s" + ";" + "])", "g");
-  RE_LT_OP = /([\w\])])<(\S)/g;
-  RE_GT_OP = /(\S)>([\w[(])/g;
+  RE_SEMI_SPACE = new RegExp("(?<=\\S);" + "([^\\s" + ";" + "])", "g");
+  RE_LT_OP = /([\w)\]])<(\d)/g;
+  RE_GT_OP = /([\w)\]])>(\d)/g;
   RE_MULTI_SPACE = /\s{2,}/g;
   RE_BLANK_LINE = /^\s*$/;
   RE_LINE_COMMENT = /^\s*\/\//;
   RE_BLOCK_COMMENT = /^\s*\/\*/;
   RE_IMPORT_STMT = /^\s*import\b/;
+  RE_IMPORT_COMPLETE = /\bfrom\s*['"][^'"]+['"]|^\s*import\s+['"][^'"]+['"]/;
   RE_PACKAGE_JSON = /package\.json$/i;
   RE_TSCONFIG_JSON = /[jt]sconfig(?:\..+)?\.json$/i;
   RE_TRAILING_WS = /[ \t]+$/;
   RE_LEADING_BLANKS = /^\n+/;
   SPACING_CHARS = new Set(["{", ",", "=", "+", "-", "*", "/", ";", "<", ">"]);
+  REGEX_PRECEDING_KEYWORDS = new Set(["return", "typeof", "instanceof", "in", "of", "new", "delete", "void", "do", "else", "case", "yield", "await"]);
 });
 
 // ../../node_modules/bunfig/dist/index.js
@@ -20767,7 +21011,7 @@ var init_no_unused_vars = __esm(() => {
         let tInBlockComment = false;
         let tEscaped = false;
         let prevSig = "";
-        const isRegexStart = () => {
+        const isRegexStart2 = () => {
           if (prevSig === "")
             return true;
           if ("=([{,;!&|?:+-*/%^~<>".includes(prevSig))
@@ -20869,7 +21113,7 @@ var init_no_unused_vars = __esm(() => {
                 else
                   tmplStack.pop();
                 prevSig = "}";
-              } else if (ch === "/" && isRegexStart()) {
+              } else if (ch === "/" && isRegexStart2()) {
                 tInRegex = true;
               } else if (!/\s/.test(ch)) {
                 prevSig = ch;
@@ -20885,7 +21129,7 @@ var init_no_unused_vars = __esm(() => {
             } else if (ch === '"') {
               tInDouble = true;
               prevSig = '"';
-            } else if (ch === "/" && isRegexStart()) {
+            } else if (ch === "/" && isRegexStart2()) {
               tInRegex = true;
             } else if (!/\s/.test(ch)) {
               prevSig = ch;
@@ -20922,6 +21166,15 @@ var init_no_unused_vars = __esm(() => {
             continue;
           }
           if (!inString) {
+            if (ch === "/" && after[k + 1] === "/")
+              break;
+            if (ch === "/" && after[k + 1] === "*") {
+              k += 2;
+              while (k < after.length && !(after[k] === "*" && after[k + 1] === "/"))
+                k++;
+              k++;
+              continue;
+            }
             if (ch === "'") {
               inString = "single";
             } else if (ch === '"') {
@@ -22084,7 +22337,7 @@ function computeLineStartsInTemplate(text) {
   let inBlockComment = false;
   let escaped = false;
   let prevSig = "";
-  const isRegexStart = () => {
+  const isRegexStart2 = () => {
     if (prevSig === "")
       return true;
     return "=([{,;!&|?:+-*/%^~<>".includes(prevSig);
@@ -22184,7 +22437,7 @@ function computeLineStartsInTemplate(text) {
           else
             tmplStack.pop();
           prevSig = "}";
-        } else if (ch === "/" && isRegexStart())
+        } else if (ch === "/" && isRegexStart2())
           inRegex = true;
         else if (!/\s/.test(ch))
           prevSig = ch;
@@ -22199,7 +22452,7 @@ function computeLineStartsInTemplate(text) {
       } else if (ch === '"') {
         inDouble = true;
         prevSig = '"';
-      } else if (ch === "/" && isRegexStart())
+      } else if (ch === "/" && isRegexStart2())
         inRegex = true;
       else if (!/\s/.test(ch))
         prevSig = ch;
@@ -23536,24 +23789,39 @@ var init_blanks_around_lists = __esm(() => {
       const lines = text.split(/\r?\n/);
       const result = [];
       let inList = false;
+      let inFence = false;
+      const isListItemLine = (l) => /^(?:\s*)(?:[*\-+]|\d+\.)\s+/.test(l);
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
         const prevLine = i > 0 ? lines[i - 1] : "";
-        const isListItem = /^(?:\s*)(?:[*\-+]|\d+\.)\s+/.test(line);
+        if (/^(?:`{3,}|~{3,})/.test(line.trim())) {
+          inFence = !inFence;
+          inList = false;
+          result.push(line);
+          continue;
+        }
+        if (inFence) {
+          result.push(line);
+          continue;
+        }
+        const isListItem = isListItemLine(line);
+        const isBlank = line.trim().length === 0;
+        const isContinuation = inList && !isListItem && !isBlank && /^\s/.test(line);
         if (isListItem && !inList) {
           if (i > 0 && prevLine.trim().length > 0 && result.length > 0) {
             result.push("");
           }
           inList = true;
-        } else if (!isListItem && line.trim().length > 0 && inList) {
+        } else if (!isListItem && !isContinuation && !isBlank && inList) {
           inList = false;
           if (result.length > 0) {
             result.push("");
           }
-        } else if (!isListItem && line.trim().length === 0) {
+        } else if (isBlank) {
           const nextLine = i + 1 < lines.length ? lines[i + 1] : "";
-          const nextIsListItem = /^(?:\s*)(?:[*\-+]|\d+\.)\s+/.test(nextLine);
-          if (!nextIsListItem && inList) {
+          const nextIsListItem = isListItemLine(nextLine);
+          const nextIsContinuation = /^\s+\S/.test(nextLine);
+          if (!nextIsListItem && !nextIsContinuation && inList) {
             inList = false;
           }
         }
@@ -23624,6 +23892,64 @@ function getCodeBlockLines(lines) {
   }
   return out;
 }
+function eachInlineSegment(line, onText, onCode) {
+  let i = 0;
+  let textStart = 0;
+  while (i < line.length) {
+    if (line[i] !== "`") {
+      i++;
+      continue;
+    }
+    let n = 0;
+    while (line[i + n] === "`")
+      n++;
+    let j = i + n;
+    let close = -1;
+    while (j < line.length) {
+      if (line[j] === "`") {
+        let k = 0;
+        while (line[j + k] === "`")
+          k++;
+        if (k === n) {
+          close = j;
+          break;
+        }
+        j += k;
+      } else {
+        j++;
+      }
+    }
+    if (close === -1) {
+      i += n;
+      continue;
+    }
+    if (textStart < i)
+      onText(line.slice(textStart, i));
+    onCode(line.slice(i, close + n));
+    i = close + n;
+    textStart = i;
+  }
+  if (textStart < line.length)
+    onText(line.slice(textStart));
+}
+function replaceOutsideInlineCode(line, transform) {
+  let out = "";
+  eachInlineSegment(line, (seg) => {
+    out += transform(seg);
+  }, (seg) => {
+    out += seg;
+  });
+  return out;
+}
+function maskInlineCode(line) {
+  let out = "";
+  eachInlineSegment(line, (seg) => {
+    out += seg;
+  }, (seg) => {
+    out += " ".repeat(seg.length);
+  });
+  return out;
+}
 
 // src/rules/markdown/_shared.ts
 function findTableRows(lines) {
@@ -24034,8 +24360,10 @@ var init_descriptive_link_text = __esm(() => {
 });
 
 // src/rules/markdown/emphasis-style.ts
-var emphasisStyleRule;
+var ASTERISK_EMPHASIS, UNDERSCORE_EMPHASIS, emphasisStyleRule;
 var init_emphasis_style = __esm(() => {
+  ASTERISK_EMPHASIS = /(?<!\*)\*(?!\*)([^*]+)\*(?!\*)/;
+  UNDERSCORE_EMPHASIS = /(?<!_)_(?!_)([^_]+)_(?!_)/;
   emphasisStyleRule = {
     meta: {
       docs: "Emphasis style should be consistent (asterisk or underscore)"
@@ -24114,27 +24442,51 @@ var init_emphasis_style = __esm(() => {
     fix: (text, ctx) => {
       const options = ctx.options || {};
       const style = options.style || "consistent";
+      const lines = text.split(/\r?\n/);
+      const inCode = getCodeBlockLines(lines);
       let targetStyle = "asterisk";
       if (style === "asterisk") {
         targetStyle = "asterisk";
       } else if (style === "underscore") {
         targetStyle = "underscore";
       } else if (style === "consistent") {
-        const asteriskMatch = text.match(/(?<!\*)\*(?!\*)([^*]+)\*(?!\*)/);
-        const underscoreMatch = text.match(/(?<!_)_(?!_)([^_]+)_(?!_)/);
-        if (asteriskMatch && (!underscoreMatch || asteriskMatch.index < underscoreMatch.index)) {
+        let firstAsterisk = null;
+        let firstUnderscore = null;
+        for (let i = 0;i < lines.length; i++) {
+          if (inCode.has(i))
+            continue;
+          const stripped = maskInlineCode(lines[i]);
+          if (firstAsterisk === null) {
+            const m = stripped.match(ASTERISK_EMPHASIS);
+            if (m)
+              firstAsterisk = { line: i, col: m.index };
+          }
+          if (firstUnderscore === null) {
+            const m = stripped.match(UNDERSCORE_EMPHASIS);
+            if (m)
+              firstUnderscore = { line: i, col: m.index };
+          }
+          if (firstAsterisk && firstUnderscore)
+            break;
+        }
+        const cmp = (a, b) => a.line !== b.line ? a.line - b.line : a.col - b.col;
+        if (firstAsterisk && (!firstUnderscore || cmp(firstAsterisk, firstUnderscore) < 0))
           targetStyle = "asterisk";
-        } else if (underscoreMatch) {
+        else if (firstUnderscore)
           targetStyle = "underscore";
-        }
       }
-      let fixed = text;
-      if (targetStyle === "asterisk") {
-        fixed = fixed.replace(/(?<!_)_(?!_)([^_]+)_(?!_)/g, "*$1*");
-      } else {
-        fixed = fixed.replace(/(?<!\*)\*(?!\*)([^*]+)\*(?!\*)/g, "_$1_");
+      let changed = false;
+      for (let i = 0;i < lines.length; i++) {
+        if (inCode.has(i))
+          continue;
+        const after = replaceOutsideInlineCode(lines[i], (seg) => targetStyle === "asterisk" ? seg.replace(/(?<!_)_(?!_)([^_]+)_(?!_)/g, "*$1*") : seg.replace(/(?<!\*)\*(?!\*)([^*]+)\*(?!\*)/g, "_$1_"));
+        if (after !== lines[i]) {
+          lines[i] = after;
+          changed = true;
+        }
       }
-      return fixed;
+      return changed ? lines.join(`
+`) : text;
     }
   };
 });
@@ -25778,8 +26130,14 @@ var init_no_space_in_code = __esm(() => {
 });
 
 // src/rules/markdown/no-space-in-emphasis.ts
-var noSpaceInEmphasisRule;
+var EMPHASIS_SPACE_PATTERNS, noSpaceInEmphasisRule;
 var init_no_space_in_emphasis = __esm(() => {
+  EMPHASIS_SPACE_PATTERNS = [
+    /(?<![A-Za-z0-9])\*\*\s+[^*]+?\*\*(?![A-Za-z0-9])/g,
+    /(?<![A-Za-z0-9])\*\*[^*]+?\s+\*\*(?![A-Za-z0-9])/g,
+    /(?<![A-Za-z0-9])__\s+[^_]+?__(?![A-Za-z0-9])/g,
+    /(?<![A-Za-z0-9])__[^_]+?\s+__(?![A-Za-z0-9])/g
+  ];
   noSpaceInEmphasisRule = {
     meta: {
       docs: "Emphasis markers should not have spaces inside them"
@@ -25797,13 +26155,7 @@ var init_no_space_in_emphasis = __esm(() => {
         if (inFence)
           continue;
         const stripped = line.replace(/`[^`]+`/g, (m) => "\x01".repeat(m.length));
-        const patterns = [
-          /\*\*\s+[^*]+?\*\*/g,
-          /\*\*[^*]+?\s+\*\*/g,
-          /__\s+[^_]+?__/g,
-          /__[^_]+?\s+__/g
-        ];
-        for (const pattern of patterns) {
+        for (const pattern of EMPHASIS_SPACE_PATTERNS) {
           for (const match of stripped.matchAll(pattern)) {
             issues.push({
               filePath: ctx.filePath,
@@ -25832,11 +26184,14 @@ var init_no_space_in_emphasis = __esm(() => {
           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__");
+        const fixed = replaceOutsideInlineCode(line, (seg) => {
+          let s = seg;
+          s = s.replace(/(?<![A-Za-z0-9])(\*\*)\s+([^*]+?)\*\*(?![A-Za-z0-9])/g, "$1$2**");
+          s = s.replace(/(?<![A-Za-z0-9])(\*\*)([^*]+?)\s+\*\*(?![A-Za-z0-9])/g, "$1$2**");
+          s = s.replace(/(?<![A-Za-z0-9])(__)\s+([^_]+?)__(?![A-Za-z0-9])/g, "$1$2__");
+          s = s.replace(/(?<![A-Za-z0-9])(__)([^_]+?)\s+__(?![A-Za-z0-9])/g, "$1$2__");
+          return s;
+        });
         result.push(fixed);
       }
       return result.join(`
@@ -32845,7 +33200,7 @@ function findMatching(text, start, open, close) {
     }
     return i;
   };
-  const isRegexStart = (i) => {
+  const isRegexStart2 = (i) => {
     let j = i - 1;
     while (j >= 0 && isWhitespace(text[j])) {
       j--;
@@ -32901,7 +33256,7 @@ function findMatching(text, start, open, close) {
       i = skipBlockComment(i) - 1;
       continue;
     }
-    if (ch === "/" && isRegexStart(i)) {
+    if (ch === "/" && isRegexStart2(i)) {
       i = skipRegex(i) - 1;
       continue;
     }
@@ -38678,7 +39033,7 @@ function stripRegexLiterals(line) {
   }
   return result;
 }
-function isRegexStart(lastSignificant, line, idx) {
+function isRegexStart2(lastSignificant, line, idx) {
   if (lastSignificant === "")
     return true;
   const regexAfter = "([{,:;!?&|=<>~^+*%-";
@@ -38764,6 +39119,7 @@ function getCommentLines(content) {
   let lineHasCode = false;
   let lineSawComment = false;
   let lineStartedInBlockComment = false;
+  const interpStack = [];
   for (let i = 0;i < content.length; i++) {
     const ch = content[i];
     const next = content[i + 1];
@@ -38887,6 +39243,20 @@ function getCommentLines(content) {
         } else if (ch === "`") {
           state = "string-template";
           lineHasCode = true;
+        } else if (ch === "{") {
+          if (interpStack.length)
+            interpStack[interpStack.length - 1]++;
+          lineHasCode = true;
+        } else if (ch === "}") {
+          if (interpStack.length) {
+            if (interpStack[interpStack.length - 1] === 0) {
+              interpStack.pop();
+              state = "string-template";
+            } else {
+              interpStack[interpStack.length - 1]--;
+            }
+          }
+          lineHasCode = true;
         } else if (!/\s/.test(ch)) {
           lineHasCode = true;
         }
@@ -38912,6 +39282,12 @@ function getCommentLines(content) {
           i++;
           break;
         }
+        if (ch === "$" && next === "{") {
+          interpStack.push(0);
+          state = "code";
+          i++;
+          break;
+        }
         if (ch === "`")
           state = "code";
         break;
@@ -39101,7 +39477,7 @@ function scanContentOptimized(filePath, content, cfg, suppress, commentLines) {
             prev = ch;
             continue;
           }
-          if (ch === "/" && ln[k + 1] !== "/" && ln[k + 1] !== "*" && isRegexStart(lastSig, ln, k)) {
+          if (ch === "/" && ln[k + 1] !== "/" && ln[k + 1] !== "*" && isRegexStart2(lastSig, ln, k)) {
             inRegex = true;
             inRegexClass = false;
             prev = ch;
@@ -43690,7 +44066,7 @@ var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "pickier",
     type: "module",
-    version: "0.1.34",
+    version: "0.1.36",
     description: "Format, lint and more in a fraction of seconds.",
     author: "Chris Breuer <chris@stacksjs.org>",
     license: "MIT",