@jpeakai/mermaidjs-lint 0.2.0 → 0.4.0

package/dist/testing.js

@@ -203,6 +203,7 @@ async function extractStats(content) {
     edges: 0,
     subgraphs: 0,
     max_subgraph_depth: 0,
+    max_tree_depth: 0,
     node_ids: [],
     subgraph_names: [],
     parser_used: langium ? "langium" : "mermaid-core",
@@ -252,6 +253,7 @@ async function extractLangiumStats(content, keyword) {
   const subgraphNames = [];
   let edges = 0;
   let maxDepth = 0;
+  let treeDepth = 0;
   switch (mapped) {
     case "architecture": {
       const services = ast.services ?? [];
@@ -298,7 +300,7 @@ async function extractLangiumStats(content, keyword) {
       const stats = indentTreeStats(nodes.map((n, i) => ({ label: n.name ?? `node_${i}`, indent: n.indent ?? 0 })));
       nodeIds.push(...stats.labels);
       edges = stats.edges;
-      maxDepth = stats.depth;
+      treeDepth = stats.depth;
       break;
     }
     case "treemap": {
@@ -306,7 +308,7 @@ async function extractLangiumStats(content, keyword) {
       const stats = indentTreeStats(rows.map((r, i) => ({ label: r.item?.name ?? `row_${i}`, indent: r.indent ?? 0 })));
       nodeIds.push(...stats.labels);
       edges = stats.edges;
-      maxDepth = stats.depth;
+      treeDepth = stats.depth;
       break;
     }
     case "wardley": {
@@ -326,6 +328,7 @@ async function extractLangiumStats(content, keyword) {
     edges,
     subgraphs: subgraphNames.length,
     max_subgraph_depth: maxDepth,
+    max_tree_depth: treeDepth,
     node_ids: [...new Set(nodeIds.filter(Boolean))].sort(),
     subgraph_names: subgraphNames,
     parser_used: "langium",
@@ -376,12 +379,13 @@ async function extractCoreStats(content, keyword) {
   if (!adapter) {
     throw new Error(`no core adapter for diagram.type="${diagramType}" (keyword="${keyword}")`);
   }
-  const { nodeIds, edges, subgraphNames, maxDepth } = adapter(diagram.db);
+  const { nodeIds, edges, subgraphNames, maxDepth, treeDepth = 0 } = adapter(diagram.db);
   return {
     nodes: nodeIds.length,
     edges,
     subgraphs: subgraphNames.length,
     max_subgraph_depth: maxDepth,
+    max_tree_depth: treeDepth,
     node_ids: [...nodeIds].sort(),
     subgraph_names: subgraphNames,
     parser_used: "mermaid-core",
@@ -392,6 +396,7 @@ async function extractCoreStats(content, keyword) {
 var CORE_ADAPTERS = {
   "flowchart-v2": adaptFlowchart,
   flowchart: adaptFlowchart,
+  "flowchart-elk": adaptFlowchart,
   graph: adaptFlowchart,
   classDiagram: adaptClass,
   "classDiagram-v2": adaptClass,
@@ -515,7 +520,13 @@ function adaptIshikawa(db) {
       walk(c, depth + 1);
   };
   walk(root, 0);
-  return { nodeIds: labels, edges: Math.max(0, labels.length - 1), subgraphNames: [], maxDepth };
+  return {
+    nodeIds: labels,
+    edges: Math.max(0, labels.length - 1),
+    subgraphNames: [],
+    maxDepth: 0,
+    treeDepth: maxDepth
+  };
 }
 function adaptKanban(db) {
   const data = callGetter(db, "getData");
@@ -543,16 +554,20 @@ function adaptMindmap(db) {
       walk(c, depth + 1);
   };
   walk(root, 0);
-  return { nodeIds: labels, edges: Math.max(0, labels.length - 1), subgraphNames: [], maxDepth };
+  return {
+    nodeIds: labels,
+    edges: Math.max(0, labels.length - 1),
+    subgraphNames: [],
+    maxDepth: 0,
+    treeDepth: maxDepth
+  };
 }
 function adaptQuadrantChart(db) {
   const data = callGetter(db, "getQuadrantData");
-  const quadrants = data?.quadrants ?? [];
-  const labels = quadrants.map((q) => {
-    const t = q.text;
-    return typeof t === "string" ? t : t?.text ?? "";
-  });
-  return { nodeIds: labels, edges: 0, subgraphNames: [], maxDepth: 0 };
+  const textOf = (t) => typeof t === "string" ? t : t?.text ?? "";
+  const quadrants = (data?.quadrants ?? []).map((q) => textOf(q.text)).filter((t) => t.trim() !== "");
+  const points = (data?.points ?? []).map((p, i) => textOf(p.text) || `point_${i}`);
+  return { nodeIds: [...quadrants, ...points], edges: 0, subgraphNames: [], maxDepth: 0 };
 }
 function adaptRequirement(db) {
   const requirements = db.requirements instanceof Map ? db.requirements : new Map;
@@ -578,18 +593,30 @@ function adaptSankey(db) {
 function adaptState(db) {
   const nodes = db.nodes ?? [];
   const edges = db.edges ?? [];
+  const groups = nodes.filter((n) => n.isGroup === true);
+  const parentOf = new Map(nodes.map((n) => [n.id ?? "", n.parentId]));
+  let maxDepth = 0;
+  for (const g of groups) {
+    let depth = 1;
+    const seen = new Set;
+    for (let cur = g.parentId;cur && !seen.has(cur); cur = parentOf.get(cur)) {
+      seen.add(cur);
+      depth++;
+    }
+    maxDepth = Math.max(maxDepth, depth);
+  }
   return {
     nodeIds: nodes.map((n) => n.id ?? ""),
     edges: edges.length,
-    subgraphNames: [],
-    maxDepth: 0
+    subgraphNames: groups.map((g) => g.id ?? ""),
+    maxDepth
   };
 }
 function adaptTimeline(db) {
   const tasks = callGetter(db, "getTasks") ?? [];
   const sections = callGetter(db, "getSections") ?? [];
   return {
-    nodeIds: tasks.map((t) => t.task ?? ""),
+    nodeIds: tasks.flatMap((t) => [t.task ?? "", ...(t.events ?? []).map((e) => `${t.task ?? ""}: ${e}`)]),
     edges: 0,
     subgraphNames: sections.map((s) => s.sectionName ?? s.section ?? ""),
     maxDepth: sections.length > 0 ? 1 : 0
@@ -619,7 +646,10 @@ function adaptVenn(db) {
 function adaptXychart(db) {
   const data = callGetter(db, "getXYChartData");
   const categories = data?.xAxis?.categories ?? [];
-  return { nodeIds: categories, edges: 0, subgraphNames: [], maxDepth: 0 };
+  if (categories.length > 0)
+    return { nodeIds: categories, edges: 0, subgraphNames: [], maxDepth: 0 };
+  const longest = Math.max(0, ...(data?.plots ?? []).map((p) => p.data?.length ?? 0));
+  return { nodeIds: Array.from({ length: longest }, (_, i) => `x_${i}`), edges: 0, subgraphNames: [], maxDepth: 0 };
 }
 function subgraphNestingDepth(subGraphs) {
   if (subGraphs.length === 0)
@@ -784,6 +814,15 @@ class RuleOptionError extends UsageError {
     this.option = option;
   }
 }
+class FixNotConvergingError extends MermaidLintError {
+  file;
+  rules;
+  constructor(file, passes, rules) {
+    super("fix-not-converging", `${file}: --fix did not converge after ${passes} passes; ${rules.join(", ")} kept proposing edits. A fixer must propose nothing once its edit is applied`);
+    this.file = file;
+    this.rules = rules;
+  }
+}
 
 class PluginLoadError extends MermaidLintError {
   source;
@@ -1146,7 +1185,7 @@ var calculateComplexity = (stats, config) => {
   const n = stats.nodes;
   const e = stats.edges;
   const s = stats.subgraphs;
-  const d = stats.max_subgraph_depth;
+  const d = Math.max(stats.max_subgraph_depth, stats.max_tree_depth);
   const base = n + e * config.edge_weight + s * config.subgraph_weight;
   const vcs = base * (1 + d * config.depth_weight);
   const maxEdges = n > 1 ? n * (n - 1) : 0;
@@ -1483,7 +1522,7 @@ 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 after the last line of the diagram.")),
+  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.")),
   fix: (ctx) => {
     const edits = [];
     const { src } = ctx.doc;
@@ -1647,29 +1686,47 @@ var sameDiagrams = async (before, after) => {
     if (!now || was.keyword !== now.keyword)
       return false;
     const [a, b] = await Promise.all([was.stats(), now.stats()]);
-    const shape = (s) => [
+    const shape = (s, source) => [
+      parseFailed(source, s),
       s.diagram_type,
       s.nodes,
       s.edges,
       s.subgraphs,
       s.max_subgraph_depth,
+      s.max_tree_depth,
       s.node_ids,
       s.subgraph_names
     ];
-    if (!sameJson(shape(a), shape(b)))
+    if (!sameJson(shape(a, was.source), shape(b, now.source)))
       return false;
   }
   return true;
 };
+var breaksAParse = async (before, after) => {
+  for (const [i, was] of before.diagrams.entries()) {
+    const now = after.diagrams[i];
+    if (!now)
+      continue;
+    const [a, b] = await Promise.all([was.stats(), now.stats()]);
+    if (!parseFailed(was.source, a) && parseFailed(now.source, b))
+      return true;
+  }
+  return false;
+};
 var verify = async (edit, before, after) => {
   if (edit.expect.kind === "same-tree") {
-    return sameTree(before.tree, after.tree, {}) ? "accept" : "refuse";
+    if (!sameTree(before.tree, after.tree, {}))
+      return "refuse";
+    if (before.kind === "markdown" && after.kind === "markdown") {
+      return await breaksAParse(before, after) ? "refuse" : "accept";
+    }
   }
   return await sameDiagrams(before, after) ? "accept" : "refuse";
 };
 
 // src/fix/engine.ts
 var MAX_PASSES = 1000;
+var RECENT_PASSES = 50;
 var splice = (src, edits) => {
   let out = src;
   for (const e of [...edits].sort((a, b) => b.start - a.start))
@@ -1687,6 +1744,7 @@ var fixSourceReport = async (src, file, flags = {}, registry = BUILTIN) => {
   const refused = [];
   const refusedKeys = new Set;
   let current = src;
+  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}`;
@@ -1719,35 +1777,39 @@ var fixSourceReport = async (src, file, flags = {}, registry = BUILTIN) => {
         continue;
       if (edits.length > 1 && !overlaps(edits) && await attempt(edits)) {
         progressed = true;
-        break;
-      }
-      for (const edit of edits) {
-        if (await attempt([edit])) {
-          progressed = true;
-          break;
+      } else {
+        for (const edit of edits) {
+          if (await attempt([edit])) {
+            progressed = true;
+            break;
+          }
+          refusedKeys.add(keyOf(edit));
+          refused.push(edit);
         }
-        refusedKeys.add(keyOf(edit));
-        refused.push(edit);
       }
-      if (progressed)
+      if (progressed) {
+        keptBy.push(rule.id);
         break;
+      }
     }
     if (!progressed)
       return { output: current, applied, refused };
   }
-  throw new Error(`fix did not converge after ${MAX_PASSES} passes; a fixer keeps proposing edits`);
+  const lingering = [...new Set(keptBy.slice(-RECENT_PASSES))].sort();
+  throw new FixNotConvergingError(file, MAX_PASSES, lingering);
 };
 
 // src/plugins/contract.ts
 var API_VERSION = 1;
 var CATEGORY_WORD = /^[a-z]+$/;
-var NAMESPACE = /^[a-z][a-z0-9-]*$/;
-var RULE_KEY = /^[a-z][a-z0-9-]*$/;
+var NAMESPACE = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+var RULE_KEY = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 
 // src/plugins/load.ts
 var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var message2 = (err) => err instanceof Error ? err.message : String(err);
 var OPTION_TYPES = new Set(["number", "string", "boolean", "string[]"]);
+var RESERVED_OPTIONS = ["preset", "profile"];
 var checkRule = (spec, key, raw, own) => {
   const where = `rule "${key}"`;
   if (!isRecord(raw))
@@ -1777,6 +1839,11 @@ var checkRule = (spec, key, raw, own) => {
     if (!valid) {
       throw new PluginContractError(spec, `${where} options must map names to number, string, boolean or string[]`);
     }
+    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`);
+      }
+    }
   }
   return raw;
 };

package/dist/types/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/types/check.d.ts

@@ -0,0 +1,10 @@
+import { type DocModel } from "./model.ts";
+import { type Registry } from "./rules/registry.ts";
+import type { Finding, Rule, RuleOptions } from "./rules/types.ts";
+export interface RunFlags {
+    preset?: string;
+    profile?: string;
+}
+export declare const optionsFor: (rule: Rule, configured: RuleOptions | undefined, flags: RunFlags) => RuleOptions;
+export declare const checkModel: (doc: DocModel, file: string, flags?: RunFlags, registry?: Registry) => Promise<Finding[]>;
+export declare const checkMarkdown: (src: string, file: string, flags?: RunFlags, registry?: Registry) => Promise<Finding[]>;

package/dist/types/cli.d.ts

@@ -0,0 +1,9 @@
+import type { PluginFailure } from "./plugins/index.ts";
+import type { LoadedSource, Registry } from "./rules/registry.ts";
+import { type Finding } from "./rules/types.ts";
+export declare const loadedLine: (sources: LoadedSource[], skipped: string[]) => string | null;
+export declare const skippedLines: (failures: PluginFailure[], ignored: string[]) => string[];
+export declare const listRules: (registry: Registry) => string;
+export declare const reportLine: (f: Finding, file: string) => string;
+export declare const describeError: (err: unknown) => string;
+export declare const main: (argv?: string[], cwd?: string) => Promise<number>;

package/dist/types/config.d.ts

@@ -0,0 +1,20 @@
+import { UsageError } from "./errors.ts";
+import type { RuleOptions } from "./rules/types.ts";
+export { UsageError };
+export type Severity = "error" | "off";
+export type PluginLoading = "strict" | "lenient";
+export interface RuleSetting {
+    severity: Severity;
+    options: RuleOptions;
+}
+export interface Config {
+    plugins: string[] | false;
+    pluginLoading: PluginLoading;
+    rules: Map<string, RuleSetting>;
+    file: string | null;
+}
+export declare const NO_CONFIG: Config;
+export declare const CONFIG_FILES: readonly ["mermaidjs-lint.config.json", "mermaidjs-lint.config.mjs"];
+export declare const parseConfig: (file: string, raw: unknown) => Config;
+export declare const findConfig: (root: string) => Promise<string | null>;
+export declare const loadConfig: (file: string) => Promise<Config>;

package/dist/types/errors.d.ts

@@ -0,0 +1,88 @@
+export declare class MermaidLintError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare class UsageError extends MermaidLintError {
+    constructor(message: string, code?: string);
+}
+export declare class FlagError extends UsageError {
+    readonly flag: string;
+    constructor(flag: string, message: string);
+}
+export declare class ConfigFileError extends UsageError {
+    readonly file: string;
+    constructor(file: string, message: string);
+}
+export declare class ConfigNotFoundError extends UsageError {
+    readonly path: string;
+    constructor(path: string);
+}
+export declare class ConfigCodeError extends UsageError {
+    readonly file: string;
+    constructor(file: string);
+}
+export declare class AmbiguousConfigError extends UsageError {
+    readonly files: string[];
+    constructor(root: string, files: string[]);
+}
+export declare class ConfigShapeError extends UsageError {
+    readonly file: string;
+    readonly key: string | null;
+    constructor(file: string, message: string, key?: string | null);
+}
+export declare class RuleSettingError extends UsageError {
+    readonly file: string;
+    readonly rule: string;
+    constructor(file: string, rule: string, message: string);
+}
+export declare class UnknownRuleError extends UsageError {
+    readonly file: string;
+    readonly rule: string;
+    readonly known: string[];
+    constructor(file: string, rule: string, known: string[]);
+}
+export declare class RuleOptionError extends UsageError {
+    readonly file: string;
+    readonly rule: string;
+    readonly option: string;
+    constructor(file: string, rule: string, option: string, message: string);
+}
+export declare class FixOutsideRootError extends UsageError {
+    readonly file: string;
+    readonly target: string;
+    constructor(file: string, target: string, root: string);
+}
+export declare class PackageJsonError extends MermaidLintError {
+    readonly file: string;
+    constructor(file: string);
+}
+export declare class FixNotConvergingError extends MermaidLintError {
+    readonly file: string;
+    readonly rules: string[];
+    constructor(file: string, passes: number, rules: string[]);
+}
+export declare class PluginLoadError extends MermaidLintError {
+    readonly source: string;
+    constructor(source: string, reason: string, code?: string);
+}
+export declare class PluginImportError extends PluginLoadError {
+    constructor(source: string, reason: string);
+}
+export declare class PluginContractError extends PluginLoadError {
+    constructor(source: string, reason: string);
+}
+export declare class PluginConflictError extends PluginLoadError {
+    readonly other: string;
+    constructor(source: string, other: string, reason: string);
+}
+export declare class PluginNotInstalledError extends PluginLoadError {
+    readonly root: string;
+    constructor(source: string, root: string);
+}
+export declare class PluginSourceError extends PluginLoadError {
+    constructor(source: string, reason: string);
+}
+export declare class PluginFixerError extends MermaidLintError {
+    readonly rule: string;
+    constructor(rule: string, reason: string);
+}

package/dist/types/files.d.ts

@@ -0,0 +1,8 @@
+export declare const DIAGRAM_FILE_EXTS: Set<string>;
+export declare const SKIP_DIRS: Set<string>;
+export interface Collected {
+    files: string[];
+    unreadable: string[];
+    symlinks: string[];
+}
+export declare const collectFiles: (paths: string[]) => Collected;

package/dist/types/fix/engine.d.ts

@@ -0,0 +1,10 @@
+import { type RunFlags } from "../check.ts";
+import { type Registry } from "../rules/registry.ts";
+import type { Edit } from "../rules/types.ts";
+export interface FixReport {
+    output: string;
+    applied: Edit[];
+    refused: Edit[];
+}
+export declare const fixSourceReport: (src: string, file: string, flags?: RunFlags, registry?: Registry) => Promise<FixReport>;
+export declare const fixSource: (src: string, file: string, flags?: RunFlags, registry?: Registry) => Promise<string>;

package/dist/types/fix/verify.d.ts

@@ -0,0 +1,12 @@
+import type { Node } from "mdast";
+import type { DocModel } from "../model.ts";
+import type { Edit } from "../rules/types.ts";
+type Plain = {
+    [k: string]: unknown;
+};
+export declare const normalise: (node: Node, opts?: {
+    blankDiagrams?: boolean;
+}) => Plain;
+export type Verdict = "accept" | "refuse";
+export declare const verify: (edit: Edit, before: DocModel, after: DocModel) => Promise<Verdict>;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,18 @@
+export { checkMarkdown, checkModel, type RunFlags } from "./check.ts";
+export { main } from "./cli.ts";
+export { type Config, loadConfig, type PluginLoading, parseConfig, type RuleSetting, type Severity } from "./config.ts";
+export * from "./errors.ts";
+export { type Collected, collectFiles } from "./files.ts";
+export { type FixReport, fixSource, fixSourceReport } from "./fix/engine.ts";
+export { buildDocModel, DIAGRAM_EXTS, type Diagram, type DocModel, documentKind } from "./model.ts";
+export type { ContrastAssessment, StyleDirective, ValueSpan } from "./parse/color.ts";
+export { PRESETS, type Preset, type ThresholdConfig, thresholdsFrom } from "./parse/metrics.ts";
+export { type DiagramStats, detectKeyword, extractStats } from "./parse/stats.ts";
+export type { Plugin, PluginEdit, PluginFinding, PluginMeta, PluginRule } from "./plugins/contract.ts";
+export type { SourceKind } from "./plugins/discover.ts";
+export type { PluginFailure } from "./plugins/index.ts";
+export { findProjectRoot, type Setup, type SetupOptions, setUp } from "./project.ts";
+export { FIX_ORDER, RULES } from "./rules/index.ts";
+export { BUILTIN, BUILTIN_CATEGORIES, buildRegistry, type LoadedSource, type Registry, type RegistryInput, } from "./rules/registry.ts";
+export type { Category, CheckContext, CoreRuleId, Edit, Expectation, Finding, FixContext, Helpers, OptionSpec, OptionType, PluginRuleId, Rule, RuleContext, RuleId, RuleOptions, } from "./rules/types.ts";
+export { CATEGORIES, RULE } from "./rules/types.ts";

package/dist/types/model.d.ts

@@ -0,0 +1,27 @@
+import type { Root } from "mdast";
+import { type StyleDirective, type ValueSpan } from "./parse/color.ts";
+import { type DiagramStats } from "./parse/stats.ts";
+export interface Diagram {
+    index: number;
+    source: string;
+    keyword: string | null;
+    startLine: number;
+    endLine: number;
+    firstLine: number;
+    terminated: boolean;
+    endOffset: number;
+    directives: StyleDirective[];
+    offsetOf: (span: ValueSpan) => number | null;
+    stats: () => Promise<DiagramStats>;
+}
+export interface DocModel {
+    src: string;
+    kind: "markdown" | "diagram";
+    tree: Root;
+    diagrams: Diagram[];
+}
+export declare const parse: (src: string) => Root;
+export declare const DIAGRAM_EXTS: readonly [".mmd", ".mermaid"];
+export declare const documentKind: (file: string) => "markdown" | "diagram";
+export declare const buildDocModel: (src: string, kind?: "markdown" | "diagram") => DocModel;
+export declare const isMarkdownFile: (file: string) => boolean;

package/dist/types/parse/color.d.ts

@@ -0,0 +1,28 @@
+export type WcagRating = "AAA" | "AA" | "AA Large" | "Fail";
+export interface ContrastAssessment {
+    foreground: string;
+    background: string;
+    ratio: number;
+    rating: WcagRating;
+    apca_lc: number;
+}
+export declare const wcagRatio: (fg: string, bg: string) => number;
+export declare const apcaLc: (fg: string, bg: string) => number;
+export declare const alphaOf: (color: string) => number;
+export declare const compositeOver: (fg: string, bg: string) => string;
+export declare const wcagRating: (ratio: number) => WcagRating;
+export declare const wcagAssess: (fg: string, bg: string) => ContrastAssessment;
+export interface ValueSpan {
+    line: number;
+    start: number;
+    end: number;
+}
+export interface StyleDirective {
+    kind: "classDef" | "style" | "linkStyle" | "inlineClass";
+    selector: string;
+    class_name?: string;
+    properties: Record<string, string>;
+    spans: Record<string, ValueSpan>;
+    line: number;
+}
+export declare const extractStyleDirectives: (source: string) => StyleDirective[];

package/dist/types/parse/contrast.d.ts

@@ -0,0 +1,35 @@
+import { type ContrastAssessment, type StyleDirective } from "./color.ts";
+export type Profile = "github" | "mkdocs-material";
+export type Theme = "light" | "dark";
+export type PairKind = "text" | "border";
+export type ErRow = "odd" | "even";
+export declare const PROFILES: readonly ["auto", "github", "mkdocs-material"];
+export declare const edgeLabelBackground: (theme: Theme) => string;
+export interface ContrastPair {
+    kind: PairKind;
+    selector: string;
+    directive: StyleDirective;
+    foreground: string;
+    background: string;
+    line: number;
+    assessment: ContrastAssessment;
+    passes: boolean;
+    theme?: Theme;
+    row?: ErRow;
+    advisory?: boolean;
+}
+export interface SkippedDirective {
+    selector: string;
+    line: number;
+    reason: string;
+    blocking?: boolean;
+}
+export interface ContrastResult {
+    pairs: ContrastPair[];
+    skipped: SkippedDirective[];
+}
+export declare const scoreGithub: (directives: StyleDirective[]) => ContrastResult;
+export declare const scoreMkdocs: (directives: StyleDirective[]) => ContrastResult;
+export declare const scoreEr: (directives: StyleDirective[]) => ContrastResult;
+export declare const scoreForProfile: (directives: StyleDirective[], profile: Profile, keyword: string | null) => ContrastResult;
+export declare const detectProfile: (filePath: string) => Profile;

package/dist/types/parse/metrics.d.ts

@@ -0,0 +1,48 @@
+import type { DiagramStats } from "./stats.ts";
+export interface Preset {
+    node_ideal: number;
+    node_acceptable: number;
+    node_complex: number;
+    node_hard_limit: number;
+    vcs_ideal: number;
+    vcs_acceptable: number;
+    vcs_complex: number;
+    vcs_critical: number;
+    node_target: number;
+    vcs_target: number;
+}
+export declare const PRESETS: Record<string, Preset>;
+export declare const DEFAULT_PRESET = "high-density";
+export interface ThresholdConfig extends Preset {
+    edge_weight: number;
+    subgraph_weight: number;
+    depth_weight: number;
+    preset_name: string;
+}
+export declare const THRESHOLD_OPTIONS: {
+    readonly nodeIdeal: "node_ideal";
+    readonly nodeAcceptable: "node_acceptable";
+    readonly nodeComplex: "node_complex";
+    readonly nodeHardLimit: "node_hard_limit";
+    readonly vcsIdeal: "vcs_ideal";
+    readonly vcsAcceptable: "vcs_acceptable";
+    readonly vcsComplex: "vcs_complex";
+    readonly vcsCritical: "vcs_critical";
+    readonly nodeTarget: "node_target";
+    readonly vcsTarget: "vcs_target";
+    readonly edgeWeight: "edge_weight";
+    readonly subgraphWeight: "subgraph_weight";
+    readonly depthWeight: "depth_weight";
+};
+export declare const PRESET_NAMES: string[];
+export declare const canonicalPreset: (name: string) => string | null;
+export declare const configFromPreset: (name: string) => ThresholdConfig;
+export declare const thresholdsFrom: (options: Readonly<Record<string, unknown>>) => ThresholdConfig;
+export interface ComplexityMetrics {
+    visual_complexity_score: number;
+    edge_density: number;
+    cyclomatic_complexity: number;
+}
+export declare const calculateComplexity: (stats: DiagramStats, config: ThresholdConfig) => ComplexityMetrics;
+export declare const parseFailed: (content: string, stats: DiagramStats) => boolean;
+export declare const sourceLines: (content: string) => number;

package/dist/types/parse/stats.d.ts

@@ -0,0 +1,25 @@
+export interface DiagramStats {
+    nodes: number;
+    edges: number;
+    subgraphs: number;
+    max_subgraph_depth: number;
+    max_tree_depth: number;
+    node_ids: string[];
+    subgraph_names: string[];
+    parser_used: "langium" | "mermaid-core";
+    diagram_type: string;
+    error: string | null;
+}
+type MermaidStats = DiagramStats;
+export declare function detectKeyword(content: string): string | null;
+export declare function extractStats(content: string): Promise<MermaidStats>;
+export declare const parserReason: (err: unknown) => string;
+export declare function indentTreeStats(items: Array<{
+    label: string;
+    indent: number;
+}>): {
+    labels: string[];
+    edges: number;
+    depth: number;
+};
+export {};