@yalehwang/plantuml-js 0.2.2 → 0.3.1

package/dist/parse/parser.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Hand-written recursive-descent parser for the PlantUML class-diagram subset.
+ *
+ * M2 scope adds members (visibility `-`/`+`/`#`/`~`, fields, method
+ * signatures), relations (inheritance / implementation / dependency /
+ * association / aggregation / composition with cardinality and labels),
+ * generics (`List~Item~`, `BaseEntity<T>`), package/namespace grouping,
+ * aliases, and tolerant skipping of skinparam/hide/note directives.
+ */
+import { PlantUmlModel } from '../foundation/model.js';
+export declare const ENTITY_LINE: RegExp;
+export declare const ENTITY_KEYWORD: RegExp;
+/**
+ * Parse a PlantUML source string into a PlantUmlModel.
+ *
+ * The parser is total: unrecognised lines (skinparam, hide, note, title,
+ * legend, …) are tolerated and skipped rather than failing the parse.
+ */
+export declare function parsePlantUml(source: string): PlantUmlModel;
+/** An undeclared relation endpoint that the parser resolved on the author's behalf. */
+export interface EndpointDiagnostic {
+    /** 1-based source line of the relation. */
+    line: number;
+    message: string;
+}
+/**
+ * Parse and also report how relation endpoints were resolved: endpoints naming
+ * a package are re-attached to a representative entity inside it, and endpoints
+ * naming nothing declared become implicit (empty) classes, as PlantUML does.
+ */
+export declare function parseWithDiagnostics(source: string): {
+    model: PlantUmlModel;
+    diagnostics: EndpointDiagnostic[];
+};
+/** Strip PlantUML `'` line comments (a leading `'` or a trailing inline `'`). */
+export declare function stripComment(line: string): string;
+/**
+ * Extract a declaration name from an entity line's tail, mirroring the parser:
+ * accepts a bare token (`class A`) or a quoted name (`class "User Repo"`), and
+ * tolerates a trailing `as <alias>`. Returns null when the name is missing or
+ * the quoted name is unterminated.
+ */
+export declare function extractDeclaredName(rest: string): string | null;

package/dist/{parser.js → parse/parser.js}

@@ -7,8 +7,9 @@
  * generics (`List~Item~`, `BaseEntity<T>`), package/namespace grouping,
  * aliases, and tolerant skipping of skinparam/hide/note directives.
  */
-import { emptyModel, } from './model.js';
-const ENTITY_LINE = /^(abstract\s+)?(class|interface|enum)\s+(.+)$/i;
+import { emptyModel, } from '../foundation/model.js';
+export const ENTITY_LINE = /^(abstract\s+)?(class|interface|enum)\s+(.+)$/i;
+export const ENTITY_KEYWORD = /^(?:abstract\s+)?(?:class|interface|enum)\b/i;
 const ARROWS = {
     '--|>': { type: 'inheritance' },
     '<|--': { type: 'inheritance', swap: true },
@@ -31,6 +32,91 @@ const ARROWS = {
  * legend, …) are tolerated and skipped rather than failing the parse.
  */
 export function parsePlantUml(source) {
+    return parseWithDiagnostics(source).model;
+}
+/**
+ * Parse and also report how relation endpoints were resolved: endpoints naming
+ * a package are re-attached to a representative entity inside it, and endpoints
+ * naming nothing declared become implicit (empty) classes, as PlantUML does.
+ */
+export function parseWithDiagnostics(source) {
+    const relationLines = [];
+    const model = parseRaw(source, relationLines);
+    const diagnostics = resolveEndpoints(model, relationLines);
+    return { model, diagnostics };
+}
+function resolveEndpoints(model, relationLines) {
+    const diagnostics = [];
+    const entityIds = new Set(model.entities.map((e) => e.id));
+    const packageIds = new Set(model.packages.map((p) => p.id));
+    const parentOf = new Map(model.packages.map((p) => [p.id, p.parentId]));
+    const inPackage = (entityPkg, pkg) => {
+        for (let cur = entityPkg; cur !== undefined; cur = parentOf.get(cur)) {
+            if (cur === pkg)
+                return true;
+        }
+        return false;
+    };
+    const representative = (pkg) => model.entities.find((e) => inPackage(e.packageId, pkg))?.id;
+    // An endpoint may name a package by its id or by the identifier form of its
+    // display name (`CLI_Layer` for `"CLI Layer (命令层)"`), as authors write it.
+    const packageByKey = new Map();
+    for (const p of model.packages) {
+        for (const key of [p.id, packageKey(p.name)]) {
+            if (!packageByKey.has(key))
+                packageByKey.set(key, p.id);
+        }
+    }
+    const asPackage = (id) => packageIds.has(id) ? id : packageByKey.get(id);
+    const resolve = (id, line, pkgOut) => {
+        if (entityIds.has(id))
+            return id;
+        const pkg = asPackage(id);
+        if (pkg !== undefined) {
+            const rep = representative(pkg);
+            if (rep !== undefined) {
+                diagnostics.push({
+                    line,
+                    message: `relation endpoint "${id}" is a package; edge attached to "${rep}" inside it`,
+                });
+                pkgOut(pkg);
+                return rep;
+            }
+        }
+        model.entities.push({
+            id,
+            name: id,
+            generics: [],
+            kind: 'class',
+            members: [],
+            external: true,
+        });
+        entityIds.add(id);
+        diagnostics.push({
+            line,
+            message: `relation endpoint "${id}" is not declared; implicit class created`,
+        });
+        return id;
+    };
+    model.relations.forEach((r, i) => {
+        const line = relationLines[i] ?? 0;
+        r.source = resolve(r.source, line, (p) => {
+            r.sourcePackageId = p;
+        });
+        r.target = resolve(r.target, line, (p) => {
+            r.targetPackageId = p;
+        });
+    });
+    return diagnostics;
+}
+/** Identifier form of a package display name: parenthetical dropped, non-word runs → `_`. */
+function packageKey(name) {
+    return name
+        .replace(/\s*\([^)]*\)\s*$/, '')
+        .trim()
+        .replace(/[^\p{L}\p{N}]+/gu, '_');
+}
+function parseRaw(source, relationLines) {
     const model = emptyModel();
     const lines = source.split(/\r?\n/);
     let inDiagram = false;
@@ -40,8 +126,8 @@ export function parsePlantUml(source) {
         stack.push(frame);
         lastDeclaration = null;
     };
-    for (const raw of lines) {
-        const line = raw.trim();
+    for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+        const line = lines[lineIdx].trim();
         if (line === '')
             continue;
         if (/^@startuml\b/i.test(line)) {
@@ -116,6 +202,7 @@ export function parsePlantUml(source) {
             const relation = parseRelationLine(code);
             if (relation) {
                 model.relations.push(relation);
+                relationLines.push(lineIdx + 1);
                 lastDeclaration = null;
                 continue;
             }
@@ -366,9 +453,28 @@ function stripQuotes(token) {
     return token;
 }
 /** Strip PlantUML `'` line comments (a leading `'` or a trailing inline `'`). */
-function stripComment(line) {
+export function stripComment(line) {
     const idx = line.indexOf("'");
     if (idx === -1)
         return line.trim();
     return line.slice(0, idx).trim();
 }
+/**
+ * Extract a declaration name from an entity line's tail, mirroring the parser:
+ * accepts a bare token (`class A`) or a quoted name (`class "User Repo"`), and
+ * tolerates a trailing `as <alias>`. Returns null when the name is missing or
+ * the quoted name is unterminated.
+ */
+export function extractDeclaredName(rest) {
+    const asIndex = rest.search(/\s+as\s+\S+\s*$/i);
+    const core = asIndex === -1 ? rest.trim() : rest.slice(0, asIndex).trim();
+    if (core === '')
+        return null;
+    if (core.startsWith('"')) {
+        const close = core.indexOf('"', 1);
+        if (close === -1)
+            return null;
+        return core.slice(1, close);
+    }
+    return core.split(/\s+/)[0] || null;
+}

package/dist/parse/serialize.d.ts

@@ -0,0 +1,32 @@
+/**
+ * PlantUmlModel → PlantUML class-diagram text.
+ *
+ * The inverse of [[parsePlantUml]]: `toPlantUml(renderDetailed(...).model)`
+ * reproduces the diagram that was actually drawn (after view/transform/detail)
+ * as source a user can copy and paste. Pure and synchronous — the model is the
+ * only input, so the caller composes the scope by picking the model
+ * (`toPlantUml(applyView(model, {kind: 'neighborhood', entity, hops}))`); this
+ * function never chooses a range on its own.
+ *
+ * Shapes that only exist after parsing (stub/external/usageCount, aggregated
+ * edge weights, cycle markers) are rendering semantics with no PlantUML
+ * spelling; they serialize as their plain-text equivalent (stub → class,
+ * weighted edge → one edge). The parts that do have a spelling — packages
+ * (nested), entity kind/generics/alias, member rows, relation arrow/label/
+ * cardinality — round-trip back through [[parsePlantUml]] unchanged.
+ *
+ * The displayed name is always emitted quoted (`class "<<function>> halt"
+ * as n0`), so names carrying a stereotype prefix or `/` path separators survive
+ * the round trip as authored.
+ */
+import type { PlantUmlModel } from '../foundation/model.js';
+/**
+ * Serialize a model to `@startuml … @enduml` class-diagram source.
+ *
+ * Emitted layout: nested `package` blocks first (each holding the entities that
+ * carry its `packageId`), then package-less entities, then every relation.
+ * Entities always use the quoted form with an explicit alias, which is the only
+ * form that carries a display name containing whitespace, `/`, or a
+ * `<<stereotype>>` prefix.
+ */
+export declare function toPlantUml(model: PlantUmlModel): string;

package/dist/parse/serialize.js

@@ -0,0 +1,218 @@
+/**
+ * PlantUmlModel → PlantUML class-diagram text.
+ *
+ * The inverse of [[parsePlantUml]]: `toPlantUml(renderDetailed(...).model)`
+ * reproduces the diagram that was actually drawn (after view/transform/detail)
+ * as source a user can copy and paste. Pure and synchronous — the model is the
+ * only input, so the caller composes the scope by picking the model
+ * (`toPlantUml(applyView(model, {kind: 'neighborhood', entity, hops}))`); this
+ * function never chooses a range on its own.
+ *
+ * Shapes that only exist after parsing (stub/external/usageCount, aggregated
+ * edge weights, cycle markers) are rendering semantics with no PlantUML
+ * spelling; they serialize as their plain-text equivalent (stub → class,
+ * weighted edge → one edge). The parts that do have a spelling — packages
+ * (nested), entity kind/generics/alias, member rows, relation arrow/label/
+ * cardinality — round-trip back through [[parsePlantUml]] unchanged.
+ *
+ * The displayed name is always emitted quoted (`class "<<function>> halt"
+ * as n0`), so names carrying a stereotype prefix or `/` path separators survive
+ * the round trip as authored.
+ */
+/** A bare PlantUML identifier (what `as <alias>` accepts). */
+const PLANTUML_ID = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const INDENT = '  ';
+const VISIBILITY_SYMBOL = {
+    public: '+',
+    private: '-',
+    protected: '#',
+    'package-private': '~',
+};
+/**
+ * One arrow per relation type, written in canonical source→target direction.
+ * The parser's own arrow table also accepts the swapped mirror forms
+ * (`<|--`, `--o`, …); emitting the canonical form is what makes the round trip
+ * stable.
+ */
+const RELATION_ARROW = {
+    inheritance: '--|>',
+    implementation: '..|>',
+    dependency: '..>',
+    association: '-->',
+    aggregation: 'o--',
+    composition: '*--',
+};
+/**
+ * Serialize a model to `@startuml … @enduml` class-diagram source.
+ *
+ * Emitted layout: nested `package` blocks first (each holding the entities that
+ * carry its `packageId`), then package-less entities, then every relation.
+ * Entities always use the quoted form with an explicit alias, which is the only
+ * form that carries a display name containing whitespace, `/`, or a
+ * `<<stereotype>>` prefix.
+ */
+export function toPlantUml(model) {
+    const entities = new AliasBook('entity');
+    const packages = new AliasBook('package');
+    const lines = ['@startuml'];
+    const nodes = packageNodes(model);
+    const emitted = new Set();
+    for (const node of nodes.roots)
+        emitPackage(node, 0, lines, entities, packages, emitted);
+    // Defensive: a parentId cycle leaves nodes unreachable from any root; emit
+    // each remaining package as a root rather than silently dropping it.
+    for (const node of nodes.all) {
+        if (!emitted.has(node.pkg.id))
+            emitPackage(node, 0, lines, entities, packages, emitted);
+    }
+    for (const entity of nodes.topLevel) {
+        lines.push(...entityLines(entity, 0, entities));
+    }
+    for (const relation of model.relations) {
+        lines.push(relationLine(relation, entities));
+    }
+    lines.push('@enduml');
+    return lines.join('\n');
+}
+/**
+ * Index packages into a tree, attaching each entity to the innermost package it
+ * names. An entity whose `packageId` names no declared package is emitted at
+ * the top level instead of being dropped.
+ */
+function packageNodes(model) {
+    const byId = new Map();
+    const all = [];
+    for (const pkg of model.packages) {
+        // A duplicated id keeps its first package; the parser never produces one.
+        if (byId.has(pkg.id))
+            continue;
+        const node = { pkg, children: [], entities: [] };
+        byId.set(pkg.id, node);
+        all.push(node);
+    }
+    const roots = [];
+    for (const node of all) {
+        const parentId = node.pkg.parentId;
+        const parent = parentId === undefined ? undefined : byId.get(parentId);
+        if (parent !== undefined && parent !== node)
+            parent.children.push(node);
+        else
+            roots.push(node);
+    }
+    const topLevel = [];
+    for (const entity of model.entities) {
+        const owner = entity.packageId === undefined ? undefined : byId.get(entity.packageId);
+        if (owner !== undefined)
+            owner.entities.push(entity);
+        else
+            topLevel.push(entity);
+    }
+    return { roots, all, topLevel };
+}
+function emitPackage(node, depth, lines, entities, packages, emitted) {
+    if (emitted.has(node.pkg.id))
+        return;
+    emitted.add(node.pkg.id);
+    const indent = INDENT.repeat(depth);
+    const alias = packages.alias(node.pkg.id, node.pkg.name);
+    lines.push(`${indent}package ${quoteName(node.pkg.name)} as ${alias} {`);
+    for (const entity of node.entities) {
+        lines.push(...entityLines(entity, depth + 1, entities));
+    }
+    for (const child of node.children) {
+        emitPackage(child, depth + 1, lines, entities, packages, emitted);
+    }
+    lines.push(`${indent}}`);
+}
+function entityKeyword(entity) {
+    return entity.kind === 'abstract' ? 'abstract class' : entity.kind;
+}
+function entityLines(entity, depth, aliases) {
+    const indent = INDENT.repeat(depth);
+    const alias = aliases.alias(entity.id, entity.name);
+    const head = `${entityKeyword(entity)} ${quoteName(entity.name)}${genericSuffix(entity)} as ${alias}`;
+    if (entity.members.length === 0)
+        return [`${indent}${head}`];
+    const lines = [`${indent}${head} {`];
+    for (const member of entity.members) {
+        lines.push(`${indent}${INDENT}${memberLine(member)}`);
+    }
+    lines.push(`${indent}}`);
+    return lines;
+}
+function genericSuffix(entity) {
+    const generics = entity.generics ?? [];
+    return generics.length === 0 ? '' : `~${generics.join(',')}~`;
+}
+/**
+ * One member row. The authored `raw` text is authoritative (it carries the
+ * visibility symbol and the exact signature), except for synthesized rows —
+ * the detail pipeline's `… +N more (M members)` truncation marker has no
+ * visibility symbol, so it gets one prefixed to stay parseable as a member
+ * row while keeping the marker text verbatim.
+ */
+function memberLine(member) {
+    const raw = (member.raw ?? '').trim();
+    const symbol = VISIBILITY_SYMBOL[member.visibility] ?? '+';
+    if (raw === '')
+        return symbol;
+    if (/^[+\-#~]/.test(raw))
+        return raw;
+    return `${symbol} ${raw}`;
+}
+function relationLine(relation, aliases) {
+    const source = aliases.alias(relation.source, relation.source);
+    const target = aliases.alias(relation.target, relation.target);
+    const parts = [source];
+    if (relation.sourceCardinality !== undefined)
+        parts.push(quoteName(relation.sourceCardinality));
+    parts.push(RELATION_ARROW[relation.type] ?? '-->');
+    if (relation.targetCardinality !== undefined)
+        parts.push(quoteName(relation.targetCardinality));
+    parts.push(target);
+    let line = parts.join(' ');
+    if (relation.label !== undefined && relation.label !== '') {
+        line += ` : ${relation.label.replace(/[\r\n]+/g, ' ')}`;
+    }
+    return line;
+}
+/** Quote a display name; a `"` inside a PlantUML name is written as `'`. */
+function quoteName(name) {
+    const safe = name.replace(/[\r\n\t]+/g, ' ').replace(/"/g, "'");
+    return `"${safe}"`;
+}
+/**
+ * Deterministic, collision-free alias assignment, in emission order. A
+ * plant-legal id is kept verbatim (so a parsed model round-trips its ids); an
+ * id PlantUML cannot spell (view-internal ids such as `ov::src`, `stub::x`)
+ * falls back to an identifier derived from the display name.
+ */
+class AliasBook {
+    used = new Set();
+    byId = new Map();
+    fallback;
+    constructor(fallback) {
+        this.fallback = fallback;
+    }
+    alias(id, name) {
+        const existing = this.byId.get(id);
+        if (existing !== undefined)
+            return existing;
+        const base = PLANTUML_ID.test(id) ? id : identifierFrom(name, this.fallback);
+        let alias = base;
+        let suffix = 2;
+        while (this.used.has(alias))
+            alias = `${base}_${suffix++}`;
+        this.used.add(alias);
+        this.byId.set(id, alias);
+        return alias;
+    }
+}
+/** Derive a bare identifier from a display name (`Src Layer` → `Src_Layer`). */
+function identifierFrom(name, fallback) {
+    const cleaned = name
+        .replace(/[^A-Za-z0-9_]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+    const base = cleaned === '' ? fallback : cleaned;
+    return /^[A-Za-z_]/.test(base) ? base : `_${base}`;
+}

package/dist/render/legend.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Legend — a small key explaining the visual encodings of a rendered diagram:
+ * feedback (back) edges, hub badges, `×N` weights and the dashed/solid node
+ * frames. Drawn below the diagram, so it never covers layout geometry.
+ */
+import { Theme } from './theme.js';
+/** Entity count above which the legend is drawn by default. */
+export declare const LEGEND_DEFAULT_NODE_THRESHOLD = 30;
+export interface Legend {
+    /** `<g class="uml-legend">` markup positioned at (x, y). */
+    svg: string;
+    width: number;
+    height: number;
+}
+export declare function renderLegend(x: number, y: number, theme: Theme): Legend;

package/dist/render/legend.js

@@ -0,0 +1,42 @@
+/**
+ * Legend — a small key explaining the visual encodings of a rendered diagram:
+ * feedback (back) edges, hub badges, `×N` weights and the dashed/solid node
+ * frames. Drawn below the diagram, so it never covers layout geometry.
+ */
+const ROW_HEIGHT = 20;
+const PAD = 10;
+const SWATCH_WIDTH = 34;
+const FONT_SIZE = 11;
+/** Entity count above which the legend is drawn by default. */
+export const LEGEND_DEFAULT_NODE_THRESHOLD = 30;
+const ITEMS = [
+    'feedback edge (dash-dot; closes a dependency cycle)',
+    'hub badge: number of dependents (edges hidden)',
+    '×N: number of merged relations',
+    'dashed frame: grouped / external package',
+    'solid frame: single module',
+];
+export function renderLegend(x, y, theme) {
+    const { color } = theme;
+    const width = PAD * 2 + SWATCH_WIDTH + 8 + 300;
+    const height = PAD * 2 + ROW_HEIGHT * ITEMS.length;
+    const rowY = (i) => y + PAD + ROW_HEIGHT * i + ROW_HEIGHT / 2;
+    const sx = x + PAD;
+    const tx = sx + SWATCH_WIDTH + 8;
+    const swatches = [
+        `<line x1="${sx}" y1="${rowY(0)}" x2="${sx + SWATCH_WIDTH}" y2="${rowY(0)}" stroke="${color.warn}" stroke-width="${theme.stroke.edge}" stroke-dasharray="${theme.dash.feedback}"/>`,
+        `<circle cx="${sx + SWATCH_WIDTH / 2}" cy="${rowY(1)}" r="8" fill="${color.accent}"/>` +
+            `<text x="${sx + SWATCH_WIDTH / 2}" y="${rowY(1) + 3.5}" text-anchor="middle" font-family="${theme.font.family}" font-size="10" fill="${color.accentText}">N</text>`,
+        `<line x1="${sx}" y1="${rowY(2)}" x2="${sx + SWATCH_WIDTH}" y2="${rowY(2)}" stroke="${color.edge}" stroke-width="2.5" stroke-opacity="${theme.stroke.opacity.strong}"/>`,
+        `<rect x="${sx}" y="${rowY(3) - 7}" width="${SWATCH_WIDTH}" height="14" rx="3" fill="${color.stubFill}" stroke="${color.strokeStub}" stroke-width="${theme.stroke.node}" stroke-dasharray="${theme.dash.stub}"/>`,
+        `<rect x="${sx}" y="${rowY(4) - 7}" width="${SWATCH_WIDTH}" height="14" rx="3" fill="${color.nodeFill}" stroke="${color.stroke}" stroke-width="${theme.stroke.node}"/>`,
+    ];
+    const texts = ITEMS.map((item, i) => `<text x="${tx}" y="${rowY(i) + 4}" text-anchor="start" font-family="${theme.font.family}"` +
+        ` font-size="${FONT_SIZE}" fill="${color.textMember}">${item.replace(/&/g, '&amp;').replace(/</g, '&lt;')}</text>`);
+    const svg = `<g class="uml-legend">` +
+        `<rect x="${x}" y="${y}" width="${width}" height="${height}" rx="6" fill="${color.canvas}" stroke="${color.legendStroke}" stroke-width="${theme.stroke.node}"/>` +
+        swatches.join('') +
+        texts.join('') +
+        `</g>`;
+    return { svg, width, height };
+}

package/dist/render/svg.d.ts

@@ -3,7 +3,64 @@
  * The renderer consumes only the LayoutResult (positions/sizes) plus the
  * model's display fields; it never reaches back into the parser.
  */
-import { PlantUmlModel } from '../model.js';
-import { LayoutResult } from '../layout.js';
+import { PlantUmlModel } from '../foundation/model.js';
+import { LayoutResult, Point } from '../foundation/layout.js';
+import { ThemeOverrides } from './theme.js';
 export declare function escapeXml(text: string): string;
-export declare function renderSvg(model: PlantUmlModel, layout: LayoutResult): string;
+export interface RenderSvgOptions {
+    /** Draw a legend of the visual encodings. Default: on for models with more than 30 entities. */
+    legend?: boolean;
+    /** Theme token overrides over `defaultTheme`. */
+    theme?: ThemeOverrides;
+    /** Edges hidden by transitive reduction; > 0 forces the legend and is reported there and in `data-hidden-transitive`. */
+    hiddenTransitive?: number;
+}
+/**
+ * Per-frame values handed to {@link RenderEngine.render}. Only values computed
+ * for the frame being rendered belong here; configuration that outlives a
+ * frame (theme, legend override) is constructor state of the engine.
+ */
+export interface RenderFrameOptions {
+    /** Edges hidden by transitive reduction in this frame; > 0 forces the legend and is reported there and in `data-hidden-transitive`. */
+    hiddenTransitive?: number;
+}
+/**
+ * The rendering counterpart of `LayoutEngine`: draw an already laid-out model.
+ * Synchronous because SVG assembly is synchronous, unlike layout. Inject one
+ * through `RendererOptions.renderer` to swap the rendering backend.
+ */
+export interface RenderEngine {
+    render(model: PlantUmlModel, layout: LayoutResult, frame?: RenderFrameOptions): string;
+}
+/** Configuration that outlives a frame — constructor state of {@link SvgRenderer}. */
+export interface SvgRendererOptions {
+    /** Draw a legend of the visual encodings. Default: on for models with more than 30 entities. */
+    legend?: boolean;
+    /** Theme token overrides over `defaultTheme`. */
+    theme?: ThemeOverrides;
+}
+/**
+ * The built-in {@link RenderEngine}: the SVG backend. Theme and legend
+ * configuration are fixed at construction; the per-frame `hiddenTransitive`
+ * count is passed to [[SvgRenderer.render]].
+ */
+export declare class SvgRenderer implements RenderEngine {
+    private readonly legend;
+    private readonly theme;
+    constructor(options?: SvgRendererOptions);
+    render(model: PlantUmlModel, layout: LayoutResult, frame?: RenderFrameOptions): string;
+}
+/**
+ * Convenience wrapper over {@link SvgRenderer}, kept for callers that build the
+ * SVG directly from a model + layout (the renderer class is preferred when
+ * injecting into `RendererOptions.renderer`).
+ */
+export declare function renderSvg(model: PlantUmlModel, layout: LayoutResult, options?: RenderSvgOptions): string;
+/** Edges sharing a source and exit direction beyond this count are drawn as one bundle. */
+export declare const EDGE_BUNDLE_MIN = 5;
+/**
+ * Polyline as an SVG path whose interior corners are rounded with quadratic
+ * curves of radius ≤ `radius` (clamped to half of each adjoining segment). The
+ * routing — the vertices — is unchanged.
+ */
+export declare function roundedPath(points: Point[], radius: number): string;