pickier 0.1.18 → 0.1.19

package/dist/src/index.js

@@ -5121,6 +5121,8 @@ var init_config = __esm(async () => {
       "**/.github/**",
       "**/*.test.ts",
       "**/*.spec.ts",
+      "**/.bunpress/**",
+      "**/.vitepress/cache/**",
       "**/*.lock",
       "**/package-lock.json",
       "**/pnpm-lock.yaml"
@@ -5241,14 +5243,14 @@ var init_config = __esm(async () => {
       "markdown/line-length": "off",
       "markdown/commands-show-output": "warn",
       "markdown/fenced-code-language": "warn",
-      "markdown/code-block-style": "warn",
+      "markdown/code-block-style": "off",
       "markdown/code-fence-style": "warn",
       "markdown/no-emphasis-as-heading": "warn",
       "markdown/no-space-in-emphasis": "warn",
       "markdown/no-space-in-code": "warn",
       "markdown/emphasis-style": "warn",
       "markdown/strong-style": "warn",
-      "markdown/no-inline-html": "warn",
+      "markdown/no-inline-html": "off",
       "markdown/hr-style": "warn",
       "markdown/first-line-heading": "off",
       "markdown/required-headings": "off",
@@ -5261,7 +5263,27 @@ var init_config = __esm(async () => {
       "lockfile/validate-https": "error",
       "lockfile/validate-integrity": ["warn", { requiredAlgorithm: "sha512" }],
       "lockfile/validate-package-names": "error",
-      "lockfile/validate-scheme": ["error", { allowedSchemes: ["https:", "git+https:", "git+ssh:"] }]
+      "lockfile/validate-scheme": ["error", { allowedSchemes: ["https:", "git+https:", "git+ssh:"] }],
+      "publint/exports-types-should-be-first": "error",
+      "publint/exports-default-should-be-last": "error",
+      "publint/exports-module-should-precede-require": "error",
+      "publint/exports-value-invalid": "error",
+      "publint/imports-key-invalid": "error",
+      "publint/imports-value-invalid": "error",
+      "publint/imports-default-should-be-last": "error",
+      "publint/imports-module-should-precede-require": "error",
+      "publint/use-type": "warn",
+      "publint/deprecated-field-jsnext": "warn",
+      "publint/field-invalid-value-type": "error",
+      "publint/local-dependency": "error",
+      "publint/has-module-but-no-exports": "warn",
+      "publint/exports-missing-root-entrypoint": "warn",
+      "publint/exports-fallback-array-use": "warn",
+      "publint/file-does-not-exist": "warn",
+      "publint/file-invalid-format": "warn",
+      "publint/module-should-be-esm": "error",
+      "publint/bin-file-not-executable": "error",
+      "publint/exports-module-should-be-esm": "error"
     },
     verbose: true
   };
@@ -14758,9 +14780,25 @@ function codeOnly(rule) {
     } : undefined
   };
 }
-var CODE_EXTS2;
+function packageJsonOnly(rule) {
+  return {
+    meta: rule.meta,
+    check: (content, context) => {
+      if (!PACKAGE_JSON_RE.test(context.filePath))
+        return [];
+      return rule.check(content, context);
+    },
+    fix: rule.fix ? (content, context) => {
+      if (!PACKAGE_JSON_RE.test(context.filePath))
+        return content;
+      return rule.fix(content, context);
+    } : undefined
+  };
+}
+var CODE_EXTS2, PACKAGE_JSON_RE;
 var init_utils = __esm(() => {
   CODE_EXTS2 = /\.(?:ts|js|tsx|jsx|mts|mjs|cts|cjs)$/;
+  PACKAGE_JSON_RE = /(?:^|[/\\])package\.json$/;
 });
 
 // src/plugins/eslint.ts
@@ -15220,7 +15258,78 @@ var init_no_unused_vars = __esm(() => {
       const argIgnoreRe = new RegExp(argsIgnorePattern, "u");
       const lines = text.split(/\r?\n/);
       const full = text;
+      const lineStartsInTemplate = new Array(lines.length).fill(false);
+      {
+        const tmplStack = [];
+        let tInSingle = false;
+        let tInDouble = false;
+        let tEscaped = false;
+        for (let li = 0;li < lines.length; li++) {
+          lineStartsInTemplate[li] = tmplStack.length > 0 && tmplStack[tmplStack.length - 1] === -1;
+          const s = lines[li];
+          for (let k = 0;k < s.length; k++) {
+            const ch = s[k];
+            if (tEscaped) {
+              tEscaped = false;
+              continue;
+            }
+            const inBody = tmplStack.length > 0 && tmplStack[tmplStack.length - 1] === -1;
+            const inExpr = tmplStack.length > 0 && tmplStack[tmplStack.length - 1] >= 0;
+            if (ch === "\\" && (tInSingle || tInDouble || inBody)) {
+              tEscaped = true;
+              continue;
+            }
+            if (tInSingle) {
+              if (ch === "'")
+                tInSingle = false;
+              continue;
+            }
+            if (tInDouble) {
+              if (ch === '"')
+                tInDouble = false;
+              continue;
+            }
+            if (inBody) {
+              if (ch === "`") {
+                tmplStack.pop();
+              } else if (ch === "$" && k + 1 < s.length && s[k + 1] === "{") {
+                tmplStack[tmplStack.length - 1] = 0;
+                k++;
+              }
+              continue;
+            }
+            if (inExpr) {
+              if (ch === "`") {
+                tmplStack.push(-1);
+              } else if (ch === "'") {
+                tInSingle = true;
+              } else if (ch === '"') {
+                tInDouble = true;
+              } else if (ch === "{") {
+                tmplStack[tmplStack.length - 1]++;
+              } else if (ch === "}") {
+                if (tmplStack[tmplStack.length - 1] > 0)
+                  tmplStack[tmplStack.length - 1]--;
+                else
+                  tmplStack[tmplStack.length - 1] = -1;
+              } else if (ch === "/" && k + 1 < s.length && s[k + 1] === "/")
+                break;
+              continue;
+            }
+            if (ch === "`") {
+              tmplStack.push(-1);
+            } else if (ch === "'") {
+              tInSingle = true;
+            } else if (ch === '"') {
+              tInDouble = true;
+            } else if (ch === "/" && k + 1 < s.length && s[k + 1] === "/")
+              break;
+          }
+        }
+      }
       for (let i = 0;i < lines.length; i++) {
+        if (lineStartsInTemplate[i])
+          continue;
         const line = lines[i];
         const decl = line.match(/^\s*(?:const|let|var)\s+(.+?);?\s*$/);
         if (!decl)
@@ -15278,15 +15387,130 @@ var init_no_unused_vars = __esm(() => {
           if (!part)
             continue;
           const simple = part.match(/^([$A-Z_][\w$]*)/i);
-          const destruct = part.match(/^[{[](.+)[}\]]/);
           const names = [];
           if (simple) {
             names.push(simple[1]);
-          } else if (destruct) {
-            const inner = destruct[1];
-            const tokens = inner.split(/[^$\w]+/).filter(Boolean);
-            for (const t of tokens)
-              names.push(t);
+          } else if (part.startsWith("{") || part.startsWith("[")) {
+            const openChar = part[0];
+            const closeChar = openChar === "{" ? "}" : "]";
+            let dDepth = 0;
+            let endIdx = -1;
+            let dStr = null;
+            let dEsc = false;
+            for (let ci = 0;ci < part.length; ci++) {
+              const ch = part[ci];
+              if (dEsc) {
+                dEsc = false;
+                continue;
+              }
+              if (ch === "\\" && dStr) {
+                dEsc = true;
+                continue;
+              }
+              if (!dStr) {
+                if (ch === "'" || ch === '"' || ch === "`") {
+                  dStr = ch === "'" ? "single" : ch === '"' ? "double" : "template";
+                } else if (ch === openChar)
+                  dDepth++;
+                else if (ch === closeChar) {
+                  dDepth--;
+                  if (dDepth === 0) {
+                    endIdx = ci;
+                    break;
+                  }
+                }
+              } else {
+                if (dStr === "single" && ch === "'" || dStr === "double" && ch === '"' || dStr === "template" && ch === "`")
+                  dStr = null;
+              }
+            }
+            if (endIdx > 0) {
+              const inner = part.slice(1, endIdx);
+              const fields = [];
+              let fCurrent = "";
+              let fDepth = 0;
+              let fStr = null;
+              let fEsc = false;
+              for (let ci = 0;ci < inner.length; ci++) {
+                const ch = inner[ci];
+                if (fEsc) {
+                  fEsc = false;
+                  fCurrent += ch;
+                  continue;
+                }
+                if (ch === "\\" && fStr) {
+                  fEsc = true;
+                  fCurrent += ch;
+                  continue;
+                }
+                if (!fStr) {
+                  if (ch === "'" || ch === '"' || ch === "`") {
+                    fStr = ch === "'" ? "single" : ch === '"' ? "double" : "template";
+                    fCurrent += ch;
+                    continue;
+                  }
+                  if (ch === "(" || ch === "{" || ch === "[")
+                    fDepth++;
+                  if (ch === ")" || ch === "}" || ch === "]")
+                    fDepth--;
+                  if (ch === "," && fDepth === 0) {
+                    fields.push(fCurrent.trim());
+                    fCurrent = "";
+                    continue;
+                  }
+                } else {
+                  if (fStr === "single" && ch === "'" || fStr === "double" && ch === '"' || fStr === "template" && ch === "`")
+                    fStr = null;
+                }
+                fCurrent += ch;
+              }
+              if (fCurrent.trim())
+                fields.push(fCurrent.trim());
+              for (const field of fields) {
+                if (field.startsWith("...")) {
+                  const restName = field.slice(3).match(/^([$A-Z_][\w$]*)/i);
+                  if (restName)
+                    names.push(restName[1]);
+                  continue;
+                }
+                const colonIdx = field.indexOf(":");
+                if (colonIdx !== -1) {
+                  let value = field.slice(colonIdx + 1).trim();
+                  let eqDepth = 0;
+                  for (let ci = 0;ci < value.length; ci++) {
+                    const ch = value[ci];
+                    if (ch === "(" || ch === "{" || ch === "[")
+                      eqDepth++;
+                    else if (ch === ")" || ch === "}" || ch === "]")
+                      eqDepth--;
+                    else if (ch === "=" && eqDepth === 0) {
+                      value = value.slice(0, ci).trim();
+                      break;
+                    }
+                  }
+                  const nameMatch = value.match(/^([$A-Z_][\w$]*)/i);
+                  if (nameMatch)
+                    names.push(nameMatch[1]);
+                } else {
+                  let fieldName = field;
+                  let eqDepth = 0;
+                  for (let ci = 0;ci < fieldName.length; ci++) {
+                    const ch = fieldName[ci];
+                    if (ch === "(" || ch === "{" || ch === "[")
+                      eqDepth++;
+                    else if (ch === ")" || ch === "}" || ch === "]")
+                      eqDepth--;
+                    else if (ch === "=" && eqDepth === 0) {
+                      fieldName = fieldName.slice(0, ci).trim();
+                      break;
+                    }
+                  }
+                  const nameMatch = fieldName.match(/^([$A-Z_][\w$]*)/i);
+                  if (nameMatch)
+                    names.push(nameMatch[1]);
+                }
+              }
+            }
           }
           for (const name of names) {
             if (varIgnoreRe.test(name))
@@ -15406,69 +15630,82 @@ var init_no_unused_vars = __esm(() => {
       const findBodyRange = (startLine, startColFrom) => {
         let openFound = false;
         let depth = 0;
+        let bodyBraceDepth = 0;
+        let bodySawBracePair = false;
+        let bodyAngleDepth = 0;
+        let bodyInStr = null;
+        let bodyEsc = false;
+        let isFirstSearchLine = true;
+        let lastNonWhitespaceBeforeBrace = "";
+        let depthInSingle = false;
+        let depthInDouble = false;
+        const depthTmplStack = [];
+        let depthEscaped = false;
         for (let ln = startLine;ln < lines.length; ln++) {
           const s = lines[ln];
           let lineToProcess = s;
+          const inMultiLineTmplBody = depthTmplStack.length > 0 && depthTmplStack[depthTmplStack.length - 1] === -1;
           let commentIdx = -1;
           let inStr = null;
           let esc = false;
-          for (let i = 0;i < s.length - 1; i++) {
-            const c = s[i];
-            const next = s[i + 1];
-            if (esc) {
-              esc = false;
-              continue;
-            }
-            if (c === "\\" && inStr) {
-              esc = true;
-              continue;
-            }
-            if (!inStr) {
-              if (c === "'") {
-                inStr = "single";
-              } else if (c === '"') {
-                inStr = "double";
-              } else if (c === "`") {
-                inStr = "template";
-              } else if (c === "/" && next === "/") {
-                commentIdx = i;
-                break;
+          if (!inMultiLineTmplBody)
+            for (let i = 0;i < s.length - 1; i++) {
+              const c = s[i];
+              const next = s[i + 1];
+              if (esc) {
+                esc = false;
+                continue;
               }
-            } else {
-              if (inStr === "single" && c === "'" || inStr === "double" && c === '"' || inStr === "template" && c === "`") {
-                inStr = null;
+              if (c === "\\" && inStr) {
+                esc = true;
+                continue;
+              }
+              if (!inStr) {
+                if (c === "'") {
+                  inStr = "single";
+                } else if (c === '"') {
+                  inStr = "double";
+                } else if (c === "`") {
+                  inStr = "template";
+                } else if (c === "/" && next === "/") {
+                  commentIdx = i;
+                  break;
+                }
+              } else {
+                if (inStr === "single" && c === "'" || inStr === "double" && c === '"' || inStr === "template" && c === "`") {
+                  inStr = null;
+                }
               }
             }
-          }
           if (commentIdx >= 0) {
             lineToProcess = s.slice(0, commentIdx);
           }
           const stripRegexFromLine = (str) => {
             let result = "";
             let i = 0;
-            let inString2 = null;
-            let escaped2 = false;
+            let inString = null;
+            let escaped = false;
             while (i < str.length) {
               const ch = str[i];
-              if (escaped2) {
-                escaped2 = false;
+              if (escaped) {
+                escaped = false;
                 result += ch;
                 i++;
                 continue;
               }
-              if (ch === "\\" && inString2) {
-                escaped2 = true;
+              if (ch === "\\" && inString) {
+                escaped = true;
                 result += ch;
                 i++;
                 continue;
               }
-              if (!inString2) {
+              if (!inString) {
                 if (ch === "'") {
-                  inString2 = "single";
+                  inString = "single";
                 } else if (ch === '"') {
-                  inString2 = "double";
+                  inString = "double";
                 } else if (ch === "`") {
-                  inString2 = "template";
+                  inString = "template";
                 } else if (ch === "/" && i > 0) {
                   const before = str.slice(0, i).trimEnd();
                   if (/[=([{,:;!&|?]$/.test(before) || before.endsWith("return")) {
@@ -15491,8 +15728,8 @@ var init_no_unused_vars = __esm(() => {
                   }
                 }
               } else {
-                if (inString2 === "single" && ch === "'" || inString2 === "double" && ch === '"' || inString2 === "template" && ch === "`") {
-                  inString2 = null;
+                if (inString === "single" && ch === "'" || inString === "double" && ch === '"' || inString === "template" && ch === "`") {
+                  inString = null;
                 }
               }
               result += ch;
@@ -15500,63 +15737,71 @@ var init_no_unused_vars = __esm(() => {
             }
             return result;
           };
-          lineToProcess = stripRegexFromLine(lineToProcess);
+          if (!inMultiLineTmplBody)
+            lineToProcess = stripRegexFromLine(lineToProcess);
           let startIdx = 0;
           if (!openFound) {
             let foundIdx = -1;
-            inStr = null;
-            esc = false;
-            let angleDepth2 = 0;
-            let braceDepth = 0;
-            let sawBracePair = false;
-            const searchStart = typeof startColFrom === "number" ? startColFrom : 0;
+            let searchStart = isFirstSearchLine ? typeof startColFrom === "number" ? startColFrom : 0 : 0;
+            isFirstSearchLine = false;
+            if (searchStart >= lineToProcess.length) {
+              const arrowInProcessed = lineToProcess.indexOf("=>");
+              searchStart = arrowInProcessed >= 0 ? arrowInProcessed + 2 : 0;
+            }
             for (let i = searchStart;i < lineToProcess.length; i++) {
               const c = lineToProcess[i];
-              if (esc) {
-                esc = false;
+              if (bodyEsc) {
+                bodyEsc = false;
                 continue;
               }
-              if (c === "\\" && inStr) {
-                esc = true;
+              if (c === "\\" && bodyInStr) {
+                bodyEsc = true;
                 continue;
               }
-              if (!inStr) {
+              if (!bodyInStr) {
+                if (c !== " " && c !== "\t" && c !== `
+` && c !== "\r" && c !== "{" && c !== "}" && bodyBraceDepth === 0) {
+                  lastNonWhitespaceBeforeBrace = c;
+                }
                 if (c === "'") {
-                  inStr = "single";
+                  bodyInStr = "single";
                 } else if (c === '"') {
-                  inStr = "double";
+                  bodyInStr = "double";
                 } else if (c === "`") {
-                  inStr = "template";
+                  bodyInStr = "template";
                 } else if (c === "<") {
-                  angleDepth2++;
+                  bodyAngleDepth++;
                 } else if (c === ">") {
-                  angleDepth2 = Math.max(0, angleDepth2 - 1);
+                  bodyAngleDepth = Math.max(0, bodyAngleDepth - 1);
                 } else if (c === "{") {
-                  if (braceDepth === 0) {
-                    if (sawBracePair && angleDepth2 === 0) {
+                  if (bodyBraceDepth === 0) {
+                    if (bodySawBracePair && bodyAngleDepth === 0) {
                       foundIdx = i;
                       break;
                     }
                   }
-                  braceDepth++;
+                  bodyBraceDepth++;
                 } else if (c === "}") {
-                  if (braceDepth > 0) {
-                    braceDepth--;
-                    if (braceDepth === 0) {
-                      sawBracePair = true;
+                  if (bodyBraceDepth > 0) {
+                    bodyBraceDepth--;
+                    if (bodyBraceDepth === 0) {
+                      bodySawBracePair = true;
                     }
                   }
                 }
               } else {
-                if (inStr === "single" && c === "'" || inStr === "double" && c === '"' || inStr === "template" && c === "`") {
-                  inStr = null;
+                if (bodyInStr === "single" && c === "'" || bodyInStr === "double" && c === '"' || bodyInStr === "template" && c === "`") {
+                  bodyInStr = null;
                 }
               }
             }
             if (foundIdx === -1) {
+              if (bodyBraceDepth > 0 && lastNonWhitespaceBeforeBrace === ":") {
+                continue;
+              }
               for (let i = searchStart;i < lineToProcess.length; i++) {
                 const c = lineToProcess[i];
-                if (c === "{" && !inStr) {
+                if (c === "{" && !bodyInStr) {
                   foundIdx = i;
                   break;
                 }
@@ -15567,47 +15812,86 @@ var init_no_unused_vars = __esm(() => {
             openFound = true;
             depth = 1;
             startIdx = foundIdx + 1;
+            startLine = ln;
           }
-          let inString = null;
-          let escaped = false;
-          let angleDepth = 0;
           for (let k = startIdx;k < lineToProcess.length; k++) {
             const ch = lineToProcess[k];
-            if (escaped) {
-              escaped = false;
+            if (depthEscaped) {
+              depthEscaped = false;
               continue;
             }
-            if (ch === "\\" && inString) {
-              escaped = true;
+            const inTmplBody = depthTmplStack.length > 0 && depthTmplStack[depthTmplStack.length - 1] === -1;
+            const inTmplExpr = depthTmplStack.length > 0 && depthTmplStack[depthTmplStack.length - 1] >= 0;
+            if (ch === "\\" && (depthInSingle || depthInDouble || inTmplBody)) {
+              depthEscaped = true;
               continue;
             }
-            if (!inString) {
+            if (depthInSingle) {
+              if (ch === "'")
+                depthInSingle = false;
+              continue;
+            }
+            if (depthInDouble) {
+              if (ch === '"')
+                depthInDouble = false;
+              continue;
+            }
+            if (inTmplBody) {
+              if (ch === "`") {
+                depthTmplStack.pop();
+              } else if (ch === "$" && k + 1 < lineToProcess.length && lineToProcess[k + 1] === "{") {
+                depthTmplStack[depthTmplStack.length - 1] = 0;
+                k++;
+              }
+              continue;
+            }
+            if (inTmplExpr) {
+              if (ch === "`") {
+                depthTmplStack.push(-1);
+                continue;
+              }
               if (ch === "'") {
-                inString = "single";
-              } else if (ch === '"') {
-                inString = "double";
-              } else if (ch === "`") {
-                inString = "template";
-              } else if (ch === "<") {
-                angleDepth++;
-              } else if (ch === ">") {
-                angleDepth = Math.max(0, angleDepth - 1);
-              } else if (ch === "{" && angleDepth === 0) {
-                depth++;
-              } else if (ch === "}" && angleDepth === 0) {
-                depth--;
-                if (depth === 0)
-                  return { from: startLine, to: ln };
+                depthInSingle = true;
+                continue;
               }
-            } else {
-              if (inString === "single" && ch === "'" || inString === "double" && ch === '"' || inString === "template" && ch === "`") {
-                inString = null;
+              if (ch === '"') {
+                depthInDouble = true;
+                continue;
+              }
+              if (ch === "{") {
+                depthTmplStack[depthTmplStack.length - 1]++;
+                continue;
               }
+              if (ch === "}") {
+                if (depthTmplStack[depthTmplStack.length - 1] > 0) {
+                  depthTmplStack[depthTmplStack.length - 1]--;
+                } else {
+                  depthTmplStack[depthTmplStack.length - 1] = -1;
+                }
+              }
+              continue;
+            }
+            if (ch === "'") {
+              depthInSingle = true;
+            } else if (ch === '"') {
+              depthInDouble = true;
+            } else if (ch === "`") {
+              depthTmplStack.push(-1);
+            } else if (ch === "{") {
+              depth++;
+            } else if (ch === "}") {
+              depth--;
+              if (depth === 0)
+                return { from: startLine, to: ln };
             }
           }
         }
         return null;
       };
+      const mainTmplStack = [];
+      let mainInSingle = false;
+      let mainInDouble = false;
+      let mainEscaped = false;
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
         if (/^\s*\/\//.test(line))
@@ -15683,11 +15967,98 @@ var init_no_unused_vars = __esm(() => {
           return result;
         };
         const codeNoRegex = stripRegex(codeOnly2);
-        const m = codeNoRegex.match(/\bfunction\b/);
+        let codeClean = codeNoRegex.replace(/'(?:[^'\\]|\\.)*'/g, "''").replace(/"(?:[^"\\]|\\.)*"/g, '""');
+        {
+          let masked = "";
+          for (let ci = 0;ci < codeClean.length; ci++) {
+            const ch = codeClean[ci];
+            if (mainEscaped) {
+              mainEscaped = false;
+              const inBody2 = mainTmplStack.length > 0 && mainTmplStack[mainTmplStack.length - 1] === -1;
+              masked += inBody2 ? " " : ch;
+              continue;
+            }
+            const inBody = mainTmplStack.length > 0 && mainTmplStack[mainTmplStack.length - 1] === -1;
+            const inExpr = mainTmplStack.length > 0 && mainTmplStack[mainTmplStack.length - 1] >= 0;
+            if (ch === "\\" && (mainInSingle || mainInDouble || inBody)) {
+              mainEscaped = true;
+              masked += inBody ? " " : ch;
+              continue;
+            }
+            if (mainInSingle) {
+              if (ch === "'")
+                mainInSingle = false;
+              masked += ch;
+              continue;
+            }
+            if (mainInDouble) {
+              if (ch === '"')
+                mainInDouble = false;
+              masked += ch;
+              continue;
+            }
+            if (inBody) {
+              if (ch === "`") {
+                mainTmplStack.pop();
+              } else if (ch === "$" && ci + 1 < codeClean.length && codeClean[ci + 1] === "{") {
+                mainTmplStack[mainTmplStack.length - 1] = 0;
+                masked += "  ";
+                ci++;
+              } else {
+                masked += " ";
+              }
+              continue;
+            }
+            if (inExpr) {
+              if (ch === "`") {
+                mainTmplStack.push(-1);
+                masked += " ";
+              } else if (ch === "'") {
+                mainInSingle = true;
+                masked += ch;
+              } else if (ch === '"') {
+                mainInDouble = true;
+                masked += ch;
+              } else if (ch === "{") {
+                mainTmplStack[mainTmplStack.length - 1]++;
+                masked += ch;
+              } else if (ch === "}") {
+                if (mainTmplStack[mainTmplStack.length - 1] > 0) {
+                  mainTmplStack[mainTmplStack.length - 1]--;
+                  masked += ch;
+                } else {
+                  mainTmplStack[mainTmplStack.length - 1] = -1;
+                  masked += " ";
+                }
+              } else {
+                masked += ch;
+              }
+              continue;
+            }
+            if (ch === "`") {
+              mainTmplStack.push(-1);
+              masked += " ";
+            } else if (ch === "'") {
+              mainInSingle = true;
+              masked += ch;
+            } else if (ch === '"') {
+              mainInDouble = true;
+              masked += ch;
+            } else {
+              masked += ch;
+            }
+          }
+          codeClean = masked;
+        }
+        const m = codeClean.match(/\bfunction\b/);
         if (m) {
           if (line.includes("function scanContent") || line.includes("function findMatching")) {
             continue;
           }
+          const afterFunc = codeClean.slice(m.index + 8).trimStart();
+          if (afterFunc.startsWith(":")) {
+            continue;
+          }
           const funcIdx = m.index;
           const openParenIdx = line.indexOf("(", funcIdx);
           if (openParenIdx === -1)
@@ -15746,7 +16117,7 @@ ${lines.slice(bodyRange.from + 1, bodyRange.to + 1).join(`
             }
           }
           for (const name of params) {
-            if (!name || argIgnoreRe.test(name))
+            if (!name || argIgnoreRe.test(name) || name === "undefined")
               continue;
             const re = new RegExp(`\\b${name}\\b`, "g");
             if (!re.test(bodyText)) {
@@ -15756,7 +16127,7 @@ ${lines.slice(bodyRange.from + 1, bodyRange.to + 1).join(`
           continue;
         }
         const arrowIdx = line.indexOf("=>");
-        if (arrowIdx !== -1 && codeNoRegex.includes("=>")) {
+        if (arrowIdx !== -1 && codeClean.includes("=>")) {
           let closeParenIdx = -1;
           for (let k = arrowIdx - 1;k >= 0; k--) {
             const ch = line[k];
@@ -15786,16 +16157,33 @@ ${lines.slice(bodyRange.from + 1, bodyRange.to + 1).join(`
             }
             if (openParenIdx !== -1) {
               let isTypeSignature = false;
+              let angleDepthBack = 0;
               for (let k = openParenIdx - 1;k >= 0; k--) {
                 const ch = line[k];
-                if (ch === ":") {
+                if (ch === ">") {
+                  angleDepthBack++;
+                  continue;
+                }
+                if (ch === "<") {
+                  if (angleDepthBack > 0) {
+                    angleDepthBack--;
+                    continue;
+                  }
+                  isTypeSignature = true;
+                  break;
+                }
+                if (ch === ":" && angleDepthBack === 0) {
                   isTypeSignature = true;
                   break;
                 }
-                if (ch === "=" || ch === "," || ch === "(" || ch === "{" || ch === "[") {
+                if (angleDepthBack > 0)
+                  continue;
+                if (ch === ",")
+                  continue;
+                if (ch === "=" || ch === "(" || ch === "{" || ch === "[") {
                   break;
                 }
-                if (ch !== " " && ch !== "\t" && !/\w/.test(ch)) {
+                if (ch !== " " && ch !== "\t" && !/[\w.]/.test(ch)) {
                   break;
                 }
               }
@@ -15832,9 +16220,12 @@ ${lines.slice(bodyRange.from + 1, bodyRange.to + 1).join(`
                     let parenDepth = 0;
                     let braceDepth = 0;
                     let bracketDepth = 0;
+                    let inTemplate = false;
                     for (let k = arrowIdx + 2;k < line.length; k++) {
                       const ch = line[k];
-                      if (ch === "(")
+                      if (ch === "`")
+                        inTemplate = !inTemplate;
+                      else if (ch === "(")
                         parenDepth++;
                       else if (ch === ")")
                         parenDepth--;
@@ -15848,12 +16239,36 @@ ${lines.slice(bodyRange.from + 1, bodyRange.to + 1).join(`
                         bracketDepth--;
                     }
                     let nextLine = i + 1;
-                    while (nextLine < lines.length && (parenDepth > 0 || braceDepth > 0 || bracketDepth > 0)) {
+                    if ((!bodyText.trim() || inTemplate) && nextLine < lines.length) {
+                      bodyText += `
+${lines[nextLine]}`;
+                      for (let k = 0;k < lines[nextLine].length; k++) {
+                        const ch = lines[nextLine][k];
+                        if (ch === "`")
+                          inTemplate = !inTemplate;
+                        else if (ch === "(")
+                          parenDepth++;
+                        else if (ch === ")")
+                          parenDepth--;
+                        else if (ch === "{")
+                          braceDepth++;
+                        else if (ch === "}")
+                          braceDepth--;
+                        else if (ch === "[")
+                          bracketDepth++;
+                        else if (ch === "]")
+                          bracketDepth--;
+                      }
+                      nextLine++;
+                    }
+                    while (nextLine < lines.length && (parenDepth > 0 || braceDepth > 0 || bracketDepth > 0 || inTemplate)) {
                       bodyText += `
 ${lines[nextLine]}`;
                       for (let k = 0;k < lines[nextLine].length; k++) {
                         const ch = lines[nextLine][k];
-                        if (ch === "(")
+                        if (ch === "`")
+                          inTemplate = !inTemplate;
+                        else if (ch === "(")
                           parenDepth++;
                         else if (ch === ")")
                           parenDepth--;
@@ -15870,7 +16285,7 @@ ${lines[nextLine]}`;
                     }
                   }
                   for (const name of params) {
-                    if (!name || argIgnoreRe.test(name))
+                    if (!name || argIgnoreRe.test(name) || name === "undefined")
                       continue;
                     const re = new RegExp(`\\b${name}\\b`, "g");
                     if (!re.test(bodyText)) {
@@ -15886,10 +16301,17 @@ ${lines[nextLine]}`;
         {
           const reSingleArrow = /(?:^|[=,:({\s])\s*([$A-Z_][\w$]*)\s*=>/gi;
           let match;
-          while ((match = reSingleArrow.exec(codeNoRegex)) !== null) {
+          while ((match = reSingleArrow.exec(codeClean)) !== null) {
             const name = match[1];
-            if (!name || argIgnoreRe.test(name))
+            if (!name || argIgnoreRe.test(name) || name === "undefined")
+              continue;
+            const beforeMatch = codeClean.slice(0, match.index + match[0].indexOf(name)).trimEnd();
+            if (/\)\s*:$/.test(beforeMatch) || /\)\s*:\s*$/.test(beforeMatch)) {
+              continue;
+            }
+            if (/^(?:string|number|boolean|void|never|any|unknown|object|bigint|symbol|undefined|null)$/.test(name)) {
               continue;
+            }
             const arrowPattern = new RegExp(`\\b${name}\\s*=>`);
             const arrowMatch = line.match(arrowPattern);
             if (!arrowMatch)
@@ -15921,9 +16343,12 @@ ${lines.slice(bodyRange.from + 1, bodyRange.to + 1).join(`
               let parenDepth = 0;
               let braceDepth = 0;
               let bracketDepth = 0;
+              let inTemplate = false;
               for (let k = arrowIdx2 + 2;k < line.length; k++) {
                 const ch = line[k];
-                if (ch === "(")
+                if (ch === "`")
+                  inTemplate = !inTemplate;
+                else if (ch === "(")
                   parenDepth++;
                 else if (ch === ")")
                   parenDepth--;
@@ -15937,12 +16362,36 @@ ${lines.slice(bodyRange.from + 1, bodyRange.to + 1).join(`
                   bracketDepth--;
               }
               let nextLine = i + 1;
-              while (nextLine < lines.length && (parenDepth > 0 || braceDepth > 0 || bracketDepth > 0)) {
+              if ((!bodyText.trim() || inTemplate) && nextLine < lines.length) {
+                bodyText += `
+${lines[nextLine]}`;
+                for (let k = 0;k < lines[nextLine].length; k++) {
+                  const ch = lines[nextLine][k];
+                  if (ch === "`")
+                    inTemplate = !inTemplate;
+                  else if (ch === "(")
+                    parenDepth++;
+                  else if (ch === ")")
+                    parenDepth--;
+                  else if (ch === "{")
+                    braceDepth++;
+                  else if (ch === "}")
+                    braceDepth--;
+                  else if (ch === "[")
+                    bracketDepth++;
+                  else if (ch === "]")
+                    bracketDepth--;
+                }
+                nextLine++;
+              }
+              while (nextLine < lines.length && (parenDepth > 0 || braceDepth > 0 || bracketDepth > 0 || inTemplate)) {
                 bodyText += `
 ${lines[nextLine]}`;
                 for (let k = 0;k < lines[nextLine].length; k++) {
                   const ch = lines[nextLine][k];
-                  if (ch === "(")
+                  if (ch === "`")
+                    inTemplate = !inTemplate;
+                  else if (ch === "(")
                     parenDepth++;
                   else if (ch === ")")
                     parenDepth--;
@@ -15971,23 +16420,82 @@ ${lines[nextLine]}`;
 });
 
 // src/rules/general/prefer-const.ts
-var preferConstRule;
-var init_prefer_const = __esm(() => {
-  preferConstRule = {
-    meta: { docs: "Suggest 'const' for variables that are never reassigned (heuristic)" },
-    check: (text, ctx) => {
-      const issues = [];
-      const lines = text.split(/\r?\n/);
-      for (let i = 0;i < lines.length; i++) {
-        const line = lines[i];
-        const decl = line.match(/^\s*(?:let|var)\s+(.+?);?\s*$/);
-        if (!decl)
-          continue;
-        const after = decl[1];
-        const parts = after.split(",");
-        for (const partRaw of parts) {
-          const part = partRaw.trim();
-          if (!part)
+function splitTopLevel(s, sep2) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  let inStr = null;
+  let escaped = false;
+  for (let i = 0;i < s.length; i++) {
+    const c = s[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (c === "\\" && inStr) {
+      escaped = true;
+      continue;
+    }
+    if (!inStr) {
+      if (c === "'")
+        inStr = "single";
+      else if (c === '"')
+        inStr = "double";
+      else if (c === "`")
+        inStr = "template";
+      else if (c === "(" || c === "{" || c === "[")
+        depth++;
+      else if (c === ")" || c === "}" || c === "]")
+        depth--;
+      else if (c === sep2 && depth === 0) {
+        parts.push(s.slice(start, i));
+        start = i + 1;
+      }
+    } else {
+      if (inStr === "single" && c === "'" || inStr === "double" && c === '"' || inStr === "template" && c === "`")
+        inStr = null;
+    }
+  }
+  parts.push(s.slice(start));
+  return parts;
+}
+function findTopLevelEquals(s) {
+  let depth = 0;
+  for (let i = 0;i < s.length; i++) {
+    const c = s[i];
+    if (c === "{" || c === "(" || c === "[" || c === "<")
+      depth++;
+    else if (c === "}" || c === ")" || c === "]" || c === ">")
+      depth--;
+    else if (c === "=" && depth === 0 && s[i + 1] !== "=" && s[i - 1] !== "!" && s[i - 1] !== "<" && s[i - 1] !== ">")
+      return i;
+  }
+  return -1;
+}
+var preferConstRule;
+var init_prefer_const = __esm(() => {
+  preferConstRule = {
+    meta: { docs: "Suggest 'const' for variables that are never reassigned (heuristic)" },
+    check: (text, ctx) => {
+      const issues = [];
+      const lines = text.split(/\r?\n/);
+      for (let i = 0;i < lines.length; i++) {
+        const line = lines[i];
+        const decl = line.match(/^\s*(?:let|var)\s+(.+?);?\s*$/);
+        if (!decl)
+          continue;
+        let after = decl[1];
+        const eqIdx = findTopLevelEquals(after);
+        if (eqIdx >= 0) {
+          const colonIdx = after.indexOf(":");
+          if (colonIdx >= 0 && colonIdx < eqIdx) {
+            after = after.slice(0, colonIdx) + after.slice(eqIdx);
+          }
+        }
+        const parts = splitTopLevel(after, ",");
+        for (const partRaw of parts) {
+          const part = partRaw.trim();
+          if (!part)
             continue;
           const simple = part.match(/^([$A-Z_][\w$]*)/i);
           const destruct = part.match(/^[{[]/);
@@ -16141,6 +16649,25 @@ var init_prefer_object_spread = __esm(() => {
 });
 
 // src/rules/general/prefer-template.ts
+function isInsideString(line, pos) {
+  let inSingle = false;
+  let inDouble = false;
+  let inTemplate = false;
+  for (let i = 0;i < pos; i++) {
+    const c = line[i];
+    if (c === "\\") {
+      i++;
+      continue;
+    }
+    if (c === "'" && !inDouble && !inTemplate)
+      inSingle = !inSingle;
+    else if (c === '"' && !inSingle && !inTemplate)
+      inDouble = !inDouble;
+    else if (c === "`" && !inSingle && !inDouble)
+      inTemplate = !inTemplate;
+  }
+  return inSingle || inDouble || inTemplate;
+}
 var preferTemplate;
 var init_prefer_template = __esm(() => {
   preferTemplate = {
@@ -16164,6 +16691,15 @@ var init_prefer_template = __esm(() => {
           const matchIdx = line.indexOf(match[0]);
           if (commentIdx >= 0 && matchIdx > commentIdx)
             continue;
+          if (isInsideString(line, matchIdx))
+            continue;
+          const isIdentPlusString = !!trimmed.match(identifierPlusString);
+          const isStringPlusIdent = !!trimmed.match(stringPlusIdentifier);
+          if (isIdentPlusString && !isStringPlusIdent) {
+            const afterMatch = trimmed.slice(trimmed.indexOf(match[0]) + match[0].length);
+            if (afterMatch.startsWith("."))
+              continue;
+          }
           issues.push({
             filePath: context.filePath,
             line: i + 1,
@@ -17150,7 +17686,7 @@ var init_blanks_around_tables = __esm(() => {
           if (line.trim().length > 0) {
             issues.push({
               filePath: ctx.filePath,
-              line: i,
+              line: i + 1,
               column: 1,
               ruleId: "markdown/blanks-around-tables",
               message: "Tables should be surrounded by blank lines",
@@ -17177,11 +17713,12 @@ var init_code_block_style = __esm(() => {
       const options = ctx.options || {};
       const style = options.style || "consistent";
       let detectedStyle = null;
+      let inFence = false;
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
         const isFenced = /^(`{3,}|~{3,})/.test(line);
-        const isIndented = /^( {4}|\t)/.test(line) && line.trim().length > 0;
         if (isFenced) {
+          inFence = !inFence;
           if (style === "indented") {
             issues.push({
               filePath: ctx.filePath,
@@ -17205,7 +17742,13 @@ var init_code_block_style = __esm(() => {
               });
             }
           }
-        } else if (isIndented) {
+          continue;
+        }
+        if (inFence) {
+          continue;
+        }
+        const isIndented = /^( {4}|\t)/.test(line) && line.trim().length > 0;
+        if (isIndented) {
           const prevLine = i > 0 ? lines[i - 1] : "";
           const isAfterBlankLine = prevLine.trim().length === 0 || i === 0;
           if (isAfterBlankLine && style === "fenced") {
@@ -17408,9 +17951,17 @@ var init_descriptive_link_text = __esm(() => {
       const issues = [];
       const lines = text.split(/\r?\n/);
       const nonDescriptive = ["click here", "here", "link", "read more", "more", "this"];
+      let inFence = false;
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
-        const matches = line.matchAll(/\[([^\]]+)\]\([^)]+\)/g);
+        if (/^(`{3,}|~{3,})/.test(line.trim())) {
+          inFence = !inFence;
+          continue;
+        }
+        if (inFence)
+          continue;
+        const stripped = line.replace(/``[^`]+``/g, (m) => " ".repeat(m.length)).replace(/`[^`]+`/g, (m) => " ".repeat(m.length));
+        const matches = stripped.matchAll(/\[([^\]]+)\]\([^)]+\)/g);
         for (const match of matches) {
           const linkText = match[1].toLowerCase().trim();
           if (nonDescriptive.includes(linkText)) {
@@ -17444,9 +17995,17 @@ var init_emphasis_style = __esm(() => {
       const options = ctx.options || {};
       const style = options.style || "consistent";
       let detectedStyle = null;
+      let inFence = false;
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
-        const asteriskMatches = line.matchAll(/(?<!\*)\*(?!\*)([^*]+)\*(?!\*)/g);
+        if (/^(?:`{3,}|~{3,})/.test(line.trim())) {
+          inFence = !inFence;
+          continue;
+        }
+        if (inFence)
+          continue;
+        const stripped = line.replace(/``[^`]+``/g, "  ").replace(/`[^`]+`/g, " ");
+        const asteriskMatches = stripped.matchAll(/(?<!\*)\*(?!\*)([^*]+)\*(?!\*)/g);
         for (const match of asteriskMatches) {
           if (style === "underscore") {
             issues.push({
@@ -17472,7 +18031,7 @@ var init_emphasis_style = __esm(() => {
             }
           }
         }
-        const underscoreMatches = line.matchAll(/(?<!_)_(?!_)([^_]+)_(?!_)/g);
+        const underscoreMatches = stripped.matchAll(/(?<!_)_(?!_)([^_]+)_(?!_)/g);
         for (const match of underscoreMatches) {
           if (style === "asterisk") {
             issues.push({
@@ -17963,7 +18522,7 @@ var init_link_image_style = __esm(() => {
       let inHtmlComment = false;
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
-        if (/^(`{3,}|~{3,})/.test(line.trim())) {
+        if (/^(?:`{3,}|~{3,})/.test(line.trim())) {
           inFence = !inFence;
           continue;
         }
@@ -18163,9 +18722,17 @@ var init_no_alt_text = __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 emptyAltMatches = line.matchAll(/!\[\s*\]\([^)]+\)/g);
+        if (/^(`{3,}|~{3,})/.test(line.trim())) {
+          inFence = !inFence;
+          continue;
+        }
+        if (inFence)
+          continue;
+        const stripped = line.replace(/``[^`]+``/g, (m) => " ".repeat(m.length)).replace(/`[^`]+`/g, (m) => " ".repeat(m.length));
+        const emptyAltMatches = stripped.matchAll(/!\[\s*\]\([^)]+\)/g);
         for (const match of emptyAltMatches) {
           const column = match.index + 1;
           issues.push({
@@ -18305,8 +18872,8 @@ var init_no_duplicate_heading = __esm(() => {
     check: (text, ctx) => {
       const issues = [];
       const lines = text.split(/\r?\n/);
-      const headings = new Map;
       let inFence = false;
+      const headingsByLevel = Array.from({ length: 7 }, () => new Map);
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
         if (/^(`{3,}|~{3,})/.test(line.trim())) {
@@ -18315,38 +18882,41 @@ var init_no_duplicate_heading = __esm(() => {
         }
         if (inFence)
           continue;
-        const atxMatch = line.match(/^#{1,6}\s+(.+?)(?:\s*#+\s*)?$/);
+        let content = null;
+        let level = 0;
+        const atxMatch = line.match(/^(#{1,6})\s+(.+?)(?:\s*#+\s*)?$/);
         if (atxMatch) {
-          const content = atxMatch[1].trim();
-          if (headings.has(content)) {
-            issues.push({
-              filePath: ctx.filePath,
-              line: i + 1,
-              column: 1,
-              ruleId: "markdown/no-duplicate-heading",
-              message: `Duplicate heading "${content}" (first occurrence on line ${headings.get(content)})`,
-              severity: "error"
-            });
-          } else {
-            headings.set(content, i + 1);
-          }
+          level = atxMatch[1].length;
+          content = atxMatch[2].trim();
         }
-        const nextLine = i + 1 < lines.length ? lines[i + 1] : "";
-        if (/^(=+|-+)\s*$/.test(nextLine) && line.trim().length > 0) {
-          const content = line.trim();
-          if (headings.has(content)) {
-            issues.push({
-              filePath: ctx.filePath,
-              line: i + 1,
-              column: 1,
-              ruleId: "markdown/no-duplicate-heading",
-              message: `Duplicate heading "${content}" (first occurrence on line ${headings.get(content)})`,
-              severity: "error"
-            });
-          } else {
-            headings.set(content, i + 1);
+        if (!content) {
+          const nextLine = i + 1 < lines.length ? lines[i + 1] : "";
+          if (/^(=+)\s*$/.test(nextLine) && line.trim().length > 0) {
+            level = 1;
+            content = line.trim();
+          } else if (/^(-+)\s*$/.test(nextLine) && line.trim().length > 0) {
+            level = 2;
+            content = line.trim();
           }
         }
+        if (!content || level === 0)
+          continue;
+        for (let l = level + 1;l <= 6; l++) {
+          headingsByLevel[l].clear();
+        }
+        const siblings = headingsByLevel[level];
+        if (siblings.has(content)) {
+          issues.push({
+            filePath: ctx.filePath,
+            line: i + 1,
+            column: 1,
+            ruleId: "markdown/no-duplicate-heading",
+            message: `Duplicate heading "${content}" (first occurrence on line ${siblings.get(content)})`,
+            severity: "error"
+          });
+        } else {
+          siblings.set(content, i + 1);
+        }
       }
       return issues;
     }
@@ -18503,10 +19073,15 @@ var init_no_inline_html = __esm(() => {
         }
         if (inFence)
           continue;
-        const stripped = line.replace(/`[^`]+`/g, (m) => " ".repeat(m.length));
+        let stripped = line;
+        stripped = stripped.replace(/``[^`]+``/g, (m) => " ".repeat(m.length));
+        stripped = stripped.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();
+          const afterTag = stripped.slice(match.index + 1 + tagName.length);
+          if (afterTag.startsWith("://") || tagName === "mailto" && afterTag.startsWith(":"))
+            continue;
           if (!allowedElements.includes(tagName)) {
             const column = match.index + 1;
             issues.push({
@@ -19259,7 +19834,8 @@ var init_reference_links_images = __esm(() => {
           continue;
         if (/^\[([^\]]+)\]:\s*\S+/.test(line))
           continue;
-        const stripped = line.replace(/`[^`]+`/g, (m) => " ".repeat(m.length));
+        let stripped = line.replace(/`[^`]+`/g, (m) => " ".repeat(m.length));
+        stripped = stripped.replace(/!?\[[^\]]*\]\([^)]*\)/g, (m) => " ".repeat(m.length));
         const linkMatches = stripped.matchAll(/\[([^\]]+)\](?:\[([^\]]+)\])?(?!\()/g);
         for (const match of linkMatches) {
           const label = (match[2] || match[1]).toLowerCase();
@@ -19531,8 +20107,19 @@ var init_table_column_count = __esm(() => {
       let inTable = false;
       let expectedColumns = -1;
       let tableStartLine = -1;
+      let inFence = false;
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
+        if (/^(`{3,}|~{3,})/.test(line.trim())) {
+          inFence = !inFence;
+          if (inTable) {
+            inTable = false;
+            expectedColumns = -1;
+          }
+          continue;
+        }
+        if (inFence)
+          continue;
         const isTableLine = /\|/.test(line) && line.trim().length > 0;
         if (isTableLine) {
           const columns = line.split("|").filter((col) => col.trim().length > 0 || line.trim().startsWith("|") || line.trim().endsWith("|"));
@@ -19730,8 +20317,15 @@ var init_ul_style = __esm(() => {
       const options = ctx.options || {};
       const style = options.style || "consistent";
       let detectedStyle = null;
+      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 marker = match[2];
@@ -19800,7 +20394,14 @@ var init_ul_style = __esm(() => {
           }
         }
       }
+      let inFence = false;
       const fixedLines = lines.map((line) => {
+        if (/^(`{3,}|~{3,})/.test(line.trim())) {
+          inFence = !inFence;
+          return line;
+        }
+        if (inFence)
+          return line;
         return line.replace(/^(\s*)([*\-+])(\s+)/, `$1${targetMarker}$3`);
       });
       return fixedLines.join(`
@@ -20029,7 +20630,7 @@ var init_prefer_global_process = __esm(() => {
     check(content, context) {
       const issues = [];
       const lines = content.split(/\r?\n/);
-      const hasProcessImport = content.match(/(?:import|require)\s*\(?.*?['"]process['"]/);
+      const hasProcessImport = content.match(/(?:import|require)\s*\(?.*?['"](?:node:)?process['"]/);
       if (!hasProcessImport) {
         for (let i = 0;i < lines.length; i++) {
           const line = lines[i];
@@ -20060,70 +20661,1033 @@ var init_prefer_global_process = __esm(() => {
           }
         }
       }
-      return issues;
+      return issues;
+    }
+  };
+});
+
+// src/plugins/node.ts
+var nodePlugin;
+var init_node = __esm(() => {
+  init_prefer_global_buffer();
+  init_prefer_global_process();
+  init_utils();
+  nodePlugin = {
+    name: "node",
+    rules: {
+      "prefer-global/buffer": codeOnly(preferGlobalBuffer),
+      "prefer-global/process": codeOnly(preferGlobalProcess)
+    }
+  };
+});
+
+// src/rules/sort/imports.ts
+var sortImportsRule;
+var init_imports = __esm(() => {
+  init_format();
+  sortImportsRule = {
+    meta: { docs: "Enforce sorted imports (delegates to formatter check only)" },
+    check: (text, ctx) => {
+      const lines = text.split(/\r?\n/);
+      let idx = 0;
+      while (idx < lines.length && (/^\s*$/.test(lines[idx]) || /^\s*\/.\/.*/.test(lines[idx]) || /^\s*\/.\*/.test(lines[idx])))
+        idx++;
+      const start = idx;
+      const imports = [];
+      while (idx < lines.length && /^\s*import\b/.test(lines[idx])) {
+        imports.push(lines[idx].trim());
+        idx++;
+      }
+      if (imports.length === 0)
+        return [];
+      const block = imports.join(`
+`);
+      const rest = lines.slice(idx).join(`
+`);
+      const reconstructed = `${block}
+${rest}`;
+      const formatted = formatImports(reconstructed);
+      if (formatted !== reconstructed) {
+        return [{ filePath: ctx.filePath, line: start + 1, column: 1, ruleId: "sort-imports", message: "Imports are not sorted/grouped consistently", severity: "warning" }];
+      }
+      return [];
+    },
+    fix: (text) => formatImports(text)
+  };
+});
+
+// src/plugins/perfectionist.ts
+var perfectionistPlugin;
+var init_perfectionist = __esm(() => {
+  init_imports();
+  init_utils();
+  perfectionistPlugin = {
+    name: "perfectionist",
+    rules: {
+      "sort-imports": codeOnly(sortImportsRule)
+    }
+  };
+});
+
+// src/rules/publint/utils.ts
+import { dirname as dirname7, resolve as resolve11 } from "path";
+function parsePackageJson(content) {
+  try {
+    const pkg = JSON.parse(content);
+    if (typeof pkg !== "object" || pkg === null || Array.isArray(pkg))
+      return null;
+    return pkg;
+  } catch {
+    return null;
+  }
+}
+function findJsonKeyLine(content, keyPath) {
+  const lines = content.split(`
+`);
+  let bestLine = 1;
+  let searchStart = 0;
+  for (const key of keyPath) {
+    const keyPattern = new RegExp(`"${escapeRegex(key)}"\\s*:`);
+    for (let i = searchStart;i < lines.length; i++) {
+      if (keyPattern.test(lines[i])) {
+        bestLine = i + 1;
+        searchStart = i + 1;
+        break;
+      }
+    }
+  }
+  return bestLine;
+}
+function getPkgDir(filePath) {
+  return dirname7(filePath);
+}
+function resolvePkgPath(pkgDir, relativePath) {
+  return resolve11(pkgDir, relativePath);
+}
+function formatPkgPath(path2) {
+  let formatted = "pkg";
+  for (const part of path2) {
+    if (/^\d+$/.test(part)) {
+      formatted += `[${part}]`;
+    } else if (!/^[a-z_$][a-z0-9_$]*$/i.test(part)) {
+      formatted += `["${part}"]`;
+    } else {
+      formatted += `.${part}`;
+    }
+  }
+  return formatted;
+}
+function getPublishedField(pkg, field) {
+  if (pkg.publishConfig?.[field] !== undefined) {
+    return [pkg.publishConfig[field], ["publishConfig", field]];
+  }
+  return [pkg[field], [field]];
+}
+function getCodeFormat(code) {
+  const stripped = stripComments(code);
+  const isEsm = ESM_CONTENT_RE.test(stripped);
+  const isCjs = CJS_CONTENT_RE.test(stripped);
+  if (isEsm && isCjs)
+    return "mixed";
+  if (isEsm)
+    return "ESM";
+  if (isCjs)
+    return "CJS";
+  return "unknown";
+}
+function getFilePathFormat(filePath, pkgType) {
+  if (filePath.endsWith(".mjs"))
+    return "ESM";
+  if (filePath.endsWith(".cjs"))
+    return "CJS";
+  return pkgType === "module" ? "ESM" : "CJS";
+}
+function getCodeFormatExtension(format) {
+  if (format === "ESM")
+    return ".mjs";
+  if (format === "CJS")
+    return ".cjs";
+  return ".js";
+}
+function isExplicitExtension(ext) {
+  return ext === ".mjs" || ext === ".cjs";
+}
+function isLintableFilePath(filePath) {
+  return filePath.endsWith(".js") || filePath.endsWith(".mjs") || filePath.endsWith(".cjs");
+}
+function startsWithShebang(code) {
+  return /^#!\s*\//.test(code);
+}
+function stripComments(code) {
+  return code.replace(/\/\*(.|[\r\n])*?\*\//gm, "").replace(/\/\/.*/g, "");
+}
+function crawlExportsOrImports(value, basePath, isImports, visitor) {
+  _crawl(value, basePath, isImports, visitor);
+}
+function _crawl(value, currentPath, isImports, visitor) {
+  if (typeof value === "string") {
+    visitor(value, { path: currentPath, isImports });
+    return;
+  }
+  if (Array.isArray(value)) {
+    visitor(value, { path: currentPath, isImports });
+    for (let i = 0;i < value.length; i++) {
+      _crawl(value[i], currentPath.concat(String(i)), isImports, visitor);
+    }
+    return;
+  }
+  if (value !== null && typeof value === "object") {
+    const keys = Object.keys(value);
+    visitor(value, { path: currentPath, isImports }, keys);
+    for (const key of keys) {
+      _crawl(value[key], currentPath.concat(key), isImports, visitor);
+    }
+  }
+}
+function createIssue(filePath, content, keyPath, ruleId, message, severity, help) {
+  return {
+    filePath,
+    line: findJsonKeyLine(content, keyPath),
+    column: 1,
+    ruleId,
+    message,
+    severity,
+    ...help && { help }
+  };
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var ESM_CONTENT_RE, CJS_CONTENT_RE;
+var init_utils2 = __esm(() => {
+  ESM_CONTENT_RE = /([\s;]|^)(import[\w,{}\s*]*from|import\s*['"*{]|export\b\s*(?:[*{]|default|type|function|const|var|let|async function)|import\.meta\b)/m;
+  CJS_CONTENT_RE = /([\s;]|^)(module.exports\b|exports\.\w|require\s*\(|global\.\w|Object\.(defineProperty|defineProperties|assign)\s*\(\s*exports\b)/m;
+});
+
+// src/rules/publint/use-type.ts
+var useType;
+var init_use_type = __esm(() => {
+  init_utils2();
+  useType = {
+    meta: {
+      docs: 'Suggest specifying the "type" field in package.json',
+      recommended: true
+    },
+    check(content, context) {
+      const pkg = parsePackageJson(content);
+      if (!pkg)
+        return [];
+      if (pkg.type == null) {
+        return [createIssue(context.filePath, content, ["name"], "publint/use-type", 'The package does not specify the "type" field. Node.js may attempt to detect the package type causing a small performance hit. Consider adding "type": "commonjs" or "type": "module".', "warning", 'Adding "type" helps Node.js resolve module format without detection overhead.')];
+      }
+      return [];
+    }
+  };
+});
+
+// src/rules/publint/local-dependency.ts
+var localDependency;
+var init_local_dependency = __esm(() => {
+  init_utils2();
+  localDependency = {
+    meta: {
+      docs: "Disallow local file references in dependencies",
+      recommended: true
+    },
+    check(content, context) {
+      const pkg = parsePackageJson(content);
+      if (!pkg)
+        return [];
+      const issues = [];
+      if (pkg.dependencies && typeof pkg.dependencies === "object") {
+        for (const depName of Object.keys(pkg.dependencies)) {
+          const depVersion = pkg.dependencies[depName];
+          if (typeof depVersion === "string" && (depVersion.startsWith("file:") || depVersion.startsWith("link:"))) {
+            issues.push(createIssue(context.filePath, content, ["dependencies", depName], "publint/local-dependency", `The "${depName}" dependency references "${depVersion}" that will likely not work when installed by end-users.`, "error", "Local file references (file: or link:) are not portable and will fail for consumers of the package."));
+          }
+        }
+      }
+      return issues;
+    }
+  };
+});
+
+// src/rules/publint/deprecated-field-jsnext.ts
+var deprecatedFieldJsnext;
+var init_deprecated_field_jsnext = __esm(() => {
+  init_utils2();
+  deprecatedFieldJsnext = {
+    meta: {
+      docs: "Disallow deprecated jsnext:main and jsnext fields",
+      recommended: true
+    },
+    check(content, context) {
+      const pkg = parsePackageJson(content);
+      if (!pkg)
+        return [];
+      const issues = [];
+      if (pkg["jsnext:main"] != null) {
+        issues.push(createIssue(context.filePath, content, ["jsnext:main"], "publint/deprecated-field-jsnext", 'pkg["jsnext:main"] is deprecated. pkg.module should be used instead.', "warning", 'The jsnext:main field is no longer recognized by modern bundlers. Use "module" instead.'));
+      }
+      if (pkg.jsnext != null) {
+        issues.push(createIssue(context.filePath, content, ["jsnext"], "publint/deprecated-field-jsnext", "pkg.jsnext is deprecated. pkg.module should be used instead.", "warning", 'The jsnext field is no longer recognized by modern bundlers. Use "module" instead.'));
+      }
+      return issues;
+    }
+  };
+});
+
+// src/rules/publint/has-module-but-no-exports.ts
+var hasModuleButNoExports;
+var init_has_module_but_no_exports = __esm(() => {
+  init_utils2();
+  hasModuleButNoExports = {
+    meta: {
+      docs: "Suggest adding exports when module field is present",
+      recommended: true
+    },
+    check(content, context) {
+      const pkg = parsePackageJson(content);
+      if (!pkg)
+        return [];
+      const [moduleValue, modulePath] = getPublishedField(pkg, "module");
+      const [exportsValue] = getPublishedField(pkg, "exports");
+      if (moduleValue != null && exportsValue == null) {
+        return [createIssue(context.filePath, content, modulePath, "publint/has-module-but-no-exports", "pkg.module is used to output ESM, but pkg.exports is not defined. As Node.js doesn't read pkg.module, the ESM output may be skipped. Consider adding pkg.exports to export the ESM output.", "warning", 'Node.js only reads "exports" for module resolution. Without it, the ESM entry point in "module" is ignored by Node.js.')];
+      }
+      return [];
+    }
+  };
+});
+
+// src/rules/publint/field-invalid-value-type.ts
+var FIELD_TYPE_CHECKS, fieldInvalidValueType;
+var init_field_invalid_value_type = __esm(() => {
+  init_utils2();
+  FIELD_TYPE_CHECKS = [
+    { field: "main", expectTypes: ["string"] },
+    { field: "module", expectTypes: ["string"] },
+    { field: "types", expectTypes: ["string"] },
+    { field: "typings", expectTypes: ["string"] },
+    { field: "browser", expectTypes: ["string", "object"] },
+    { field: "bin", expectTypes: ["string", "object"] },
+    { field: "exports", expectTypes: ["string", "object"] },
+    { field: "imports", expectTypes: ["object"] },
+    { field: "name", expectTypes: ["string"] },
+    { field: "version", expectTypes: ["string"] },
+    { field: "description", expectTypes: ["string"] },
+    { field: "license", expectTypes: ["string"] }
+  ];
+  fieldInvalidValueType = {
+    meta: {
+      docs: "Ensure package.json fields have correct value types",
+      recommended: true
+    },
+    check(content, context) {
+      const pkg = parsePackageJson(content);
+      if (!pkg)
+        return [];
+      const issues = [];
+      for (const { field, expectTypes } of FIELD_TYPE_CHECKS) {
+        const [value, path2] = getPublishedField(pkg, field);
+        if (value == null)
+          continue;
+        const actualType = typeof value;
+        if (!expectTypes.includes(actualType)) {
+          const expectStr = expectTypes.length === 1 ? expectTypes[0] : `${expectTypes.slice(0, -1).join(", ")} or ${expectTypes[expectTypes.length - 1]}`;
+          issues.push(createIssue(context.filePath, content, path2, "publint/field-invalid-value-type", `${formatPkgPath(path2)} has an invalid ${actualType} type. Expected a ${expectStr} type instead.`, "error", `The "${field}" field must be of type ${expectStr}.`));
+        }
+      }
+      return issues;
+    }
+  };
+});
+
+// src/rules/publint/exports-types-should-be-first.ts
+function objectHasKeyNested(obj, key) {
+  for (const k in obj) {
+    if (k === key)
+      return true;
+    if (typeof obj[k] === "object" && obj[k] !== null && objectHasKeyNested(obj[k], key))
+      return true;
+  }
+  return false;
+}
+var exportsTypesShouldBeFirst;
+var init_exports_types_should_be_first = __esm(() => {
+  init_utils2();
+  exportsTypesShouldBeFirst = {
+    meta: {
+      docs: 'Ensure "types" condition is first in exports objects',
+      recommended: true
+    },
+    check(content, context) {
+      const pkg = parsePackageJson(content);
+      if (!pkg)
+        return [];
+      const issues = [];
+      const [exportsValue, exportsPath] = getPublishedField(pkg, "exports");
+      if (exportsValue == null)
+        return [];
+      crawlExportsOrImports(exportsValue, exportsPath, false, (value, ctx, objectKeys) => {
+        if (!objectKeys || typeof value !== "object" || Array.isArray(value))
+          return;
+        if (!("types" in value))
+          return;
+        const typesIndex = objectKeys.indexOf("types");
+        if (typesIndex === 0)
+          return;
+        const precedingKeys = objectKeys.slice(0, typesIndex).filter((key) => {
+          if (key.startsWith("types"))
+            return false;
+          if (typeof value[key] === "object" && value[key] !== null && objectHasKeyNested(value[key], "types")) {
+            return false;
+          }
+          return true;
+        });
+        if (precedingKeys.length > 0) {
+          issues.push(createIssue(context.filePath, content, ctx.path.concat("types"), "publint/exports-types-should-be-first", `${formatPkgPath(ctx.path.concat("types"))} should be the first condition in the object so it can be resolved by TypeScript.`, "error", 'TypeScript resolves conditions in order. The "types" condition must come first to ensure correct type resolution.'));
+        }
+      });
+      return issues;
+    }
+  };
+});
+
+// src/rules/publint/exports-default-should-be-last.ts
+var exportsDefaultShouldBeLast;
+var init_exports_default_should_be_last = __esm(() => {
+  init_utils2();
+  exportsDefaultShouldBeLast = {
+    meta: {
+      docs: 'Ensure "default" condition is last in exports objects',
+      recommended: true
+    },
+    check(content, context) {
+      const pkg = parsePackageJson(content);
+      if (!pkg)
+        return [];
+      const issues = [];
+      const [exportsValue, exportsPath] = getPublishedField(pkg, "exports");
+      if (exportsValue == null)
+        return [];
+      crawlExportsOrImports(exportsValue, exportsPath, false, (value, ctx, objectKeys) => {
+        if (!objectKeys || typeof value !== "object" || Array.isArray(value))
+          return;
+        if (!("default" in value))
+          return;
+        if (objectKeys[objectKeys.length - 1] !== "default") {
+          issues.push(createIssue(context.filePath, content, ctx.path.concat("default"), "publint/exports-default-should-be-last", `${formatPkgPath(ctx.path.concat("default"))} should be the last condition in the object so it doesn't take precedence over the keys following it.`, "error", 'Conditions are resolved in order. "default" acts as a fallback and should come last.'));
+        }
+      });
+      return issues;
+    }
+  };
+});
+
+// src/rules/publint/exports-module-should-precede-require.ts
+var exportsModuleShouldPrecedeRequire;
+var init_exports_module_should_precede_require = __esm(() => {
+  init_utils2();
+  exportsModuleShouldPrecedeRequire = {
+    meta: {
+      docs: 'Ensure "module" condition precedes "require" in exports',
+      recommended: true
+    },
+    check(content, context) {
+      const pkg = parsePackageJson(content);
+      if (!pkg)
+        return [];
+      const issues = [];
+      const [exportsValue, exportsPath] = getPublishedField(pkg, "exports");
+      if (exportsValue == null)
+        return [];
+      crawlExportsOrImports(exportsValue, exportsPath, false, (value, ctx, objectKeys) => {
+        if (!objectKeys || typeof value !== "object" || Array.isArray(value))
+          return;
+        if (!("module" in value) || !("require" in value))
+          return;
+        if (objectKeys.indexOf("module") > objectKeys.indexOf("require")) {
+          issues.push(createIssue(context.filePath, content, ctx.path.concat("module"), "publint/exports-module-should-precede-require", `${formatPkgPath(ctx.path.concat("module"))} should come before the "require" condition so it can take precedence when used by a bundler.`, "error", 'Bundlers prioritize conditions by order. "module" should precede "require" to ensure ESM is preferred.'));
+        }
+      });
+      return issues;
+    }
+  };
+});
+
+// src/rules/publint/exports-value-invalid.ts
+var exportsValueInvalid;
+var init_exports_value_invalid = __esm(() => {
+  init_utils2();
+  exportsValueInvalid = {
+    meta: {
+      docs: 'Ensure exports values start with "./"',
+      recommended: true
+    },
+    check(content, context) {
+      const pkg = parsePackageJson(content);
+      if (!pkg)
+        return [];
+      const issues = [];
+      const [exportsValue, exportsPath] = getPublishedField(pkg, "exports");
+      if (exportsValue == null)
+        return [];
+      crawlExportsOrImports(exportsValue, exportsPath, false, (value, ctx) => {
+        if (typeof value !== "string")
+          return;
+        if (value.startsWith("./"))
+          return;
+        const suggestValue = "./" + value.replace(/^[/]+/, "");
+        issues.push(createIssue(context.filePath, content, ctx.path, "publint/exports-value-invalid", `${formatPkgPath(ctx.path)} is "${value}" which is invalid as it does not start with "./". Use "${suggestValue}" instead.`, "error", 'All exports values must be relative paths starting with "./".'));
+      });
+      return issues;
+    }
+  };
+});
+
+// src/rules/publint/exports-missing-root-entrypoint.ts
+var exportsMissingRootEntrypoint;
+var init_exports_missing_root_entrypoint = __esm(() => {
+  init_utils2();
+  exportsMissingRootEntrypoint = {
+    meta: {
+      docs: "Ensure exports has a root entrypoint when main/module exist",
+      recommended: true
+    },
+    check(content, context) {
+      const pkg = parsePackageJson(content);
+      if (!pkg)
+        return [];
+      const [mainValue] = getPublishedField(pkg, "main");
+      const [moduleValue] = getPublishedField(pkg, "module");
+      const [exportsValue, exportsPath] = getPublishedField(pkg, "exports");
+      if (mainValue == null && moduleValue == null || exportsValue == null)
+        return [];
+      if (typeof exportsValue !== "object" || Array.isArray(exportsValue))
+        return [];
+      const exportsKeys = Object.keys(exportsValue);
+      if (exportsKeys.length === 0)
+        return [];
+      const hasSubpathKeys = exportsKeys[0]?.startsWith(".");
+      if (!hasSubpathKeys)
+        return [];
+      if (exportsKeys.includes("."))
+        return [];
+      const mainFields = [];
+      if (mainValue)
+        mainFields.push("main");
+      if (moduleValue)
+        mainFields.push("module");
+      return [createIssue(context.filePath, content, exportsPath, "publint/exports-missing-root-entrypoint", `${formatPkgPath(exportsPath)} is missing the root entrypoint export, which is defined in pkg.${mainFields[0]}. Environments that support "exports" will ignore pkg.${mainFields[0]} as "exports" takes the highest priority.`, "warning", `Add ${formatPkgPath(exportsPath.concat("."))} to ensure the root entrypoint is accessible.`)];
+    }
+  };
+});
+
+// src/rules/publint/exports-fallback-array-use.ts
+var exportsFallbackArrayUse;
+var init_exports_fallback_array_use = __esm(() => {
+  init_utils2();
+  exportsFallbackArrayUse = {
+    meta: {
+      docs: "Warn against using fallback arrays in exports",
+      recommended: true
+    },
+    check(content, context) {
+      const pkg = parsePackageJson(content);
+      if (!pkg)
+        return [];
+      const issues = [];
+      const [exportsValue, exportsPath] = getPublishedField(pkg, "exports");
+      if (exportsValue == null)
+        return [];
+      crawlExportsOrImports(exportsValue, exportsPath, false, (value, ctx) => {
+        if (!Array.isArray(value))
+          return;
+        issues.push(createIssue(context.filePath, content, ctx.path, "publint/exports-fallback-array-use", `${formatPkgPath(ctx.path)} uses fallback arrays which is not recommended. It works differently in some tools and may face inconsistent behaviors.`, "warning", "Fallback arrays pick the first parseable value and have no practical use case in Node.js currently."));
+      });
+      return issues;
+    }
+  };
+});
+
+// src/rules/publint/imports-key-invalid.ts
+var importsKeyInvalid;
+var init_imports_key_invalid = __esm(() => {
+  init_utils2();
+  importsKeyInvalid = {
+    meta: {
+      docs: 'Ensure imports keys start with "#"',
+      recommended: true
+    },
+    check(content, context) {
+      const pkg = parsePackageJson(content);
+      if (!pkg)
+        return [];
+      const issues = [];
+      const [importsValue, importsPath] = getPublishedField(pkg, "imports");
+      if (importsValue == null || typeof importsValue !== "object" || Array.isArray(importsValue))
+        return [];
+      for (const key of Object.keys(importsValue)) {
+        if (!key.startsWith("#")) {
+          const suggestKey = "#" + key.replace(/^[/]+/, "");
+          const path2 = importsPath.concat(key);
+          issues.push(createIssue(context.filePath, content, path2, "publint/imports-key-invalid", `${formatPkgPath(path2)} is invalid as the imports key does not start with "#". Use "${suggestKey}" instead.`, "error", 'All imports keys must start with "#" to distinguish them from package specifiers.'));
+        }
+      }
+      return issues;
+    }
+  };
+});
+
+// src/rules/publint/imports-value-invalid.ts
+var importsValueInvalid;
+var init_imports_value_invalid = __esm(() => {
+  init_utils2();
+  importsValueInvalid = {
+    meta: {
+      docs: 'Ensure imports values start with "./"',
+      recommended: true
+    },
+    check(content, context) {
+      const pkg = parsePackageJson(content);
+      if (!pkg)
+        return [];
+      const issues = [];
+      const [importsValue, importsPath] = getPublishedField(pkg, "imports");
+      if (importsValue == null || typeof importsValue !== "object")
+        return [];
+      crawlExportsOrImports(importsValue, importsPath, true, (value, ctx) => {
+        if (typeof value !== "string")
+          return;
+        if (!value.startsWith("."))
+          return;
+        if (value.startsWith("./"))
+          return;
+        const suggestValue = "./" + value.replace(/^[/]+/, "");
+        issues.push(createIssue(context.filePath, content, ctx.path, "publint/imports-value-invalid", `${formatPkgPath(ctx.path)} is "${value}" which is invalid as it does not start with "./". Use "${suggestValue}" instead.`, "error", 'Relative imports values must start with "./".'));
+      });
+      return issues;
+    }
+  };
+});
+
+// src/rules/publint/imports-default-should-be-last.ts
+var importsDefaultShouldBeLast;
+var init_imports_default_should_be_last = __esm(() => {
+  init_utils2();
+  importsDefaultShouldBeLast = {
+    meta: {
+      docs: 'Ensure "default" condition is last in imports objects',
+      recommended: true
+    },
+    check(content, context) {
+      const pkg = parsePackageJson(content);
+      if (!pkg)
+        return [];
+      const issues = [];
+      const [importsValue, importsPath] = getPublishedField(pkg, "imports");
+      if (importsValue == null || typeof importsValue !== "object")
+        return [];
+      crawlExportsOrImports(importsValue, importsPath, true, (value, ctx, objectKeys) => {
+        if (!objectKeys || typeof value !== "object" || Array.isArray(value))
+          return;
+        if (!("default" in value))
+          return;
+        if (objectKeys[objectKeys.length - 1] !== "default") {
+          issues.push(createIssue(context.filePath, content, ctx.path.concat("default"), "publint/imports-default-should-be-last", `${formatPkgPath(ctx.path.concat("default"))} should be the last condition in the object so it doesn't take precedence over the keys following it.`, "error", 'Conditions are resolved in order. "default" acts as a fallback and should come last.'));
+        }
+      });
+      return issues;
+    }
+  };
+});
+
+// src/rules/publint/imports-module-should-precede-require.ts
+var importsModuleShouldPrecedeRequire;
+var init_imports_module_should_precede_require = __esm(() => {
+  init_utils2();
+  importsModuleShouldPrecedeRequire = {
+    meta: {
+      docs: 'Ensure "module" condition precedes "require" in imports',
+      recommended: true
+    },
+    check(content, context) {
+      const pkg = parsePackageJson(content);
+      if (!pkg)
+        return [];
+      const issues = [];
+      const [importsValue, importsPath] = getPublishedField(pkg, "imports");
+      if (importsValue == null || typeof importsValue !== "object")
+        return [];
+      crawlExportsOrImports(importsValue, importsPath, true, (value, ctx, objectKeys) => {
+        if (!objectKeys || typeof value !== "object" || Array.isArray(value))
+          return;
+        if (!("module" in value) || !("require" in value))
+          return;
+        if (objectKeys.indexOf("module") > objectKeys.indexOf("require")) {
+          issues.push(createIssue(context.filePath, content, ctx.path.concat("module"), "publint/imports-module-should-precede-require", `${formatPkgPath(ctx.path.concat("module"))} should come before the "require" condition so it can take precedence when used by a bundler.`, "error", 'Bundlers prioritize conditions by order. "module" should precede "require" to ensure ESM is preferred.'));
+        }
+      });
+      return issues;
+    }
+  };
+});
+
+// src/rules/publint/file-does-not-exist.ts
+import { existsSync as existsSync9 } from "fs";
+function checkFileRef(value, path2, issues, filePath, content, pkgDir) {
+  const resolved = resolvePkgPath(pkgDir, value);
+  if (!fileExistsWithFallbacks(resolved)) {
+    issues.push(createIssue(filePath, content, path2, "publint/file-does-not-exist", `${formatPkgPath(path2)} is "${value}" but the file does not exist.`, "error", "The referenced file path cannot be found. Check the path for typos."));
+  }
+}
+function fileExistsWithFallbacks(resolved) {
+  if (existsSync9(resolved))
+    return true;
+  if (existsSync9(resolved + ".js"))
+    return true;
+  if (existsSync9(resolved + "/index.js"))
+    return true;
+  return false;
+}
+var fileDoesNotExist;
+var init_file_does_not_exist = __esm(() => {
+  init_utils2();
+  fileDoesNotExist = {
+    meta: {
+      docs: "Ensure files referenced in package.json exist",
+      recommended: true
+    },
+    check(content, context) {
+      const pkg = parsePackageJson(content);
+      if (!pkg)
+        return [];
+      const issues = [];
+      const pkgDir = getPkgDir(context.filePath);
+      const stringFields = ["main", "module", "types", "typings", "unpkg", "jsdelivr"];
+      for (const field of stringFields) {
+        const [value, path2] = getPublishedField(pkg, field);
+        if (value == null || typeof value !== "string")
+          continue;
+        const resolved = resolvePkgPath(pkgDir, value);
+        if (!fileExistsWithFallbacks(resolved)) {
+          issues.push(createIssue(context.filePath, content, path2, "publint/file-does-not-exist", `${formatPkgPath(path2)} is "${value}" but the file does not exist.`, "error", "The referenced file path cannot be found. Check the path for typos."));
+        }
+      }
+      const [binValue, binPath] = getPublishedField(pkg, "bin");
+      if (binValue != null) {
+        if (typeof binValue === "string") {
+          checkFileRef(binValue, binPath, issues, context.filePath, content, pkgDir);
+        } else if (typeof binValue === "object") {
+          for (const key of Object.keys(binValue)) {
+            if (typeof binValue[key] === "string") {
+              checkFileRef(binValue[key], binPath.concat(key), issues, context.filePath, content, pkgDir);
+            }
+          }
+        }
+      }
+      const [exportsValue, exportsPath] = getPublishedField(pkg, "exports");
+      if (exportsValue != null) {
+        crawlExportsOrImports(exportsValue, exportsPath, false, (value, ctx) => {
+          if (typeof value !== "string")
+            return;
+          if (!value.startsWith("./") && !value.startsWith("../"))
+            return;
+          if (value.includes("*"))
+            return;
+          const resolved = resolvePkgPath(pkgDir, value);
+          if (!existsSync9(resolved)) {
+            issues.push(createIssue(context.filePath, content, ctx.path, "publint/file-does-not-exist", `${formatPkgPath(ctx.path)} is "${value}" but the file does not exist.`, "error", "The referenced file path cannot be found. Check the path for typos."));
+          }
+        });
+      }
+      return issues;
+    }
+  };
+});
+
+// src/rules/publint/file-invalid-format.ts
+import { existsSync as existsSync11, readFileSync } from "fs";
+import { extname } from "path";
+function checkFileFormat(filePath, pkgPath, pkgDir, pkgType, issues, contextFilePath, content) {
+  const resolved = resolvePkgPath(pkgDir, filePath);
+  if (!existsSync11(resolved))
+    return;
+  if (!isLintableFilePath(filePath))
+    return;
+  let fileContent;
+  try {
+    fileContent = readFileSync(resolved, "utf8");
+  } catch {
+    return;
+  }
+  const actualFormat = getCodeFormat(fileContent);
+  if (actualFormat === "unknown" || actualFormat === "mixed")
+    return;
+  const expectFormat = getFilePathFormat(resolved, pkgType);
+  if (actualFormat === expectFormat)
+    return;
+  const actualExtension = extname(resolved);
+  const expectExtension = getCodeFormatExtension(actualFormat);
+  const code = isExplicitExtension(actualExtension) ? "FILE_INVALID_EXPLICIT_FORMAT" : "FILE_INVALID_FORMAT";
+  const message = code === "FILE_INVALID_EXPLICIT_FORMAT" ? `${formatPkgPath(pkgPath)} is "${filePath}" and ends with the ${actualExtension} extension, but the code is written in ${actualFormat}. Consider using the ${expectExtension} extension.` : `${formatPkgPath(pkgPath)} is "${filePath}" and is written in ${actualFormat}, but is interpreted as ${expectFormat}. Consider using the ${expectExtension} extension.`;
+  issues.push(createIssue(contextFilePath, content, pkgPath, "publint/file-invalid-format", message, "warning", `The file's code format (${actualFormat}) doesn't match the expected format (${expectFormat}) based on its extension and package type.`));
+}
+var fileInvalidFormat;
+var init_file_invalid_format = __esm(() => {
+  init_utils2();
+  fileInvalidFormat = {
+    meta: {
+      docs: "Ensure file code format matches its extension and package type",
+      recommended: true
+    },
+    check(content, context) {
+      const pkg = parsePackageJson(content);
+      if (!pkg)
+        return [];
+      const issues = [];
+      const pkgDir = getPkgDir(context.filePath);
+      const pkgType = pkg.type;
+      const [mainValue, mainPath] = getPublishedField(pkg, "main");
+      if (mainValue != null && typeof mainValue === "string") {
+        checkFileFormat(mainValue, mainPath, pkgDir, pkgType, issues, context.filePath, content);
+      }
+      const [exportsValue, exportsPath] = getPublishedField(pkg, "exports");
+      if (exportsValue != null) {
+        crawlExportsOrImports(exportsValue, exportsPath, false, (value, ctx) => {
+          if (typeof value !== "string")
+            return;
+          if (!value.startsWith("./") && !value.startsWith("../"))
+            return;
+          if (value.includes("*"))
+            return;
+          if (ctx.path.includes("browser"))
+            return;
+          checkFileFormat(value, ctx.path, pkgDir, pkgType, issues, context.filePath, content);
+        });
+      }
+      return issues;
+    }
+  };
+});
+
+// src/rules/publint/module-should-be-esm.ts
+import { existsSync as existsSync12, readFileSync as readFileSync2 } from "fs";
+var moduleShouldBeEsm;
+var init_module_should_be_esm = __esm(() => {
+  init_utils2();
+  moduleShouldBeEsm = {
+    meta: {
+      docs: 'Ensure the "module" field points to an ESM file',
+      recommended: true
+    },
+    check(content, context) {
+      const pkg = parsePackageJson(content);
+      if (!pkg)
+        return [];
+      const [moduleValue, modulePath] = getPublishedField(pkg, "module");
+      if (moduleValue == null || typeof moduleValue !== "string")
+        return [];
+      const pkgDir = getPkgDir(context.filePath);
+      const resolved = resolvePkgPath(pkgDir, moduleValue);
+      if (!existsSync12(resolved))
+        return [];
+      if (!isLintableFilePath(moduleValue))
+        return [];
+      let fileContent;
+      try {
+        fileContent = readFileSync2(resolved, "utf8");
+      } catch {
+        return [];
+      }
+      const actualFormat = getCodeFormat(fileContent);
+      if (actualFormat === "CJS") {
+        return [createIssue(context.filePath, content, modulePath, "publint/module-should-be-esm", `${formatPkgPath(modulePath)} should be ESM, but the code is written in CJS.`, "error", 'The "module" field is intended for ESM output used by bundlers. It should point to an ESM file.')];
+      }
+      return [];
     }
   };
 });
 
-// src/plugins/node.ts
-var nodePlugin;
-var init_node = __esm(() => {
-  init_prefer_global_buffer();
-  init_prefer_global_process();
-  init_utils();
-  nodePlugin = {
-    name: "node",
-    rules: {
-      "prefer-global/buffer": codeOnly(preferGlobalBuffer),
-      "prefer-global/process": codeOnly(preferGlobalProcess)
+// src/rules/publint/bin-file-not-executable.ts
+import { existsSync as existsSync13, readFileSync as readFileSync3 } from "fs";
+function checkBin(filePath, pkgPath, pkgDir, issues, contextFilePath, content) {
+  const resolved = resolvePkgPath(pkgDir, filePath);
+  if (!existsSync13(resolved))
+    return;
+  if (!isLintableFilePath(filePath))
+    return;
+  let fileContent;
+  try {
+    fileContent = readFileSync3(resolved, "utf8");
+  } catch {
+    return;
+  }
+  if (!startsWithShebang(fileContent)) {
+    issues.push(createIssue(contextFilePath, content, pkgPath, "publint/bin-file-not-executable", `${formatPkgPath(pkgPath)} is "${filePath}" but the file is not executable. It should start with a shebang, e.g. #!/usr/bin/env node.`, "error", "Bin files must start with a shebang (e.g. #!/usr/bin/env node) to be executable."));
+  }
+}
+var binFileNotExecutable;
+var init_bin_file_not_executable = __esm(() => {
+  init_utils2();
+  binFileNotExecutable = {
+    meta: {
+      docs: "Ensure bin files have a shebang for executability",
+      recommended: true
+    },
+    check(content, context) {
+      const pkg = parsePackageJson(content);
+      if (!pkg)
+        return [];
+      const issues = [];
+      const pkgDir = getPkgDir(context.filePath);
+      const [binValue, binPath] = getPublishedField(pkg, "bin");
+      if (binValue == null)
+        return [];
+      if (typeof binValue === "string") {
+        checkBin(binValue, binPath, pkgDir, issues, context.filePath, content);
+      } else if (typeof binValue === "object") {
+        for (const key of Object.keys(binValue)) {
+          if (typeof binValue[key] === "string") {
+            checkBin(binValue[key], binPath.concat(key), pkgDir, issues, context.filePath, content);
+          }
+        }
+      }
+      return issues;
     }
   };
 });
 
-// src/rules/sort/imports.ts
-var sortImportsRule;
-var init_imports = __esm(() => {
-  init_format();
-  sortImportsRule = {
-    meta: { docs: "Enforce sorted imports (delegates to formatter check only)" },
-    check: (text, ctx) => {
-      const lines = text.split(/\r?\n/);
-      let idx = 0;
-      while (idx < lines.length && (/^\s*$/.test(lines[idx]) || /^\s*\/.\/.*/.test(lines[idx]) || /^\s*\/.\*/.test(lines[idx])))
-        idx++;
-      const start = idx;
-      const imports = [];
-      while (idx < lines.length && /^\s*import\b/.test(lines[idx])) {
-        imports.push(lines[idx].trim());
-        idx++;
-      }
-      if (imports.length === 0)
+// src/rules/publint/exports-module-should-be-esm.ts
+import { existsSync as existsSync14, readFileSync as readFileSync4 } from "fs";
+var exportsModuleShouldBeEsm;
+var init_exports_module_should_be_esm = __esm(() => {
+  init_utils2();
+  exportsModuleShouldBeEsm = {
+    meta: {
+      docs: 'Ensure files under "module" condition in exports are ESM',
+      recommended: true
+    },
+    check(content, context) {
+      const pkg = parsePackageJson(content);
+      if (!pkg)
         return [];
-      const block = imports.join(`
-`);
-      const rest = lines.slice(idx).join(`
-`);
-      const reconstructed = `${block}
-${rest}`;
-      const formatted = formatImports(reconstructed);
-      if (formatted !== reconstructed) {
-        return [{ filePath: ctx.filePath, line: start + 1, column: 1, ruleId: "sort-imports", message: "Imports are not sorted/grouped consistently", severity: "warning" }];
+      const issues = [];
+      const pkgDir = getPkgDir(context.filePath);
+      const [exportsValue, exportsPath] = getPublishedField(pkg, "exports");
+      if (exportsValue == null)
+        return [];
+      crawlExportsOrImports(exportsValue, exportsPath, false, (value, ctx) => {
+        if (typeof value !== "string")
+          return;
+        if (!ctx.path.includes("module"))
+          return;
+        if (!value.startsWith("./") && !value.startsWith("../"))
+          return;
+        if (value.includes("*"))
+          return;
+        const resolved = resolvePkgPath(pkgDir, value);
+        if (!existsSync14(resolved))
+          return;
+        if (!isLintableFilePath(value))
+          return;
+        let fileContent;
+        try {
+          fileContent = readFileSync4(resolved, "utf8");
+        } catch {
+          return;
+        }
+        const actualFormat = getCodeFormat(fileContent);
+        if (actualFormat === "CJS") {
+          issues.push(createIssue(context.filePath, content, ctx.path, "publint/exports-module-should-be-esm", `${formatPkgPath(ctx.path)} should be ESM, but the code is written in CJS.`, "error", 'The "module" condition is only used by bundlers and must contain ESM code.'));
+        }
+      });
+      const [importsValue, importsPath] = getPublishedField(pkg, "imports");
+      if (importsValue != null && typeof importsValue === "object") {
+        crawlExportsOrImports(importsValue, importsPath, true, (value, ctx) => {
+          if (typeof value !== "string")
+            return;
+          if (!ctx.path.includes("module"))
+            return;
+          if (!value.startsWith("./"))
+            return;
+          if (value.includes("*"))
+            return;
+          const resolved = resolvePkgPath(pkgDir, value);
+          if (!existsSync14(resolved))
+            return;
+          if (!isLintableFilePath(value))
+            return;
+          let fileContent;
+          try {
+            fileContent = readFileSync4(resolved, "utf8");
+          } catch {
+            return;
+          }
+          const actualFormat = getCodeFormat(fileContent);
+          if (actualFormat === "CJS") {
+            issues.push(createIssue(context.filePath, content, ctx.path, "publint/exports-module-should-be-esm", `${formatPkgPath(ctx.path)} should be ESM, but the code is written in CJS.`, "error", 'The "module" condition is only used by bundlers and must contain ESM code.'));
+          }
+        });
       }
-      return [];
-    },
-    fix: (text) => formatImports(text)
+      return issues;
+    }
   };
 });
 
-// src/plugins/perfectionist.ts
-var perfectionistPlugin;
-var init_perfectionist = __esm(() => {
-  init_imports();
+// src/rules/publint/index.ts
+var init_publint = __esm(() => {
+  init_use_type();
+  init_local_dependency();
+  init_deprecated_field_jsnext();
+  init_has_module_but_no_exports();
+  init_field_invalid_value_type();
+  init_exports_types_should_be_first();
+  init_exports_default_should_be_last();
+  init_exports_module_should_precede_require();
+  init_exports_value_invalid();
+  init_exports_missing_root_entrypoint();
+  init_exports_fallback_array_use();
+  init_imports_key_invalid();
+  init_imports_value_invalid();
+  init_imports_default_should_be_last();
+  init_imports_module_should_precede_require();
+  init_file_does_not_exist();
+  init_file_invalid_format();
+  init_module_should_be_esm();
+  init_bin_file_not_executable();
+  init_exports_module_should_be_esm();
+});
+
+// src/plugins/publint.ts
+var publintPlugin;
+var init_publint2 = __esm(() => {
+  init_publint();
   init_utils();
-  perfectionistPlugin = {
-    name: "perfectionist",
+  publintPlugin = {
+    name: "publint",
     rules: {
-      "sort-imports": codeOnly(sortImportsRule)
+      "use-type": packageJsonOnly(useType),
+      "local-dependency": packageJsonOnly(localDependency),
+      "deprecated-field-jsnext": packageJsonOnly(deprecatedFieldJsnext),
+      "has-module-but-no-exports": packageJsonOnly(hasModuleButNoExports),
+      "field-invalid-value-type": packageJsonOnly(fieldInvalidValueType),
+      "exports-types-should-be-first": packageJsonOnly(exportsTypesShouldBeFirst),
+      "exports-default-should-be-last": packageJsonOnly(exportsDefaultShouldBeLast),
+      "exports-module-should-precede-require": packageJsonOnly(exportsModuleShouldPrecedeRequire),
+      "exports-value-invalid": packageJsonOnly(exportsValueInvalid),
+      "exports-missing-root-entrypoint": packageJsonOnly(exportsMissingRootEntrypoint),
+      "exports-fallback-array-use": packageJsonOnly(exportsFallbackArrayUse),
+      "imports-key-invalid": packageJsonOnly(importsKeyInvalid),
+      "imports-value-invalid": packageJsonOnly(importsValueInvalid),
+      "imports-default-should-be-last": packageJsonOnly(importsDefaultShouldBeLast),
+      "imports-module-should-precede-require": packageJsonOnly(importsModuleShouldPrecedeRequire),
+      "file-does-not-exist": packageJsonOnly(fileDoesNotExist),
+      "file-invalid-format": packageJsonOnly(fileInvalidFormat),
+      "module-should-be-esm": packageJsonOnly(moduleShouldBeEsm),
+      "bin-file-not-executable": packageJsonOnly(binFileNotExecutable),
+      "exports-module-should-be-esm": packageJsonOnly(exportsModuleShouldBeEsm)
     }
   };
 });
@@ -20199,8 +21763,8 @@ var init_import_dedupe = __esm(() => {
 });
 
 // src/rules/imports/named.ts
-import { existsSync as existsSync9, readFileSync } from "fs";
-import { dirname as dirname7, resolve as resolve11 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname8, resolve as resolve12 } from "path";
 var namedRule;
 var init_named = __esm(() => {
   namedRule = {
@@ -20211,7 +21775,7 @@ var init_named = __esm(() => {
     check: (text, ctx) => {
       const issues = [];
       const lines = text.split(/\r?\n/);
-      const currentDir = dirname7(ctx.filePath);
+      const currentDir = dirname8(ctx.filePath);
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
         const namedImportMatch = line.match(/\bimport\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/);
@@ -20224,9 +21788,9 @@ var init_named = __esm(() => {
           const extensions = [".ts", ".tsx", ".js", ".jsx", ""];
           let targetContent = "";
           for (const ext of extensions) {
-            const fullPath = resolve11(currentDir, importPath + ext);
-            if (existsSync9(fullPath)) {
-              targetContent = readFileSync(fullPath, "utf8");
+            const fullPath = resolve12(currentDir, importPath + ext);
+            if (existsSync15(fullPath)) {
+              targetContent = readFileSync5(fullPath, "utf8");
               break;
             }
           }
@@ -20257,8 +21821,8 @@ var init_named = __esm(() => {
 });
 
 // src/rules/imports/no-cycle.ts
-import { existsSync as existsSync11, readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname8, resolve as resolve12 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname9, resolve as resolve13 } from "path";
 var noCycleRule;
 var init_no_cycle = __esm(() => {
   noCycleRule = {
@@ -20282,8 +21846,8 @@ var init_no_cycle = __esm(() => {
         visited.add(filePath);
         stack.add(filePath);
         try {
-          const content = readFileSync2(filePath, "utf8");
-          const imports = extractImports(content, dirname8(filePath));
+          const content = readFileSync6(filePath, "utf8");
+          const imports = extractImports(content, dirname9(filePath));
           for (const imp of imports) {
             if (detectCycle(imp, [...importChain, imp])) {
               return true;
@@ -20302,8 +21866,8 @@ var init_no_cycle = __esm(() => {
           if (importPath.startsWith(".") || importPath.startsWith("/")) {
             const extensions = [".ts", ".tsx", ".js", ".jsx", ""];
             for (const ext of extensions) {
-              const fullPath = resolve12(baseDir, importPath + ext);
-              if (existsSync11(fullPath)) {
+              const fullPath = resolve13(baseDir, importPath + ext);
+              if (existsSync16(fullPath)) {
                 imports.push(fullPath);
                 break;
               }
@@ -20321,8 +21885,8 @@ var init_no_cycle = __esm(() => {
             const extensions = [".ts", ".tsx", ".js", ".jsx", ""];
             let resolvedPath = "";
             for (const ext of extensions) {
-              const fullPath = resolve12(dirname8(currentFile), importPath + ext);
-              if (existsSync11(fullPath)) {
+              const fullPath = resolve13(dirname9(currentFile), importPath + ext);
+              if (existsSync16(fullPath)) {
                 resolvedPath = fullPath;
                 break;
               }
@@ -20488,8 +22052,8 @@ var init_no_import_node_modules_by_path = __esm(() => {
 });
 
 // src/rules/imports/no-unresolved.ts
-import { existsSync as existsSync12 } from "fs";
-import { dirname as dirname9, join as join6, resolve as resolve13 } from "path";
+import { existsSync as existsSync17 } from "fs";
+import { dirname as dirname10, join as join6, resolve as resolve14 } from "path";
 var noUnresolvedRule;
 var init_no_unresolved = __esm(() => {
   noUnresolvedRule = {
@@ -20500,7 +22064,7 @@ var init_no_unresolved = __esm(() => {
     check: (text, ctx) => {
       const issues = [];
       const lines = text.split(/\r?\n/);
-      const currentDir = dirname9(ctx.filePath);
+      const currentDir = dirname10(ctx.filePath);
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
         const importMatches = [
@@ -20516,11 +22080,11 @@ var init_no_unresolved = __esm(() => {
           const possiblePaths = [];
           const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ""];
           for (const ext of extensions) {
-            const fullPath = resolve13(currentDir, importPath + ext);
+            const fullPath = resolve14(currentDir, importPath + ext);
             possiblePaths.push(fullPath);
             possiblePaths.push(join6(fullPath, `index${ext}`));
           }
-          const resolved = possiblePaths.some((p) => existsSync12(p));
+          const resolved = possiblePaths.some((p) => existsSync17(p));
           if (!resolved) {
             issues.push({
               filePath: ctx.filePath,
@@ -20693,7 +22257,7 @@ var init_heritage_clauses = __esm(() => {
         }
         return "unknown";
       };
-      const splitTopLevel = (src) => {
+      const splitTopLevel2 = (src) => {
         const out = [];
         let depth = 0;
         let token = "";
@@ -20720,7 +22284,7 @@ var init_heritage_clauses = __esm(() => {
         return m ? m[1] : t;
       };
       const checkList = (lineNo, listSrc) => {
-        const items = splitTopLevel(listSrc);
+        const items = splitTopLevel2(listSrc);
         if (items.length <= 1)
           return;
         const names = items.map(baseName);
@@ -20960,6 +22524,9 @@ var init_top_level_function = __esm(() => {
 // src/plugins/pickier.ts
 var pickierPlugin;
 var init_pickier = __esm(() => {
+  init_no_unused_vars();
+  init_prefer_const();
+  init_prefer_template();
   init_first();
   init_import_dedupe();
   init_named();
@@ -20993,7 +22560,10 @@ var init_pickier = __esm(() => {
       "no-import-dist": codeOnly(noImportDistRule),
       "no-import-node-modules-by-path": codeOnly(noImportNodeModulesByPathRule),
       "no-duplicate-imports": codeOnly(noDuplicateImportsRule),
-      "top-level-function": codeOnly(topLevelFunctionRule)
+      "top-level-function": codeOnly(topLevelFunctionRule),
+      "prefer-const": codeOnly(preferConstRule),
+      "prefer-template": codeOnly(preferTemplate),
+      "no-unused-vars": codeOnly(noUnusedVarsRule)
     }
   };
 });
@@ -21094,7 +22664,7 @@ var init_no_super_linear_backtracking = __esm(() => {
     meta: { docs: "Detects potentially super-linear backtracking patterns in regex literals (heuristic)" },
     check: (text, ctx) => {
       const issues = [];
-      const regexLiteral = /\/[^/\\]*(?:\\.[^/\\]*)*\//g;
+      const regexLiteral = /\/[^/\\\n]*(?:\\.[^/\\\n]*)*\//g;
       const mark = (idx, _len, msg) => {
         const before = text.slice(0, idx);
         const line = (before.match(/\n/g) || []).length + 1;
@@ -21102,10 +22672,34 @@ var init_no_super_linear_backtracking = __esm(() => {
 `);
         issues.push({ filePath: ctx.filePath, line, column: col, ruleId: "no-super-linear-backtracking", message: msg, severity: "error" });
       };
+      const commentRanges = [];
+      const blockComment = /\/\*[\s\S]*?\*\//g;
+      let bc;
+      while (bc = blockComment.exec(text)) {
+        commentRanges.push({ start: bc.index, end: bc.index + bc[0].length });
+      }
+      const lineComment = /\/\/[^\n]*/g;
+      let lc;
+      while (lc = lineComment.exec(text)) {
+        commentRanges.push({ start: lc.index, end: lc.index + lc[0].length });
+      }
       let m;
       while (m = regexLiteral.exec(text)) {
         const literal = m[0];
         const idx = m.index;
+        if (commentRanges.some((r) => idx >= r.start && idx < r.end)) {
+          continue;
+        }
+        if (idx > 0) {
+          const prevChar = text[idx - 1];
+          if (prevChar === ")" || prevChar === "]" || prevChar === "." || /[\w$]/.test(prevChar)) {
+            continue;
+          }
+          const inner = literal.slice(1, literal.lastIndexOf("/"));
+          if (/^\s+\w/.test(inner) && /\w\s*\)/.test(inner)) {
+            continue;
+          }
+        }
         const patt = literal.slice(1, literal.lastIndexOf("/"));
         const flat = patt.replace(/\[.*?\]/g, "");
         const exch = flat.includes(".+?\\s*") || flat.includes("\\s*.+?") || flat.includes(".*\\s*") || flat.includes("\\s*.*");
@@ -21118,7 +22712,7 @@ var init_no_super_linear_backtracking = __esm(() => {
           mark(idx, literal.length, "Multiple adjacent unlimited wildcard quantifiers can cause super-linear backtracking");
           continue;
         }
-        if (/\((?:\?:)?[^)]*?[+*][^)]*\)\s*[+*]/.test(flat)) {
+        if (/\((?:\?:)?[^)]*?[+*][^)]*\)\s*[+*]/.test(flat.replace(/\\[()]/g, "_"))) {
           mark(idx, literal.length, "Nested unlimited quantifiers detected (e.g., (.+)+) which can cause catastrophic backtracking");
           continue;
         }
@@ -21259,6 +22853,43 @@ function areCapturesUsed(content, regexStart, regexEnd) {
   }
   return true;
 }
+function skipRegexLiteral(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 idx + 1;
+  let i = idx + 1;
+  let inClass = false;
+  let escaped = false;
+  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) {
+      i++;
+      while (i < content.length && /[gimsuy]/.test(content[i]))
+        i++;
+      return i;
+    } else if (c === `
+`) {
+      break;
+    }
+    i++;
+  }
+  return idx + 1;
+}
 function findIssues(content, ctx) {
   const issues = [];
   const filePath = ctx.filePath;
@@ -21297,7 +22928,12 @@ function findIssues(content, ctx) {
     if (ch === "/") {
       const info = parseRegexLiteral(content, idx);
       if (!info) {
-        idx++;
+        const skipEnd = skipRegexLiteral(content, idx);
+        if (skipEnd > idx + 1) {
+          idx = skipEnd;
+        } else {
+          idx++;
+        }
         continue;
       }
       if (!areCapturesUsed(content, info.patternStart, info.patternEnd)) {
@@ -21721,6 +23357,8 @@ var init_brace_style = __esm(() => {
       for (let i = 0;i < lines.length; i++) {
         const line = lines[i];
         const trimmed = line.trim();
+        if (trimmed.startsWith("//") || trimmed.startsWith("/*"))
+          continue;
         const closingBraceWithNext = /\}\s+(else|catch|finally)\b/;
         if (closingBraceWithNext.test(trimmed)) {
           issues.push({
@@ -21734,6 +23372,8 @@ var init_brace_style = __esm(() => {
         }
         if (trimmed === "{" && i > 0) {
           const prevLine = lines[i - 1].trim();
+          if (!prevLine || prevLine.startsWith("//") || prevLine.startsWith("/*") || prevLine.endsWith("*/"))
+            continue;
           if (prevLine && !prevLine.endsWith("{") && !prevLine.endsWith(",") && !prevLine.endsWith("(")) {
             if (!prevLine.match(/[=:]\s*$/) && !prevLine.endsWith("[")) {
               issues.push({
@@ -26629,7 +28269,7 @@ var init_prefer_nullish_coalescing = __esm(() => {
       for (const line of lines) {
         let fixedLine = line;
         fixedLine = fixedLine.replace(/(\b[\w$]+(?:\.[\w$]+)*)\s*\|\|\s*([^|&]+?)(?=\s*[;,)\]}]|$)/g, (match, left, right) => {
-          if (/\b(true|false)\b/.test(right.trim())) {
+          if (/\b(?:true|false)\b/.test(right.trim())) {
             return match;
           }
           return `${left} ?? ${right}`;
@@ -27095,6 +28735,7 @@ function getAllPlugins() {
     markdownPlugin,
     nodePlugin,
     lockfilePlugin,
+    publintPlugin,
     unusedImportsPlugin,
     perfectionistPlugin
   ];
@@ -27106,6 +28747,7 @@ var init_plugins = __esm(() => {
   init_markdown();
   init_node();
   init_perfectionist();
+  init_publint2();
   init_pickier();
   init_quality();
   init_regexp();
@@ -27115,11 +28757,23 @@ var init_plugins = __esm(() => {
 });
 
 // src/utils.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { extname, isAbsolute as isAbsolute3, resolve as resolve14 } from "path";
+import { readFileSync as readFileSync7 } from "fs";
+import { extname as extname2, isAbsolute as isAbsolute3, resolve as resolve15 } from "path";
 import process15 from "process";
 function getRuleSetting(rulesConfig, ruleId) {
-  const raw = rulesConfig[ruleId];
+  let raw = rulesConfig[ruleId];
+  if (raw === undefined) {
+    const slash = ruleId.indexOf("/");
+    if (slash > 0) {
+      const prefix = ruleId.slice(0, slash);
+      const name = ruleId.slice(slash + 1);
+      const altPrefix = prefix === "general" ? "pickier" : prefix === "pickier" ? "general" : null;
+      if (altPrefix)
+        raw = rulesConfig[`${altPrefix}/${name}`];
+      if (raw === undefined)
+        raw = rulesConfig[name];
+    }
+  }
   let sev;
   let opts;
   if (typeof raw === "string") {
@@ -27184,10 +28838,10 @@ async function loadConfigFromPath(pathLike) {
     } catch {}
     return mergeConfig(defaultConfig3, {});
   }
-  const abs = isAbsolute3(pathLike) ? pathLike : resolve14(process15.cwd(), pathLike);
-  const ext = extname(abs).toLowerCase();
+  const abs = isAbsolute3(pathLike) ? pathLike : resolve15(process15.cwd(), pathLike);
+  const ext = extname2(abs).toLowerCase();
   if (ext === ".json") {
-    const raw = readFileSync3(abs, "utf8");
+    const raw = readFileSync7(abs, "utf8");
     return mergeConfig(defaultConfig3, JSON.parse(raw));
   }
   const mod = await import(abs);
@@ -27245,7 +28899,7 @@ function shouldIgnorePath(absPath, ignoreGlobs) {
   return false;
 }
 var MAX_FIXER_PASSES = 5, ENV, UNIVERSAL_IGNORES, colors, _cachedDefaultConfig = null;
-var init_utils2 = __esm(async () => {
+var init_utils3 = __esm(async () => {
   await init_config();
   ENV = {
     get TRACE() {
@@ -27319,7 +28973,7 @@ var init_utils2 = __esm(async () => {
 });
 
 // src/formatter.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync8 } from "fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "fs";
 import { relative as relative6 } from "path";
 import process16 from "process";
 function getLogger() {
@@ -27362,7 +29016,7 @@ ${colors.bold(`\x1B[4m${filePath}\x1B[24m`)}
 `;
     let fileContent;
     try {
-      fileContent = readFileSync4(filePath, "utf8");
+      fileContent = readFileSync8(filePath, "utf8");
     } catch {
       for (const issue of fileIssues) {
         const sev = issue.severity === "error" ? colors.red("error") : colors.yellow("warn ");
@@ -27503,7 +29157,7 @@ async function runFormat(globs, options) {
   let checked = 0;
   for (const file of files) {
     trace("format start", relative6(process16.cwd(), file));
-    const src = readFileSync4(file, "utf8");
+    const src = readFileSync8(file, "utf8");
     const fmt = formatCode(src, cfg, file);
     if (options.check) {
       if (fmt !== src) {
@@ -27538,7 +29192,7 @@ var init_formatter = __esm(async () => {
   init_plugins();
   await __promiseAll([
     init_src(),
-    init_utils2()
+    init_utils3()
   ]);
 });
 
@@ -27577,6 +29231,9 @@ var init_yocto_queue = __esm(() => {
       }
       this.#head = this.#head.next;
       this.#size--;
+      if (!this.#head) {
+        this.#tail = undefined;
+      }
       return current.value;
     }
     peek() {
@@ -27610,13 +29267,20 @@ var init_yocto_queue = __esm(() => {
 
 // ../../node_modules/p-limit/index.js
 function pLimit(concurrency) {
+  let rejectOnClear = false;
+  if (typeof concurrency === "object") {
+    ({ concurrency, rejectOnClear = false } = concurrency);
+  }
   validateConcurrency(concurrency);
+  if (typeof rejectOnClear !== "boolean") {
+    throw new TypeError("Expected `rejectOnClear` to be a boolean");
+  }
   const queue = new Queue2;
   let activeCount = 0;
   const resumeNext = () => {
     if (activeCount < concurrency && queue.size > 0) {
       activeCount++;
-      queue.dequeue()();
+      queue.dequeue().run();
     }
   };
   const next = () => {
@@ -27631,16 +29295,18 @@ function pLimit(concurrency) {
     } catch {}
     next();
   };
-  const enqueue = (function_, resolve9, arguments_) => {
+  const enqueue = (function_, resolve9, reject, arguments_) => {
+    const queueItem = { reject };
     new Promise((internalResolve) => {
-      queue.enqueue(internalResolve);
+      queueItem.run = internalResolve;
+      queue.enqueue(queueItem);
     }).then(run.bind(undefined, function_, resolve9, arguments_));
     if (activeCount < concurrency) {
       resumeNext();
     }
   };
-  const generator = (function_, ...arguments_) => new Promise((resolve9) => {
-    enqueue(function_, resolve9, arguments_);
+  const generator = (function_, ...arguments_) => new Promise((resolve9, reject) => {
+    enqueue(function_, resolve9, reject, arguments_);
   });
   Object.defineProperties(generator, {
     activeCount: {
@@ -27651,7 +29317,14 @@ function pLimit(concurrency) {
     },
     clearQueue: {
       value() {
-        queue.clear();
+        if (!rejectOnClear) {
+          queue.clear();
+          return;
+        }
+        const abortError = AbortSignal.abort().reason;
+        while (queue.size > 0) {
+          queue.dequeue().reject(abortError);
+        }
       }
     },
     concurrency: {
@@ -27694,8 +29367,8 @@ __export(exports_linter, {
   lintText: () => lintText,
   applyPlugins: () => applyPlugins
 });
-import { readdirSync as readdirSync6, readFileSync as readFileSync5, statSync as statSync2, writeFileSync as writeFileSync9 } from "fs";
-import { isAbsolute as isAbsolute4, join as join7, relative as relative7, resolve as resolve15 } from "path";
+import { readdirSync as readdirSync6, readFileSync as readFileSync9, statSync as statSync2, writeFileSync as writeFileSync9 } from "fs";
+import { isAbsolute as isAbsolute4, join as join7, relative as relative7, resolve as resolve16 } from "path";
 import process17 from "process";
 function getLogger2() {
   if (!_logger2)
@@ -27753,7 +29426,7 @@ async function runLintProgrammatic(globs, options, signal) {
   const timeoutMs = ENV.TIMEOUT_MS;
   const isGlobbingOutsideProject = patterns.some((p) => {
     const base = p.replace(/\/?\*\*\/*\*\*?$/, "");
-    const absBase = isAbsolute4(base) ? base : resolve15(process17.cwd(), base);
+    const absBase = isAbsolute4(base) ? base : resolve16(process17.cwd(), base);
     return !absBase.startsWith(process17.cwd());
   });
   const globIgnores = isGlobbingOutsideProject ? [...UNIVERSAL_IGNORES] : cfg.ignores;
@@ -27763,7 +29436,7 @@ async function runLintProgrammatic(globs, options, signal) {
     try {
       const st = statSync2(patterns[0]);
       if (st.isFile()) {
-        const abs = isAbsolute4(patterns[0]) ? patterns[0] : resolve15(process17.cwd(), patterns[0]);
+        const abs = isAbsolute4(patterns[0]) ? patterns[0] : resolve16(process17.cwd(), patterns[0]);
         entries = [abs];
       }
     } catch {}
@@ -27771,7 +29444,7 @@ async function runLintProgrammatic(globs, options, signal) {
   const simpleDirPattern = patterns.length === 1 && /\*\*\/*\*$/.test(patterns[0]);
   if (!entries.length && simpleDirPattern) {
     const base = patterns[0].replace(/\/?\*\*\/*\*\*?$/, "");
-    const rootBase = isAbsolute4(base) ? base : resolve15(process17.cwd(), base);
+    const rootBase = isAbsolute4(base) ? base : resolve16(process17.cwd(), base);
     try {
       const stack = [rootBase];
       while (stack.length) {
@@ -27838,7 +29511,7 @@ async function runLintProgrammatic(globs, options, signal) {
   const processFile = async (file) => {
     if (signal?.aborted)
       throw new Error("AbortError");
-    const src = readFileSync5(file, "utf8");
+    const src = readFileSync9(file, "utf8");
     const suppress = parseDisableDirectives(src);
     const commentLines = getCommentLines(src);
     cfg._internalSkipPluginRulesInScan = true;
@@ -27863,6 +29536,16 @@ async function runLintProgrammatic(globs, options, signal) {
         });
       }
     } catch {}
+    {
+      const seen = new Set;
+      issues = issues.filter((i) => {
+        const key = `${i.line}:${i.column}:${i.ruleId}`;
+        if (seen.has(key))
+          return false;
+        seen.add(key);
+        return true;
+      });
+    }
     if (options.fix) {
       const dbgLine = /^\s*debugger\b/;
       let fixed = src;
@@ -28133,6 +29816,7 @@ async function applyPlugins(filePath, content, cfg) {
     }
   }
   const baseCtx = { filePath, config: cfg };
+  const executedRules = new Set;
   for (const plugin of pluginDefs) {
     const r = plugin.rules;
     for (const ruleName in r) {
@@ -28140,6 +29824,10 @@ async function applyPlugins(filePath, content, cfg) {
       const setting = getRuleSetting(rulesConfig, fullRuleId);
       if (!setting.enabled)
         continue;
+      if (executedRules.has(ruleName)) {
+        continue;
+      }
+      executedRules.add(ruleName);
       const rule = r[ruleName];
       const overrideSeverity = setting.severity;
       if (!rule || typeof rule.check !== "function") {
@@ -28258,7 +29946,7 @@ function stripRegexLiterals(line) {
   }
   return result;
 }
-function stripComments(line) {
+function stripComments2(line) {
   let result = "";
   let i = 0;
   let inString = null;
@@ -28349,17 +30037,92 @@ function getCommentLines(content) {
       }
       continue;
     }
-    if ((state === "string-single" || state === "string-double" || state === "string-template") && prev === "\\") {
-      continue;
-    }
     switch (state) {
       case "code":
         if (ch === "/" && next === "/") {
           state = "line-comment";
           i++;
         } else if (ch === "/" && next === "*") {
-          state = "block-comment";
-          i++;
+          let isRegex = false;
+          if (i > 0) {
+            let k = i - 1;
+            while (k > 0 && (content[k] === " " || content[k] === "\t"))
+              k--;
+            const bc = content[k];
+            if ("=([{,;!&|?:~^%+-".includes(bc) && bc !== `
+`) {
+              isRegex = true;
+            } else if (/[a-z]/.test(bc)) {
+              const slice = content.slice(Math.max(0, k - 6), k + 1);
+              if (/\b(?:return|case|typeof|void|in|of|new|throw|delete)$/.test(slice)) {
+                isRegex = true;
+              }
+            }
+          }
+          if (isRegex) {
+            lineHasCode = true;
+            i++;
+            while (i < content.length) {
+              if (content[i] === "\\") {
+                i += 2;
+                continue;
+              }
+              if (content[i] === "/") {
+                i++;
+                break;
+              }
+              if (content[i] === `
+`)
+                break;
+              i++;
+            }
+            while (i < content.length && /[gimsuy]/.test(content[i]))
+              i++;
+            i--;
+          } else {
+            state = "block-comment";
+            i++;
+          }
+        } else if (ch === "/" && next !== undefined) {
+          let isRegex = false;
+          if (i > 0) {
+            let k = i - 1;
+            while (k > 0 && (content[k] === " " || content[k] === "\t"))
+              k--;
+            const bc = content[k];
+            if ("=([{,;!&|?:~^%+-".includes(bc) || bc === `
+`) {
+              isRegex = true;
+            } else if (/[a-z]/.test(bc)) {
+              const slice = content.slice(Math.max(0, k - 6), k + 1);
+              if (/\b(?:return|case|typeof|void|in|of|new|throw|delete)$/.test(slice)) {
+                isRegex = true;
+              }
+            }
+          }
+          if (isRegex) {
+            lineHasCode = true;
+            i++;
+            while (i < content.length) {
+              if (content[i] === "\\") {
+                i += 2;
+                continue;
+              }
+              if (content[i] === "/") {
+                i++;
+                break;
+              }
+              if (content[i] === `
+`)
+                break;
+              i++;
+            }
+            while (i < content.length && /[gimsuy]/.test(content[i]))
+              i++;
+            i--;
+          } else {
+            lineHasCode = true;
+          }
         } else if (ch === "'") {
           state = "string-single";
           lineHasCode = true;
@@ -28374,19 +30137,28 @@ function getCommentLines(content) {
         }
         break;
       case "string-single":
-        if (ch === "'") {
-          state = "code";
+        if (ch === "\\") {
+          i++;
+          break;
         }
+        if (ch === "'")
+          state = "code";
         break;
       case "string-double":
-        if (ch === '"') {
-          state = "code";
+        if (ch === "\\") {
+          i++;
+          break;
         }
+        if (ch === '"')
+          state = "code";
         break;
       case "string-template":
-        if (ch === "`") {
-          state = "code";
+        if (ch === "\\") {
+          i++;
+          break;
         }
+        if (ch === "`")
+          state = "code";
         break;
       case "line-comment":
         break;
@@ -28410,7 +30182,9 @@ function scanContentOptimized(filePath, content, cfg, suppress, commentLines) {
   const lines = content.split(/\r?\n/);
   const preferredQuotes = cfg.format.quotes;
   const fileExt = filePath.split(".").pop()?.toLowerCase() ?? "";
-  const skipQuotesCheck = fileExt === "json" || fileExt === "jsonc" || fileExt === "lock" || fileExt === "md" || fileExt === "yaml" || fileExt === "yml" || filePath.endsWith("bun.lock");
+  const isMd = fileExt === "md";
+  const skipQuotesCheck = fileExt === "json" || fileExt === "jsonc" || fileExt === "lock" || isMd || fileExt === "yaml" || fileExt === "yml" || filePath.endsWith("bun.lock");
+  const skipCodeRules = isMd || fileExt === "yaml" || fileExt === "yml" || fileExt === "json" || fileExt === "jsonc";
   let quotesReported = false;
   const sevMap = (s) => s === "warn" ? "warning" : s === "error" ? "error" : undefined;
   const wantDebugger = sevMap(cfg.rules.noDebugger);
@@ -28423,7 +30197,7 @@ function scanContentOptimized(filePath, content, cfg, suppress, commentLines) {
   if (fileExt === "md") {
     let inFence = false;
     for (let li = 0;li < lines.length; li++) {
-      if (/^(`{3,}|~{3,})/.test(lines[li].trim())) {
+      if (/^(?:`{3,}|~{3,})/.test(lines[li].trim())) {
         inFence = !inFence;
         continue;
       }
@@ -28468,7 +30242,7 @@ function scanContentOptimized(filePath, content, cfg, suppress, commentLines) {
       continue;
     }
     if (!skipQuotesCheck && !linesInTemplate.has(lineNo)) {
-      const strippedLine = stripComments(stripRegexLiterals(line));
+      const strippedLine = stripComments2(stripRegexLiterals(line));
       const indices = detectQuoteIssues(strippedLine, preferredQuotes);
       if (indices.length > 0 && !quotesReported) {
         if (!isSuppressed("quotes", lineNo, suppress)) {
@@ -28483,11 +30257,11 @@ function scanContentOptimized(filePath, content, cfg, suppress, commentLines) {
       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` });
     }
-    if (wantDebugger && debuggerStmt.test(line)) {
+    if (!skipCodeRules && wantDebugger && debuggerStmt.test(line)) {
       if (!isSuppressed("no-debugger", lineNo, suppress))
         issues.push({ filePath, line: lineNo, column: 1, ruleId: "no-debugger", message: "Unexpected debugger statement", severity: wantDebugger, help: "Remove debugger statements before committing code. Use breakpoints in your IDE instead, or run with --fix to auto-remove" });
     }
-    if (wantConsole && !linesInTemplate.has(lineNo) && consoleCall.test(line)) {
+    if (!skipCodeRules && wantConsole && !linesInTemplate.has(lineNo) && consoleCall.test(line)) {
       const commentIdx = line.indexOf("//");
       const consoleIdx = line.indexOf("console.");
       if (commentIdx !== -1 && consoleIdx > commentIdx) {} else {
@@ -28552,9 +30326,9 @@ function scanContentOptimized(filePath, content, cfg, suppress, commentLines) {
         prev = ch;
       }
     }
-    if (wantNoCondAssign && !linesInTemplate.has(lineNo)) {
-      const strippedLine = stripComments(stripRegexLiterals(line));
-      const checkCond = (cond) => /[^=!<>]=(?![=>])/.test(cond);
+    if (!skipCodeRules && wantNoCondAssign && !linesInTemplate.has(lineNo)) {
+      const strippedLine = stripComments2(stripRegexLiterals(line));
+      const checkCond = (cond) => /[^=!<>]=(?![=>])/.test(cond.replace(/'[^']*'|"[^"]*"/g, '""'));
       const m1 = strippedLine.match(/\b(?:if|while)\s*\(([^)]*)\)/);
       if (m1) {
         const cond = m1[1];
@@ -28620,12 +30394,16 @@ function scanContent(filePath, content, cfg) {
         return;
       };
       const ctx = { filePath, config: cfg };
+      const executedRulesInScan = new Set;
       for (const plugin of pluginDefs) {
         const r = plugin.rules;
         for (const ruleName in r) {
           const fullRuleId = `${plugin.name}/${ruleName}`;
           if (!isRuleEnabled(fullRuleId))
             continue;
+          if (executedRulesInScan.has(ruleName))
+            continue;
+          executedRulesInScan.add(ruleName);
           const rule = r[ruleName];
           if (!rule || typeof rule.check !== "function")
             continue;
@@ -28669,7 +30447,7 @@ async function runLint(globs, options) {
       getLogger2().info(`[pickier:diagnostics] Glob timeout: ${timeoutMs}ms`);
     const isGlobbingOutsideProject = patterns.some((p) => {
       const base = p.replace(/\/?\*\*\/*\*\*?$/, "");
-      const absBase = isAbsolute4(base) ? base : resolve15(process17.cwd(), base);
+      const absBase = isAbsolute4(base) ? base : resolve16(process17.cwd(), base);
       return !absBase.startsWith(process17.cwd());
     });
     const globIgnores = isGlobbingOutsideProject ? [...UNIVERSAL_IGNORES] : cfg.ignores;
@@ -28686,7 +30464,7 @@ async function runLint(globs, options) {
       try {
         const st = statSync2(patterns[0]);
         if (st.isFile()) {
-          const abs = isAbsolute4(patterns[0]) ? patterns[0] : resolve15(process17.cwd(), patterns[0]);
+          const abs = isAbsolute4(patterns[0]) ? patterns[0] : resolve16(process17.cwd(), patterns[0]);
           entries = [abs];
         }
       } catch {}
@@ -28697,7 +30475,7 @@ async function runLint(globs, options) {
       if (enableDiagnostics)
         getLogger2().info(`[pickier:diagnostics] Using fast directory scan for: ${base}`);
       try {
-        const rootBase = isAbsolute4(base) ? base : resolve15(process17.cwd(), base);
+        const rootBase = isAbsolute4(base) ? base : resolve16(process17.cwd(), base);
         const stack = [rootBase];
         let dirCount = 0;
         while (stack.length) {
@@ -28813,7 +30591,7 @@ async function runLint(globs, options) {
         if (processedCount === 1 || processedCount % 10 === 0 || processedCount === files.length)
           getLogger2().info(`[pickier:diagnostics] Processing file ${processedCount}/${files.length}: ${relative7(process17.cwd(), file)}`);
       }
-      const src = readFileSync5(file, "utf8");
+      const src = readFileSync9(file, "utf8");
       if (formatOnly) {
         const fixed = formatCode(src, cfg, file);
         if (fixed !== src && !options.dryRun) {
@@ -28822,7 +30600,8 @@ async function runLint(globs, options) {
         return [];
       }
       const suppress = parseDisableDirectives(src);
-      const commentLines = getCommentLines(src);
+      const isCodeFileForComments = /\.(?:ts|js|tsx|jsx|mts|mjs|cts|cjs)$/.test(file);
+      const commentLines = isCodeFileForComments ? getCommentLines(src) : new Set;
       cfg._internalSkipPluginRulesInScan = true;
       let issues = scanContentOptimized(file, src, cfg, suppress, commentLines);
       try {
@@ -28843,6 +30622,16 @@ async function runLint(globs, options) {
           });
         }
       } catch {}
+      {
+        const seen = new Set;
+        issues = issues.filter((i) => {
+          const key = `${i.line}:${i.column}:${i.ruleId}`;
+          if (seen.has(key))
+            return false;
+          seen.add(key);
+          return true;
+        });
+      }
       if (options.fix) {
         const dbgLine = /^\s*debugger\b/;
         let fixed = src;
@@ -28964,28 +30753,34 @@ var init_linter = __esm(async () => {
   await __promiseAll([
     init_src(),
     init_formatter(),
-    init_utils2()
+    init_utils3()
   ]);
 });
 
+// src/index.ts
+await __promiseAll([
+  init_config(),
+  init_formatter(),
+  init_linter()
+]);
+init_format();
+
 // src/run.ts
-var exports_run = {};
-__export(exports_run, {
-  runUnified: () => runUnified
-});
-import { readFileSync as readFileSync6, statSync as statSync3, writeFileSync as writeFileSync10 } from "fs";
-import { isAbsolute as isAbsolute5, resolve as resolve16 } from "path";
+init_format();
+await init_utils3();
+import { readFileSync as readFileSync10, statSync as statSync3, writeFileSync as writeFileSync10 } from "fs";
+import { isAbsolute as isAbsolute5, resolve as resolve17 } from "path";
 import process18 from "process";
 async function runUnified(globs, options) {
   const mode = options.mode || "auto";
   if (mode === "format" && globs.length === 1 && !/[*?[\]{}()!]/.test(globs[0])) {
     try {
       const p = globs[0];
-      const filePath = isAbsolute5(p) ? p : resolve16(process18.cwd(), p);
+      const filePath = isAbsolute5(p) ? p : resolve17(process18.cwd(), p);
       const st = statSync3(filePath);
       if (st.isFile()) {
         const cfg = await loadConfigFromPath(options.config);
-        const src = readFileSync6(filePath, "utf8");
+        const src = readFileSync10(filePath, "utf8");
         const fmt = formatCode(src, cfg, filePath);
         if (options.write && fmt !== src) {
           writeFileSync10(filePath, fmt, "utf8");
@@ -29017,20 +30812,9 @@ async function runUnified(globs, options) {
   };
   return runLint2(globs, lintOpts);
 }
-var init_run = __esm(async () => {
-  init_format();
-  await init_utils2();
-});
 
 // src/index.ts
-await __promiseAll([
-  init_config(),
-  init_formatter(),
-  init_linter(),
-  init_run()
-]);
-init_format();
-init_utils2();
+init_utils3();
 export {
   yellow5 as yellow,
   shouldIgnorePath,