@jarenjs/mermaid 0.34.0

package/dist/types/index.d.ts

@@ -0,0 +1,97 @@
+/**
+ * @file `@jarenjs/mermaid` — a native, headless Mermaid clone. This is
+ * the **engine** (part one): pure functions over data — text ⇄ AST ⇄
+ * pure-vnode SVG — that know only the `@jarenjs/view` vnode shape. It
+ * imports nothing from the component, `@jarenjs/app`, the DOM or
+ * `@jarenjs/md` (the two-layer rule).
+ *
+ * The pipeline mirrors `@jarenjs/md`:
+ *
+ *   source ──parseMermaid──▶ DiagramDocument (geometry-free JSON AST)
+ *                              │
+ *            ┌─────────────────┼───────────────────┐
+ *            ▼                 ▼                   ▼
+ *       toMermaid()      layoutDiagram()      JSLT / query
+ *       (canonical        → diagramToVnode()  (the AST is an
+ *        round-trip)       (pure-vnode SVG)    ordinary document)
+ */
+import { hashContent } from './utils.js';
+export { parseMermaid } from './parser/index.js';
+export { toMermaid } from './to-mermaid.js';
+export { parseMermaidConfig } from './parser/config.js';
+export { layoutDiagram, diagramToVnode } from './render/index.js';
+export { createTheme, THEMES, HOST_VARS } from './theme.js';
+export { sanitizeHref } from '@jarenjs/view/helpers';
+export { MermaidParseError } from './errors.js';
+export { hashContent } from './utils.js';
+export { MERMAID_VERSION, diagramDocument, walkSequence, flowNode, flowEdge, sequenceAst, flowchartAst, } from './ast.js';
+/**
+ * Convenience: parse → layout → render, error-safe, in one call.
+ * @param {string} source
+ * @param {{ theme?: any }} [options]
+ * @returns {any} an SVG vnode
+ */
+export declare function renderMermaid(source: string, options?: {
+    theme?: any;
+}): any;
+export type CompiledMermaid = {
+    /**
+     * the parsed document
+     */
+    doc: import('./ast.js').DiagramDocument;
+    /**
+     * cached pure-vnode SVG
+     */
+    toVnode: () => any;
+    /**
+     * cached standalone SVG string (SSR)
+     */
+    toSvgString: () => string;
+    /**
+     * canonical Mermaid text (`toMermaid`)
+     */
+    toText: () => string;
+    /**
+     * walk the AST
+     */
+    walk: (visitor: (stmt: any) => void) => void;
+};
+/**
+ * @typedef {object} CompiledMermaid
+ * @property {import('./ast.js').DiagramDocument} doc the parsed document
+ * @property {() => any} toVnode cached pure-vnode SVG
+ * @property {() => string} toSvgString cached standalone SVG string (SSR)
+ * @property {() => string} toText canonical Mermaid text (`toMermaid`)
+ * @property {(visitor: (stmt: any) => void) => void} walk walk the AST
+ */
+/**
+ * Parse once and return a bundle of cached projections.
+ * `toVnode`/`toSvgString`/`toText` each compute at most once; the
+ * vnode is returned by reference on repeat calls, so an unchanged
+ * document patches in O(1) through the view reconciler.
+ *
+ * @param {string} source
+ * @param {{ theme?: any, [k: string]: any }} [options]
+ * @returns {CompiledMermaid}
+ */
+export declare function compileMermaid(source: string, options?: {
+    theme?: any;
+    [k: string]: any;
+}): CompiledMermaid;
+/**
+ * A host-DOM renderer (mirrors `@jarenjs/md`'s `createMdRenderer`).
+ * Owns a `@jarenjs/view` DOM renderer over `container` and patches the
+ * rendered SVG on each `render(docOrSource)` call. `createDomRenderer`
+ * touches no DOM until it is handed a container, so importing it keeps
+ * the engine host-agnostic.
+ *
+ * @param {{ container: any, document?: any, theme?: any, [k: string]: any }} config
+ * @returns {(docOrSource: any) => void}
+ */
+export declare function createMermaidRenderer(config: {
+    container: any;
+    document?: any;
+    theme?: any;
+    [k: string]: any;
+}): (docOrSource: any) => void;
+export { hashContent as contentHash };

package/dist/types/interactive.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @file Optional pan/zoom/touch for a rendered diagram.
+ *
+ * The render stays pure: this module is never imported by it, runs only in a
+ * browser, and only when a consumer opts in with `mermaidPlugin({ interactive:
+ * true })`. Server-rendered output is byte-identical with and without it, and
+ * a page that never enables it tree-shakes the whole file away.
+ *
+ * Everything happens on the SVG's `viewBox`. Nothing re-renders, nothing is
+ * re-parsed, no `eval`, no `innerHTML` — panning is four numbers changing.
+ *
+ * The interaction rules are chosen so the diagram never fights the page,
+ * which is the usual failure of embedded zoomable content:
+ *
+ *   - **A plain wheel scrolls the page.** Zoom needs ctrl/⌘ (the browser's own
+ *     zoom gesture) or the on-diagram buttons. Hijacking the wheel is the
+ *     fastest way to make a document unreadable.
+ *   - **A one-finger drag pans only once zoomed in.** At rest the whole
+ *     diagram is visible, so there is nothing to pan to, and a swipe should
+ *     scroll the page like every other element. `touch-action` is switched to
+ *     match, so the browser never has to guess.
+ *   - **Two fingers always pinch-zoom**, because that gesture means nothing
+ *     else inside a figure.
+ *   - **Keyboard works**: the figure is focusable, `+`/`-`/`0` zoom and reset,
+ *     arrows pan. A pointer-only zoom control is not usable by everyone.
+ */
+/**
+ * Attach pan/zoom to one rendered diagram element.
+ * @param {any} el the block element wrapping the `<svg>`
+ * @param {{ document?: any }} [env] injection seam for tests
+ * @returns {(() => void)|undefined} a teardown function, or undefined when
+ *   there is nothing to attach to
+ */
+export declare function attachInteractiveDiagram(el: any, env?: {
+    document?: any;
+}): (() => void) | undefined;

package/dist/types/layout/flowchart.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @file Flowchart layout: a compact "dagre-lite" — longest-path rank
+ * assignment, stable within-rank ordering, banded coordinate
+ * assignment, and straight border-clipped edge routing. Pure and
+ * deterministic (same AST → identical geometry), so the golden-JSON
+ * tests catch any drift. Output is a host-free `PositionedDiagram`.
+ */
+/**
+ * @param {any} ast flowchart AST
+ * @returns {any} PositionedDiagram
+ */
+export declare function layoutFlowchart(ast: any): any;

package/dist/types/layout/sequence.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @file Sequence layout: actor lifeline x-positions, message y-advance,
+ * activation bars, note boxes and nested block frames
+ * (loop/alt/opt/par). Pure and deterministic; emits a host-free
+ * `PositionedDiagram`. Geometry is an approximation over the headless
+ * text metrics (no DOM) — pixel parity is a non-goal.
+ */
+/**
+ * @param {any} ast sequence AST
+ * @returns {any} PositionedDiagram
+ */
+export declare function layoutSequence(ast: any): any;

package/dist/types/layout/state.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @file State-diagram layout: an ADAPTER, not a second algorithm. The
+ * state AST (states + labeled transitions + `[*]` pseudo-states) maps
+ * onto the flowchart layout's input vocabulary — states as rounded
+ * nodes, transition labels as edge labels, the start/end pseudo-states
+ * as synthetic `statedot`/`doublecircle` nodes — and `layoutFlowchart`
+ * does the ranking, ordering and routing. Same AST → identical
+ * geometry, like every layout in this component.
+ *
+ * Composite states arrive flattened from the parser (the `parent`
+ * field is recorded but not drawn as a cluster in v1 — the honest
+ * limitation lives in MERMAID-FORMAT §6).
+ */
+/**
+ * Lay out a state AST through the flowchart engine.
+ * @param {any} ast state AST ({ states, transitions })
+ * @returns {any} PositionedDiagram
+ */
+export declare function layoutState(ast: any): any;

package/dist/types/parser/class.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @file Class-diagram grammar → class AST. Supports `class Foo { … }`
+ * bodies, `Foo : +member` line form, and relations
+ * (`<|--`, `*--`, `o--`, `-->`, `..>`, `..|>`) with optional `: label`.
+ * Geometry-free: members and relations preserve declaration order.
+ */
+/**
+ * @param {string[]} lines
+ * @returns {object}
+ */
+export declare function parseClass(lines: string[]): object;

package/dist/types/parser/config.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @file Config extraction: the leading `---` front-matter block and any
+ * `%%{init: {...}}%%` directives → a plain-JSON `config` (MERMAID-FORMAT
+ * §3).
+ *
+ * The raw source is never consumed here — this returns the cleaned body
+ * (front-matter, init directives and `%%` comments removed) plus the
+ * merged config and title, and the original source stays in the
+ * Markdown fence `value` so `toMarkdown` round-trips verbatim.
+ *
+ * Front-matter is a YAML subset. The engine may NOT statically import
+ * `@jarenjs/md` (two-layer rule), so a small built-in subset parser is
+ * the default; a host that already has `@jarenjs/md` can inject its
+ * richer `parseFrontmatter` through `options.parseFrontmatter`.
+ */
+export type MermaidConfigResult = {
+    /**
+     * merged config object
+     */
+    config: Record<string, any>;
+    /**
+     * front-matter `title`, if any
+     */
+    title: string | null;
+    /**
+     * source with front-matter/init/comments stripped
+     */
+    body: string;
+};
+/**
+ * @typedef {object} MermaidConfigResult
+ * @property {Record<string, any>} config merged config object
+ * @property {string|null} title front-matter `title`, if any
+ * @property {string} body source with front-matter/init/comments stripped
+ */
+/**
+ * Extract config + title and return the cleaned diagram body.
+ * @param {string} source
+ * @param {{ parseFrontmatter?: (text: string) => any }} [options]
+ * @returns {MermaidConfigResult}
+ */
+export declare function parseMermaidConfig(source: string, options?: {
+    parseFrontmatter?: (text: string) => any;
+}): MermaidConfigResult;
+/**
+ * Parse a small YAML subset: `key: value` and one level of nesting via
+ * two-space indentation. Values are scalars (string/number/bool/null).
+ * Deliberately minimal — the documented default when `@jarenjs/md`'s
+ * parser is not injected.
+ * @param {string} text
+ * @returns {Record<string, any>}
+ */
+export declare function parseYamlSubset(text: string): Record<string, any>;
+/**
+ * Parse the relaxed object inside `%%{init: … }%%`. Tries strict JSON
+ * first, then a light normalization (quote bare keys, single→double
+ * quotes). Returns `null` on failure (config parsing never throws).
+ * @param {string} text
+ * @returns {Record<string, any> | null}
+ */
+export declare function parseLooseObject(text: string): Record<string, any> | null;

package/dist/types/parser/er.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @file ER-diagram grammar → ER AST. Entity blocks
+ * (`CUSTOMER { string name PK }`) and relationships
+ * (`CUSTOMER ||--o{ ORDER : places`). Cardinality tokens are preserved
+ * verbatim for a faithful, geometry-free model.
+ */
+/**
+ * @param {string[]} lines
+ * @returns {object}
+ */
+export declare function parseEr(lines: string[]): object;

package/dist/types/parser/flowchart.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @file Flowchart grammar → flowchart AST. Flowchart and sequence are
+ * the two fully-modeled diagram types; this is the first.
+ *
+ * Char-code recursive descent over one statement at a time. Every
+ * pattern regex is a module constant used with the sticky (`y`) flag so
+ * there is no per-call `RegExp` allocation; the vertex/edge chain is a
+ * hand-written scan. Produces the geometry-free flowchart AST from
+ * `ast.js` — nodes, edges, subgraphs, classDef/class/style — preserving
+ * shape, label and declaration order so `to-mermaid.js` is a fixed
+ * point.
+ */
+/**
+ * Parse a flowchart body (config already stripped) into the flowchart
+ * AST. `keyword`/`firstLine` give the header; `direction` overrides.
+ * @param {string[]} lines body lines
+ * @param {number} lineOffset absolute line number of `lines[0]`
+ * @param {string} direction detected direction
+ * @returns {object}
+ */
+export declare function parseFlowchart(lines: string[], lineOffset: number, direction: string): object;
+/**
+ * Strip surrounding matching quotes from a label.
+ * @param {string} s @returns {string}
+ */
+export declare function stripQuotes(s: string): string;

package/dist/types/parser/gantt.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @file Gantt grammar → gantt AST: a schedule DAG. Header
+ * directives (`title`, `dateFormat`, `axisFormat`, `excludes`) go to
+ * `meta`; `section` groups tasks; task rows keep their raw metadata
+ * string (`:done, id, 2014-01-06, 3d`) verbatim, geometry-free.
+ */
+/**
+ * @param {string[]} lines
+ * @returns {object}
+ */
+export declare function parseGantt(lines: string[]): object;

package/dist/types/parser/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @file `parseMermaid`: detect the diagram type + config on the first
+ * non-config line, dispatch to the type parser, and assemble the shared
+ * `DiagramDocument` envelope.
+ *
+ * Flowchart and sequence are fully modeled. The remaining
+ * first-class types (class, ER, state, gantt, pie) plug in through
+ * `TYPE_PARSERS`; secondary types (mindmap, gitGraph, journey, timeline,
+ * quadrantChart) parse-accept into a geometry-free `rawAst` and are
+ * counted honestly in the coverage scorecard.
+ */
+/** Types that parse-accept into a placeholder in the coverage scorecard. */
+export declare const SECONDARY_TYPES: Set<string>;
+/**
+ * Parse Mermaid source into a `DiagramDocument`.
+ * @param {string} source
+ * @param {{ parseFrontmatter?: (text: string) => any }} [options]
+ * @returns {import('../ast.js').DiagramDocument}
+ */
+export declare function parseMermaid(source: string, options?: {
+    parseFrontmatter?: (text: string) => any;
+}): import('../ast.js').DiagramDocument;

package/dist/types/parser/pie.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @file Pie grammar → pie AST. `pie [showData]` then `"label" : value`
+ * rows, with an optional `title …`.
+ */
+/**
+ * @param {string[]} lines
+ * @param {number} lineOffset
+ * @param {string} header
+ * @returns {object}
+ */
+export declare function parsePie(lines: string[], lineOffset: number, header: string): object;

package/dist/types/parser/sequence.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @file Sequence grammar → sequence AST. Flowchart and sequence are
+ * the two fully-modeled diagram types; this is the second.
+ *
+ * Line-oriented, with a block stack for loop/alt/opt/par/critical/break.
+ * Explicitly declared participants keep their declaration order; a
+ * message to an undeclared actor is legal (the layout pass creates the
+ * lifeline), so the AST records only what the source states — faithful
+ * and geometry-free. Module-const regexes only.
+ */
+/**
+ * @param {string[]} lines body lines (config stripped)
+ * @param {number} lineOffset absolute line number of `lines[0]`
+ * @returns {object}
+ */
+export declare function parseSequence(lines: string[], lineOffset: number): object;

package/dist/types/parser/state.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @file State-diagram grammar (`stateDiagram-v2`) → state AST. Models
+ * the finite state machine faithfully: states, transitions
+ * (`A --> B : label`), the `[*]` start/end pseudo-states, `state "x" as
+ * s` descriptions and `s : desc` labels. This is the AST the flagship
+ * `state ⇄ workflow` JSLT projection consumes.
+ *
+ * A transition carries its verbatim `label` — what renderers draw and
+ * `toMermaid` prints — plus the label's UML reading, parsed into
+ * `event [guard] / effect` parts (each null when absent). A label that
+ * fits no UML pattern reads whole as the event, so plain labels keep
+ * their historical meaning byte for byte.
+ *
+ * Composite states (`state Foo { … }`) are flattened one level: the
+ * inner transitions are captured with their parent recorded, keeping the
+ * AST geometry-free.
+ */
+/**
+ * @param {string[]} lines
+ * @returns {object}
+ */
+export declare function parseState(lines: string[]): object;

package/dist/types/plugin.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @file The Markdown plugin — the md→mermaid dependency arrow.
+ * `mermaidPlugin()` returns a **plain, self-frozen object**
+ * shaped exactly like `@jarenjs/md`'s `MdPlugin` typedef, but it does
+ * **not** import `definePlugin` from `@jarenjs/md` — so there is no
+ * import cycle. `@jarenjs/md` re-exports this and adds `@jarenjs/mermaid`
+ * to its dependencies; consumers who never use it tree-shake it away
+ * (`sideEffects:false`).
+ *
+ * `render` is pure, synchronous and error-safe: a `mermaid`
+ * fence becomes inline SVG with no injected instance and no `innerHTML`,
+ * so a Markdown document renders to a full SVG string through SSR with
+ * no browser — a capability the old injection wrapper lacked.
+ *
+ * `hydrate` exists only when a consumer asks for `interactive: true`. The
+ * render is complete without it: hydration adds pan/zoom/touch to an already
+ * finished SVG, so server output is byte-identical either way and a page that
+ * does not opt in never loads the module.
+ */
+/**
+ * @param {{ theme?: any, [k: string]: any }} [options]
+ * @returns {Readonly<{ name: string, fences: string[], node: string, render: (node: any, h: any, ctx: any) => any }>}
+ */
+export declare function mermaidPlugin(options?: {
+    theme?: any;
+    [k: string]: any;
+}): Readonly<{
+    name: string;
+    fences: string[];
+    node: string;
+    render: (node: any, h: any, ctx: any) => any;
+}>;
+/**
+ * Refresh a `mermaid` fence node's source after a JSLT transform so the
+ * generic Markdown fence printer re-emits the new diagram. Because
+ * there is no per-plugin `toMarkdown` hook, this is the primitive that
+ * makes a transformed diagram round-trip through `toMarkdown`.
+ *
+ * @param {{ value: string, [k: string]: any }} node the fence node (mutated copy is caller's job)
+ * @param {import('./ast.js').DiagramDocument} newDoc the transformed document
+ * @returns {{ type: string, value: string, meta: any }} a fresh fence node
+ */
+export declare function refreshMermaidFence(node: {
+    value: string;
+    [k: string]: any;
+}, newDoc: import('./ast.js').DiagramDocument): {
+    type: string;
+    value: string;
+    meta: any;
+};

package/dist/types/render/error.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @file The error vnode. The render path never
+ * throws: a parse/layout failure becomes a clear error box — message +
+ * offending line — mirroring Mermaid's own error box, keyed so the
+ * patcher swaps it cleanly.
+ *
+ * It themes like every other diagram (DESIGN.md §7): concrete colors ride
+ * as presentation attributes so `toSvgString()` stays standalone-valid,
+ * and the root carries the inline `--mm-*` stamp plus a class per shape,
+ * so a host theme re-colors the error box along with the diagrams it
+ * replaces. The font is pinned to monospace because the box quotes source.
+ */
+import { createTheme } from '../theme.js';
+/**
+ * @param {string} message
+ * @param {number} [line]
+ * @param {string} [sourceLine] the offending source line, if known
+ * @param {ReturnType<typeof createTheme>} [theme] the resolved theme; the
+ *   default keeps the vnode renderable on its own (a parse failure has no
+ *   document to read a theme from)
+ * @returns {any} an SVG error vnode
+ */
+export declare function errorVnode(message: string, line?: number, sourceLine?: string, theme?: ReturnType<typeof createTheme>): any;

package/dist/types/render/flowchart.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @file Flowchart renderer: `PositionedDiagram` → pure-vnode SVG. One
+ * specialized closure over the scene graph; arrowheads are inline
+ * polygons (no `<marker>` id collisions across diagrams on one page),
+ * every shape carries a `mm-*` class for CSS re-theming and concrete
+ * theme colors for standalone SSR.
+ */
+/**
+ * @param {any} scene PositionedDiagram (flowchart or state, via its adapter)
+ * @param {{ tokens: Record<string,string>, cssVars: Record<string,string> }} theme
+ * @param {string} hash content hash for the root key
+ * @param {string} [rootClass] root `class` — the state renderer adds `mm-state`
+ * @returns {any}
+ */
+export declare function renderFlowchart(scene: any, theme: {
+    tokens: Record<string, string>;
+    cssVars: Record<string, string>;
+}, hash: string, rootClass?: string): any;

package/dist/types/render/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @file The render dispatcher. Turns a `DiagramDocument` (or raw source)
+ * into a pure-vnode SVG, choosing the specialized layout+render closure
+ * per diagram type, and **never throws**: a
+ * parse/layout error becomes an error vnode.
+ */
+/**
+ * Compute the pure `PositionedDiagram` scene for a document (no vnode).
+ * Returns `null` for types without a geometric layout (structured/raw).
+ * @param {import('../ast.js').DiagramDocument} doc
+ * @returns {any}
+ */
+export declare function layoutDiagram(doc: import('../ast.js').DiagramDocument): any;
+/**
+ * Render a doc or source to a pure-vnode SVG. Error-safe.
+ * @param {import('../ast.js').DiagramDocument | string} docOrSource
+ * @param {{ theme?: any, [k: string]: any }} [options]
+ * @returns {any} an SVG vnode
+ */
+export declare function diagramToVnode(docOrSource: import('../ast.js').DiagramDocument | string, options?: {
+    theme?: any;
+    [k: string]: any;
+}): any;

package/dist/types/render/misc.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @file Renderers for the first-class types beyond flowchart and
+ * sequence, and an honest placeholder for the deferred secondary
+ * types. Pie is
+ * a real chart; class/ER/state/gantt render as structured panels — a
+ * readable, geometry-light view that renders without error and so counts
+ * honestly in the coverage scorecard. Secondary types (mindmap,
+ * gitGraph, journey, timeline) render a labeled "not yet laid out"
+ * placeholder.
+ */
+/**
+ * Pie rendering delegates to `@jarenjs/charts` (the pie engine's single
+ * home); the options carry the mermaid class names, palette and theme
+ * so the SVG is byte-identical to the pre-delegation renderer.
+ * @param {any} ast pie AST
+ * @param {any} theme
+ * @param {string} hash
+ * @returns {any}
+ */
+export declare function renderPie(ast: any, theme: any, hash: string): any;
+/**
+ * Render a structured panel: a title and a list of sections, each a
+ * bordered box with a heading and text rows.
+ * @param {string} title
+ * @param {{ heading: string, rows: string[] }[]} sections
+ * @param {any} theme
+ * @param {string} hash
+ * @returns {any}
+ */
+export declare function renderStructured(title: string, sections: {
+    heading: string;
+    rows: string[];
+}[], theme: any, hash: string): any;
+/**
+ * The honest placeholder for a parse-accepted secondary type.
+ * @param {string} type
+ * @param {any} theme
+ * @param {string} hash
+ * @returns {any}
+ */
+export declare function renderPlaceholder(type: string, theme: any, hash: string): any;
+/**
+ * Build the sections for the structured renderers.
+ * @param {string} diagram
+ * @param {any} ast
+ * @returns {{ title: string, sections: { heading: string, rows: string[] }[] }}
+ */
+export declare function structuredSections(diagram: string, ast: any): {
+    title: string;
+    sections: {
+        heading: string;
+        rows: string[];
+    }[];
+};

package/dist/types/render/sequence.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @file Sequence renderer: `PositionedDiagram` → pure-vnode SVG.
+ * Actor boxes (top and bottom), dashed lifelines, activation bars,
+ * messages with solid/dotted lines and arrow/open/cross/async heads,
+ * note boxes and block frames.
+ */
+/**
+ * @param {any} scene PositionedDiagram (sequence)
+ * @param {{ tokens: Record<string,string>, cssVars: Record<string,string> }} theme
+ * @param {string} hash
+ * @returns {any}
+ */
+export declare function renderSequence(scene: any, theme: {
+    tokens: Record<string, string>;
+    cssVars: Record<string, string>;
+}, hash: string): any;

package/dist/types/styles.d.ts

@@ -0,0 +1,81 @@
+/**
+ * @file `classDef` / `class` / `style` resolution.
+ *
+ * The parser has always recorded these three statements; nothing consumed
+ * them, so a diagram that styled a node rendered identically to one that did
+ * not. This module turns them into per-node style objects the layout attaches
+ * to its positioned nodes, which is what lets a diagram carry emphasis —
+ * "this box is the input", "this one is an aside" — instead of every node
+ * looking the same.
+ *
+ * One built-in class ships: **`note`**. Mermaid has no flowchart note, and a
+ * diagram that cannot annotate a node loses exactly the information an ASCII
+ * drawing used to carry in a margin comment. Rather than invent syntax for
+ * it, `note` is a class any diagram can apply with the standard `class`
+ * statement, themed from the `note*` tokens the sequence renderer already
+ * uses. A dotted link to a note-classed node reads as an annotation and stays
+ * valid Mermaid that other tools can still parse.
+ */
+/**
+ * Parse a Mermaid style string (`fill:#eee,stroke-width:2px`) into an object.
+ * Unknown properties are kept: a consumer may understand more than this one,
+ * and silently dropping a declaration the author wrote is the same class of
+ * dishonesty as dropping a schema constraint.
+ * @param {string} source
+ * @returns {Record<string,string>}
+ */
+export declare function parseStyleString(source: string): Record<string, string>;
+/**
+ * Resolve every node's styles from a flowchart AST.
+ *
+ * Precedence, lowest to highest: the built-in `note` class, then each
+ * `classDef` in the order the node's `class` statements applied them, then a
+ * per-node `style` statement. That is Mermaid's own order — later wins — and
+ * it is what lets a diagram say "these are all notes, except this one is
+ * red".
+ * @param {any} ast flowchart AST
+ * @returns {Map<string, Record<string,string>>} node id -> style properties
+ */
+export declare function resolveNodeStyles(ast: any): Map<string, Record<string, string>>;
+/**
+ * The author's styles as an inline CSS declaration, or `null` when there are
+ * none.
+ *
+ * This has to be a `style` attribute rather than presentation attributes:
+ * the bundled stylesheet sets `.mermaid .mm-node-shape { fill: var(...) }` so
+ * a themed page can retheme every diagram at once, and a CSS rule outranks a
+ * presentation attribute. Emitting `fill="..."` therefore looked correct in
+ * the SSR string and was silently overridden the moment the stylesheet
+ * loaded — a classDef that worked in a test and did nothing on the page.
+ * Inline style outranks the rule, which is the precedence an author asking
+ * for a specific colour expects.
+ * @param {Record<string,string>|undefined} styles
+ * @param {Record<string,string>} tokens theme tokens
+ * @returns {string|null}
+ */
+export declare function shapeStyle(styles: Record<string, string> | undefined, tokens: Record<string, string>): string | null;
+/**
+ * The SVG attributes a resolved style object contributes to a shape, with the
+ * built-in `note` marker expanded against the live theme.
+ * @param {Record<string,string>|undefined} styles
+ * @param {Record<string,string>} tokens theme tokens
+ * @returns {Record<string,string>}
+ */
+export declare function shapeAttributes(styles: Record<string, string> | undefined, tokens: Record<string, string>): Record<string, string>;
+/**
+ * The text color for a node, or null to keep the theme's.
+ *
+ * An author-specified `fill` is a CONSTANT — it does not follow light/dark —
+ * so the ink over it must not follow the theme either. A pale `fill:#dcfce7`
+ * under a dark theme would otherwise get the theme's light text and the label
+ * would vanish into its own box. The ink is therefore derived from the fill's
+ * luminance, exactly as chart tiles do it, unless the author named a `color`
+ * themselves.
+ *
+ * The built-in `note` class is the opposite case and keeps the theme's note
+ * ink: its fill is a theme token too, so the pair moves together.
+ * @param {Record<string,string>|undefined} styles
+ * @param {Record<string,string>} tokens theme tokens
+ * @returns {string|null}
+ */
+export declare function textColor(styles: Record<string, string> | undefined, tokens: Record<string, string>): string | null;