@jpeakai/mermaidjs-lint 0.7.1 → 0.7.2

package/dist/bin.js

@@ -9,7 +9,7 @@ import { parseArgs } from "node:util";
 // package.json
 var package_default = {
   name: "@jpeakai/mermaidjs-lint",
-  version: "0.7.1",
+  version: "0.7.2",
   type: "module",
   description: "Deterministic lint gates and verified fixers for Mermaid diagrams in markdown",
   license: "MIT",
@@ -329,7 +329,7 @@ var parseProperties = (raw, rawStart, line) => {
     const key = pair.slice(0, colon).trim().toLowerCase();
     const valueRaw = pair.slice(colon + 1);
     const value = valueRaw.trim();
-    if (!key || !value)
+    if (!(key && value))
       continue;
     properties[key] = value;
     const lead = valueRaw.length - valueRaw.trimStart().length;
@@ -484,7 +484,7 @@ var parserReason = (err) => {
 `);
   if (message.startsWith("No diagram type detected"))
     return (lines[0] ?? "").trim();
-  return lines.filter((line, i) => !POINTER.test(line.trim()) && !POINTER.test((lines[i + 1] ?? "").trim())).join(" ").replace(/\s+/g, " ").trim();
+  return lines.filter((line, i) => !(POINTER.test(line.trim()) || POINTER.test((lines[i + 1] ?? "").trim()))).join(" ").replace(/\s+/g, " ").trim();
 };
 async function langiumParseAny(type, content) {
   switch (type) {
@@ -515,80 +515,7 @@ async function extractLangiumStats(content, keyword) {
   if (!mapped)
     throw new Error(`not a langium keyword: ${keyword}`);
   const ast = await langiumParseAny(mapped, content);
-  const nodeIds = [];
-  const subgraphNames = [];
-  let edges = 0;
-  let maxDepth = 0;
-  let treeDepth = 0;
-  switch (mapped) {
-    case "architecture": {
-      const services = ast.services ?? [];
-      const groups = ast.groups ?? [];
-      const edgeArr = ast.edges ?? [];
-      nodeIds.push(...services.map((s) => s.id ?? ""));
-      subgraphNames.push(...groups.map((g) => g.title ?? g.id ?? ""));
-      maxDepth = architectureDepth(groups);
-      edges = edgeArr.length;
-      break;
-    }
-    case "pie": {
-      const sections = ast.sections ?? [];
-      nodeIds.push(...sections.map((s, i) => s.label ?? `slice_${i}`));
-      break;
-    }
-    case "packet": {
-      const blocks = ast.blocks ?? [];
-      nodeIds.push(...blocks.map((_, i) => `block_${i}`));
-      break;
-    }
-    case "gitGraph": {
-      const statements = ast.statements ?? [];
-      for (const s of statements) {
-        if (s.$type === "Commit")
-          nodeIds.push(s.id ?? `commit_${nodeIds.length}`);
-        else if (s.$type === "Branch")
-          subgraphNames.push(s.name ?? `branch_${subgraphNames.length}`);
-        else if (s.$type === "Merge")
-          edges++;
-      }
-      break;
-    }
-    case "radar": {
-      const axes = ast.axes ?? [];
-      const curves = ast.curves ?? [];
-      nodeIds.push(...axes.map((a, i) => a.name ?? `axis_${i}`));
-      nodeIds.push(...curves.map((c, i) => c.name ?? `curve_${i}`));
-      edges = axes.length * curves.length;
-      break;
-    }
-    case "treeView": {
-      const nodes = ast.nodes ?? [];
-      const stats = indentTreeStats(nodes.map((n, i) => ({ label: n.name ?? `node_${i}`, indent: n.indent ?? 0 })));
-      nodeIds.push(...stats.labels);
-      edges = stats.edges;
-      treeDepth = stats.depth;
-      break;
-    }
-    case "treemap": {
-      const rows = ast.TreemapRows ?? [];
-      const stats = indentTreeStats(rows.map((r, i) => ({ label: r.item?.name ?? `row_${i}`, indent: r.indent ?? 0 })));
-      nodeIds.push(...stats.labels);
-      edges = stats.edges;
-      treeDepth = stats.depth;
-      break;
-    }
-    case "wardley": {
-      const components = ast.components ?? [];
-      const anchors = ast.anchors ?? [];
-      const links = ast.links ?? [];
-      nodeIds.push(...anchors.map((a, i) => a.name ?? `anchor_${i}`));
-      nodeIds.push(...components.map((c, i) => c.name ?? `comp_${i}`));
-      edges = links.length;
-      break;
-    }
-    case "info":
-      break;
-  }
+  const { nodeIds, edges, subgraphNames, maxDepth, treeDepth = 0 } = LANGIUM_ADAPTERS[mapped](ast);
   return {
     nodes: new Set(nodeIds.filter(Boolean)).size,
     edges,
@@ -602,6 +529,85 @@ async function extractLangiumStats(content, keyword) {
     error: null
   };
 }
+var LANGIUM_ADAPTERS = {
+  architecture: adaptLangiumArchitecture,
+  info: adaptLangiumInfo,
+  pie: adaptLangiumPie,
+  gitGraph: adaptLangiumGitGraph,
+  packet: adaptLangiumPacket,
+  radar: adaptLangiumRadar,
+  treemap: adaptLangiumTreemap,
+  treeView: adaptLangiumTreeView,
+  wardley: adaptLangiumWardley
+};
+function adaptLangiumArchitecture(ast) {
+  const services = ast.services ?? [];
+  const groups = ast.groups ?? [];
+  const edgeArr = ast.edges ?? [];
+  return {
+    nodeIds: services.map((s) => s.id ?? ""),
+    edges: edgeArr.length,
+    subgraphNames: groups.map((g) => g.title ?? g.id ?? ""),
+    maxDepth: architectureDepth(groups)
+  };
+}
+function adaptLangiumInfo() {
+  return { nodeIds: [], edges: 0, subgraphNames: [], maxDepth: 0 };
+}
+function adaptLangiumPie(ast) {
+  const sections = ast.sections ?? [];
+  return { nodeIds: sections.map((s, i) => s.label ?? `slice_${i}`), edges: 0, subgraphNames: [], maxDepth: 0 };
+}
+function adaptLangiumPacket(ast) {
+  const blocks = ast.blocks ?? [];
+  return { nodeIds: blocks.map((_, i) => `block_${i}`), edges: 0, subgraphNames: [], maxDepth: 0 };
+}
+function adaptLangiumGitGraph(ast) {
+  const statements = ast.statements ?? [];
+  const nodeIds = [];
+  const subgraphNames = [];
+  let edges = 0;
+  for (const s of statements) {
+    if (s.$type === "Commit")
+      nodeIds.push(s.id ?? `commit_${nodeIds.length}`);
+    else if (s.$type === "Branch")
+      subgraphNames.push(s.name ?? `branch_${subgraphNames.length}`);
+    else if (s.$type === "Merge")
+      edges++;
+  }
+  return { nodeIds, edges, subgraphNames, maxDepth: 0 };
+}
+function adaptLangiumRadar(ast) {
+  const axes = ast.axes ?? [];
+  const curves = ast.curves ?? [];
+  return {
+    nodeIds: [...axes.map((a, i) => a.name ?? `axis_${i}`), ...curves.map((c, i) => c.name ?? `curve_${i}`)],
+    edges: axes.length * curves.length,
+    subgraphNames: [],
+    maxDepth: 0
+  };
+}
+function adaptLangiumTreeView(ast) {
+  const nodes = ast.nodes ?? [];
+  const stats = indentTreeStats(nodes.map((n, i) => ({ label: n.name ?? `node_${i}`, indent: n.indent ?? 0 })));
+  return { nodeIds: stats.labels, edges: stats.edges, subgraphNames: [], maxDepth: 0, treeDepth: stats.depth };
+}
+function adaptLangiumTreemap(ast) {
+  const rows = ast.TreemapRows ?? [];
+  const stats = indentTreeStats(rows.map((r, i) => ({ label: r.item?.name ?? `row_${i}`, indent: r.indent ?? 0 })));
+  return { nodeIds: stats.labels, edges: stats.edges, subgraphNames: [], maxDepth: 0, treeDepth: stats.depth };
+}
+function adaptLangiumWardley(ast) {
+  const components = ast.components ?? [];
+  const anchors = ast.anchors ?? [];
+  const links = ast.links ?? [];
+  return {
+    nodeIds: [...anchors.map((a, i) => a.name ?? `anchor_${i}`), ...components.map((c, i) => c.name ?? `comp_${i}`)],
+    edges: links.length,
+    subgraphNames: [],
+    maxDepth: 0
+  };
+}
 function architectureDepth(groups) {
   const parentOf = new Map;
   for (const g of groups)
@@ -1025,7 +1031,7 @@ var buildDocModel = (src, kind = "markdown") => {
   collectMermaid(tree, fences);
   const diagrams = fences.flatMap((node, index) => {
     const { start, end } = node.position ?? {};
-    if (!start || !end || start.offset === undefined || end.offset === undefined)
+    if (!(start && end) || start.offset === undefined || end.offset === undefined)
       return [];
     return [
       makeDiagram(src, lineStarts, {
@@ -1092,72 +1098,71 @@ var scorePair = (kind, d, fg, bg) => {
   };
 };
 var message = (err) => err instanceof Error ? err.message : String(err);
-var scoreEdgeLabel = (d, canvas, pairs, skipped) => {
+var skip = (out, d, reason, blocking) => {
+  out.skipped.push({ selector: d.selector, line: d.line, reason, ...blocking && { blocking } });
+};
+var scoreEdgeLabel = (d, canvas, out) => {
   const { color } = d.properties;
   if (!color)
     return;
   try {
-    pairs.push(...THEMES.map((t) => scoreHostPair("text", d, t, color, edgeLabelBackground(t, canvas))));
+    out.pairs.push(...THEMES.map((t) => scoreHostPair("text", d, t, { fg: color, bg: edgeLabelBackground(t, canvas) })));
   } catch (err) {
-    skipped.push({
-      selector: d.selector,
-      line: d.line,
-      reason: `edge label text unparseable: ${message(err)}`,
-      blocking: true
-    });
+    skip(out, d, `edge label text unparseable: ${message(err)}`, true);
+  }
+};
+var githubBoxes = (fill, alpha, canvas) => alpha < 1 ? THEMES.map((t) => [compositeOver(fill, canvas[t]), t]) : [[fill, undefined]];
+var scoreGithubPair = (out, d, kind, { fg, bg, theme }) => {
+  try {
+    out.pairs.push({ ...scorePair(kind, d, fg, bg), ...theme && { theme } });
+  } catch (err) {
+    skip(out, d, `${kind} pair unparseable: ${message(err)}`, true);
+  }
+};
+var fillAlpha = (out, d, fill) => {
+  try {
+    return alphaOf(fill);
+  } catch (err) {
+    skip(out, d, `fill unparseable: ${message(err)}`, true);
+    return null;
+  }
+};
+var scoreGithubStyle = (d, canvas, out) => {
+  const { fill, color, stroke } = d.properties;
+  if (!fill) {
+    const reason = color || stroke ? "no fill declared, so text and border contrast have no anchor" : "no color properties";
+    skip(out, d, reason);
+    return;
+  }
+  const alpha = fillAlpha(out, d, fill);
+  if (alpha === null)
+    return;
+  if (alpha === 0) {
+    skip(out, d, "fill is fully transparent, so there is no box to anchor contrast");
+    return;
+  }
+  const boxes = githubBoxes(fill, alpha, canvas);
+  if (!color) {
+    skip(out, d, "no color: declared beside fill:, and the github profile requires one " + "(if the host forces label text, use the mkdocs-material profile)", true);
+  }
+  for (const [bg, theme] of boxes) {
+    if (color)
+      scoreGithubPair(out, d, "text", { fg: color, bg, theme });
+    if (stroke)
+      scoreGithubPair(out, d, "border", { fg: stroke, bg, theme });
   }
 };
 var scoreGithub = (directives, canvas = GITHUB_CANVAS) => {
-  const pairs = [];
-  const skipped = [];
+  const out = { pairs: [], skipped: [] };
   for (const d of directives) {
     if (d.kind === "linkStyle")
-      scoreEdgeLabel(d, canvas, pairs, skipped);
-    if (d.kind !== "classDef" && d.kind !== "style")
-      continue;
-    const { fill, color, stroke } = d.properties;
-    const note = (reason, blocking) => {
-      skipped.push({ selector: d.selector, line: d.line, reason, ...blocking && { blocking } });
-    };
-    if (!fill) {
-      note(color || stroke ? "no fill declared, so text and border contrast have no anchor" : "no color properties");
-      continue;
-    }
-    let alpha;
-    try {
-      alpha = alphaOf(fill);
-    } catch (err) {
-      note(`fill unparseable: ${message(err)}`, true);
-      continue;
-    }
-    if (alpha === 0) {
-      note("fill is fully transparent, so there is no box to anchor contrast");
-      continue;
-    }
-    const boxes = alpha < 1 ? THEMES.map((t) => [compositeOver(fill, canvas[t]), t]) : [[fill, undefined]];
-    if (!color) {
-      note("no color: declared beside fill:, and the github profile requires one " + "(if the host forces label text, use the mkdocs-material profile)", true);
-    }
-    for (const [box, theme] of boxes) {
-      if (color) {
-        try {
-          pairs.push({ ...scorePair("text", d, color, box), ...theme && { theme } });
-        } catch (err) {
-          note(`text pair unparseable: ${message(err)}`, true);
-        }
-      }
-      if (stroke) {
-        try {
-          pairs.push({ ...scorePair("border", d, stroke, box), ...theme && { theme } });
-        } catch (err) {
-          note(`border pair unparseable: ${message(err)}`, true);
-        }
-      }
-    }
+      scoreEdgeLabel(d, canvas, out);
+    if (d.kind === "classDef" || d.kind === "style")
+      scoreGithubStyle(d, canvas, out);
   }
-  return { pairs, skipped };
+  return out;
 };
-var scoreHostPair = (kind, d, theme, fgRaw, box) => {
+var scoreHostPair = (kind, d, theme, { fg: fgRaw, bg: box }) => {
   const fg = compositeOver(fgRaw, box);
   const assessment = wcagAssess(fg, box);
   return {
@@ -1173,99 +1178,83 @@ var scoreHostPair = (kind, d, theme, fgRaw, box) => {
     advisory: kind === "border"
   };
 };
-var scoreMkdocs = (directives) => {
-  const pairs = [];
-  const skipped = [];
-  for (const d of directives) {
-    if (d.kind === "linkStyle" && d.properties.color) {
-      skipped.push({
-        selector: d.selector,
-        line: d.line,
-        reason: "color: ignored, because the host theme forces edge label text"
-      });
-    }
-    if (d.kind !== "classDef" && d.kind !== "style")
-      continue;
-    const { fill, stroke, color } = d.properties;
-    const note = (reason) => {
-      skipped.push({ selector: d.selector, line: d.line, reason });
-    };
-    if (!fill) {
-      note("no fill declared, and the host theme controls the text");
-      continue;
+var scoreMkdocsStyle = (d, out) => {
+  const { fill, stroke, color } = d.properties;
+  if (!fill) {
+    skip(out, d, "no fill declared, and the host theme controls the text");
+    return;
+  }
+  if (color)
+    skip(out, d, "color: ignored, because the host theme forces label text");
+  for (const theme of THEMES) {
+    let box;
+    try {
+      box = compositeOver(fill, MKDOCS_MATERIAL[theme].bg);
+    } catch (err) {
+      skip(out, d, `fill unparseable: ${message(err)}`, true);
+      break;
     }
-    if (color)
-      note("color: ignored, because the host theme forces label text");
-    for (const theme of THEMES) {
-      let box;
+    out.pairs.push(scoreHostPair("text", d, theme, { fg: MKDOCS_MATERIAL[theme].text, bg: box }));
+    if (stroke) {
       try {
-        box = compositeOver(fill, MKDOCS_MATERIAL[theme].bg);
+        out.pairs.push(scoreHostPair("border", d, theme, { fg: stroke, bg: box }));
       } catch (err) {
-        skipped.push({
-          selector: d.selector,
-          line: d.line,
-          reason: `fill unparseable: ${message(err)}`,
-          blocking: true
-        });
-        break;
-      }
-      pairs.push(scoreHostPair("text", d, theme, MKDOCS_MATERIAL[theme].text, box));
-      if (stroke) {
-        try {
-          pairs.push(scoreHostPair("border", d, theme, stroke, box));
-        } catch (err) {
-          skipped.push({
-            selector: d.selector,
-            line: d.line,
-            reason: `border pair unparseable: ${message(err)}`,
-            blocking: true
-          });
-        }
+        skip(out, d, `border pair unparseable: ${message(err)}`, true);
       }
     }
   }
-  return { pairs, skipped };
+};
+var scoreMkdocs = (directives) => {
+  const out = { pairs: [], skipped: [] };
+  for (const d of directives) {
+    if (d.kind === "linkStyle" && d.properties.color) {
+      skip(out, d, "color: ignored, because the host theme forces edge label text");
+    }
+    if (d.kind === "classDef" || d.kind === "style")
+      scoreMkdocsStyle(d, out);
+  }
+  return out;
+};
+var erRows = (theme, fill) => {
+  const anchor = MERMAID_ER[theme];
+  return [
+    ["odd", anchor.odd],
+    ["even", fill ? compositeOver(fill, anchor.even) : anchor.even]
+  ];
+};
+var erPairs = (d) => {
+  const { fill, color, stroke } = d.properties;
+  const scored = [];
+  const score = (kind, theme, row, colours) => {
+    scored.push({ ...scoreHostPair(kind, d, theme, colours), row, advisory: kind === "border" });
+  };
+  for (const theme of THEMES) {
+    for (const [row, bg] of erRows(theme, fill)) {
+      if (color || row === "even" && fill)
+        score("text", theme, row, { fg: color ?? MERMAID_ER[theme].label, bg });
+      if (stroke)
+        score("border", theme, row, { fg: stroke, bg });
+    }
+  }
+  return scored;
 };
 var scoreEr = (directives) => {
-  const pairs = [];
-  const skipped = [];
+  const out = { pairs: [], skipped: [] };
   for (const d of directives) {
     if (d.kind !== "classDef" && d.kind !== "style")
       continue;
     const { fill, color, stroke } = d.properties;
-    if (!fill && !color && !stroke) {
-      skipped.push({ selector: d.selector, line: d.line, reason: "no color properties" });
+    if (!(fill || color || stroke)) {
+      skip(out, d, "no color properties");
       continue;
     }
-    const scored = [];
-    const score = (kind, theme, row, fg, bg) => {
-      scored.push({ ...scoreHostPair(kind, d, theme, fg, bg), row, advisory: kind === "border" });
-    };
     try {
-      for (const theme of THEMES) {
-        const anchor = MERMAID_ER[theme];
-        const rows = [
-          ["odd", anchor.odd],
-          ["even", fill ? compositeOver(fill, anchor.even) : anchor.even]
-        ];
-        for (const [row, bg] of rows) {
-          if (color || row === "even" && fill)
-            score("text", theme, row, color ?? anchor.label, bg);
-          if (stroke)
-            score("border", theme, row, stroke, bg);
-        }
-      }
-      pairs.push(...scored);
+      out.pairs.push(...erPairs(d));
     } catch (err) {
-      skipped.push({
-        selector: d.selector,
-        line: d.line,
-        reason: `erDiagram pair unparseable: ${message(err)}`,
-        blocking: true
-      });
+      skip(out, d, `erDiagram pair unparseable: ${message(err)}`, true);
     }
   }
-  return { pairs, skipped };
+  return out;
 };
 var scoreForProfile = (directives, profile, keyword, canvas = GITHUB_CANVAS) => {
   if (profile === "mkdocs-material")
@@ -1307,9 +1296,7 @@ var themeVariable = (selector, line) => ({
   spans: {},
   line
 });
-var scoreSequence = async (source, profile, canvas = GITHUB_CANVAS) => {
-  const pairs = [];
-  const skipped = [];
+var sequenceLines = (source) => {
   const lines = source.split(`
 `);
   const keywordLine = lines.findIndex((l) => /^\s*sequenceDiagram\b/.test(l)) + 1;
@@ -1317,94 +1304,125 @@ var scoreSequence = async (source, profile, canvas = GITHUB_CANVAS) => {
     const found = lines.findLastIndex((l) => new RegExp(`\\b${key}["']?\\s*:`).test(l));
     return found < 0 ? keywordLine : found + 1;
   };
-  const rectLines = lines.flatMap((l, i) => /^\s*rect\s/.test(l) ? [i + 1] : []);
-  const mermaid = await getMermaidCore();
-  let config;
-  let db;
+  return { lineOf, rectLines: lines.flatMap((l, i) => /^\s*rect\s/.test(l) ? [i + 1] : []) };
+};
+var parseSequence = async (mermaid, source) => {
   try {
-    config = (await mermaid.parse(source)).config;
-    db = (await mermaid.mermaidAPI.getDiagramFromText(source)).db;
+    const { config } = await mermaid.parse(source);
+    const { db } = await mermaid.mermaidAPI.getDiagramFromText(source);
+    return { config, db };
   } catch {
-    return { pairs, skipped };
+    return null;
+  }
+};
+var unmodelled = (config) => {
+  if (config.themeCSS !== undefined) {
+    return { selector: "themeCSS", reason: "themeCSS restyles the diagram with CSS the audit cannot model" };
   }
-  const block = (selector, reason) => {
-    skipped.push({ selector, line: lineOf(selector), reason, blocking: true });
-    return { pairs, skipped };
-  };
-  if (config.themeCSS !== undefined)
-    return block("themeCSS", "themeCSS restyles the diagram with CSS the audit cannot model");
   const pinned = config.theme;
   if (pinned !== undefined && !SEQUENCE_THEMES.includes(String(pinned))) {
-    return block("theme", `the ${String(pinned)} theme is not modelled, only ${SEQUENCE_THEMES.join(", ")}`);
+    return {
+      selector: "theme",
+      reason: `the ${String(pinned)} theme is not modelled, only ${SEQUENCE_THEMES.join(", ")}`
+    };
   }
+  return null;
+};
+var sequenceThemes = (pinned, host) => {
+  const theme = (fallback) => pinned === undefined ? fallback : String(pinned);
+  return { light: theme("default"), dark: theme(host ? "default" : "dark") };
+};
+var sequencePair = ({ theme: t, page, vars, host, lineOf, out }) => (kind, fgKey, bg, { suffix = "", at } = {}) => {
+  const color = (key) => {
+    const value = vars[key];
+    if (typeof value !== "string")
+      throw new Error(`${key} is not a resolved colour`);
+    return value;
+  };
+  const selector = fgKey + suffix;
+  const line = at ?? lineOf(fgKey);
+  try {
+    const box = compositeOver("key" in bg ? color(bg.key) : bg.colour, page);
+    out.pairs.push({
+      ...scoreHostPair(kind, themeVariable(selector, line), t, { fg: color(fgKey), bg: box }),
+      advisory: host
+    });
+  } catch (err) {
+    out.skipped.push({ selector, line, reason: `${t} sequence pair unparseable: ${message(err)}`, blocking: true });
+  }
+};
+var scoreHostSequence = (pair, page, features) => {
+  const onPage = { colour: page };
+  pair("border", "actorLineColor", onPage);
+  pair("border", "signalColor", onPage, { suffix: " (arrowhead)" });
+  if (features.activation)
+    pair("border", "activationBorderColor", { key: "activationBkgColor" });
+};
+var scoreAuthorSequence = (pair, page, features, rectLines) => {
+  const onPage = { colour: page };
+  pair("text", "actorTextColor", { key: "actorBkg" });
+  pair("border", "actorBorder", { key: "actorBkg" });
+  if (features.humanActor) {
+    pair("text", "actorTextColor", onPage, { suffix: " (human actor label)" });
+    pair("border", "actorBorder", onPage, { suffix: " (human actor glyph)" });
+  }
+  pair("border", "actorLineColor", onPage);
+  pair("text", "signalTextColor", onPage);
+  pair("border", "signalColor", onPage);
+  if (features.note)
+    pair("text", "noteTextColor", { key: "noteBkgColor" });
+  if (features.frame) {
+    pair("text", "labelTextColor", { key: "labelBoxBkgColor" });
+    pair("text", "loopTextColor", onPage);
+    pair("border", "labelBoxBorderColor", onPage, { suffix: " (loop frame)" });
+  }
+  if (features.activation)
+    pair("border", "activationBorderColor", { key: "activationBkgColor" });
+  if (features.numbered)
+    pair("text", "sequenceNumberColor", { key: "signalColor" });
+  for (const [i, rect] of features.rects.entries()) {
+    const fill = { colour: rect };
+    const where = { suffix: " (rect)", at: rectLines[i] };
+    pair("text", "signalTextColor", fill, where);
+    pair("border", "signalColor", fill, where);
+    if (features.frame)
+      pair("text", "loopTextColor", fill, where);
+  }
+};
+var scoreSequence = async (source, profile, canvas = GITHUB_CANVAS) => {
+  const out = { pairs: [], skipped: [] };
+  const { lineOf, rectLines } = sequenceLines(source);
+  const mermaid = await getMermaidCore();
+  const parsed = await parseSequence(mermaid, source);
+  if (!parsed)
+    return out;
+  const { config, db } = parsed;
+  const block = (selector, reason) => {
+    out.skipped.push({ selector, line: lineOf(selector), reason, blocking: true });
+    return out;
+  };
+  const problem = unmodelled(config);
+  if (problem)
+    return block(problem.selector, problem.reason);
   const features = sequenceFeatures(db);
   const host = profile === "mkdocs-material";
-  const theme = (fallback) => pinned === undefined ? fallback : String(pinned);
   let variables;
   try {
-    variables = resolveVariables(mermaid, config, { light: theme("default"), dark: theme(host ? "default" : "dark") });
+    variables = resolveVariables(mermaid, config, sequenceThemes(config.theme, host));
   } catch (err) {
     return block("themeVariables", `Mermaid could not resolve the theme: ${message(err)}`);
   }
   for (const t of THEMES) {
     const page = host ? MKDOCS_MATERIAL[t].bg : canvas[t];
-    const vars = variables[t];
-    const color = (key) => {
-      const value = vars[key];
-      if (typeof value !== "string")
-        throw new Error(`${key} is not a resolved colour`);
-      return value;
-    };
-    const pair = (kind, fgKey, bg, suffix = "", at) => {
-      const selector = fgKey + suffix;
-      const line = at ?? lineOf(fgKey);
-      try {
-        const box = compositeOver("key" in bg ? color(bg.key) : bg.colour, page);
-        pairs.push({ ...scoreHostPair(kind, themeVariable(selector, line), t, color(fgKey), box), advisory: host });
-      } catch (err) {
-        skipped.push({ selector, line, reason: `${t} sequence pair unparseable: ${message(err)}`, blocking: true });
-      }
-    };
-    const onPage = { colour: page };
-    if (host) {
-      pair("border", "actorLineColor", onPage);
-      pair("border", "signalColor", onPage, " (arrowhead)");
-      if (features.activation)
-        pair("border", "activationBorderColor", { key: "activationBkgColor" });
-      continue;
-    }
-    pair("text", "actorTextColor", { key: "actorBkg" });
-    pair("border", "actorBorder", { key: "actorBkg" });
-    if (features.humanActor) {
-      pair("text", "actorTextColor", onPage, " (human actor label)");
-      pair("border", "actorBorder", onPage, " (human actor glyph)");
-    }
-    pair("border", "actorLineColor", onPage);
-    pair("text", "signalTextColor", onPage);
-    pair("border", "signalColor", onPage);
-    if (features.note)
-      pair("text", "noteTextColor", { key: "noteBkgColor" });
-    if (features.frame) {
-      pair("text", "labelTextColor", { key: "labelBoxBkgColor" });
-      pair("text", "loopTextColor", onPage);
-      pair("border", "labelBoxBorderColor", onPage, " (loop frame)");
-    }
-    if (features.activation)
-      pair("border", "activationBorderColor", { key: "activationBkgColor" });
-    if (features.numbered)
-      pair("text", "sequenceNumberColor", { key: "signalColor" });
-    for (const [i, rect] of features.rects.entries()) {
-      const fill = { colour: rect };
-      const at = rectLines[i];
-      pair("text", "signalTextColor", fill, " (rect)", at);
-      pair("border", "signalColor", fill, " (rect)", at);
-      if (features.frame)
-        pair("text", "loopTextColor", fill, " (rect)", at);
-    }
+    const pair = sequencePair({ theme: t, page, vars: variables[t], host, lineOf, out });
+    if (host)
+      scoreHostSequence(pair, page, features);
+    else
+      scoreAuthorSequence(pair, page, features, rectLines);
   }
-  return { pairs, skipped };
+  return out;
 };
-var scoreDiagram = (source, directives, profile, keyword, canvas = GITHUB_CANVAS) => keyword === "sequenceDiagram" ? scoreSequence(source, profile, canvas) : Promise.resolve(scoreForProfile(directives, profile, keyword, canvas));
+var scoreDiagram = ({ source, directives, keyword }, profile, canvas = GITHUB_CANVAS) => keyword === "sequenceDiagram" ? scoreSequence(source, profile, canvas) : Promise.resolve(scoreForProfile(directives, profile, keyword, canvas));
 var detectProfile = (filePath) => {
   let dir = dirname(resolve(filePath));
   for (let i = 0;i < 20; i++) {
@@ -1496,7 +1514,7 @@ var canonicalPreset = (name) => {
 var configFromPreset = (name) => {
   const canonical = canonicalPreset(name);
   const preset = canonical ? PRESETS[canonical] : undefined;
-  if (!canonical || !preset) {
+  if (!(canonical && preset)) {
     throw new Error(`Unknown preset '${name}'. Valid: ${PRESET_NAMES.join(", ")}`);
   }
   return {
@@ -1575,7 +1593,7 @@ var measure = async (diagram, config) => {
     return null;
   return { stats, metrics: calculateComplexity(stats, config) };
 };
-var finding = (ctx, diagram, rule, message2, remediation) => ({
+var finding = (ctx, diagram, rule, { message: message2, remediation }) => ({
   file: ctx.file,
   line: diagram.startLine,
   endLine: diagram.endLine,
@@ -1626,7 +1644,7 @@ var contrastOf = (diagram, settings) => {
   }
   let result = bySettings.get(key);
   if (!result) {
-    result = scoreDiagram(diagram.source, diagram.directives, profile, diagram.keyword, canvas);
+    result = scoreDiagram(diagram, profile, canvas);
     bySettings.set(key, result);
   }
   return result;
@@ -1648,7 +1666,7 @@ var complexityRule = (spec) => ({
         continue;
       const hit = spec.hit(measured, config);
       if (hit)
-        found.push(finding(ctx, diagram, spec.id, hit.message, hit.remediation));
+        found.push(finding(ctx, diagram, spec.id, hit));
     }
     return found;
   }
@@ -1793,6 +1811,30 @@ var contrastDirectiveUnauditable = {
 var AA_NORMAL2 = 4.5;
 var CANDIDATES = ["#000000", "#ffffff"];
 var ratioOn = (fg, bg) => wcagRatio(compositeOver(fg, bg), bg);
+var remediationOf = (profile, kind) => {
+  if (profile === "mkdocs-material") {
+    return "The host theme forces the label text, so change the fill until the host text reads on it in both themes.";
+  }
+  if (kind === "themeVariables") {
+    return "A sequence diagram colour is a theme variable, and text with no box of its own sits on the page, so set the variable to a colour that reads on its background in both themes, or remove it and let the theme set it.";
+  }
+  if (kind === "linkStyle") {
+    return "An edge label sits on Mermaid's own label box, light in one theme and grey in the other, and no one colour reads on both, so drop color: from the linkStyle and let the theme set the label text.";
+  }
+  return "Darken or lighten the fill, or change color:, until the ratio reaches 4.5:1 in every theme.";
+};
+var textFinding = (ctx, diagram, p, profile) => {
+  const where = [p.theme, p.row].filter(Boolean).join("/");
+  const line = fileLine(diagram, p.line);
+  return {
+    file: ctx.file,
+    line,
+    endLine: line,
+    rule: RULE.TEXT,
+    message: `${p.directive.kind} ${p.selector}: text ${p.assessment.ratio.toFixed(2)}:1 < ${AA_NORMAL2} ` + `(${p.foreground} on ${p.background}${where ? `, ${where}` : ""})`,
+    remediation: remediationOf(profile, p.directive.kind)
+  };
+};
 var contrastTextBelowAa = {
   id: RULE.TEXT,
   category: "contrast",
@@ -1803,18 +1845,8 @@ var contrastTextBelowAa = {
     const found = [];
     for (const diagram of ctx.doc.diagrams) {
       for (const p of (await contrastOf(diagram, settings)).pairs) {
-        if (p.kind !== "text" || p.passes)
-          continue;
-        const where = [p.theme, p.row].filter(Boolean).join("/");
-        const line = fileLine(diagram, p.line);
-        found.push({
-          file: ctx.file,
-          line,
-          endLine: line,
-          rule: RULE.TEXT,
-          message: `${p.directive.kind} ${p.selector}: text ${p.assessment.ratio.toFixed(2)}:1 < ${AA_NORMAL2} ` + `(${p.foreground} on ${p.background}${where ? `, ${where}` : ""})`,
-          remediation: settings.profile === "mkdocs-material" ? "The host theme forces the label text, so change the fill until the host text reads on it in both themes." : p.directive.kind === "themeVariables" ? "A sequence diagram colour is a theme variable, and text with no box of its own sits on the page, so set the variable to a colour that reads on its background in both themes, or remove it and let the theme set it." : p.directive.kind === "linkStyle" ? "An edge label sits on Mermaid's own label box, light in one theme and grey in the other, and no one colour reads on both, so drop color: from the linkStyle and let the theme set the label text." : "Darken or lighten the fill, or change color:, until the ratio reaches 4.5:1 in every theme."
-        });
+        if (p.kind === "text" && !p.passes)
+          found.push(textFinding(ctx, diagram, p, settings.profile));
       }
     }
     return found;
@@ -1873,7 +1905,7 @@ var parseDiagramUnparseable = {
       if (!parseFailed(diagram.source, stats))
         continue;
       const remediation = EXTERNAL_TYPES.has(stats.diagram_type) ? `No fixer can help: mermaidjs-lint has no ${stats.diagram_type} parser. Redraw it as a type mermaid core includes, such as sequenceDiagram, or turn this rule off in the config.` : "Verify the diagram renders in mermaid.js and fix its syntax. Complexity rules are skipped for this diagram while it cannot be parsed.";
-      found.push(finding(ctx, diagram, RULE.UNPARSEABLE, messageOf(stats), remediation));
+      found.push(finding(ctx, diagram, RULE.UNPARSEABLE, { message: messageOf(stats), remediation }));
     }
     return found;
   }
@@ -1885,7 +1917,10 @@ var parseFenceUnterminated = {
   id: RULE.FENCE_UNTERMINATED,
   category: "parse",
   summary: "a mermaid fence that is never closed",
-  check: (ctx) => ctx.doc.diagrams.filter((d) => !d.terminated).map((d) => finding(ctx, d, RULE.FENCE_UNTERMINATED, `mermaid fence opened at line ${d.startLine} is never closed`, "Add a closing fence directly after the last line of the diagram, with the opening line's prefix: `> ` in a quote, the item's indent in a list.")),
+  check: (ctx) => ctx.doc.diagrams.filter((d) => !d.terminated).map((d) => finding(ctx, d, RULE.FENCE_UNTERMINATED, {
+    message: `mermaid fence opened at line ${d.startLine} is never closed`,
+    remediation: "Add a closing fence directly after the last line of the diagram, with the opening line's prefix: `> ` in a quote, the item's indent in a list."
+  })),
   fix: (ctx) => {
     const edits = [];
     const { src } = ctx.doc;
@@ -1982,20 +2017,20 @@ var checkCanvas = (where, rule, name, value) => {
     }
   }
 };
-var checkOptions = (where, rule, options) => {
-  const accepted = Object.keys(rule.options ?? {});
-  for (const [name, value] of Object.entries(options)) {
-    const want = rule.options?.[name];
-    if (!want) {
-      const list = accepted.length > 0 ? `it accepts ${accepted.join(", ")}` : "it takes no options";
-      throw new RuleOptionError(where, rule.id, name, `rule "${rule.id}" has no option "${name}"; ${list}`);
-    }
-    if (typeOf(value) !== want) {
-      throw new RuleOptionError(where, rule.id, name, `option "${name}" of "${rule.id}" must be ${describeType(want)}`);
-    }
-    if (want === "canvas")
-      checkCanvas(where, rule, name, value);
+var checkOption = (where, rule, name, value) => {
+  const want = rule.options?.[name];
+  if (!want) {
+    const accepted = Object.keys(rule.options ?? {});
+    const list = accepted.length > 0 ? `it accepts ${accepted.join(", ")}` : "it takes no options";
+    throw new RuleOptionError(where, rule.id, name, `rule "${rule.id}" has no option "${name}"; ${list}`);
   }
+  if (typeOf(value) !== want) {
+    throw new RuleOptionError(where, rule.id, name, `option "${name}" of "${rule.id}" must be ${describeType(want)}`);
+  }
+  if (want === "canvas")
+    checkCanvas(where, rule, name, value);
+};
+var checkSharedOptions = (where, rule, options) => {
   if (options.profile === "mkdocs-material" && options.canvas !== undefined && rule.options?.canvas === "canvas") {
     throw new RuleOptionError(where, rule.id, "canvas", `option "canvas" of "${rule.id}" applies under the github profile only, and this rule sets profile mkdocs-material, whose page is Material's own`);
   }
@@ -2006,10 +2041,12 @@ var checkOptions = (where, rule, options) => {
     throw new RuleOptionError(where, rule.id, "profile", `option "profile" of "${rule.id}" must be one of ${PROFILES.join(", ")}`);
   }
 };
-var buildRegistry = (input) => {
-  const { rules, fixOrder, categories, sources = [], config, ignoreUnknownPluginIds = false } = input;
-  const selection = input.selection ?? {};
-  checkSelection(selection, categories);
+var checkOptions = (where, rule, options) => {
+  for (const [name, value] of Object.entries(options))
+    checkOption(where, rule, name, value);
+  checkSharedOptions(where, rule, options);
+};
+var applyConfig = (rules, config, ignoreUnknownPluginIds) => {
   const off = new Set;
   const options = new Map;
   const ignored = [];
@@ -2028,6 +2065,13 @@ var buildRegistry = (input) => {
     if (setting.severity === "off")
       off.add(id);
   }
+  return { off, options, ignored };
+};
+var buildRegistry = (input) => {
+  const { rules, fixOrder, categories, sources = [], config, ignoreUnknownPluginIds = false } = input;
+  const selection = input.selection ?? {};
+  checkSelection(selection, categories);
+  const { off, options, ignored } = applyConfig(rules, config, ignoreUnknownPluginIds);
   for (const rule of rules) {
     if (selection.enable?.includes(rule.category))
       off.delete(rule.id);
@@ -2080,6 +2124,17 @@ var checkRunFlags = (flags, prefix = "") => {
 var canvasOptions = (rule) => Object.entries(rule.options ?? {}).filter(([, type]) => type === "canvas").map(([name]) => name);
 var hasFlagCanvas = (flags) => THEMES.some((side) => flags.canvas?.[side] !== undefined);
 var setsAside = (rule, options, flags, file) => !hasFlagCanvas(flags) && rule.options?.profile !== undefined && (options.profile ?? "auto") === "auto" && canvasOptions(rule).some((name) => options[name] !== undefined) && detectProfile(file) === "mkdocs-material";
+var mergeCanvas = (current, canvas) => {
+  const merged = {
+    ...typeof current === "object" && current !== null ? current : {}
+  };
+  for (const side of THEMES) {
+    const value = canvas[side];
+    if (value !== undefined)
+      merged[side] = value;
+  }
+  return merged;
+};
 var optionsFor = (rule, configured, flags, file) => {
   const options = { ...configured };
   for (const name of ["preset", "profile"]) {
@@ -2091,18 +2146,8 @@ var optionsFor = (rule, configured, flags, file) => {
     options.preset = canonicalPreset(options.preset) ?? options.preset;
   const canvas = flags.canvas;
   if (canvas && hasFlagCanvas(flags)) {
-    for (const name of canvasOptions(rule)) {
-      const current = options[name];
-      const merged = {
-        ...typeof current === "object" && current !== null ? current : {}
-      };
-      for (const side of THEMES) {
-        const value = canvas[side];
-        if (value !== undefined)
-          merged[side] = value;
-      }
-      options[name] = merged;
-    }
+    for (const name of canvasOptions(rule))
+      options[name] = mergeCanvas(options[name], canvas);
   }
   if (file !== undefined && setsAside(rule, options, flags, file)) {
     for (const name of canvasOptions(rule))
@@ -2127,6 +2172,7 @@ import { extname, join as join2, resolve as resolve2 } from "node:path";
 var DIAGRAM_FILE_EXTS = new Set([...DIAGRAM_EXTS, ".md", ".markdown"]);
 var SKIP_DIRS = new Set(["node_modules", "vendor", "dist", "build", "tmp", "__pycache__"]);
 var skipDir = (name) => name.startsWith(".") || SKIP_DIRS.has(name);
+var isDiagramFile = (name) => DIAGRAM_FILE_EXTS.has(extname(name).toLowerCase());
 var linksToDir = (path) => {
   try {
     return statSync(path).isDirectory();
@@ -2139,6 +2185,24 @@ var collectFiles = (paths) => {
   const unreadable = [];
   const symlinks = [];
   const seen = new Set;
+  const add = (abs) => {
+    if (seen.has(abs))
+      return;
+    seen.add(abs);
+    files.push(abs);
+  };
+  const visit = (dir, entry) => {
+    const abs = join2(dir, entry.name);
+    if (entry.isSymbolicLink()) {
+      if (!skipDir(entry.name) && (isDiagramFile(entry.name) || linksToDir(abs)))
+        symlinks.push(abs);
+    } else if (entry.isDirectory()) {
+      if (!skipDir(entry.name))
+        walk(abs);
+    } else if (entry.isFile() && isDiagramFile(entry.name)) {
+      add(abs);
+    }
+  };
   const walk = (dir) => {
     let entries;
     try {
@@ -2147,22 +2211,8 @@ var collectFiles = (paths) => {
       unreadable.push(dir);
       return;
     }
-    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-      const abs = join2(dir, entry.name);
-      if (entry.isSymbolicLink()) {
-        if (!skipDir(entry.name) && (DIAGRAM_FILE_EXTS.has(extname(entry.name).toLowerCase()) || linksToDir(abs))) {
-          symlinks.push(abs);
-        }
-      } else if (entry.isDirectory()) {
-        if (!skipDir(entry.name))
-          walk(abs);
-      } else if (entry.isFile() && DIAGRAM_FILE_EXTS.has(extname(entry.name).toLowerCase())) {
-        if (!seen.has(abs)) {
-          seen.add(abs);
-          files.push(abs);
-        }
-      }
-    }
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name)))
+      visit(dir, entry);
   };
   for (const p of paths) {
     const abs = resolve2(p);
@@ -2170,9 +2220,8 @@ var collectFiles = (paths) => {
       const st = statSync(abs);
       if (st.isDirectory()) {
         walk(abs);
-      } else if (st.isFile() && !seen.has(abs)) {
-        seen.add(abs);
-        files.push(abs);
+      } else if (st.isFile()) {
+        add(abs);
       }
     } catch {
       unreadable.push(p);
@@ -2186,21 +2235,24 @@ var OMIT = new Set(["position", "data"]);
 var normalise = (node, opts = {}) => {
   const out = {};
   const isDiagram = node.type === "code" && node.lang === "mermaid";
+  const blank = isDiagram && Boolean(opts.blankDiagrams);
   for (const [key, value] of Object.entries(node)) {
     if (OMIT.has(key))
       continue;
-    if (key === "children" && Array.isArray(value)) {
-      out.children = value.map((child) => normalise(child, opts));
-    } else if (key === "value" && typeof value === "string") {
-      if (isDiagram && opts.blankDiagrams)
-        continue;
-      out.value = node.type === "text" ? value.replace(/\s+/g, " ").trim() : value;
-    } else {
-      out[key] = value;
-    }
+    if (blank && isStringValue(key, value))
+      continue;
+    out[key] = normaliseField(node, key, value, opts);
   }
   return out;
 };
+var isStringValue = (key, value) => key === "value" && typeof value === "string";
+var normaliseField = (node, key, value, opts) => {
+  if (key === "children" && Array.isArray(value))
+    return value.map((child) => normalise(child, opts));
+  if (isStringValue(key, value))
+    return node.type === "text" ? value.replace(/\s+/g, " ").trim() : value;
+  return value;
+};
 var sameJson = (a, b) => JSON.stringify(a) === JSON.stringify(b);
 var sameTree = (a, b, opts) => sameJson(normalise(a, opts), normalise(b, opts));
 var sameDiagrams = async (before, after) => {
@@ -2265,63 +2317,68 @@ var overlaps = (edits) => {
   return sorted.some((e, i) => i > 0 && e.start < sorted[i - 1].end);
 };
 var wellFormed = (e, length) => Number.isInteger(e.start) && Number.isInteger(e.end) && e.start >= 0 && e.start <= e.end && e.end <= length && typeof e.text === "string";
+var keyOf = (run, e) => `${e.rule}\x00${run.current.slice(e.start, e.end)}\x00${e.text}`;
+var attempt = async (run, doc, edits) => {
+  const next = splice(run.current, edits);
+  const after = buildDocModel(next, run.kind);
+  for (const e of edits)
+    if (await verify(e, doc, after) !== "accept")
+      return false;
+  run.current = next;
+  run.applied.push(...edits);
+  return true;
+};
+var soundEdits = (run, proposed) => proposed.filter((e) => {
+  if (wellFormed(e, run.current.length))
+    return true;
+  const key = `${e.rule}\x00malformed\x00${e.start}:${e.end}`;
+  if (!run.refusedKeys.has(key)) {
+    run.refusedKeys.add(key);
+    run.refused.push(e);
+  }
+  return false;
+});
+var applyRule = async (run, doc, rule) => {
+  const options = optionsFor(rule, run.registry.options.get(rule.id), run.flags, run.file);
+  const proposed = await rule.fix?.({ doc, file: run.file, options, helpers: HELPERS }) ?? [];
+  const edits = soundEdits(run, proposed).filter((e) => run.current.slice(e.start, e.end) !== e.text && !run.refusedKeys.has(keyOf(run, e)));
+  if (edits.length === 0)
+    return false;
+  if (edits.length > 1 && !overlaps(edits) && await attempt(run, doc, edits))
+    return true;
+  for (const edit of edits) {
+    if (await attempt(run, doc, [edit]))
+      return true;
+    run.refusedKeys.add(keyOf(run, edit));
+    run.refused.push(edit);
+  }
+  return false;
+};
+var runPass = async (run) => {
+  const doc = buildDocModel(run.current, run.kind);
+  for (const rule of run.registry.fixOrder)
+    if (await applyRule(run, doc, rule))
+      return rule.id;
+  return;
+};
 var fixSourceReport = async (src, file, flags = {}, registry = BUILTIN) => {
   checkRunFlags(flags);
-  const kind = documentKind(file);
-  const applied = [];
-  const refused = [];
-  const refusedKeys = new Set;
-  let current = src;
+  const run = {
+    file,
+    flags,
+    registry,
+    kind: documentKind(file),
+    current: src,
+    applied: [],
+    refused: [],
+    refusedKeys: new Set
+  };
   const keptBy = [];
   for (let pass = 0;pass < MAX_PASSES; pass++) {
-    const doc = buildDocModel(current, kind);
-    const keyOf = (e) => `${e.rule}\x00${current.slice(e.start, e.end)}\x00${e.text}`;
-    const attempt = async (edits) => {
-      const next = splice(current, edits);
-      const after = buildDocModel(next, kind);
-      for (const e of edits)
-        if (await verify(e, doc, after) !== "accept")
-          return false;
-      current = next;
-      applied.push(...edits);
-      return true;
-    };
-    let progressed = false;
-    for (const rule of registry.fixOrder) {
-      const options = optionsFor(rule, registry.options.get(rule.id), flags, file);
-      const proposed = await rule.fix?.({ doc, file, options, helpers: HELPERS }) ?? [];
-      const sound = proposed.filter((e) => {
-        if (wellFormed(e, current.length))
-          return true;
-        const key = `${e.rule}\x00malformed\x00${e.start}:${e.end}`;
-        if (!refusedKeys.has(key)) {
-          refusedKeys.add(key);
-          refused.push(e);
-        }
-        return false;
-      });
-      const edits = sound.filter((e) => current.slice(e.start, e.end) !== e.text && !refusedKeys.has(keyOf(e)));
-      if (edits.length === 0)
-        continue;
-      if (edits.length > 1 && !overlaps(edits) && await attempt(edits)) {
-        progressed = true;
-      } else {
-        for (const edit of edits) {
-          if (await attempt([edit])) {
-            progressed = true;
-            break;
-          }
-          refusedKeys.add(keyOf(edit));
-          refused.push(edit);
-        }
-      }
-      if (progressed) {
-        keptBy.push(rule.id);
-        break;
-      }
-    }
-    if (!progressed)
-      return { output: current, applied, refused };
+    const kept = await runPass(run);
+    if (kept === undefined)
+      return { output: run.current, applied: run.applied, refused: run.refused };
+    keptBy.push(kept);
   }
   const lingering = [...new Set(keptBy.slice(-RECENT_PASSES))].sort();
   throw new FixNotConvergingError(file, MAX_PASSES, lingering);
@@ -2439,26 +2496,22 @@ var localSources = async (root) => {
   }
   return names.filter((name) => LOCAL_EXTENSIONS.has(extname3(name)) && !name.endsWith(".d.ts") && !name.endsWith(".d.mts")).map((name) => ({ kind: "local", spec: join4(LOCAL_RULES, name), path: join4(dir, name) }));
 };
+var CONDITIONS = ["node", "import", "default"];
+var pickFirst = (candidates) => {
+  for (const item of candidates) {
+    const found = pick(item);
+    if (found)
+      return found;
+  }
+  return null;
+};
 var pick = (target) => {
   if (typeof target === "string")
     return target;
-  if (Array.isArray(target)) {
-    for (const item of target) {
-      const found = pick(item);
-      if (found)
-        return found;
-    }
-    return null;
-  }
-  if (isRecord2(target)) {
-    for (const condition of ["node", "import", "default"]) {
-      if (condition in target) {
-        const found = pick(target[condition]);
-        if (found)
-          return found;
-      }
-    }
-  }
+  if (Array.isArray(target))
+    return pickFirst(target);
+  if (isRecord2(target))
+    return pickFirst(CONDITIONS.filter((c) => (c in target)).map((c) => target[c]));
   return null;
 };
 var entryOf = (pkg) => {
@@ -2560,23 +2613,40 @@ var importModule = async (source, runtime) => {
 };
 var OPTION_TYPES = new Set(["number", "string", "boolean", "string[]", "canvas"]);
 var RESERVED_OPTIONS = ["preset", "profile"];
-var checkRule = (spec, key, raw, own) => {
+var checkRuleCategory = (spec, key, category, own) => {
   const where = `rule "${key}"`;
-  if (!isRecord3(raw))
-    throw new PluginContractError(spec, `${where} must be an object`);
-  if (!RULE_KEY.test(key)) {
-    throw new PluginContractError(spec, `${where} is not a valid key; use lower-case words joined by hyphens`);
-  }
-  const { category, summary, options, check, fix } = raw;
   if (typeof category !== "string" || !CATEGORY_WORD.test(category)) {
     throw new PluginContractError(spec, `${where} needs a category of one lower-case word`);
   }
-  if (!BUILTIN_CATEGORIES.has(category) && !own.has(category)) {
+  if (!(BUILTIN_CATEGORIES.has(category) || own.has(category))) {
     throw new PluginContractError(spec, `${where} uses the category "${category}", which this plugin does not declare in meta.categories`);
   }
   if (!key.startsWith(`${category}-`)) {
     throw new PluginContractError(spec, `${where} must start with its category, as "${category}-short-name"`);
   }
+};
+var checkRuleOptions = (spec, where, options) => {
+  if (options === undefined)
+    return;
+  const valid = isRecord3(options) && Object.values(options).every((t) => OPTION_TYPES.has(t));
+  if (!valid) {
+    throw new PluginContractError(spec, `${where} options must map names to number, string, boolean, string[] or canvas`);
+  }
+  for (const name of RESERVED_OPTIONS) {
+    if (name in options && options[name] !== "string") {
+      throw new PluginContractError(spec, `${where} declares option "${name}" as ${String(options[name])}, but "${name}" is reserved for the built-in ${name}, which is a string set by --${name}; declare it as "string" to follow the run's ${name}, or pick another name`);
+    }
+  }
+};
+var checkRule = (spec, key, raw, own) => {
+  const where = `rule "${key}"`;
+  if (!isRecord3(raw))
+    throw new PluginContractError(spec, `${where} must be an object`);
+  if (!RULE_KEY.test(key)) {
+    throw new PluginContractError(spec, `${where} is not a valid key; use lower-case words joined by hyphens`);
+  }
+  const { category, summary, options, check, fix } = raw;
+  checkRuleCategory(spec, key, category, own);
   if (typeof summary !== "string" || summary === "")
     throw new PluginContractError(spec, `${where} needs a summary`);
   if (typeof check !== "function")
@@ -2584,17 +2654,7 @@ var checkRule = (spec, key, raw, own) => {
   if (fix !== undefined && typeof fix !== "function") {
     throw new PluginContractError(spec, `${where} fix must be a function`);
   }
-  if (options !== undefined) {
-    const valid = isRecord3(options) && Object.values(options).every((t) => OPTION_TYPES.has(t));
-    if (!valid) {
-      throw new PluginContractError(spec, `${where} options must map names to number, string, boolean, string[] or canvas`);
-    }
-    for (const name of RESERVED_OPTIONS) {
-      if (name in options && options[name] !== "string") {
-        throw new PluginContractError(spec, `${where} declares option "${name}" as ${String(options[name])}, but "${name}" is reserved for the built-in ${name}, which is a string set by --${name}; declare it as "string" to follow the run's ${name}, or pick another name`);
-      }
-    }
-  }
+  checkRuleOptions(spec, where, options);
   return raw;
 };
 var checkCategories = (spec, raw) => {
@@ -2615,7 +2675,7 @@ var checkCategories = (spec, raw) => {
   return raw;
 };
 var parsePlugin = (spec, raw, reserved) => {
-  if (!isRecord3(raw) || !isRecord3(raw.meta) || !isRecord3(raw.rules)) {
+  if (!(isRecord3(raw) && isRecord3(raw.meta) && isRecord3(raw.rules))) {
     throw new PluginContractError(spec, "the default export must be { meta, rules }");
   }
   const { name, namespace, apiVersion } = raw.meta;
@@ -2635,6 +2695,31 @@ var parsePlugin = (spec, raw, reserved) => {
   return { meta: { name, namespace, apiVersion, categories }, rules };
 };
 var loadPackage = async (source, reserved) => parsePlugin(source.spec, (await importModule(source)).default, reserved);
+var keyOf2 = (source) => basename(source.path, extname4(source.path));
+var groupByKey = (sources) => {
+  const byKey = new Map;
+  for (const source of sources)
+    byKey.set(keyOf2(source), [...byKey.get(keyOf2(source)) ?? [], source]);
+  return byKey;
+};
+var duplicateKeyError = (key, group) => new PluginContractError(group[0].spec, `rule "${key}" is defined by more than one file: ${group.map((s) => s.spec).join(", ")}; each rule comes from exactly one file, so rename or remove all but one`);
+var mergeCategories = (seen, spec, declared) => {
+  for (const [word, description] of Object.entries(declared)) {
+    if (seen.categories[word] !== undefined && seen.categories[word] !== description) {
+      throw new PluginConflictError(spec, seen.owner[word], `declares category "${word}" with a different description than another local file`);
+    }
+    seen.categories[word] = description;
+    seen.owner[word] = spec;
+  }
+};
+var importLocal = async (source, seen, runtime) => {
+  const mod = await importModule(source, runtime);
+  if (mod.default === undefined) {
+    throw new PluginContractError(source.spec, "has no default export; export one rule");
+  }
+  mergeCategories(seen, source.spec, checkCategories(source.spec, mod.categories));
+  return mod.default;
+};
 var loadLocal = async (sources, runtime) => {
   const failures = [];
   const fail = (err) => {
@@ -2642,35 +2727,19 @@ var loadLocal = async (sources, runtime) => {
       throw err;
     failures.push(err);
   };
-  const categories = {};
-  const owner = {};
+  const seen = { categories: {}, owner: {} };
+  const { categories } = seen;
   const loaded = [];
-  const keyOf = (source) => basename(source.path, extname4(source.path));
-  const byKey = new Map;
-  for (const source of sources)
-    byKey.set(keyOf(source), [...byKey.get(keyOf(source)) ?? [], source]);
+  const byKey = groupByKey(sources);
   for (const [key, group] of byKey) {
-    if (group.length < 2)
-      continue;
-    fail(new PluginContractError(group[0].spec, `rule "${key}" is defined by more than one file: ${group.map((s) => s.spec).join(", ")}; each rule comes from exactly one file, so rename or remove all but one`));
+    if (group.length > 1)
+      fail(duplicateKeyError(key, group));
   }
   for (const source of sources) {
-    if ((byKey.get(keyOf(source))?.length ?? 0) > 1)
+    if ((byKey.get(keyOf2(source))?.length ?? 0) > 1)
       continue;
     try {
-      const mod = await importModule(source, runtime);
-      if (mod.default === undefined) {
-        throw new PluginContractError(source.spec, "has no default export; export one rule");
-      }
-      const declared = checkCategories(source.spec, mod.categories);
-      for (const [word, description] of Object.entries(declared)) {
-        if (categories[word] !== undefined && categories[word] !== description) {
-          throw new PluginConflictError(source.spec, owner[word], `declares category "${word}" with a different description than another local file`);
-        }
-        categories[word] = description;
-        owner[word] = source.spec;
-      }
-      loaded.push({ key: keyOf(source), source, raw: mod.default });
+      loaded.push({ key: keyOf2(source), source, raw: await importLocal(source, seen, runtime) });
     } catch (err) {
       fail(err);
     }
@@ -2701,7 +2770,7 @@ var toRule = (namespace, key, rule) => {
     } catch (err) {
       return report(`threw: ${message2(err)}`);
     }
-    if (!Array.isArray(found) || !found.every(validFinding)) {
+    if (!(Array.isArray(found) && found.every(validFinding))) {
       return report("returned something other than a list of { line, message } findings");
     }
     return found.map((f) => ({
@@ -2723,7 +2792,7 @@ var toRule = (namespace, key, rule) => {
     if (!Array.isArray(edits))
       throw new PluginFixerError(id, "fixer returned something other than a list of edits");
     return edits.map((e) => {
-      if (!isRecord3(e) || !isRecord3(e.expect) || !EXPECTATIONS.has(e.expect.kind)) {
+      if (!(isRecord3(e) && isRecord3(e.expect) && EXPECTATIONS.has(e.expect.kind))) {
         throw new PluginFixerError(id, "fixer returned an edit with no valid expectation");
       }
       return { ...e, rule: id };
@@ -2733,26 +2802,7 @@ var toRule = (namespace, key, rule) => {
 };
 
 // src/plugins/index.ts
-var loadPlugins = async (root, config, mode) => {
-  const { sources: found, failures: unresolved } = await discoverSources(root, config, mode === "off");
-  const set = {
-    rules: [],
-    categories: new Map(BUILTIN_CATEGORIES),
-    sources: [],
-    skipped: [],
-    failures: []
-  };
-  if (mode === "off") {
-    return { ...set, skipped: [...found.map((s) => s.spec), ...unresolved.map((u) => u.error.source)] };
-  }
-  const settle = (error, kind) => {
-    if (mode === "strict")
-      throw error;
-    if (!set.failures.some((f) => f.source === error.source))
-      set.failures.push({ source: error.source, kind, error });
-  };
-  for (const { error, kind } of unresolved)
-    settle(error, kind);
+var loadAll = async (found, settle) => {
   const loaded = [];
   const locals = found.filter((s) => s.kind === "local");
   if (locals.length > 0) {
@@ -2771,28 +2821,59 @@ var loadPlugins = async (root, config, mode) => {
       settle(err, source.kind);
     }
   }
-  const namespaces = new Map;
-  const declaredBy = new Map;
+  return loaded;
+};
+var conflictOf = (plugin, spec, claims) => {
+  const { namespace } = plugin.meta;
+  const words = Object.keys(plugin.meta.categories ?? {});
+  const taken = claims.namespaces.get(namespace);
+  const clash = words.find((w) => claims.declaredBy.has(w));
+  if (!(taken || clash))
+    return null;
+  const other = taken ?? claims.declaredBy.get(clash);
+  const reason2 = taken ? `namespace "${namespace}" is already used by ${other}` : `category "${clash}" is already declared by ${other}`;
+  return new PluginConflictError(spec, other, reason2);
+};
+var acceptClaims = (loaded, set, settle) => {
+  const claims = { namespaces: new Map, declaredBy: new Map };
   const accepted = [];
   for (const entry of loaded) {
     const { plugin, spec, kind } = entry;
-    const { namespace } = plugin.meta;
-    const words = Object.keys(plugin.meta.categories ?? {});
-    const taken = namespaces.get(namespace);
-    const clash = words.find((w) => declaredBy.has(w));
-    if (taken || clash) {
-      const other = taken ?? declaredBy.get(clash);
-      const reason2 = taken ? `namespace "${namespace}" is already used by ${other}` : `category "${clash}" is already declared by ${other}`;
-      settle(new PluginConflictError(spec, other, reason2), kind);
+    const conflict = conflictOf(plugin, spec, claims);
+    if (conflict) {
+      settle(conflict, kind);
       continue;
     }
-    namespaces.set(namespace, spec);
+    claims.namespaces.set(plugin.meta.namespace, spec);
     for (const [word, description] of Object.entries(plugin.meta.categories ?? {})) {
-      declaredBy.set(word, spec);
+      claims.declaredBy.set(word, spec);
       set.categories.set(word, description);
     }
     accepted.push(entry);
   }
+  return accepted;
+};
+var loadPlugins = async (root, config, mode) => {
+  const { sources: found, failures: unresolved } = await discoverSources(root, config, mode === "off");
+  const set = {
+    rules: [],
+    categories: new Map(BUILTIN_CATEGORIES),
+    sources: [],
+    skipped: [],
+    failures: []
+  };
+  if (mode === "off") {
+    return { ...set, skipped: [...found.map((s) => s.spec), ...unresolved.map((u) => u.error.source)] };
+  }
+  const settle = (error, kind) => {
+    if (mode === "strict")
+      throw error;
+    if (!set.failures.some((f) => f.source === error.source))
+      set.failures.push({ source: error.source, kind, error });
+  };
+  for (const { error, kind } of unresolved)
+    settle(error, kind);
+  const accepted = acceptClaims(await loadAll(found, settle), set, settle);
   for (const { plugin, kind, spec } of accepted) {
     const rules = Object.entries(plugin.rules).map(([key, rule]) => toRule(plugin.meta.namespace, key, rule));
     set.rules.push(...rules);
@@ -3012,84 +3093,72 @@ var refuseOutsideLinks = async (files, root, cwd) => {
       throw new FixOutsideRootError(display(file, cwd), target, root);
   }
 };
-var run = async (argv, cwd) => {
-  let parsed;
+var parseArgv = (argv) => {
   try {
-    parsed = parse2(argv);
+    return parse2(argv);
   } catch (err) {
     throw new FlagError("argv", err instanceof Error ? err.message : String(err));
   }
-  const { values, positionals } = parsed;
-  if (values.help) {
-    console.log(USAGE);
-    return 0;
-  }
-  if (values.version) {
-    console.log(package_default.version);
-    return 0;
-  }
-  const listing = values["list-rules"];
-  const validating = values["validate-plugins"];
+};
+var runFlagsOf = (values) => {
   const canvas = {
     ...values["canvas-light"] !== undefined && { light: values["canvas-light"] },
     ...values["canvas-dark"] !== undefined && { dark: values["canvas-dark"] }
   };
-  const flags = {
+  return {
     preset: values.preset,
     profile: values.profile,
     ...Object.keys(canvas).length > 0 && { canvas }
   };
-  checkRunFlags(flags, "--");
+};
+var checkPluginFlags = (values) => {
   if (values["no-plugins"] && values["lenient-plugins"]) {
     throw new FlagError("--lenient-plugins", "--no-plugins and --lenient-plugins contradict each other");
   }
-  if (validating && (values["no-plugins"] || values.fix || listing)) {
+  if (values["validate-plugins"] && (values["no-plugins"] || values.fix || values["list-rules"])) {
     throw new FlagError("--validate-plugins", "--validate-plugins takes no --no-plugins, --fix or --list-rules");
   }
-  const enable = categoryWords("--category", values.category);
-  const disable = categoryWords("--disable-category", values["disable-category"]);
-  if (validating && enable.length + disable.length > 0) {
-    throw new FlagError("--validate-plugins", "--validate-plugins checks every plugin, so it takes no category flag");
-  }
-  if (listing && !validating) {
-    const ignored = [
-      ...["fix", "json", "preset", "profile", "canvas-light", "canvas-dark"].filter((name) => values[name] !== undefined && values[name] !== false).map((name) => `--${name}`),
-      ...positionals.length > 0 ? ["a path"] : []
-    ];
-    if (ignored.length > 0) {
-      throw new FlagError("--list-rules", `--list-rules takes only --config and --no-plugins or --lenient-plugins, not ${ignored.join(", ")}`);
-    }
+};
+var checkListingFlags = (values, positionals) => {
+  const ignored = [
+    ...["fix", "json", "preset", "profile", "canvas-light", "canvas-dark"].filter((name) => values[name] !== undefined && values[name] !== false).map((name) => `--${name}`),
+    ...positionals.length > 0 ? ["a path"] : []
+  ];
+  if (ignored.length > 0) {
+    throw new FlagError("--list-rules", `--list-rules takes only --config and --no-plugins or --lenient-plugins, not ${ignored.join(", ")}`);
   }
+};
+var checkPositionals = (values, positionals) => {
+  const validating = values["validate-plugins"];
   if (validating && positionals.length > 0) {
     throw new FlagError("files", "--validate-plugins runs no check, so it takes no files");
   }
-  if (positionals.length === 0 && !listing && !validating)
+  if (positionals.length === 0 && !(values["list-rules"] || validating)) {
     throw new FlagError("files", "no files given");
-  const { root, registry, skipped, failures } = await setUp({
-    cwd,
-    configPath: values.config,
-    noPlugins: values["no-plugins"],
-    lenient: values["lenient-plugins"],
-    collect: validating,
-    selection: { enable, disable, prefix: "--" }
-  });
-  if (validating) {
-    const result = validate(registry, failures, Boolean(values.json));
-    for (const line of result.stderr)
-      console.error(line);
-    if (result.stdout)
-      console.log(result.stdout);
-    return result.code;
   }
-  const note = loadedLine(registry.sources, skipped);
-  if (note)
-    console.error(note);
-  for (const line of skippedLines(failures, registry.ignoredSettings))
-    console.error(line);
-  if (listing) {
-    console.log(listRules(registry));
-    return 0;
+};
+var checkCombinations = (values, positionals) => {
+  checkPluginFlags(values);
+  const enable = categoryWords("--category", values.category);
+  const disable = categoryWords("--disable-category", values["disable-category"]);
+  const validating = values["validate-plugins"];
+  if (validating && enable.length + disable.length > 0) {
+    throw new FlagError("--validate-plugins", "--validate-plugins checks every plugin, so it takes no category flag");
   }
+  if (values["list-rules"] && !validating)
+    checkListingFlags(values, positionals);
+  checkPositionals(values, positionals);
+  return { enable, disable };
+};
+var printValidation = (registry, failures, json) => {
+  const result = validate(registry, failures, json);
+  for (const line of result.stderr)
+    console.error(line);
+  if (result.stdout)
+    console.log(result.stdout);
+  return result.code;
+};
+var filesToCheck = (positionals, cwd) => {
   const { files, unreadable, symlinks } = collectFiles(positionals.map((p) => resolve5(cwd, p)));
   if (unreadable.length > 0)
     throw new FlagError("files", `cannot read ${unreadable.join(", ")}`);
@@ -3098,39 +3167,83 @@ var run = async (argv, cwd) => {
   }
   if (files.length === 0)
     throw new FlagError("files", "no matching files");
-  if (values.fix)
-    await refuseOutsideLinks(files, root, cwd);
+  return files;
+};
+var reportSetAside = (files, flags, registry, cwd) => {
   const setAside = files.filter((file) => canvasSetAside(file, flags, registry)).map((f) => display(f, cwd));
   if (setAside.length > 0) {
     console.error(`mermaidjs-lint: config canvas set aside for ${plural(setAside.length, "file")} scored under mkdocs-material: ${setAside.join(", ")}`);
   }
-  const perFile = await Promise.all(files.map(async (file) => {
-    let src = await readFile3(file, "utf8");
-    if (values.fix) {
-      const fixed = (await fixSourceReport(src, file, flags, registry)).output;
-      if (fixed !== src) {
-        await writeFile(file, fixed);
-        src = fixed;
-      }
+  return setAside;
+};
+var checkFile = async (file, { flags, registry, fix, cwd }) => {
+  let src = await readFile3(file, "utf8");
+  if (fix) {
+    const fixed = (await fixSourceReport(src, file, flags, registry)).output;
+    if (fixed !== src) {
+      await writeFile(file, fixed);
+      src = fixed;
     }
-    const shown = display(file, cwd);
-    const found = await checkModel(buildDocModel(src, documentKind(file)), file, flags, registry);
-    return found.map((f) => ({ ...f, file: shown }));
-  }));
-  const all = perFile.flat();
-  if (values.json) {
+  }
+  const shown = display(file, cwd);
+  const found = await checkModel(buildDocModel(src, documentKind(file)), file, flags, registry);
+  return found.map((f) => ({ ...f, file: shown }));
+};
+var printReport = (json, { all, files, registry, failures, setAside }) => {
+  if (json) {
     const skippedPlugins = failures.map((f) => ({
       source: f.source,
       kind: f.kind,
       code: f.error.code,
       message: reasonOf(f)
     }));
-    console.log(JSON.stringify({ findings: all, files: files.length, plugins: registry.sources, skippedPlugins, canvasSetAside: setAside }, null, 2));
-  } else {
-    for (const f of all)
-      console.log(reportLine(f, f.file));
-    console.log(`${all.length} finding(s) in ${files.length} file(s)`);
+    console.log(JSON.stringify({ findings: all, files, plugins: registry.sources, skippedPlugins, canvasSetAside: setAside }, null, 2));
+    return;
+  }
+  for (const f of all)
+    console.log(reportLine(f, f.file));
+  console.log(`${all.length} finding(s) in ${files} file(s)`);
+};
+var run = async (argv, cwd) => {
+  const { values, positionals } = parseArgv(argv);
+  if (values.help) {
+    console.log(USAGE);
+    return 0;
+  }
+  if (values.version) {
+    console.log(package_default.version);
+    return 0;
   }
+  const flags = runFlagsOf(values);
+  checkRunFlags(flags, "--");
+  const { enable, disable } = checkCombinations(values, positionals);
+  const { root, registry, skipped, failures } = await setUp({
+    cwd,
+    configPath: values.config,
+    noPlugins: values["no-plugins"],
+    lenient: values["lenient-plugins"],
+    collect: values["validate-plugins"],
+    selection: { enable, disable, prefix: "--" }
+  });
+  if (values["validate-plugins"])
+    return printValidation(registry, failures, Boolean(values.json));
+  const note = loadedLine(registry.sources, skipped);
+  if (note)
+    console.error(note);
+  for (const line of skippedLines(failures, registry.ignoredSettings))
+    console.error(line);
+  if (values["list-rules"]) {
+    console.log(listRules(registry));
+    return 0;
+  }
+  const files = filesToCheck(positionals, cwd);
+  const fix = Boolean(values.fix);
+  if (fix)
+    await refuseOutsideLinks(files, root, cwd);
+  const setAside = reportSetAside(files, flags, registry, cwd);
+  const perFile = await Promise.all(files.map((file) => checkFile(file, { flags, registry, fix, cwd })));
+  const all = perFile.flat();
+  printReport(Boolean(values.json), { all, files: files.length, registry, failures, setAside });
   return all.length > 0 ? 1 : 0;
 };
 var describeError = (err) => err instanceof MermaidLintError ? `error[${err.code}]: ${err.message}` : `error: ${err instanceof Error ? err.message : String(err)}`;