@oh-my-pi/pi-utils 16.0.7 → 16.0.9

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [16.0.8] - 2026-06-18
+
+### Changed
+
+- Mermaid diagrams are now rendered to ASCII by a first-party vendored renderer (`src/vendor/mermaid-ascii`, derived from the MIT-licensed `beautiful-mermaid`, ASCII pipeline only) with terminal display width measured via `Bun.stringWidth` (grapheme-aware, correct for wide/East-Asian glyphs and emoji). Inline label formatting (HTML formatting tags and markdown emphasis) is now reduced to plain text instead of printed raw.
+
+### Removed
+
+- Removed the external `beautiful-mermaid` dependency (and its transitive `elkjs`, ~3.13MB) in favor of the vendored ASCII renderer.
+
 ## [16.0.3] - 2026-06-16
 
 ### Added

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

@@ -1,4 +1,4 @@
-import { type AsciiRenderOptions } from "beautiful-mermaid";
+import { type AsciiRenderOptions } from "./vendor/mermaid-ascii";
 export type { AsciiRenderOptions as MermaidAsciiRenderOptions };
 export declare function renderMermaidAscii(source: string, options?: AsciiRenderOptions): string;
 export declare function renderMermaidAsciiSafe(source: string, options?: AsciiRenderOptions): string | null;

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

@@ -0,0 +1,41 @@
+import type { CharRole, AsciiTheme, ColorMode } from './types';
+/**
+ * Default ASCII theme derived from the SVG renderer's color palette.
+ * Uses the same mixing ratios to maintain visual consistency.
+ */
+export declare const DEFAULT_ASCII_THEME: AsciiTheme;
+/**
+ * Detect the best color mode for the current environment.
+ *
+ * Terminal detection order:
+ * 1. COLORTERM=truecolor or COLORTERM=24bit → truecolor
+ * 2. TERM contains "256color" → ansi256
+ * 3. TERM is set and not "dumb" → ansi16
+ *
+ * Browser: returns 'html' (uses <span> tags with inline styles).
+ * Unknown/piped: returns 'none'.
+ */
+export declare function detectColorMode(): ColorMode;
+/**
+ * Generate the ANSI escape sequence for a role color.
+ */
+export declare function getAnsiColor(role: CharRole, theme: AsciiTheme, mode: ColorMode): string;
+/**
+ * Get the ANSI reset sequence.
+ */
+export declare function getAnsiReset(mode: ColorMode): string;
+/**
+ * Wrap a character with ANSI color codes based on its role.
+ */
+export declare function colorizeChar(char: string, role: CharRole | null, theme: AsciiTheme, mode: ColorMode): string;
+/**
+ * Colorize an entire line efficiently by grouping consecutive same-role characters.
+ * This reduces the number of escape sequences (ANSI) or span tags (HTML) in the output.
+ */
+export declare function colorizeLine(chars: string[], roles: (CharRole | null)[], theme: AsciiTheme, mode: ColorMode): string;
+/**
+ * Colorize a text string with a direct hex color.
+ * Used by renderers that need per-cell color control (e.g. multi-series xychart).
+ * Handles all output modes: ANSI (16/256/truecolor) and HTML.
+ */
+export declare function colorizeText(text: string, hex: string, mode: ColorMode): string;

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

@@ -0,0 +1,89 @@
+import type { Canvas, DrawingCoord, RoleCanvas, CharRole, AsciiTheme, ColorMode } from './types';
+/**
+ * Create a blank canvas filled with spaces.
+ * Dimensions are inclusive: mkCanvas(3, 2) creates a 4x3 grid (indices 0..3, 0..2).
+ */
+export declare function mkCanvas(x: number, y: number): Canvas;
+/** Create a blank canvas with the same dimensions as the given canvas. */
+export declare function copyCanvas(source: Canvas): Canvas;
+/**
+ * Create a blank role canvas filled with nulls.
+ * Same dimensions as mkCanvas — column-major, roleCanvas[x][y].
+ */
+export declare function mkRoleCanvas(x: number, y: number): RoleCanvas;
+/** Create a blank role canvas with the same dimensions as the given role canvas. */
+export declare function copyRoleCanvas(source: RoleCanvas): RoleCanvas;
+/**
+ * Grow the role canvas to fit at least (newX, newY), preserving existing roles.
+ * Mutates the role canvas in place and returns it.
+ */
+export declare function increaseRoleCanvasSize(roleCanvas: RoleCanvas, newX: number, newY: number): RoleCanvas;
+/**
+ * Set a role at a specific coordinate.
+ * Expands the role canvas if necessary.
+ */
+export declare function setRole(roleCanvas: RoleCanvas, x: number, y: number, role: CharRole): void;
+/**
+ * Merge role canvases — same logic as mergeCanvases but for roles.
+ * Non-null roles in overlays overwrite null roles in base.
+ */
+export declare function mergeRoleCanvases(base: RoleCanvas, offset: DrawingCoord, ...overlays: RoleCanvas[]): RoleCanvas;
+/** Returns [maxX, maxY] — the highest valid indices in each dimension. */
+export declare function getCanvasSize(canvas: Canvas): [number, number];
+/**
+ * Grow the canvas to fit at least (newX, newY), preserving existing content.
+ * Mutates the canvas in place and returns it.
+ */
+export declare function increaseSize(canvas: Canvas, newX: number, newY: number): Canvas;
+export declare function isJunctionChar(c: string): boolean;
+export declare function mergeJunctions(c1: string, c2: string): string;
+/**
+ * Merge overlay canvases onto a base canvas at the given offset.
+ * Non-space characters in overlays overwrite the base.
+ * When both characters are Unicode junction chars, they're merged intelligently.
+ */
+export declare function mergeCanvases(base: Canvas, offset: DrawingCoord, useAscii: boolean, ...overlays: Canvas[]): Canvas;
+/** Options for converting canvas to string with optional coloring. */
+export interface CanvasToStringOptions {
+    /** Role canvas for applying colors. If not provided, output is plain text. */
+    roleCanvas?: RoleCanvas;
+    /** Color mode for terminal output. Default: 'none' */
+    colorMode?: ColorMode;
+    /** Theme colors for ASCII output. Uses default theme if not provided. */
+    theme?: AsciiTheme;
+}
+/**
+ * Convert the canvas to a multi-line string (row by row, left to right).
+ * Optionally applies ANSI color codes based on character roles.
+ */
+export declare function canvasToString(canvas: Canvas, options?: CanvasToStringOptions): string;
+/**
+ * Flip the canvas vertically (mirror across the horizontal center).
+ * Reverses row order within each column and remaps directional characters
+ * (arrows, corners, junctions) so they point the correct way after flip.
+ *
+ * Used to transform a TD-rendered canvas into BT output.
+ * Mutates the canvas in place and returns it.
+ */
+export declare function flipCanvasVertically(canvas: Canvas): Canvas;
+/**
+ * Flip the role canvas vertically to match flipCanvasVertically.
+ * Mutates the role canvas in place and returns it.
+ */
+export declare function flipRoleCanvasVertically(roleCanvas: RoleCanvas): RoleCanvas;
+/**
+ * Draw text string onto the canvas starting at the given coordinate.
+ * By default, preserves existing non-space characters (labels don't overwrite each other).
+ * Set forceOverwrite=true to always overwrite (for box content).
+ */
+export declare function drawText(canvas: Canvas, start: DrawingCoord, text: string, forceOverwrite?: boolean): void;
+/**
+ * Set the canvas size to fit all grid columns and rows.
+ * Called after layout to ensure the canvas covers the full drawing area.
+ */
+export declare function setCanvasSizeToGrid(canvas: Canvas, columnWidth: Map<number, number>, rowHeight: Map<number, number>): void;
+/**
+ * Set the role canvas size to match the grid dimensions.
+ * Should be called alongside setCanvasSizeToGrid.
+ */
+export declare function setRoleCanvasSizeToGrid(roleCanvas: RoleCanvas, columnWidth: Map<number, number>, rowHeight: Map<number, number>): void;

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

@@ -0,0 +1,7 @@
+import type { AsciiConfig, AsciiTheme, ColorMode } from './types';
+/**
+ * Render a Mermaid class diagram to ASCII/Unicode text.
+ *
+ * Pipeline: parse → build boxes → level-based layout → draw boxes → draw relationships → string.
+ */
+export declare function renderClassAscii(text: string, config: AsciiConfig, colorMode?: ColorMode, theme?: AsciiTheme): string;

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

@@ -0,0 +1,12 @@
+import type { MermaidGraph } from '../types';
+import type { AsciiGraph, AsciiConfig } from './types';
+/**
+ * Convert a parsed MermaidGraph into an AsciiGraph ready for grid layout.
+ *
+ * Key mappings:
+ * - MermaidGraph.nodes (Map) → ordered AsciiNode[] preserving insertion order
+ * - MermaidGraph.edges → AsciiEdge[] with resolved node references
+ * - MermaidGraph.subgraphs → AsciiSubgraph[] with parent/child tree
+ * - Node labels are used as display names (not raw IDs)
+ */
+export declare function convertToAsciiGraph(parsed: MermaidGraph, config: AsciiConfig): AsciiGraph;

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

@@ -0,0 +1,66 @@
+import type { Canvas, DrawingCoord, AsciiGraph, AsciiNode, AsciiEdge, AsciiSubgraph, AsciiEdgeStyle } from './types';
+/**
+ * Draw a node using its shape type.
+ * Returns a standalone canvas containing the rendered shape.
+ *
+ * For basic shapes (rectangle, rounded), uses grid-determined dimensions
+ * to ensure consistent sizing across nodes in the same column.
+ * For special shapes (diamond, circle, state pseudo-states, etc.),
+ * uses shape-specific dimension calculation but centers the content
+ * within the grid cell dimensions to ensure proper vertical alignment.
+ */
+export declare function drawNode(node: AsciiNode, graph: AsciiGraph): Canvas;
+/**
+ * Draw a node box with centered label text.
+ * Returns a standalone canvas containing just the box.
+ * Box size is determined by the grid column/row sizes for the node's position.
+ */
+export declare function drawBox(node: AsciiNode, graph: AsciiGraph): Canvas;
+/**
+ * Draw a multi-section box with horizontal dividers between sections.
+ * Used by class diagrams (header | attributes | methods) and ER diagrams (header | attributes).
+ * Each section is an array of text lines to render left-aligned with padding.
+ *
+ * @param sections - Array of sections, each section is an array of text lines
+ * @param useAscii - true for ASCII chars, false for Unicode box-drawing
+ * @param padding - horizontal padding inside the box (default 1)
+ * @returns A standalone Canvas containing the multi-section box
+ */
+export declare function drawMultiBox(sections: string[][], useAscii: boolean, padding?: number): Canvas;
+/**
+ * Draw a line between two drawing coordinates using orthogonal Manhattan routing.
+ * Returns the list of coordinates that were drawn on.
+ * offsetFrom/offsetTo control how many cells to skip at the start/end.
+ *
+ * All lines use 90° bends only - no diagonal lines are produced.
+ * For diagonal directions, uses horizontal-first routing (draws horizontal
+ * segment, then vertical segment).
+ */
+export declare function drawLine(canvas: Canvas, from: DrawingCoord, to: DrawingCoord, offsetFrom: number, offsetTo: number, useAscii: boolean, style?: AsciiEdgeStyle): DrawingCoord[];
+/**
+ * Draw a complete arrow (edge) between two nodes.
+ * Returns 6 separate canvases for layered compositing:
+ * [path, boxStart, arrowHeadEnd, arrowHeadStart, corners, label]
+ *
+ * Supports bidirectional arrows via edge.hasArrowStart and edge.hasArrowEnd.
+ */
+export declare function drawArrow(graph: AsciiGraph, edge: AsciiEdge): [Canvas, Canvas, Canvas, Canvas, Canvas, Canvas];
+/** Draw a subgraph border rectangle. */
+export declare function drawSubgraphBox(sg: AsciiSubgraph, graph: AsciiGraph): Canvas;
+/** Draw a subgraph label centered in its header area. Supports multi-line labels. */
+export declare function drawSubgraphLabel(sg: AsciiSubgraph, graph: AsciiGraph): [Canvas, DrawingCoord];
+/**
+ * Main draw function — renders the entire graph onto the canvas.
+ * Drawing order matters for correct layering:
+ * 1. Subgraph borders (bottom layer)
+ * 2. Node boxes
+ * 3. Edge paths (lines)
+ * 4. Edge corners
+ * 5. Arrowheads
+ * 6. Box-start junctions
+ * 7. Edge labels
+ * 8. Subgraph labels (top layer)
+ *
+ * Also fills the roleCanvas with character roles for colored output.
+ */
+export declare function drawGraph(graph: AsciiGraph): Canvas;

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

@@ -0,0 +1,48 @@
+import type { AsciiGraph, EdgeBundle, GridCoord } from './types';
+/**
+ * Analyze graph edges and create bundles for parallel links.
+ *
+ * Groups edges by:
+ * - Fan-in: Multiple edges sharing the same target (A & B --> C)
+ * - Fan-out: Multiple edges sharing the same source (A --> B & C)
+ *
+ * Only creates bundles when:
+ * - Graph direction is TD (top-down) - LR routing handles merging naturally
+ * - 2+ edges share the endpoint
+ * - All edges have the same style (solid/dotted/thick)
+ * - None of the edges have labels (labels would overlap at junction)
+ * - Edges are not self-loops
+ *
+ * @returns Array of bundles. Each edge can belong to at most one bundle.
+ */
+export declare function analyzeEdgeBundles(graph: AsciiGraph): EdgeBundle[];
+/**
+ * Calculate the optimal junction point for a bundle.
+ *
+ * For fan-in (A & B --> C):
+ *   - Junction is placed between the sources and the target
+ *   - In TD: above the target, horizontally centered between sources
+ *   - In LR: left of the target, vertically centered between sources
+ *
+ * For fan-out (A --> B & C):
+ *   - Junction is placed between the source and the targets
+ *   - In TD: below the source, horizontally centered between targets
+ *   - In LR: right of the source, vertically centered between targets
+ */
+export declare function calculateJunctionPoint(graph: AsciiGraph, bundle: EdgeBundle): GridCoord;
+/**
+ * Route all edges in a bundle through the junction point.
+ *
+ * For fan-in bundles:
+ *   1. Route each source → junction (stored in edge.pathToJunction)
+ *   2. Route junction → target (stored in bundle.sharedPath)
+ *
+ * For fan-out bundles:
+ *   1. Route source → junction (stored in bundle.sharedPath)
+ *   2. Route junction → each target (stored in edge.pathToJunction)
+ */
+export declare function routeBundledEdges(graph: AsciiGraph, bundle: EdgeBundle): void;
+/**
+ * Process all bundles in a graph: calculate junction points and route edges.
+ */
+export declare function processBundles(graph: AsciiGraph): void;

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

@@ -0,0 +1,43 @@
+import type { Direction, AsciiEdge, AsciiGraph } from './types';
+export declare function getOpposite(d: Direction): Direction;
+/** Compare directions by value (not reference). */
+export declare function dirEquals(a: Direction, b: Direction): boolean;
+/**
+ * Determine 8-way direction from one coordinate to another.
+ * Uses the coordinate difference to pick one of 8 cardinal/ordinal directions.
+ */
+export declare function determineDirection(from: {
+    x: number;
+    y: number;
+}, to: {
+    x: number;
+    y: number;
+}): Direction;
+/**
+ * Determine preferred and alternative start/end directions for an edge.
+ * Returns [preferredStart, preferredEnd, alternativeStart, alternativeEnd].
+ *
+ * The edge routing tries both pairs and picks the shorter path.
+ * Direction selection depends on relative node positions and graph direction (LR vs TD).
+ */
+export declare function determineStartAndEndDir(edge: AsciiEdge, graphDirection: string): [Direction, Direction, Direction, Direction];
+/**
+ * Determine the path for an edge by trying two candidate routes (preferred + alternative)
+ * and picking the shorter one. Sets edge.path, edge.startDir, edge.endDir.
+ *
+ * When both A* paths fail (common for edges crossing subgraph boundaries), falls back
+ * to a direct path using the start/end points. This ensures edges always have a path
+ * for arrowhead rendering.
+ *
+ * Uses the effective direction for edge routing, respecting subgraph direction overrides
+ * when both source and target are in the same subgraph.
+ */
+export declare function determinePath(graph: AsciiGraph, edge: AsciiEdge): void;
+/**
+ * Find the best line segment in an edge's path to place a label on.
+ * Prefers vertical segments for TD/BT graphs and horizontal for LR/RL to avoid
+ * label collisions when multiple edges share initial segments.
+ * Falls back to the widest segment if none are suitable.
+ * Also increases the column width at the label position to fit the text.
+ */
+export declare function determineLabelLine(graph: AsciiGraph, edge: AsciiEdge): void;

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

@@ -0,0 +1,7 @@
+import type { AsciiConfig, AsciiTheme, ColorMode } from './types';
+/**
+ * Render a Mermaid ER diagram to ASCII/Unicode text.
+ *
+ * Pipeline: parse → build boxes → component-aware layout → draw boxes → draw relationships → string.
+ */
+export declare function renderErAscii(text: string, config: AsciiConfig, colorMode?: ColorMode, theme?: AsciiTheme): string;

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

@@ -0,0 +1,56 @@
+import type { GridCoord, DrawingCoord, Direction, AsciiGraph, AsciiNode, AsciiSubgraph } from './types';
+/**
+ * Convert a grid coordinate to a drawing (character) coordinate.
+ * Sums column widths up to the target column, and row heights up to the target row,
+ * then centers within the cell.
+ */
+export declare function gridToDrawingCoord(graph: AsciiGraph, c: GridCoord, dir?: Direction): DrawingCoord;
+/** Convert a path of grid coords to drawing coords. */
+export declare function lineToDrawing(graph: AsciiGraph, line: GridCoord[]): DrawingCoord[];
+/**
+ * Reserve a 3x3 block in the grid for a node.
+ * If the requested position is occupied, recursively shift by 4 grid units
+ * (in the perpendicular direction based on effective direction) until a free spot is found.
+ *
+ * @param effectiveDir - Optional direction override. If not provided, uses the node's
+ *                       effective direction (subgraph direction if in a subgraph with override,
+ *                       otherwise graph direction).
+ */
+export declare function reserveSpotInGrid(graph: AsciiGraph, node: AsciiNode, requested: GridCoord, effectiveDir?: 'LR' | 'TD'): GridCoord;
+/**
+ * Set column widths and row heights for a node's 3x3 grid block.
+ * Each node occupies 3 columns (border, content, border) and 3 rows.
+ * Uses shape-aware dimensions to properly size non-rectangular shapes.
+ */
+export declare function setColumnWidth(graph: AsciiGraph, node: AsciiNode): void;
+/** Ensure grid has width/height entries for all cells along an edge path. */
+export declare function increaseGridSizeForPath(graph: AsciiGraph, path: GridCoord[]): void;
+/**
+ * Get the innermost subgraph that directly contains this node.
+ * Returns null if node is not in any subgraph.
+ */
+export declare function getNodeSubgraph(graph: AsciiGraph, node: AsciiNode): AsciiSubgraph | null;
+/**
+ * Get the effective direction for a node's layout.
+ * Returns the subgraph's direction override if the node is in a subgraph with one,
+ * otherwise returns the graph-level direction.
+ */
+export declare function getEffectiveDirection(graph: AsciiGraph, node: AsciiNode): 'LR' | 'TD';
+export declare function calculateSubgraphBoundingBoxes(graph: AsciiGraph): void;
+/**
+ * Offset all drawing coordinates so subgraph borders don't go negative.
+ * If any subgraph has negative min coordinates, shift everything positive.
+ */
+export declare function offsetDrawingForSubgraphs(graph: AsciiGraph): void;
+/**
+ * createMapping performs the full grid layout:
+ * 1. Place root nodes on the grid
+ * 2. Place child nodes level by level
+ * 3. Compute column widths and row heights
+ * 4. Run A* pathfinding for all edges
+ * 5. Determine label placement
+ * 6. Convert grid coords → drawing coords
+ * 7. Generate node box drawings
+ * 8. Calculate subgraph bounding boxes
+ */
+export declare function createMapping(graph: AsciiGraph): void;

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

@@ -0,0 +1,65 @@
+import { detectColorMode, DEFAULT_ASCII_THEME } from './ansi';
+import type { AsciiTheme, ColorMode } from './types';
+import type { Direction } from '../types';
+export type { AsciiTheme, ColorMode };
+export { DEFAULT_ASCII_THEME, detectColorMode };
+export interface AsciiRenderOptions {
+    /** 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;
+    /**
+     * Force the layout direction, overriding the direction parsed from the
+     * diagram source. Applies to the flowchart + state-diagram grid pipeline
+     * (sequence/class/ER/xychart renderers ignore it). Useful for re-fitting a
+     * wide `LR` graph into a narrow viewport by laying it out top-down.
+     * Default: undefined (use the source's own direction).
+     */
+    direction?: Direction;
+    /**
+     * Color mode for output.
+     * - 'none': No colors (plain text)
+     * - 'auto': Auto-detect (terminal ANSI capabilities, or HTML in browsers)
+     * - 'ansi16': 16-color ANSI
+     * - 'ansi256': 256-color xterm
+     * - 'truecolor': 24-bit RGB
+     * - 'html': HTML <span> tags with inline color styles (for browser rendering)
+     * Default: 'auto'
+     */
+    colorMode?: ColorMode | 'auto';
+    /** Theme colors for ASCII output. Uses default theme if not provided. */
+    theme?: Partial<AsciiTheme>;
+}
+/**
+ * Render Mermaid diagram text to an ASCII/Unicode string.
+ *
+ * Synchronous — no async layout engine needed (unlike the SVG renderer).
+ * Auto-detects diagram type from the header line and dispatches to
+ * the appropriate renderer.
+ *
+ * @param text - Mermaid source text (any supported diagram type)
+ * @param options - Rendering options
+ * @returns Multi-line ASCII/Unicode string
+ *
+ * @example
+ * ```ts
+ * const result = renderMermaidAscii(`
+ *   graph LR
+ *     A --> B --> C
+ * `, { useAscii: true })
+ *
+ * // Output:
+ * // +---+     +---+     +---+
+ * // |   |     |   |     |   |
+ * // | A |---->| B |---->| C |
+ * // |   |     |   |     |   |
+ * // +---+     +---+     +---+
+ * ```
+ */
+export declare function renderMermaidASCII(text: string, options?: AsciiRenderOptions): string;
+/** Lowercase alias kept as the public name used by the pi-utils wrapper. */
+export declare const renderMermaidAscii: typeof renderMermaidASCII;

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

@@ -0,0 +1,27 @@
+import type { Canvas } from './types';
+/**
+ * Split a label into lines.
+ * Labels are already normalized by parsers (br tags → \n).
+ */
+export declare function splitLines(label: string): string[];
+/**
+ * Get the maximum line width for sizing calculations.
+ * Used to determine column widths for multi-line labels.
+ */
+export declare function maxLineWidth(label: string): number;
+/**
+ * Get the number of lines for height calculations.
+ * Used to determine row heights for multi-line labels.
+ */
+export declare function lineCount(label: string): number;
+/**
+ * Draw multi-line text centered at (cx, cy).
+ * Expands vertically from the center point.
+ * Each line is horizontally centered independently.
+ */
+export declare function drawMultilineTextCentered(canvas: Canvas, label: string, cx: number, cy: number): void;
+/**
+ * Draw multi-line text left-aligned starting at (x, y).
+ * Each subsequent line is placed one row below.
+ */
+export declare function drawMultilineTextLeft(canvas: Canvas, label: string, x: number, y: number): void;

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

@@ -0,0 +1,17 @@
+import type { GridCoord, AsciiNode } from './types';
+/**
+ * Manhattan distance with a +1 penalty when both dx and dy are non-zero.
+ * This encourages the pathfinder to prefer straight lines and minimize corners.
+ */
+export declare function heuristic(a: GridCoord, b: GridCoord): number;
+/**
+ * Find a path from `from` to `to` on the grid using A*.
+ * Returns the path as an array of GridCoords, or null if no path exists.
+ */
+export declare function getPath(grid: Map<string, AsciiNode>, from: GridCoord, to: GridCoord): GridCoord[] | null;
+/**
+ * Simplify a path by removing intermediate waypoints on straight segments.
+ * E.g., [(0,0), (1,0), (2,0), (2,1)] becomes [(0,0), (2,0), (2,1)].
+ * This reduces the number of line-drawing operations.
+ */
+export declare function mergePath(path: GridCoord[]): GridCoord[];

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

@@ -0,0 +1,7 @@
+import type { AsciiConfig, AsciiTheme, ColorMode } from './types';
+/**
+ * Render a Mermaid sequence diagram to ASCII/Unicode text.
+ *
+ * Pipeline: parse → layout (columns + rows) → draw onto canvas → string.
+ */
+export declare function renderSequenceAscii(text: string, config: AsciiConfig, colorMode?: ColorMode, theme?: AsciiTheme): string;

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

@@ -0,0 +1,11 @@
+import type { ShapeRenderer } from './types';
+/**
+ * Circle shape renderer.
+ * Uses circle markers (◯) at corners to indicate circular shape semantics.
+ *
+ * Renders as:
+ *   ◯─────────◯
+ *   │  Label  │
+ *   ◯─────────◯
+ */
+export declare const circleRenderer: ShapeRenderer;

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

@@ -0,0 +1,34 @@
+import type { AsciiNodeShape } from '../types';
+/**
+ * Corner characters for a shape in both Unicode and ASCII modes.
+ */
+export interface CornerChars {
+    /** Top-left corner */
+    tl: string;
+    /** Top-right corner */
+    tr: string;
+    /** Bottom-left corner */
+    bl: string;
+    /** Bottom-right corner */
+    br: string;
+}
+/**
+ * Shape corner configuration with both Unicode and ASCII variants.
+ */
+export interface ShapeCorners {
+    unicode: CornerChars;
+    ascii: CornerChars;
+}
+/**
+ * Corner character lookup table for all shape types.
+ *
+ * Design principles:
+ * - All shapes use orthogonal box structure (no diagonals)
+ * - Corner characters indicate shape semantics
+ * - ASCII fallbacks use available punctuation
+ */
+export declare const SHAPE_CORNERS: Record<AsciiNodeShape, ShapeCorners>;
+/**
+ * Get corner characters for a shape type.
+ */
+export declare function getCorners(shape: AsciiNodeShape, useAscii: boolean): CornerChars;

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

@@ -0,0 +1,11 @@
+import type { ShapeRenderer } from './types';
+/**
+ * Diamond shape renderer.
+ * Uses diamond markers (◇) at corners to indicate decision node semantics.
+ *
+ * Renders as:
+ *   ◇─────────◇
+ *   │  Label  │
+ *   ◇─────────◇
+ */
+export declare const diamondRenderer: ShapeRenderer;

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

@@ -0,0 +1,11 @@
+import type { ShapeRenderer } from './types';
+/**
+ * Hexagon shape renderer.
+ * Uses hexagon markers (⬡) at corners to indicate process node semantics.
+ *
+ * Renders as:
+ *   ⬡─────────⬡
+ *   │  Label  │
+ *   ⬡─────────⬡
+ */
+export declare const hexagonRenderer: ShapeRenderer;

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

@@ -0,0 +1,26 @@
+import type { AsciiNodeShape, Canvas, DrawingCoord, Direction } from '../types';
+import type { ShapeRenderer, ShapeDimensions, ShapeRenderOptions, ShapeRegistry } from './types';
+export type { ShapeRenderer, ShapeDimensions, ShapeRenderOptions, ShapeRegistry };
+/**
+ * Global shape registry — maps shape types to their renderers.
+ * Rectangle is the default fallback for unregistered shapes.
+ */
+export declare const shapeRegistry: ShapeRegistry;
+/**
+ * Get the renderer for a shape type, falling back to rectangle.
+ */
+export declare function getShapeRenderer(shape: AsciiNodeShape): ShapeRenderer;
+/**
+ * Render a node shape to a canvas.
+ * This is the main entry point for shape rendering.
+ */
+export declare function renderShape(shape: AsciiNodeShape, label: string, options: ShapeRenderOptions): Canvas;
+/**
+ * Get dimensions for a shape given a label.
+ * Used during layout to determine node size.
+ */
+export declare function getShapeDimensions(shape: AsciiNodeShape, label: string, options: ShapeRenderOptions): ShapeDimensions;
+/**
+ * Get edge attachment point for a shape.
+ */
+export declare function getShapeAttachmentPoint(shape: AsciiNodeShape, dir: Direction, dimensions: ShapeDimensions, baseCoord: DrawingCoord): DrawingCoord;

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

@@ -0,0 +1,31 @@
+import type { Canvas, DrawingCoord, Direction } from '../types';
+import type { ShapeRenderer, ShapeDimensions, ShapeRenderOptions } from './types';
+import { type CornerChars } from './corners';
+/**
+ * Calculate standard box dimensions for any rectangular shape.
+ * Used by rectangle, circle, diamond, hexagon, etc.
+ */
+export declare function getBoxDimensions(label: string, options: ShapeRenderOptions): ShapeDimensions;
+/**
+ * Render a box with custom corner characters.
+ * This is the core rendering function used by all rectangular shapes.
+ *
+ * @param label - Text to display in the box
+ * @param dimensions - Pre-calculated dimensions
+ * @param corners - Corner characters (tl, tr, bl, br)
+ * @param useAscii - Whether to use ASCII or Unicode for lines
+ */
+export declare function renderBox(label: string, dimensions: ShapeDimensions, corners: CornerChars, useAscii: boolean): Canvas;
+/**
+ * Calculate edge attachment point for rectangular shapes.
+ * All box-based shapes use the same attachment logic.
+ */
+export declare function getBoxAttachmentPoint(dir: Direction, dimensions: ShapeDimensions, baseCoord: DrawingCoord): DrawingCoord;
+/**
+ * Rectangle shape renderer — the default box shape.
+ * Renders as:
+ *   ┌─────────┐
+ *   │  Label  │
+ *   └─────────┘
+ */
+export declare const rectangleRenderer: ShapeRenderer;