@zombie-mermaid/core 2.2.1

package/dist/index.d.ts

@@ -0,0 +1,1236 @@
+import { ElkNode } from 'elkjs';
+
+/**
+ * Test-only: reset the title-id counter so id assertions in tests don't
+ * depend on how many titled diagrams earlier tests in the same file rendered.
+ * Not part of the public API (not re-exported from src/index.ts).
+ */
+export declare function __resetSvgTitleIdCounterForTests(): void;
+
+/**
+ * Parse a `click <id> ...` statement and record the resulting
+ * {@link NodeInteraction} in `interactions`, keyed by whatever id scheme the
+ * caller's diagram type uses (flowchart/state node id, class diagram class
+ * id, ...).
+ *
+ * Supported forms:
+ *   click id "url" ["tooltip"] [_blank|_self|_parent|_top]
+ *   click id href "url" ["tooltip"] [_blank|_self|_parent|_top]
+ *   click id call fn() ["tooltip"]
+ *   click id callback fn() ["tooltip"]
+ *
+ * A line that doesn't match `click <id> ...` at all is a no-op — callers are
+ * expected to have already gated on a leading `click` keyword before calling
+ * this (see the `/^click\s+/i` checks at each call site) purely so this
+ * function's own regex can stay anchored to the id capture.
+ */
+export declare function applyClickStatement(line: string, interactions: Map<string, NodeInteraction>): void;
+
+/**
+ * Fold an init config into render options.
+ *
+ * Caller-supplied options always win: a directive supplies a default, never
+ * an override. See the module header for why.
+ */
+export declare function applyInitConfig(options: RenderOptions, config: InitConfig): RenderOptions;
+
+/**
+ * Build the CSS variable derivation rules for the SVG <style> block.
+ *
+ * When an optional variable (--line, --accent, etc.) is set on the SVG or
+ * a parent element, it's used directly. When unset, the fallback computes
+ * a blended value from --fg and --bg using color-mix().
+ *
+ * `nonce`, when given, lands on the `<style>` element as a `nonce`
+ * attribute — see `styleOpenTag()`.
+ *
+ * `font` is user-supplied input. When it's a CSS `var(...)` reference (e.g.
+ * `var(--font-family-body)`, letting the SVG inherit a host page's
+ * design-system font), the Google Fonts `@import` is skipped — it would
+ * otherwise URL-encode the literal `var(...)` string into a `family=` query
+ * param and produce a guaranteed no-op request — and the value is emitted
+ * unquoted, since a quoted string isn't parsed as a `var()` call by CSS.
+ *
+ * The `@import` is likewise skipped when `font` is a font *stack* (a
+ * comma-separated list, e.g. `"ui-sans-serif, system-ui, sans-serif"`) or a
+ * single CSS generic family keyword (e.g. `"system-ui"`) — see
+ * `isFontStackOrGenericFamily`. Neither names a single concrete font that
+ * Google Fonts could host, so importing one always produces a dead,
+ * always-404 request (#223). This is additive to the `var()` skip above,
+ * and only affects the `@import` decision — the `text { font-family: ... }`
+ * rule still renders the literal value exactly as it does today.
+ *
+ * Any other value is treated as a literal font name: sanitized and quoted
+ * exactly as before.
+ *
+ * `hasMonoFont`'s `.mono` rule (class-diagram method signatures, ER-diagram
+ * attribute types) never reaches out to Google Fonts at all — it used to
+ * `@import` 'JetBrains Mono' from Google's CDN, a third-party network
+ * dependency a published library's default SVG output had no business
+ * making (#1061, filed as a follow-up from #1059's ASCII-side self-hosting
+ * fix). It now embeds {@link SVG_MONO_FONT_FACE_CSS} — a small, subsetted
+ * (Basic Latin + Latin-1 Supplement), self-hosted `@font-face` as a base64
+ * `woff2` data URI, generated by scripts/build-mono-font-subset.ts into
+ * ./generated/mono-font-subset.ts — directly in the SVG's own `<style>`
+ * block. Unlike `font` above, this isn't caller-configurable: it's the same
+ * embed for every consumer, on by default, with no network request either
+ * way — a strict improvement over the dead-or-alive CDN fetch it replaces,
+ * and the only way a *standalone* SVG (no surrounding host page providing
+ * its own copy of the font) renders `.mono` text correctly out of the box.
+ */
+export declare function buildStyleBlock(font: string, hasMonoFont: boolean, nonce?: string): string;
+
+/**
+ * Options applicable to class diagrams (`classDiagram`). Class diagrams use
+ * fixed internal padding/spacing (not `padding`/`nodeSpacing`/
+ * `layerSpacing`) and have no `direction` or `curve` concept; `interactivity`
+ * gates `click`-based links only — there's no edge-animation concept to gate.
+ */
+export declare type ClassRenderOptions = CommonRenderOptions & Pick<RenderOptions, 'fontSizes' | 'interactivity' | 'layoutCache'>;
+
+/**
+ * Options every diagram type honors: theming (colors, font), the shared
+ * strict-CSP/accessibility/output controls, and the post-render
+ * `resolveColors` pass. Every other `RenderOptions` field applies to only a
+ * subset of diagram types — see the per-type types below.
+ */
+export declare type CommonRenderOptions = Pick<RenderOptions, 'bg' | 'fg' | 'line' | 'accent' | 'muted' | 'surface' | 'border' | 'font' | 'transparent' | 'embedSource' | 'resolveColors' | 'nonce' | 'styleAttribute' | 'title' | 'decorative'>;
+
+/** How an edge path is interpolated between its routed points. */
+export declare type CurveStyle = 'linear' | 'basis' | 'natural' | 'step' | 'stepBefore' | 'stepAfter';
+
+/** Default bg/fg when no colors are provided (zinc light) */
+export declare const DEFAULTS: Readonly<{
+    bg: string;
+    fg: string;
+}>;
+
+/** Human-readable note about directive keys that were parsed but not applied. */
+export declare function describeIgnored(config: InitConfig): string[];
+
+/**
+ * Detect the diagram type from the mermaid source text.
+ * Returns the type keyword used for routing to the correct pipeline.
+ *
+ * The header keyword is the first *statement*, not the first line: Mermaid
+ * allows `;` as a statement separator, so `flowchart TD;A-->B` has its header
+ * and first edge on one line. Uses the same splitter every parser uses, so
+ * routing and parsing can never disagree about where the header ends.
+ */
+export declare function detectDiagramType(text: string): DiagramType;
+
+/**
+ * Diagram color configuration.
+ *
+ * Required: bg + fg give you a clean mono diagram.
+ * Optional: line, accent, muted, surface, border bring in richer color
+ * from Shiki themes or custom palettes. Each falls back to a color-mix()
+ * derivation from bg + fg if not set.
+ */
+export declare interface DiagramColors {
+    /** Background color → CSS variable --bg */
+    bg: string;
+    /** Foreground / primary text color → CSS variable --fg */
+    fg: string;
+    /** Edge/connector color → CSS variable --line */
+    line?: string;
+    /** Arrow heads, highlights, special nodes → CSS variable --accent */
+    accent?: string;
+    /** Secondary text, edge labels → CSS variable --muted */
+    muted?: string;
+    /** Node/box fill tint → CSS variable --surface */
+    surface?: string;
+    /** Node/group stroke color → CSS variable --border */
+    border?: string;
+}
+
+/** The diagram types this library can detect and route to a renderer. */
+export declare type DiagramType = 'flowchart' | 'sequence' | 'class' | 'er' | 'xychart';
+
+export declare type Direction = 'TD' | 'TB' | 'LR' | 'BT' | 'RL';
+
+export declare type EdgeStyle = 'solid' | 'dotted' | 'thick'
+/** `A ~~~ B` — participates in layout but draws no line or arrowhead. */
+| 'invisible';
+
+/**
+ * Options applicable to ER diagrams (`erDiagram`). ER diagrams use fixed
+ * internal padding/spacing and ignore `curve` and `interactivity` (no
+ * animated edges or `click` links in this renderer's ER support), but do
+ * honor `direction` (applied before layout via `withDirectionOverride`).
+ */
+export declare type ErRenderOptions = CommonRenderOptions & Pick<RenderOptions, 'direction' | 'fontSizes' | 'layoutCache'>;
+
+/**
+ * Escape a string for use as an XML/HTML attribute value.
+ * Escapes quotes and ampersands to prevent attribute injection.
+ *
+ * Deliberately distinct from `escapeXml()` above: attribute values in this
+ * codebase are always double-quoted, so single quotes don't need escaping —
+ * `escapeXml()` escapes them too (for safe embedding in either quote style),
+ * which would change output if reused here.
+ */
+export declare function escapeAttr(value: string): string;
+
+/**
+ * Escape special XML characters in text content.
+ */
+export declare function escapeXml(text: string): string;
+
+/**
+ * Scan a whole diagram for init directives and merge them.
+ *
+ * Later directives win over earlier ones, matching Mermaid, where a second
+ * directive overrides the first.
+ */
+export declare function extractInitConfig(lines: string[]): InitConfig;
+
+/**
+ * Options applicable to flowchart (`graph` / `flowchart`) and state
+ * (`stateDiagram-v2`) diagrams — both share `DiagramType: 'flowchart'` and
+ * the same layout/render pipeline (src/layout-engine.ts, src/renderer.ts),
+ * so they share one option shape. `componentSpacing` is currently a no-op
+ * everywhere (accepted for forward compatibility only) but grouped here
+ * since it's spacing-shaped like `padding`/`nodeSpacing`/`layerSpacing`.
+ */
+export declare type FlowchartRenderOptions = CommonRenderOptions & Pick<RenderOptions, 'padding' | 'nodeSpacing' | 'layerSpacing' | 'componentSpacing' | 'mergeEdges' | 'direction' | 'curve' | 'fontSizes' | 'interactivity' | 'layoutCache'>;
+
+/**
+ * Serialize a color as `#rrggbb` when fully opaque, otherwise as
+ * `rgba(r, g, b, a)` — the two forms every SVG consumer (browsers, resvg,
+ * librsvg, Inkscape) agrees on.
+ */
+export declare function formatCssColor(c: RgbaColor): string;
+
+/**
+ * Extract diagram colors from a Shiki theme object.
+ * Works with any VS Code / TextMate theme loaded by Shiki.
+ *
+ * Maps editor UI colors to diagram roles:
+ *   editor.background         → bg
+ *   editor.foreground         → fg
+ *   editorLineNumber.fg       → line (optional)
+ *   focusBorder / keyword     → accent (optional)
+ *   comment token             → muted (optional)
+ *   editor.selectionBackground→ surface (optional)
+ *   editorWidget.border       → border (optional)
+ *
+ * @example
+ * ```ts
+ * import { getSingletonHighlighter } from 'shiki'
+ * import { fromShikiTheme } from 'zombie-mermaid'
+ *
+ * const hl = await getSingletonHighlighter({ themes: ['tokyo-night'] })
+ * const colors = fromShikiTheme(hl.getTheme('tokyo-night'))
+ * const svg = renderMermaidSVG(code, colors)
+ * ```
+ */
+export declare function fromShikiTheme(theme: ShikiThemeLike): DiagramColors;
+
+/**
+ * Get the relative width of a single character.
+ *
+ * Returns a normalized width ratio where:
+ * - 0.0 = zero-width (combining marks)
+ * - 0.3 = space
+ * - 0.4 = narrow (i, l, t, f, j, I, 1)
+ * - 0.8 = semi-narrow (r)
+ * - 1.0 = average lowercase
+ * - 1.2 = wide lowercase / uppercase
+ * - 1.5 = very wide (W, M)
+ * - 2.0 = fullwidth (CJK, emoji)
+ */
+export declare function getCharWidth(char: string): number;
+
+/**
+ * Pick a readable text color for a given fill color.
+ *
+ * If `fill` is a concrete, resolvable hex color, returns pure black or
+ * white depending on the fill's perceptual luminance (threshold 0.5: light
+ * fills get dark text, dark fills get light text). If `fill` is undefined
+ * or isn't a resolvable color (a `var(...)` reference, a named CSS color,
+ * or malformed input), returns `fallback` unchanged so callers don't guess
+ * at colors they can't actually evaluate.
+ */
+export declare function getReadableTextColor(fill: string | undefined, fallback: string): string;
+
+/**
+ * Whether `char` has an exact measured Inter advance in `INTER_ADVANCES`,
+ * as opposed to falling through to a coarse character-class bucket or the
+ * default width in `getCharWidth`. Exported only so tests can assert the
+ * table covers every printable ASCII character (U+0020–U+007E) — a gap
+ * here means a real character silently degrades to an approximate width.
+ */
+export declare function hasMeasuredAdvance(char: string): boolean;
+
+/** Configuration a diagram can set for itself via `%%{init: ...}%%`. */
+export declare interface InitConfig {
+    theme?: string;
+    /** Flowchart edge interpolation. */
+    curve?: CurveStyle;
+    /** Recognized but not acted on — see `IGNORED_KEYS`. */
+    ignored: string[];
+}
+
+/** True when `value` is one of the five directions Mermaid recognizes. */
+export declare function isDirection(value: string): value is Direction;
+
+/** True if `line` is an init directive. */
+export declare function isInitDirective(line: string): boolean;
+
+/** Fonts whose glyphs all share one advance width. */
+export declare function isMonospaceFont(font: string): boolean;
+
+/**
+ * Check if a single character (code point) is "wide" — i.e. renders as two
+ * columns in a monospace terminal / two grid cells wide instead of one.
+ * Covers CJK/kana/hangul/fullwidth-form characters (via `isFullwidth`) as
+ * well as emoji. Shared by the SVG text-measurement path (`getCharWidth`
+ * above) and the ASCII grid's display-width helpers
+ * (`src/ascii/display-width.ts`), so both agree on what counts as wide.
+ */
+export declare function isWideChar(char: string): boolean;
+
+/**
+ * Opt-in bounded LRU cache for `elkLayoutSync()` results.
+ *
+ * Off by default — `elkLayoutSync()` only consults a cache when one is
+ * explicitly passed in, so existing callers see no behavior change.
+ * Create one with `createLayoutCache()` and reuse it across renders (e.g.
+ * module scope, or a `useRef` in React) — a fresh cache per render defeats
+ * the point.
+ *
+ * The `map`/`maxSize` fields are implementation detail exposed only so
+ * `elkLayoutSync()` (and tests) can read/mutate them directly without a
+ * class; treat a `LayoutCache` as opaque from outside this module.
+ */
+export declare interface LayoutCache {
+    /* Excluded from this release type: map */
+    /* Excluded from this release type: maxSize */
+}
+
+/** Standard line height ratio for multi-line text (1.3 = 130% of font size) */
+export declare const LINE_HEIGHT_RATIO = 1.3;
+
+/**
+ * Measure multi-line text dimensions.
+ *
+ * Splits text on newlines and returns the maximum width across all lines,
+ * total height based on line count, and the split lines for rendering.
+ *
+ * @param text - The text to measure (may contain \n)
+ * @param fontSize - Font size in pixels
+ * @param fontWeight - Font weight (affects width slightly)
+ * @returns Metrics including width, height, lines array, and lineHeight
+ */
+export declare function measureMultilineText(text: string, fontSize: number, fontWeight: number): MultilineMetrics;
+
+export declare function measureTextWidth(text: string, fontSize: number, fontWeight: number): number;
+
+export declare interface MermaidEdge {
+    source: string;
+    target: string;
+    label?: string;
+    style: EdgeStyle;
+    /** Whether to render an arrowhead at the start (source end) of the edge */
+    hasArrowStart: boolean;
+    /** Whether to render an arrowhead at the end (target end) of the edge */
+    hasArrowEnd: boolean;
+    /**
+     * Terminator shape at the source end when it's a circle/cross marker
+     * (`o--`/`x--`) rather than a plain arrowhead. Undefined for a regular
+     * `<`-style arrowhead or no marker at all — `hasArrowStart` alone still
+     * governs whether anything is drawn there. Currently consumed by the
+     * ASCII renderer only (see issue #330); the SVG renderer still draws a
+     * plain arrowhead for these.
+     */
+    startMarker?: 'circle' | 'cross';
+    /** Terminator shape at the target end (`--o`/`--x`). See `startMarker`. */
+    endMarker?: 'circle' | 'cross';
+    /** Edge id from `A e1@--> B` (Mermaid v11.10.0+), for `e1@{ ... }` and CSS targeting */
+    id?: string;
+    /** Set by `e1@{ animate: true }` — renders as a marching-ants dash */
+    animate?: boolean;
+}
+
+export declare interface MermaidGraph {
+    direction: Direction;
+    nodes: Map<string, MermaidNode>;
+    edges: MermaidEdge[];
+    subgraphs: MermaidSubgraph[];
+    classDefs: Map<string, Record<string, string>>;
+    /** Maps node IDs to their class names (from `class X className` or `:::className` shorthand) */
+    classAssignments: Map<string, string>;
+    /** Maps node IDs to inline styles (from `style X fill:#f00,stroke:#333`) */
+    nodeStyles: Map<string, Record<string, string>>;
+    /** Maps edge indices (or 'default') to inline styles from `linkStyle` directives */
+    linkStyles: Map<number | 'default', Record<string, string>>;
+    /** Maps node IDs to interactions declared by `click` statements */
+    interactions: Map<string, NodeInteraction>;
+    /** Configuration the diagram set for itself via `%%{init: ...}%%` */
+    initConfig?: InitConfig;
+}
+
+export declare interface MermaidNode {
+    id: string;
+    label: string;
+    shape: NodeShape;
+}
+
+export declare interface MermaidSubgraph {
+    id: string;
+    label: string;
+    nodeIds: string[];
+    children: MermaidSubgraph[];
+    /** Optional direction override for this subgraph's internal layout */
+    direction?: Direction;
+}
+
+export declare const MIX: {
+    /** Primary text: near-full fg */
+    readonly text: 100;
+    /** Secondary text (group headers): fg mixed at 60% */
+    readonly textSec: 60;
+    /** Muted text (edge labels, notes): fg mixed at 40% */
+    readonly textMuted: 40;
+    /** Faint text (de-emphasized): fg mixed at 25% */
+    readonly textFaint: 25;
+    /** Edge/connector lines: fg mixed at 50% for clear visibility */
+    readonly line: 50;
+    /** Arrow head fill: fg mixed at 85% for clear visibility */
+    readonly arrow: 85;
+    /** Node fill tint: fg mixed at 3% */
+    readonly nodeFill: 3;
+    /** Node/group stroke: fg mixed at 20% */
+    readonly nodeStroke: 20;
+    /** Group header band tint: fg mixed at 5% */
+    readonly groupHeader: 5;
+    /** Inner divider strokes: fg mixed at 12% */
+    readonly innerStroke: 12;
+    /** Key badge background opacity (ER diagrams) */
+    readonly keyBadge: 10;
+};
+
+/**
+ * Mix `fg` into `bg` at `pct` percent — the shape every MIX entry in
+ * packages/core/src/theme.ts uses (`color-mix(in srgb, var(--fg) N%, var(--bg))`).
+ * Returns `fg` unchanged when either input isn't a concrete color this
+ * module can parse (a `var(...)` reference, a named color).
+ */
+export declare function mixHexColors(fg: string, bg: string, pct: number): string;
+
+/**
+ * Evaluate `color-mix(in srgb, c1 p1%, c2 p2%)` per CSS Color Module
+ * Level 5 (https://www.w3.org/TR/css-color-5/#color-mix): percentages are
+ * normalized so they sum to 100 (a sum under 100 additionally scales the
+ * result's alpha by `sum / 100`), and the two colors are interpolated in
+ * premultiplied-alpha space, so mixing an opaque color toward
+ * `transparent` fades its alpha without darkening it.
+ *
+ * `p1`/`p2` follow the spec's omission rules: pass `undefined` for an
+ * omitted percentage (both omitted → 50/50; one omitted → 100 minus the
+ * other). Returns null when both percentages are zero, which the spec
+ * defines as invalid.
+ */
+export declare function mixSrgb(c1: RgbaColor, c2: RgbaColor, p1?: number, p2?: number): RgbaColor | null;
+
+/** Metrics for multi-line text measurement */
+export declare interface MultilineMetrics {
+    /** Maximum line width in pixels */
+    width: number;
+    /** Total height in pixels (lines × lineHeight) */
+    height: number;
+    /** Individual lines after splitting */
+    lines: string[];
+    /** Computed line height in pixels */
+    lineHeight: number;
+}
+
+/**
+ * An interaction attached to a node by a `click` statement.
+ *
+ * This renderer emits static SVG and never executes diagram-supplied script,
+ * so a `call`/callback binding is parsed but not invoked — see
+ * docs/diagrams.md and docs/decisions/no-script-interactivity.md. An `href`
+ * becomes a real SVG link and a tooltip becomes a `<title>`.
+ */
+export declare interface NodeInteraction {
+    /** `click A "https://..."` — rendered as an <a> wrapper */
+    href?: string;
+    /** Link target, e.g. `_blank` */
+    target?: string;
+    /** Tooltip text — rendered as a <title> child */
+    tooltip?: string;
+    /**
+     * `click A call fn()` — the raw expression text (`fn()`), exposed as data
+     * only. Nothing in the rendered SVG carries it and the library never
+     * evaluates it; a host that trusts its diagram source reads it from
+     * `parseMermaid(source).interactions` and binds behaviour to the node's
+     * `data-id` attribute itself:
+     *
+     * ```ts
+     * for (const [id, { callback }] of parseMermaid(source).interactions) {
+     *   if (callback === 'showDetail()') {
+     *     svgRoot.querySelector(`[data-id="${id}"]`)
+     *       ?.addEventListener('click', () => showDetail(id))
+     *   }
+     * }
+     * ```
+     */
+    callback?: string;
+}
+
+export declare type NodeShape = 'rectangle' | 'rounded' | 'diamond' | 'stadium' | 'circle' | 'subroutine' | 'doublecircle' | 'hexagon' | 'cylinder' | 'asymmetric' | 'trapezoid' | 'trapezoid-alt' | 'parallelogram' | 'parallelogram-alt' | 'state-start' | 'state-end' | 'document' | 'stacked-document' | 'stacked-process' | 'card' | 'lined-process' | 'divided-process' | 'window-pane' | 'triangle' | 'flipped-triangle' | 'filled-circle' | 'crossed-circle' | 'fork-join' | 'notched-pentagon' | 'sloped-rectangle' | 'flag' | 'bow-tie-rectangle' | 'half-rounded-rectangle' | 'brace' | 'brace-right' | 'braces' | 'bolt' | 'text' | 'anchor';
+
+/**
+ * Normalize label text: strip surrounding quotes, convert <br> tags and
+ * literal \n sequences to newline characters. Strips unsupported HTML tags
+ * but preserves formatting tags (<b>, <i>, <u>, <s>) for SVG rendering.
+ */
+export declare function normalizeBrTags(label: string): string;
+
+/**
+ * Parse a concrete CSS color value into sRGB components.
+ *
+ * Accepts the forms this library's own theme system produces or documents:
+ * hex literals (`#rgb`, `#rgba`, `#rrggbb`, `#rrggbbaa`), `rgb()`/`rgba()`,
+ * and the `transparent` keyword. Anything else — CSS named colors, `hsl()`,
+ * `var(...)`, an unresolved `color-mix(...)` — returns null so the caller
+ * can leave it untouched rather than guess.
+ */
+export declare function parseCssColor(value: string): RgbaColor | null;
+
+/**
+ * Parse a hex color string into 0-255 RGB components, ignoring any alpha
+ * digits. Returns null for anything that isn't a well-formed hex literal
+ * (e.g. `var(--foo)`, named CSS colors, or attribute-injection payloads) —
+ * the caller should treat those as unresolvable and fall back.
+ */
+export declare function parseHexColor(value: string): [number, number, number] | null;
+
+/** Parse a hex color literal (3/4/6/8 digits) into an RgbaColor, or null. */
+export declare function parseHexRgba(value: string): RgbaColor | null;
+
+/**
+ * Parse an init directive's payload.
+ *
+ * Returns `undefined` when the line is not a directive or its payload cannot
+ * be parsed. A malformed directive is ignored rather than fatal: Mermaid
+ * treats config as advisory, and failing an entire diagram over a stray brace
+ * in a comment-like construct would be a poor trade.
+ */
+export declare function parseInitDirective(line: string): InitConfig | undefined;
+
+/** Parse "fill:#f00,stroke:#333" style property strings into a Record */
+export declare function parseStyleProps(propsStr: string): Record<string, string>;
+
+export declare interface Point {
+    x: number;
+    y: number;
+}
+
+export declare interface PositionedEdge {
+    source: string;
+    target: string;
+    label?: string;
+    style: EdgeStyle;
+    hasArrowStart: boolean;
+    hasArrowEnd: boolean;
+    /** Full path including bends — array of {x, y} points */
+    points: Point[];
+    /** Layout-computed label center position (avoids label-label collisions) */
+    labelPosition?: Point;
+    /** Inline styles resolved from `linkStyle` directives — override theme defaults */
+    inlineStyle?: Record<string, string>;
+    /** Edge id from `A e1@--> B`, emitted as data-id for CSS targeting */
+    id?: string;
+    /** Set by `e1@{ animate: true }` — renders as a marching-ants dash */
+    animate?: boolean;
+}
+
+export declare interface PositionedGraph {
+    width: number;
+    height: number;
+    nodes: PositionedNode[];
+    edges: PositionedEdge[];
+    groups: PositionedGroup[];
+}
+
+export declare interface PositionedGroup {
+    id: string;
+    label: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    children: PositionedGroup[];
+}
+
+export declare interface PositionedNode {
+    id: string;
+    label: string;
+    shape: NodeShape;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Inline styles resolved from classDef + explicit `style` statements — override theme defaults */
+    inlineStyle?: Record<string, string>;
+    /** Custom class name assigned via `class A className` or `:::className` shorthand — emitted onto the rendered element's `class` attribute so external CSS can target it */
+    className?: string;
+    /** Interaction from a `click` statement — an href wraps the node in an <a> */
+    interaction?: NodeInteraction;
+}
+
+/**
+ * Render a multi-line text element with proper vertical centering.
+ *
+ * For single-line text, returns a simple <text> element.
+ * For multi-line text (containing \n), returns <text> with <tspan> children.
+ * Inline formatting tags (<b>, <i>, <u>, <s>) are rendered as SVG attributes.
+ *
+ * @param text - The text to render (may contain \n and formatting tags)
+ * @param cx - Center x coordinate
+ * @param cy - Center y coordinate
+ * @param fontSize - Font size in pixels
+ * @param attrs - Additional SVG attributes (e.g., 'text-anchor="middle" fill="var(--_text)"')
+ * @param baselineShift - Baseline shift for vertical alignment (default 0.35)
+ * @returns SVG text element string
+ */
+export declare function renderMultilineText(text: string, cx: number, cy: number, fontSize: number, attrs: string, baselineShift?: number): string;
+
+/**
+ * Render a multi-line text element with a background rectangle (pill).
+ *
+ * Used for edge labels that need a background for readability.
+ *
+ * @param text - The text to render (may contain \n)
+ * @param cx - Center x coordinate
+ * @param cy - Center y coordinate
+ * @param textWidth - Pre-calculated text width (max line width)
+ * @param textHeight - Pre-calculated text height (lines × lineHeight)
+ * @param fontSize - Font size in pixels
+ * @param padding - Padding around text
+ * @param textAttrs - SVG attributes for the text element
+ * @param bgAttrs - SVG attributes for the background rect
+ * @returns SVG elements string (rect + text)
+ */
+export declare function renderMultilineTextWithBackground(text: string, cx: number, cy: number, textWidth: number, textHeight: number, fontSize: number, padding: number, textAttrs: string, bgAttrs: string): string;
+
+export declare interface RenderOptions {
+    /** Background color → CSS variable --bg. Default: '#FFFFFF' */
+    bg?: string;
+    /** Foreground / primary text color → CSS variable --fg. Default: '#27272A' */
+    fg?: string;
+    /** Edge/connector color → CSS variable --line */
+    line?: string;
+    /** Arrow heads, highlights → CSS variable --accent */
+    accent?: string;
+    /** Secondary text, edge labels → CSS variable --muted */
+    muted?: string;
+    /** Node/box fill tint → CSS variable --surface */
+    surface?: string;
+    /** Node/group stroke color → CSS variable --border */
+    border?: string;
+    /** Font family for all text. Default: 'Inter' */
+    font?: string;
+    /** Canvas padding in px. Default: 40. Flowchart/state diagrams only — class/ER diagrams use fixed internal padding. */
+    padding?: number;
+    /** Horizontal spacing between sibling nodes. Default: 28. Flowchart/state diagrams only — class/ER diagrams use fixed internal spacing. */
+    nodeSpacing?: number;
+    /** Vertical spacing between layers. Default: 48. Flowchart/state diagrams only — class/ER diagrams use fixed internal spacing. */
+    layerSpacing?: number;
+    /** Currently unused — accepted for forward compatibility but not read anywhere. */
+    componentSpacing?: number;
+    /** Whether to bundle overlapping fan-out/fan-in edge paths into shared trunks to reduce visual clutter. Default: true */
+    mergeEdges?: boolean;
+    /**
+     * Force the diagram's layout direction, overriding the one its source
+     * declares — a flowchart's `graph LR` / `flowchart TD` header, or a state
+     * diagram's / ER diagram's top-level `direction LR` line. Applied after
+     * parsing and before layout, so the source text is never rewritten and
+     * `parseMermaid()` output is unaffected.
+     *
+     * Replaces only the *top-level* direction. A nested subgraph's or
+     * composite state's own `direction` line still applies on top of this
+     * override, exactly as it does on top of the diagram's own header — the
+     * override behaves as if the caller had written that direction in the
+     * source header, nothing more.
+     *
+     * Flowchart, state, and ER diagrams only — the three diagram types that
+     * have a direction concept to override. Sequence, class, and XY-chart
+     * diagrams ignore it (no error; output is identical with or without it).
+     *
+     * Unset (the default) keeps the source's direction, so existing output is
+     * unchanged. See issue #276.
+     */
+    direction?: Direction;
+    /** Render with transparent background (no background style on SVG). Default: false */
+    transparent?: boolean;
+    /**
+     * Render-target-scoped interactivity level. Declarative only — this
+     * library never emits `<script>`; see
+     * docs/decisions/no-script-interactivity.md for the tier model this maps
+     * to (tier 1: `<title>`/text; tier 2: `<a href>`, CSS `:hover`, CSS
+     * animation; tier 3: `click ... call fn()`, recorded as data, never
+     * executed). Default: `'static'`.
+     *
+     * - `'none'` — strips flowchart/state-diagram edge animation
+     *   (`e1@{ animate: true }`), and strips `click`-based links
+     *   (`<a href>`) and `<title>` tooltips. Intended for print/rasterized
+     *   output: a CSS `@keyframes` animation would otherwise silently
+     *   render as a single static frame with no indication that motion
+     *   was intended, and a link is meaningless once rasterized.
+     * - `'static'` — default. Tier 1 + tier 2 minus motion: `click`-based
+     *   links and `<title>` tooltips still render, but flowchart/state-diagram
+     *   edge animation does not — a diagram that opts into
+     *   `e1@{ animate: true }` renders as a still line unless `'full'` is
+     *   requested. xychart hover tooltips stay off unless requested via
+     *   `'full'` or the deprecated `interactive: true` below. This is a
+     *   breaking change from earlier releases, where `'static'` (and the
+     *   default) still animated — animation is tier-2 *motion*, which the
+     *   stricter `'static'` reading excludes; see the ADR.
+     * - `'full'` — also enables flowchart/state-diagram edge animation and
+     *   xychart hover tooltips.
+     */
+    interactivity?: 'none' | 'static' | 'full';
+    /**
+     * @deprecated Use `interactivity` instead. Enable hover tooltips on chart
+     * data points (xychart only). Default: false.
+     *
+     * When `interactivity` is not set, this boolean still controls xychart
+     * tooltips as before (`true` behaves like `interactivity: 'full'` for
+     * that one effect). When `interactivity` *is* set, it takes precedence
+     * and this field is ignored.
+     */
+    interactive?: boolean;
+    /** Stamp the original diagram source onto the root `<svg>` as a `data-src` attribute (HTML-escaped). Default: false */
+    embedSource?: boolean;
+    /**
+     * Replace every CSS `var(--…)` and `color-mix(…)` in the output with its
+     * computed sRGB value (`#rrggbb`, or `rgba()` when translucent), using
+     * the same mix percentages the `<style>` block declares (see
+     * `MIX` in src/theme.ts — there is one table, not a copy). Default: false.
+     *
+     * Browsers evaluate both natively, so the default output stays a live
+     * function of its CSS custom properties (docs/theming.md). Rasterizers
+     * and non-browser SVG consumers — resvg, librsvg, Inkscape, ImageMagick —
+     * implement neither and render the whole theme as black; turn this on
+     * for any output headed to one of them (GitHub issue #456).
+     *
+     * Trade-off: the result is a fixed palette. Overriding `--bg`/`--fg` on
+     * the embedded SVG no longer restyles it, and passing a `var(...)`
+     * reference as a color (the React live-theming pattern) has nothing to
+     * resolve against — such references, and any `var()` this library did
+     * not declare itself (e.g. a host-page font variable), are left as-is.
+     */
+    resolveColors?: boolean;
+    /**
+     * CSP nonce to stamp on every `<style>` element in the output (see GitHub
+     * issue #216).
+     *
+     * The renderer styles its SVG with an inline `<style>` element (the theme
+     * block; flowcharts with `e1@{ animate: true }` edges and xycharts add a
+     * second one). A host page whose `Content-Security-Policy` has a
+     * `style-src` without `'unsafe-inline'` blocks those, and the diagram
+     * silently renders unstyled. The standard fix is a per-response nonce:
+     * the host generates one, lists it as `style-src 'nonce-<value>'`, and
+     * puts `nonce="<value>"` on each element it wants to allow. Pass that
+     * value here and every emitted `<style>` gets it — one `<style>` left
+     * un-nonced is enough to lose the whole diagram's styling, so this is
+     * applied at the single shared emission point rather than per diagram
+     * type.
+     *
+     * The value is attribute-escaped on output. An empty string is treated as
+     * unset. Default: undefined (no `nonce` attribute).
+     *
+     * A nonce only authorises `<style>` *elements* — it cannot authorise a
+     * `style="…"` *attribute* (browsers apply nonces to elements only), so the
+     * root `<svg style="--bg: …">` attribute stays blocked under the same
+     * policy. Pair this with `styleAttribute: false` and put the theme
+     * variables in your own stylesheet; see that option.
+     */
+    nonce?: string;
+    /**
+     * Emit the root `<svg style="--bg: …; --fg: …; background: var(--bg)">`
+     * attribute. Default: true.
+     *
+     * That attribute is how the theme colours reach the SVG: every rule in
+     * the embedded `<style>` block resolves against the `--bg`/`--fg`/…
+     * custom properties it sets. Under a strict `Content-Security-Policy`
+     * (`style-src` without `'unsafe-inline'`) the browser drops it, and no
+     * `nonce` can rescue it — nonces apply to elements, never attributes —
+     * so the diagram loses its colours even when the `<style>` element itself
+     * is allowed (see GitHub issue #216).
+     *
+     * Set this to `false` to leave the attribute out entirely. The host must
+     * then define the same custom properties on the SVG or an ancestor from
+     * its own (nonced or external) stylesheet; `themeCssVariables(options)`
+     * returns the exact declaration list the attribute would have carried,
+     * so the two can't drift:
+     *
+     * ```ts
+     * const opts = { bg: '#fff', fg: '#000', nonce, styleAttribute: false }
+     * const svg = renderMermaidSVG(code, opts)
+     * const css = `.diagram svg { ${themeCssVariables(opts)} }`
+     * // `<style nonce="…">${css}</style>` + `<div class="diagram">${svg}</div>`
+     * ```
+     *
+     * With the attribute gone, the SVG has no inline `background` either; the
+     * declarations from `themeCssVariables()` include it (unless
+     * `transparent`) so the host's rule restores it. Only the *root* `style`
+     * attribute is affected: a per-node `style A font-family:…` override
+     * still renders as that node's own `style` attribute, since it's diagram
+     * content rather than theming, and under such a CSP it is simply ignored
+     * by the browser. `nonce` and this option are independent — a host using
+     * hashes rather than nonces may want only this one.
+     */
+    styleAttribute?: boolean;
+    /**
+     * Accessible name for the rendered SVG (see GitHub issue #215). Rendered
+     * as `role="img"` + `aria-labelledby` pointing at a `<title>` child
+     * holding this text — the standard SVG/WAI-ARIA technique for naming an
+     * inline image. Without a name, assistive tech either treats the SVG as a
+     * plain group (every node/edge label announced individually, out of
+     * reading order) or skips it — a WCAG 1.1.1 failure for diagrams embedded
+     * in a page.
+     *
+     * Supply your own description of what the diagram shows (e.g. "Flowchart:
+     * Build → Test → Ship") — this library does not auto-generate one, since a
+     * fabricated summary like "flowchart with 3 nodes" would be a confidently
+     * useless accessible name. When omitted, the SVG still gets `role="img"`
+     * (so it's read as one image, not a leaky group) but claims no name — the
+     * same as an `<img>` with no `alt`.
+     *
+     * Ignored when `decorative` is true. Default: undefined (no name).
+     *
+     * If the diagram has a `click A "url"` link, `role="img"` is never
+     * applied regardless of this option — see `decorative` below.
+     */
+    title?: string;
+    /**
+     * Mark the diagram as decorative — already described in surrounding
+     * prose, so it shouldn't be announced as its own image. Emits
+     * `aria-hidden="true"` on the root `<svg>` instead of
+     * `role`/`aria-labelledby`/`<title>`; `title`, if also given, is ignored.
+     * Default: false
+     *
+     * Silently overridden (no `aria-hidden`) if the diagram has any
+     * `click A "url"` link: that renders as a real, focusable `<a href>`
+     * inside the SVG, and `aria-hidden="true"` on an ancestor of a focusable
+     * element is an explicit WAI-ARIA violation — assistive tech would drop
+     * the link from the accessibility tree while it stays reachable by Tab.
+     * `title`, if also given, still applies in that case (see #239).
+     */
+    decorative?: boolean;
+    /**
+     * Edge path interpolation for flowcharts and state diagrams.
+     * Default: 'linear'. A diagram's own
+     * `%%{init: {"flowchart": {"curve": ...}}}%%` supplies this when the caller
+     * does not; an explicit value here always wins.
+     */
+    curve?: CurveStyle;
+    /**
+     * Font size overrides (px). Fields left unspecified fall back to their
+     * default. Applies to all diagram types (flowchart, sequence, class, ER).
+     */
+    fontSizes?: {
+        /** Node label text. Default: 13 */
+        nodeLabel?: number;
+        /** Edge label text. Default: 11 */
+        edgeLabel?: number;
+        /** Subgraph header text. Default: 12 */
+        groupHeader?: number;
+    };
+    /**
+     * Sequence-diagram layout overrides (px). Fields left unspecified fall
+     * back to their default. Sequence diagrams only.
+     */
+    sequence?: {
+        /** Vertical space per message row. Default: 40 */
+        messageRowHeight?: number;
+        /** Vertical space between actor boxes and the first message. Default: 20 */
+        headerGap?: number;
+        /** Actor box height. Default: 40 */
+        actorHeight?: number;
+        /** Gap between a message arrow and a note positioned directly after it. Default: 8 */
+        noteOffsetAfterMessage?: number;
+        /** Gap between consecutively stacked notes. Default: 4 */
+        noteStackGap?: number;
+    };
+    /**
+     * Opt-in ELK layout cache (see `createLayoutCache()`). When set,
+     * `layoutGraphSync()` / `layoutClassDiagramSync()` / `layoutErDiagramSync()`
+     * (flowchart/state, class, and ER diagrams — the ELK-based layout
+     * engines) skip re-running ELK layout on a cache hit, keyed on a
+     * deterministic serialization of the fully-resolved ELK input graph
+     * (diagram structure + every layout-affecting option already baked in).
+     *
+     * Unset (the default) preserves the original always-recompute behavior
+     * exactly — this cache is entirely opt-in. Create one instance and
+     * reuse it across renders (e.g. module scope, or a `useRef` in React);
+     * passing a freshly-created cache on every call defeats the point,
+     * since it starts empty each time.
+     */
+    layoutCache?: LayoutCache;
+}
+
+/**
+ * Resolve the final inline style for a node from classDefs and nodeStyles.
+ *
+ * Cascade, weakest to strongest:
+ *   1. `classDef default` — Mermaid's implicit base for every node
+ *   2. the node's own assigned class (`class A foo` / `A:::foo`)
+ *   3. an explicit `style A ...` directive
+ *
+ * Returns undefined when nothing in the cascade applies, so callers can fall
+ * back to theme defaults without an empty-object check.
+ */
+export declare function resolveNodeStyle(nodeId: string, directives: StyleDirectives): Record<string, string> | undefined;
+
+/** An sRGB color: 0-255 channels plus a 0-1 alpha. */
+export declare interface RgbaColor {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+
+/**
+ * Accept only link schemes that cannot execute script.
+ *
+ * A `click` target comes from diagram text, which may be untrusted. An
+ * `href` of `javascript:...` (or a `data:` URL containing markup) would turn
+ * a rendered diagram into an XSS vector for any page that inlines the SVG, so
+ * anything but http/https/mailto and same-document or relative references is
+ * dropped rather than emitted.
+ *
+ * C0 controls are rejected outright, before any other check. The URL parser
+ * strips tab and newline from *anywhere* in a URL, so `java\tscript:` reaches
+ * a browser as `javascript:` — while the scheme match below sees `java\t…`,
+ * finds no scheme, and waves it through as a relative reference. Splitting a
+ * blocked scheme with a control character is the whole bypass; there is no
+ * legitimate URL with a raw control in it, so the entire range goes.
+ */
+export declare function safeHref(href: string | undefined): string | undefined;
+
+/**
+ * Validate a user-authored class name (from `:::className` or
+ * `class A className`) before it's emitted into the SVG `class` attribute.
+ *
+ * The parsers already constrain class names to word characters and hyphens
+ * (see `splitClassShorthand` above and the flowchart parser's
+ * CLASS_SHORTHAND_REGEX), so this is a defense-in-depth allowlist rather
+ * than an escaping step — a class name can't be made "safe" by escaping
+ * since any character other than a valid CSS identifier character would
+ * break the class token itself, not just the surrounding attribute quotes.
+ * Anything that doesn't match a valid CSS identifier (letters, digits,
+ * underscore, hyphen; not starting with a digit or a hyphen+digit) is
+ * dropped rather than emitted.
+ */
+export declare function sanitizeClassName(className: string | undefined): string | undefined;
+
+/**
+ * Options applicable to sequence diagrams (`sequenceDiagram`). Sequence
+ * diagrams ignore `direction`, `curve`, spacing/`layoutCache` (a
+ * non-ELK layout), and `interactivity` (no animated edges or `click` links
+ * in this renderer's sequence support).
+ */
+export declare type SequenceRenderOptions = CommonRenderOptions & Pick<RenderOptions, 'fontSizes' | 'sequence'>;
+
+/** Select the metrics model for subsequent measurements. Called once per render. */
+export declare function setMonospaceMetrics(monospace: boolean): void;
+
+/**
+ * Minimal subset of Shiki's ThemeRegistrationResolved that we need.
+ * We don't import from shiki to avoid a hard dependency.
+ */
+declare interface ShikiThemeLike {
+    type?: string;
+    colors?: Record<string, string>;
+    tokenColors?: Array<{
+        scope?: string | string[];
+        settings?: {
+            foreground?: string;
+        };
+    }>;
+}
+
+/**
+ * Split the `:::className` shorthand off a node/class identifier.
+ *
+ * `Animal:::someclass` → `{ id: 'Animal', className: 'someclass' }`;
+ * an identifier without the shorthand comes back unchanged with no class.
+ * Class names follow CSS identifier conventions (word characters and
+ * hyphens), the same constraint the flowchart parser's CLASS_SHORTHAND_REGEX
+ * applies.
+ */
+export declare function splitClassShorthand(identifier: string): {
+    id: string;
+    className?: string;
+};
+
+/**
+ * Split Mermaid source into trimmed statements, dropping blank lines and
+ * `%%` comment lines. See `splitStatementsByLine` for the line-grouped form
+ * this flattens.
+ */
+export declare function splitStatements(text: string): Statement[];
+
+/**
+ * Split Mermaid source into trimmed statements, grouped by the physical
+ * source line each one came from — dropping blank lines and `%%` comment
+ * lines.
+ *
+ * Newlines and semicolons both separate statements, matching Mermaid's own
+ * `graph TD; A-->B;` form. Comments are removed *before* semicolon splitting
+ * so that a `;` inside a comment can't resurrect the rest of that line as
+ * code.
+ *
+ * The grouping is what lets a caller tell a genuine multi-line continuation
+ * (crossing from one line's group into the next) apart from an explicit
+ * `;`-separated statement on the *same* line (a later entry within one
+ * group) — see `src/parser.ts`'s `mergeContinuationLines`, which only
+ * treats the former as mergeable.
+ */
+export declare function splitStatementsByLine(text: string): Statement[][];
+
+/**
+ * One statement produced by the splitter, paired with the 1-based physical
+ * source line it came from.
+ *
+ * `line` is captured while walking `text.split('\n')`, before blank lines
+ * and `%%` comment lines are dropped — so it survives being the original
+ * source line number even though a statement's array index no longer does.
+ * This is what lets every parser built on top of `splitStatements`/
+ * `splitStatementsByLine` report *where* an error is, not just quote back
+ * the offending statement's text (see issue #760).
+ */
+export declare interface Statement {
+    text: string;
+    line: number;
+}
+
+/**
+ * Strip all inline formatting tags from text, keeping only plain text.
+ * Used for text measurement where tag characters shouldn't affect width.
+ */
+export declare function stripFormattingTags(text: string): string;
+
+/** The three maps a styling-aware diagram carries. `MermaidGraph` and
+ * `ClassDiagram` both satisfy this structurally. */
+export declare interface StyleDirectives {
+    /** Maps class names to their style properties (from `classDef name prop:val`) */
+    classDefs: Map<string, Record<string, string>>;
+    /** Maps node IDs to their assigned class name (from `class A,B name`, `cssClass "A,B" name`, or `A:::name`) */
+    classAssignments: Map<string, string>;
+    /** Maps node IDs to inline styles (from `style X fill:#f00,stroke:#333`) */
+    nodeStyles: Map<string, Record<string, string>>;
+}
+
+/**
+ * The opening `<style>` tag every renderer uses — with a `nonce` attribute
+ * when the caller supplied one (see `RenderOptions.nonce`, #216).
+ *
+ * All `<style>` emission points go through this one function so a nonce
+ * can't be missed on one of them: under a nonce-based CSP a single
+ * un-nonced `<style>` is silently dropped by the browser, which for the
+ * theme block means an unstyled diagram with no console hint as to why.
+ *
+ * An empty/whitespace-only nonce is treated as unset — `nonce=""` would
+ * authorise nothing and only mislead a reader into thinking it did.
+ * The value is attribute-escaped; a real nonce is base64 and never needs
+ * escaping, but the option is a plain string and this keeps a stray `"`
+ * from breaking out of the attribute.
+ */
+export declare function styleOpenTag(nonce?: string): string;
+
+/**
+ * How the renderers emit their two inline-style surfaces — the `<style>`
+ * element(s) and the root `<svg style="--bg: …">` attribute. Both exist so a
+ * host page with a strict `Content-Security-Policy` (`style-src` without
+ * `'unsafe-inline'`) can still render diagrams with their colours intact;
+ * see `RenderOptions.nonce` / `RenderOptions.styleAttribute` in packages/core/src/types.ts
+ * and GitHub issue #216. Threaded as one object through every diagram
+ * renderer so the two options can't drift apart per diagram type.
+ */
+export declare interface SvgEmitOptions {
+    /** Value for a `nonce` attribute on every emitted `<style>` element. */
+    nonce?: string;
+    /** Emit the root `style="--bg: …"` attribute. Default: true. */
+    styleAttribute?: boolean;
+}
+
+/**
+ * Build the SVG opening tag with CSS variables set as inline styles.
+ * Only includes optional variables that are actually provided — unset ones
+ * will fall back to the color-mix() derivations in the <style> block.
+ *
+ * `styleAttribute: false` drops the `style="…"` attribute entirely (the
+ * host supplies those declarations from its own stylesheet — see
+ * `themeStyleDeclarations()` and `RenderOptions.styleAttribute`, #216).
+ * Every other attribute — `xmlns`, `viewBox`, `width`/`height`, the
+ * `role`/`aria-*` accessibility attributes, and anything a caller splices
+ * on afterwards (`data-src`, `data-xychart-colors`) — is unaffected.
+ *
+ * Also handles the SVG's accessible name (see `RenderOptions.title` /
+ * `RenderOptions.decorative` in packages/core/src/types.ts, and GitHub issue #215):
+ *
+ * - `decorative: true` → `aria-hidden="true"` on the root, no `role` or
+ *   name. Use for a diagram already described in surrounding prose; `title`
+ *   is ignored when this is set.
+ * - `title` given (and not decorative) → `role="img"` +
+ *   `aria-labelledby="zm-title-N"` on the root, plus a `<title id="zm-title-N">`
+ *   as the SVG's first child holding the escaped text. This is the standard
+ *   SVG/WAI-ARIA "accessible name via a referenced title element" technique
+ *   (see MDN "SVG accessibility" and the WAI-ARIA `img` role: an element
+ *   with `role="img"` needs a computed accessible name to be meaningful to
+ *   assistive tech; `aria-labelledby` pointing at a `<title>` is the
+ *   documented way to supply one for inline SVG).
+ * - Neither given → `role="img"` only, no name. This still stops assistive
+ *   tech from treating the SVG as a plain group (which announces every
+ *   node/edge label individually, out of reading order — the core bug in
+ *   #215), without fabricating a name the library can't honestly claim. It
+ *   reads the same as an `<img>` with no `alt`: present as a single image,
+ *   unlabeled.
+ *
+ * `hasInteractiveLinks` overrides all of the above (see #239): a `click A
+ * "url"` statement renders a real, focusable `<a href>` inside the SVG, and
+ * both `role="img"` and `aria-hidden="true"` are unsafe on an ancestor of a
+ * focusable element — `role="img"` tells assistive tech to stop descending
+ * into children (the link becomes unreachable by screen reader while still
+ * Tab-focusable), and `aria-hidden="true"` on a focusable descendant is an
+ * explicit WAI-ARIA violation (the link vanishes from the accessibility tree
+ * but not from the tab order). When any node has a link, the root gets no
+ * `role` at all — `decorative` is silently overridden rather than honored,
+ * since aria-hiding a diagram that contains an actionable link is not a safe
+ * request to fulfill — but `title`/`aria-labelledby` still apply if given:
+ * an accessible name is still valid on an element with no explicit role.
+ *
+ * The per-node/per-point `<title>` tooltips added by earlier work (nested
+ * inside `<g>` elements, with no `id` attribute) are unaffected: they never
+ * collide with the root title's generated id, and a root `<title>` alongside
+ * unrelated descendant `<title>` elements is valid SVG.
+ *
+ * @param transparent - If true, omits the background style for transparent SVGs
+ * @param title - Accessible name text. Ignored when `decorative` is true
+ *                and there are no interactive links (see `hasInteractiveLinks`).
+ * @param decorative - Marks the SVG as decorative (`aria-hidden="true"`).
+ *                      Overridden when `hasInteractiveLinks` is true.
+ * @param hasInteractiveLinks - True if any node has a `click`-based `href`.
+ *                              See #239 — forces no root `role` so the link
+ *                              stays reachable, regardless of `decorative`.
+ * @param styleAttribute - Emit the root `style="…"` attribute. Default true.
+ */
+export declare function svgOpenTag(width: number, height: number, colors: DiagramColors, transparent?: boolean, title?: string, decorative?: boolean, hasInteractiveLinks?: boolean, styleAttribute?: boolean): string;
+
+export declare type ThemeName = keyof typeof THEMES;
+
+export declare const THEMES: Record<string, DiagramColors>;
+
+/**
+ * The exact CSS declaration list the root `<svg style="…">` attribute
+ * carries: the theme custom properties (`--bg`, `--fg`, plus whichever
+ * enrichment variables were actually provided — unset ones fall back to the
+ * color-mix() derivations in the `<style>` block) and, unless `transparent`,
+ * a `background: var(--bg)`.
+ *
+ * Exposed (via `themeCssVariables()` in src/index.ts) so a host that turns
+ * the attribute off with `styleAttribute: false` — because its
+ * Content-Security-Policy forbids `style=` attributes, which a nonce can
+ * never authorise (#216) — can put the very same declarations in its own
+ * stylesheet on a wrapper instead. Single source of truth for the variable
+ * list: `svgOpenTag()` and the helper both call this, so the two can't
+ * drift.
+ *
+ * Emitted compactly (`--bg:#fff;--fg:#000;background:var(--bg)`) rather
+ * than pretty-printed: it's the same string the attribute has always
+ * carried, so default output stays byte-identical. Colour values are the
+ * caller's own `RenderOptions` and are not escaped here — same as before.
+ */
+export declare function themeStyleDeclarations(colors: DiagramColors, transparent?: boolean): string;
+
+/**
+ * Normalize a regex-captured direction token to a `Direction`.
+ *
+ * Accepts `string | undefined` because every call site passes a regex
+ * capture group value (`match[1]`, typed as possibly-`undefined` under
+ * `noUncheckedIndexedAccess`) straight through. Each call site's regex
+ * guards the capture with the same `(TD|TB|LR|BT|RL)` alternation
+ * (case-insensitively), so the group always participates in the match in
+ * practice — but that's a regex-structure guarantee the type checker can't
+ * see across the call site. Validating `undefined` here, instead of
+ * asserting non-null at each call site, turns a hypothetical violation into
+ * a clear, descriptive error rather than a raw `undefined` crash.
+ */
+export declare function toDirection(raw: string | undefined): Direction;
+
+/**
+ * `class A,B className` — attach a style class to one or more nodes.
+ *
+ * Allows an optional trailing semicolon (`class A,B foo;`) — Mermaid treats
+ * it as valid/optional, and `classDef`/`style` already tolerate it via their
+ * `(.+)$` capture. Without this, the semicolon form fails to match here and
+ * falls through to node parsing, rendering a stray node labelled "class".
+ *
+ * Returns true when `line` was a class-assignment statement.
+ */
+export declare function tryApplyClassAssignment(line: string, target: StyleDirectives): boolean;
+
+/**
+ * `classDef name prop:val,prop:val` — define a named style class.
+ *
+ * Mermaid's `classList` rule accepts a comma-separated list of names
+ * (`classDef a,b font-size:12pt`) in both the flowchart and class grammars;
+ * every name in the list gets the same properties.
+ *
+ * Returns true when `line` was a classDef statement (and has been applied).
+ */
+export declare function tryApplyClassDef(line: string, target: StyleDirectives): boolean;
+
+/**
+ * `cssClass "A,B" className` — the class-diagram grammar's own attachment
+ * form (`cssClassStatement: CSSCLASS STR ALPHA` in classDiagram.jison).
+ * Same effect as `class A,B className`.
+ *
+ * Returns true when `line` was a cssClass statement.
+ */
+export declare function tryApplyCssClass(line: string, target: StyleDirectives): boolean;
+
+/**
+ * `style A,B fill:#f00,stroke:#333` — inline style on specific nodes.
+ * Repeated `style` statements for the same node merge property by property.
+ *
+ * Returns true when `line` was a style statement.
+ */
+export declare function tryApplyStyleStatement(line: string, target: StyleDirectives): boolean;
+
+/**
+ * Return `diagram` with its top-level `direction` replaced by `override`,
+ * or `diagram` itself (same reference) when there is nothing to apply.
+ *
+ * The parsed diagram is never mutated — a shallow clone carries the new
+ * direction, so `parseMermaid()` output a caller holds on to stays exactly
+ * what the parser produced, and a second render of the same parsed object
+ * without the option sees the source direction again.
+ *
+ * `isDirection` re-checks the value at runtime because `Direction` is only
+ * a compile-time guarantee: a plain-JavaScript caller can pass any string.
+ * An unrecognized value is ignored (the diagram's own direction stands)
+ * rather than thrown on — the same lenient treatment every other
+ * `RenderOptions` value gets, e.g. an unknown `interactivity` or `curve`
+ * string falls back to its default instead of failing the render.
+ */
+export declare function withDirectionOverride<T extends {
+    direction?: Direction;
+}>(diagram: T, override: Direction | undefined): T;
+
+/**
+ * Options applicable to XY charts (`xychart-beta`). XY charts have no
+ * spacing/`direction`/`curve`/`fontSizes`/`layoutCache` concept (layout is
+ * a fixed pixel computation, not ELK-based); `interactivity` (preferred) and
+ * the deprecated `interactive` boolean both gate hover tooltips only.
+ */
+export declare type XyChartRenderOptions = CommonRenderOptions & Pick<RenderOptions, 'interactivity' | 'interactive'>;
+
+export { }