@oh-my-pi/pi-utils 16.0.6 → 16.0.8

package/dist/types/vendor/mermaid-ascii/ascii/shapes/rounded.d.ts

@@ -0,0 +1,11 @@
+import type { ShapeRenderer } from './types';
+/**
+ * Rounded rectangle shape renderer.
+ * Uses rounded corner markers (╭╮╰╯) to indicate soft edges.
+ *
+ * Renders as:
+ *   ╭─────────╮
+ *   │  Label  │
+ *   ╰─────────╯
+ */
+export declare const roundedRenderer: ShapeRenderer;

package/dist/types/vendor/mermaid-ascii/ascii/shapes/special.d.ts

@@ -0,0 +1,59 @@
+import type { ShapeRenderer } from './types';
+/**
+ * Subroutine shape renderer — double-bordered rectangle.
+ * Renders as:
+ *   ┌┬─────────┬┐
+ *   ││  Label  ││
+ *   └┴─────────┴┘
+ */
+export declare const subroutineRenderer: ShapeRenderer;
+/**
+ * Double circle shape renderer.
+ * Uses double circle markers (◎) at corners.
+ *
+ * Renders as:
+ *   ◎─────────◎
+ *   │  Label  │
+ *   ◎─────────◎
+ */
+export declare const doublecircleRenderer: ShapeRenderer;
+/**
+ * Cylinder shape renderer — database symbol.
+ * Renders as:
+ *   ╭─────╮
+ *   │─────│
+ *   │ DB  │
+ *   │─────│
+ *   ╰─────╯
+ */
+export declare const cylinderRenderer: ShapeRenderer;
+/**
+ * Asymmetric (flag/banner) shape renderer.
+ * Uses arrow markers (▷) on left corners.
+ *
+ * Renders as:
+ *   ▷─────────┐
+ *   │  Label  │
+ *   ▷─────────┘
+ */
+export declare const asymmetricRenderer: ShapeRenderer;
+/**
+ * Trapezoid shape renderer — wider at bottom.
+ * Uses slope markers (◸◹) on top corners.
+ *
+ * Renders as:
+ *   ◸─────────◹
+ *   │  Label  │
+ *   └─────────┘
+ */
+export declare const trapezoidRenderer: ShapeRenderer;
+/**
+ * Trapezoid-alt shape renderer — wider at top.
+ * Uses slope markers (◺◿) on bottom corners.
+ *
+ * Renders as:
+ *   ┌─────────┐
+ *   │  Label  │
+ *   ◺─────────◿
+ */
+export declare const trapezoidAltRenderer: ShapeRenderer;

package/dist/types/vendor/mermaid-ascii/ascii/shapes/stadium.d.ts

@@ -0,0 +1,17 @@
+import type { ShapeRenderer } from './types';
+/**
+ * Stadium (pill) shape renderer.
+ *
+ * Single-line:  ( Label )
+ *
+ * Multi-line unicode:
+ *   ╭──────────╮
+ *   │  Label   │
+ *   ╰──────────╯
+ *
+ * Multi-line ASCII:
+ *   (----------)
+ *   (  Label   )
+ *   (----------)
+ */
+export declare const stadiumRenderer: ShapeRenderer;

package/dist/types/vendor/mermaid-ascii/ascii/shapes/state.d.ts

@@ -0,0 +1,30 @@
+import type { ShapeRenderer } from './types';
+/**
+ * State start pseudo-state renderer — filled circle in rounded box.
+ * Renders as:
+ *   ╭───╮
+ *   │ ● │   (Unicode)
+ *   ╰───╯
+ *
+ *   .---.
+ *   | * |   (ASCII)
+ *   '---'
+ *
+ * This represents the UML initial pseudo-state.
+ */
+export declare const stateStartRenderer: ShapeRenderer;
+/**
+ * State end pseudo-state renderer — bullseye in double-bordered box.
+ * Renders as:
+ *   ╔═══╗
+ *   ║ ◎ ║   (Unicode)
+ *   ╚═══╝
+ *
+ *   #===#
+ *   # * #   (ASCII)
+ *   #===#
+ *
+ * This represents the UML final state. The double border distinguishes it
+ * from the start state's single rounded border.
+ */
+export declare const stateEndRenderer: ShapeRenderer;

package/dist/types/vendor/mermaid-ascii/ascii/shapes/types.d.ts

@@ -0,0 +1,55 @@
+import type { Canvas, DrawingCoord, Direction, AsciiNodeShape } from '../types';
+/**
+ * Dimensions calculated for a shape, used by layout and rendering.
+ */
+export interface ShapeDimensions {
+    /** Total width in characters including borders */
+    width: number;
+    /** Total height in characters including borders */
+    height: number;
+    /** Label area bounds (where text can be placed) */
+    labelArea: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Grid column widths for the 3-column layout [left, center, right] */
+    gridColumns: [number, number, number];
+    /** Grid row heights for the 3-row layout [top, middle, bottom] */
+    gridRows: [number, number, number];
+}
+/**
+ * Options passed to shape renderers.
+ */
+export interface ShapeRenderOptions {
+    /** Use ASCII chars (+,-,|) vs Unicode box-drawing (┌,─,│) */
+    useAscii: boolean;
+    /** Padding inside the shape */
+    padding: number;
+}
+/**
+ * Interface for pluggable shape renderers.
+ * Each shape type implements this interface.
+ */
+export interface ShapeRenderer {
+    /**
+     * Calculate dimensions for this shape given a label.
+     * Used during layout to determine node size.
+     */
+    getDimensions(label: string, options: ShapeRenderOptions): ShapeDimensions;
+    /**
+     * Render the shape to a canvas.
+     * Returns a standalone canvas containing just the shape.
+     */
+    render(label: string, dimensions: ShapeDimensions, options: ShapeRenderOptions): Canvas;
+    /**
+     * Get the edge attachment point for a given direction.
+     * Used by edge routing to determine where edges connect.
+     */
+    getAttachmentPoint(dir: Direction, dimensions: ShapeDimensions, baseCoord: DrawingCoord): DrawingCoord;
+}
+/**
+ * Registry of shape renderers keyed by shape type.
+ */
+export type ShapeRegistry = Map<AsciiNodeShape, ShapeRenderer>;

package/dist/types/vendor/mermaid-ascii/ascii/types.d.ts

@@ -0,0 +1,206 @@
+import type { NodeShape } from '../types';
+export type { NodeShape };
+/**
+ * Shape type for ASCII rendering — maps parser shapes to ASCII renderers.
+ * Most shapes from the parser are supported, with fallback to 'rectangle'.
+ */
+export type AsciiNodeShape = NodeShape;
+/** Logical grid coordinate — nodes occupy 3x3 blocks on this grid. */
+export interface GridCoord {
+    x: number;
+    y: number;
+}
+/** Character-level coordinate on the 2D text canvas. */
+export interface DrawingCoord {
+    x: number;
+    y: number;
+}
+/**
+ * Direction constants model positions on a node's 3x3 grid block.
+ * Each node occupies grid cells [x..x+2, y..y+2].
+ * Directions are offsets into that block, used for edge attachment points.
+ *
+ *   (0,0) UL   (1,0) Up   (2,0) UR
+ *   (0,1) Left (1,1) Mid  (2,1) Right
+ *   (0,2) LL   (1,2) Down (2,2) LR
+ */
+export interface Direction {
+    readonly x: number;
+    readonly y: number;
+}
+export declare const Up: Direction;
+export declare const Down: Direction;
+export declare const Left: Direction;
+export declare const Right: Direction;
+export declare const UpperRight: Direction;
+export declare const UpperLeft: Direction;
+export declare const LowerRight: Direction;
+export declare const LowerLeft: Direction;
+export declare const Middle: Direction;
+/** All named directions for iteration. */
+export declare const ALL_DIRECTIONS: readonly Direction[];
+/**
+ * 2D text canvas — column-major (canvas[x][y]).
+ * Each cell holds a single character (or space).
+ */
+export type Canvas = string[][];
+/** A node in the ASCII graph, positioned on the grid. */
+export interface AsciiNode {
+    /** Unique identity key — the original node ID from the parser (e.g. "A", "B"). */
+    name: string;
+    /** Human-readable label for rendering inside the box (e.g. "Web Server"). */
+    displayLabel: string;
+    /** Node shape from the parser (e.g. "rectangle", "diamond", "circle"). */
+    shape: AsciiNodeShape;
+    index: number;
+    gridCoord: GridCoord | null;
+    drawingCoord: DrawingCoord | null;
+    drawing: Canvas | null;
+    drawn: boolean;
+    styleClassName: string;
+    styleClass: AsciiStyleClass;
+}
+/** Style class for colored node text (ported from Go's classDef). */
+export interface AsciiStyleClass {
+    name: string;
+    styles: Record<string, string>;
+}
+/** Edge line style for ASCII rendering. */
+export type AsciiEdgeStyle = 'solid' | 'dotted' | 'thick';
+/** An edge in the ASCII graph, with a routed path. */
+export interface AsciiEdge {
+    from: AsciiNode;
+    to: AsciiNode;
+    text: string;
+    path: GridCoord[];
+    labelLine: GridCoord[];
+    startDir: Direction;
+    endDir: Direction;
+    /** Line style: solid (default), dotted (-.->) or thick (==>) */
+    style: AsciiEdgeStyle;
+    /** 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;
+    /** Bundle this edge belongs to (if any). Set during bundling analysis. */
+    bundle?: EdgeBundle;
+    /**
+     * For bundled edges: path from source/target to the junction point.
+     * The full visual path is: pathToJunction + bundle.sharedPath (for fan-in)
+     * or bundle.sharedPath + pathToJunction (for fan-out).
+     */
+    pathToJunction?: GridCoord[];
+}
+/** A subgraph container with bounding box for rendering. */
+export interface AsciiSubgraph {
+    name: string;
+    nodes: AsciiNode[];
+    parent: AsciiSubgraph | null;
+    children: AsciiSubgraph[];
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    /** Optional direction override for layout within this subgraph (LR or TD). */
+    direction?: 'LR' | 'TD';
+}
+/** Configuration for ASCII rendering. */
+export interface AsciiConfig {
+    /** true = ASCII chars (+,-,|), false = Unicode box-drawing (┌,─,│). Default: false */
+    useAscii: boolean;
+    /** Horizontal spacing between nodes. Default: 5 */
+    paddingX: number;
+    /** Vertical spacing between nodes. Default: 5 */
+    paddingY: number;
+    /** Padding inside node boxes. Default: 1 */
+    boxBorderPadding: number;
+    /** Graph direction: "LR" or "TD". */
+    graphDirection: 'LR' | 'TD';
+}
+/** Full ASCII graph state used during layout and rendering. */
+export interface AsciiGraph {
+    nodes: AsciiNode[];
+    edges: AsciiEdge[];
+    canvas: Canvas;
+    /** Role canvas — tracks the role of each character for colored output. */
+    roleCanvas: RoleCanvas;
+    /** Grid occupancy map — maps "x,y" keys to node references. */
+    grid: Map<string, AsciiNode>;
+    columnWidth: Map<number, number>;
+    rowHeight: Map<number, number>;
+    subgraphs: AsciiSubgraph[];
+    config: AsciiConfig;
+    /** Offset applied to all drawing coords to accommodate subgraph borders. */
+    offsetX: number;
+    offsetY: number;
+    /** Edge bundles for parallel link visualization. Set during bundling analysis. */
+    bundles: EdgeBundle[];
+}
+export declare function gridCoordEquals(a: GridCoord, b: GridCoord): boolean;
+export declare function drawingCoordEquals(a: DrawingCoord, b: DrawingCoord): boolean;
+/** Apply a direction offset to a grid coordinate (move into the 3x3 block). */
+export declare function gridCoordDirection(c: GridCoord, dir: Direction): GridCoord;
+/** Key for storing GridCoord in a Map. */
+export declare function gridKey(c: GridCoord): string;
+/** Default empty style class. */
+export declare const EMPTY_STYLE: AsciiStyleClass;
+/**
+ * Role of a character in the ASCII diagram, used for theming.
+ * Each role maps to a different color when colors are enabled.
+ */
+export type CharRole = 'text' | 'border' | 'line' | 'arrow' | 'corner' | 'junction';
+/**
+ * Role canvas — parallel to Canvas, tracks the role of each character.
+ * Same column-major structure: roleCanvas[x][y] gives the role at (x, y).
+ * null means the character has no role (whitespace).
+ */
+export type RoleCanvas = (CharRole | null)[][];
+/**
+ * Theme colors for ASCII output — hex color strings.
+ * Derived from the SVG theme system for visual consistency.
+ */
+export interface AsciiTheme {
+    /** Text color (node labels, edge labels) */
+    fg: string;
+    /** Box border color (node borders, subgraph borders) */
+    border: string;
+    /** Edge line color (paths between nodes) */
+    line: string;
+    /** Arrowhead color (▲▼◄► or ^v<>) */
+    arrow: string;
+    /** Theme accent color (optional, used by xycharts for series 0) */
+    accent?: string;
+    /** Background color (optional, used by xycharts for dark-mode-aware shading) */
+    bg?: string;
+    /** Corner character color (optional, defaults to line) */
+    corner?: string;
+    /** Junction character color (optional, defaults to border) */
+    junction?: string;
+}
+/** Color mode for output. */
+export type ColorMode = 'none' | 'ansi16' | 'ansi256' | 'truecolor' | 'html';
+/**
+ * Edge bundle — groups edges that share a common source or target.
+ * Used to visually merge parallel links before they reach the shared node.
+ *
+ * For fan-in (A & B --> C): multiple sources converge to one target.
+ * For fan-out (A --> B & C): one source diverges to multiple targets.
+ */
+export interface EdgeBundle {
+    /** Bundle type: fan-in = many→one, fan-out = one→many */
+    type: 'fan-in' | 'fan-out';
+    /** Edges in this bundle */
+    edges: AsciiEdge[];
+    /** The common node (target for fan-in, source for fan-out) */
+    sharedNode: AsciiNode;
+    /** The non-shared nodes (sources for fan-in, targets for fan-out) */
+    otherNodes: AsciiNode[];
+    /** Junction point where edges merge/split — set during routing */
+    junctionPoint: GridCoord | null;
+    /** Path from junction to shared node (drawn once for all edges) */
+    sharedPath: GridCoord[];
+    /** Direction when entering/exiting the junction */
+    junctionDir: Direction;
+    /** Direction when entering/exiting the shared node */
+    sharedNodeDir: Direction;
+}

package/dist/types/vendor/mermaid-ascii/ascii/validate.d.ts

@@ -0,0 +1,51 @@
+/**
+ * ASCII Rendering Validation Utilities
+ *
+ * Provides validation functions for ASCII diagram output,
+ * including diagonal line detection to ensure orthogonal-only routing.
+ */
+/**
+ * Characters that represent diagonal lines in ASCII and Unicode modes.
+ * These should never appear in properly rendered diagrams.
+ */
+export declare const DIAGONAL_CHARS: {
+    readonly ascii: readonly ['/', '\\'];
+    readonly unicode: readonly ['╱', '╲'];
+    readonly all: readonly ['/', '\\', '╱', '╲'];
+};
+/**
+ * Position of a diagonal character in ASCII output.
+ */
+export interface DiagonalPosition {
+    line: number;
+    col: number;
+    char: string;
+}
+/**
+ * Check if ASCII output contains any diagonal line characters.
+ * Returns true if diagonals are found (which is an error condition).
+ *
+ * @param asciiOutput - The rendered ASCII diagram string
+ * @returns true if diagonal characters are present, false otherwise
+ */
+export declare function hasDiagonalLines(asciiOutput: string): boolean;
+/**
+ * Find all diagonal line character positions in ASCII output.
+ * Useful for debugging when diagonals are detected.
+ *
+ * Skips diagonal characters that appear inside node labels (between box borders).
+ * This prevents false positives from labels like "feature/auth" or "release/1.0".
+ *
+ * @param asciiOutput - The rendered ASCII diagram string
+ * @returns Array of positions where diagonal characters were found
+ */
+export declare function findDiagonalLines(asciiOutput: string): DiagonalPosition[];
+/**
+ * Assert that ASCII output contains no diagonal lines.
+ * Throws an error with detailed position information if diagonals are found.
+ *
+ * @param asciiOutput - The rendered ASCII diagram string
+ * @param context - Optional context string for error message (e.g., diagram name)
+ * @throws Error if diagonal characters are present
+ */
+export declare function assertNoDiagonals(asciiOutput: string, context?: string): void;

package/dist/types/vendor/mermaid-ascii/ascii/xychart.d.ts

@@ -0,0 +1,2 @@
+import type { AsciiConfig, AsciiTheme, ColorMode } from './types';
+export declare function renderXYChartAscii(text: string, config: AsciiConfig, colorMode: ColorMode, theme: AsciiTheme): string;

package/dist/types/vendor/mermaid-ascii/class/parser.d.ts

@@ -0,0 +1,6 @@
+import type { ClassDiagram } from './types';
+/**
+ * Parse a Mermaid class diagram.
+ * Expects the first line to be "classDiagram".
+ */
+export declare function parseClassDiagram(lines: string[]): ClassDiagram;

package/dist/types/vendor/mermaid-ascii/class/types.d.ts

@@ -0,0 +1,102 @@
+/** Parsed class diagram — logical structure from mermaid text */
+export interface ClassDiagram {
+    /** All class definitions */
+    classes: ClassNode[];
+    /** Relationships between classes */
+    relationships: ClassRelationship[];
+    /** Optional namespace groupings */
+    namespaces: ClassNamespace[];
+}
+export interface ClassNode {
+    id: string;
+    label: string;
+    /** Annotation like <<interface>>, <<abstract>>, <<service>>, <<enumeration>> */
+    annotation?: string;
+    /** Class attributes (fields/properties) */
+    attributes: ClassMember[];
+    /** Class methods (functions) */
+    methods: ClassMember[];
+}
+export interface ClassMember {
+    /** Visibility: + public, - private, # protected, ~ package */
+    visibility: '+' | '-' | '#' | '~' | '';
+    /** Member name */
+    name: string;
+    /** Type annotation (e.g., "String", "int", "void") */
+    type?: string;
+    /** Whether the member is static (underlined in UML) */
+    isStatic?: boolean;
+    /** Whether the member is abstract (italic in UML) */
+    isAbstract?: boolean;
+    /** Whether the member is a method (renders with parentheses) */
+    isMethod?: boolean;
+    /** Method parameters (e.g., "data", "key, val") — only for methods */
+    params?: string;
+}
+/** Relationship types following UML conventions */
+export type RelationshipType = 'inheritance' | 'composition' | 'aggregation' | 'association' | 'dependency' | 'realization';
+export interface ClassRelationship {
+    from: string;
+    to: string;
+    type: RelationshipType;
+    /**
+     * Which end of the relationship line has the UML marker (triangle, diamond, arrow).
+     * Determined by the arrow syntax direction:
+     *   - Prefix markers like `<|--`, `*--`, `o--` → 'from' (marker on left/from side)
+     *   - Suffix markers like `..|>`, `-->`, `..>`, `--*`, `--o` → 'to' (marker on right/to side)
+     */
+    markerAt: 'from' | 'to';
+    /** Label on the relationship line */
+    label?: string;
+    /** Cardinality at the "from" end (e.g., "1", "*", "0..1") */
+    fromCardinality?: string;
+    /** Cardinality at the "to" end */
+    toCardinality?: string;
+}
+export interface ClassNamespace {
+    name: string;
+    classIds: string[];
+}
+export interface PositionedClassDiagram {
+    width: number;
+    height: number;
+    classes: PositionedClassNode[];
+    relationships: PositionedClassRelationship[];
+}
+export interface PositionedClassNode {
+    id: string;
+    label: string;
+    annotation?: string;
+    attributes: ClassMember[];
+    methods: ClassMember[];
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Height of the header section (name + annotation) */
+    headerHeight: number;
+    /** Height of the attributes section */
+    attrHeight: number;
+    /** Height of the methods section */
+    methodHeight: number;
+}
+export interface PositionedClassRelationship {
+    from: string;
+    to: string;
+    type: RelationshipType;
+    /** Which end of the line has the UML marker — propagated from ClassRelationship */
+    markerAt: 'from' | 'to';
+    label?: string;
+    fromCardinality?: string;
+    toCardinality?: string;
+    /** Path points from source to target */
+    points: Array<{
+        x: number;
+        y: number;
+    }>;
+    /** Dagre-computed label center position (avoids overlaps between nearby edges) */
+    labelPosition?: {
+        x: number;
+        y: number;
+    };
+}

package/dist/types/vendor/mermaid-ascii/er/parser.d.ts

@@ -0,0 +1,6 @@
+import type { ErDiagram } from './types';
+/**
+ * Parse a Mermaid ER diagram.
+ * Expects the first line to be "erDiagram".
+ */
+export declare function parseErDiagram(lines: string[]): ErDiagram;

package/dist/types/vendor/mermaid-ascii/er/types.d.ts

@@ -0,0 +1,76 @@
+/** Parsed ER diagram — logical structure from mermaid text */
+export interface ErDiagram {
+    /** All entity definitions */
+    entities: ErEntity[];
+    /** Relationships between entities */
+    relationships: ErRelationship[];
+}
+export interface ErEntity {
+    id: string;
+    /** Display name (same as id unless aliased) */
+    label: string;
+    /** Entity attributes (columns) */
+    attributes: ErAttribute[];
+}
+export interface ErAttribute {
+    /** Data type (string, int, varchar, etc.) */
+    type: string;
+    /** Attribute name */
+    name: string;
+    /** Key constraints: PK, FK, UK */
+    keys: Array<'PK' | 'FK' | 'UK'>;
+    /** Optional comment */
+    comment?: string;
+}
+/**
+ * Cardinality notation (crow's foot):
+ *   'one'       ||  exactly one
+ *   'zero-one'  |o  zero or one
+ *   'many'      }|  one or more
+ *   'zero-many' o{  zero or more
+ */
+export type Cardinality = 'one' | 'zero-one' | 'many' | 'zero-many';
+export interface ErRelationship {
+    entity1: string;
+    entity2: string;
+    /** Cardinality at entity1's end */
+    cardinality1: Cardinality;
+    /** Cardinality at entity2's end */
+    cardinality2: Cardinality;
+    /** Relationship verb/label (e.g., "places", "contains") */
+    label: string;
+    /** Whether the relationship is identifying (solid line) or non-identifying (dashed) */
+    identifying: boolean;
+}
+export interface PositionedErDiagram {
+    width: number;
+    height: number;
+    entities: PositionedErEntity[];
+    relationships: PositionedErRelationship[];
+}
+export interface PositionedErEntity {
+    id: string;
+    label: string;
+    attributes: ErAttribute[];
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Height of the header row */
+    headerHeight: number;
+    /** Height per attribute row */
+    rowHeight: number;
+}
+export interface PositionedErRelationship {
+    entity1: string;
+    entity2: string;
+    cardinality1: Cardinality;
+    cardinality2: Cardinality;
+    label: string;
+    identifying: boolean;
+    /** Path points from entity1 to entity2 */
+    points: Array<{
+        x: number;
+        y: number;
+    }>;
+}

package/dist/types/vendor/mermaid-ascii/index.d.ts

@@ -0,0 +1 @@
+export * from './ascii/index';

package/dist/types/vendor/mermaid-ascii/multiline-utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Normalize label text for terminal ASCII output: strip surrounding quotes,
+ * convert <br> tags and literal newline escapes to newlines, and reduce
+ * inline formatting (HTML bold/italic/underline/strike tags and the markdown
+ * bold, italic, and strikethrough markers) to plain text. The ASCII renderer
+ * has no styled spans, so preserving the markup would print raw tags and
+ * markers inside node boxes.
+ */
+export declare function normalizeBrTags(label: string): string;

package/dist/types/vendor/mermaid-ascii/parser.d.ts

@@ -0,0 +1,7 @@
+import type { MermaidGraph } from './types';
+/**
+ * Parse Mermaid text into a logical graph structure.
+ * Auto-detects diagram type (flowchart or state diagram).
+ * Throws on invalid/unsupported input.
+ */
+export declare function parseMermaid(text: string): MermaidGraph;

package/dist/types/vendor/mermaid-ascii/sequence/parser.d.ts

@@ -0,0 +1,6 @@
+import type { SequenceDiagram } from './types';
+/**
+ * Parse a Mermaid sequence diagram.
+ * Expects the first line to be "sequenceDiagram".
+ */
+export declare function parseSequenceDiagram(lines: string[]): SequenceDiagram;