@oh-my-pi-zen/pi-utils 16.3.6-zen.1

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;

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

@@ -0,0 +1,130 @@
+/** Parsed sequence diagram — logical structure from mermaid text */
+export interface SequenceDiagram {
+    /** Ordered list of actors/participants */
+    actors: Actor[];
+    /** Messages between actors in chronological order */
+    messages: Message[];
+    /** Structural blocks (loop, alt, opt, par, critical) */
+    blocks: Block[];
+    /** Notes attached to actors */
+    notes: Note[];
+}
+export interface Actor {
+    id: string;
+    label: string;
+    /** 'participant' renders as a box, 'actor' renders as a stick figure */
+    type: 'participant' | 'actor';
+}
+export interface Message {
+    from: string;
+    to: string;
+    label: string;
+    /** Arrow style: solid line or dashed line */
+    lineStyle: 'solid' | 'dashed';
+    /** Arrow head: filled (closed) or open */
+    arrowHead: 'filled' | 'open';
+    /** Activate the target lifeline (+) */
+    activate?: boolean;
+    /** Deactivate the source lifeline (-) */
+    deactivate?: boolean;
+}
+export interface Block {
+    /** Block type keyword */
+    type: 'loop' | 'alt' | 'opt' | 'par' | 'critical' | 'break' | 'rect';
+    /** Label for the block header */
+    label: string;
+    /** Index of the first message inside this block */
+    startIndex: number;
+    /** Index of the last message inside this block (inclusive) */
+    endIndex: number;
+    /** For alt/par blocks: indices where "else"/"and" dividers appear (message indices) */
+    dividers: Array<{
+        index: number;
+        label: string;
+    }>;
+}
+export interface Note {
+    /** Which actor(s) the note is attached to */
+    actorIds: string[];
+    /** Note text content */
+    text: string;
+    /** Position relative to the actor(s) */
+    position: 'left' | 'right' | 'over';
+    /** Message index after which this note appears */
+    afterIndex: number;
+}
+export interface PositionedSequenceDiagram {
+    width: number;
+    height: number;
+    actors: PositionedActor[];
+    lifelines: Lifeline[];
+    messages: PositionedMessage[];
+    activations: Activation[];
+    blocks: PositionedBlock[];
+    notes: PositionedNote[];
+}
+export interface PositionedActor {
+    id: string;
+    label: string;
+    type: 'participant' | 'actor';
+    /** Center x of the actor box */
+    x: number;
+    /** Top y of the actor box */
+    y: number;
+    width: number;
+    height: number;
+}
+/** Vertical dashed line from actor to bottom of diagram */
+export interface Lifeline {
+    actorId: string;
+    x: number;
+    topY: number;
+    bottomY: number;
+}
+export interface PositionedMessage {
+    from: string;
+    to: string;
+    label: string;
+    lineStyle: 'solid' | 'dashed';
+    arrowHead: 'filled' | 'open';
+    /** Start point (from actor's lifeline) */
+    x1: number;
+    /** End point (to actor's lifeline) */
+    x2: number;
+    /** Vertical position */
+    y: number;
+    /** Whether this is a self-message (same actor) */
+    isSelf: boolean;
+}
+/** Narrow rectangle on a lifeline showing active processing */
+export interface Activation {
+    actorId: string;
+    x: number;
+    topY: number;
+    bottomY: number;
+    width: number;
+}
+export interface PositionedBlock {
+    type: Block['type'];
+    label: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Divider lines within the block (for alt/par) */
+    dividers: Array<{
+        y: number;
+        label: string;
+    }>;
+}
+export interface PositionedNote {
+    text: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Actor IDs this note is attached to (for SVG attribution) */
+    actors?: string[];
+    /** Note position relative to actors (for SVG attribution) */
+    position?: 'left' | 'right' | 'over';
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Placeholder occupying the second cell of a fullwidth glyph on the ASCII
+ * canvas. U+0000 cannot appear in parsed Mermaid labels, is treated as
+ * occupied label content by canvas merging, and is stripped at
+ * serialization time. Invariant: a WIDE_PAD cell always sits immediately
+ * right of its lead cell; canvas writes keep the pair atomic.
+ */
+export declare const WIDE_PAD = "\0";
+/**
+ * Display width of a string in terminal columns, summed over grapheme
+ * clusters so it always equals `toCells(text).length`. ASCII-only strings
+ * take a fast path.
+ */
+export declare function displayWidth(text: string): number;
+/**
+ * Expand a string into ASCII-canvas cells: each 2-column grapheme cluster
+ * is stored whole in one cell and followed by WIDE_PAD, so that
+ * `cells.length === displayWidth(text)`. Per-character placement loops can
+ * iterate the result with plain cell offsets.
+ */
+export declare function toCells(text: string): string[];

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

@@ -0,0 +1,114 @@
+export interface MermaidGraph {
+    direction: Direction;
+    nodes: Map<string, MermaidNode>;
+    edges: MermaidEdge[];
+    subgraphs: MermaidSubgraph[];
+    classDefs: Map<string, Record<string, string>>;
+    /** Maps node IDs to their class names (from `class X className` or `:::className` shorthand) */
+    classAssignments: Map<string, string>;
+    /** Maps node IDs to inline styles (from `style X fill:#f00,stroke:#333`) */
+    nodeStyles: Map<string, Record<string, string>>;
+    /** Maps edge indices (or 'default') to inline styles from `linkStyle` directives */
+    linkStyles: Map<number | 'default', Record<string, string>>;
+}
+export type Direction = 'TD' | 'TB' | 'LR' | 'BT' | 'RL';
+export interface MermaidNode {
+    id: string;
+    label: string;
+    shape: NodeShape;
+}
+export type NodeShape = 'rectangle' | 'rounded' | 'diamond' | 'stadium' | 'circle' | 'subroutine' | 'doublecircle' | 'hexagon' | 'cylinder' | 'asymmetric' | 'trapezoid' | 'trapezoid-alt' | 'state-start' | 'state-end';
+export interface MermaidEdge {
+    source: string;
+    target: string;
+    label?: string;
+    style: EdgeStyle;
+    /** Whether to render an arrowhead at the start (source end) of the edge */
+    hasArrowStart: boolean;
+    /** Whether to render an arrowhead at the end (target end) of the edge */
+    hasArrowEnd: boolean;
+}
+export type EdgeStyle = 'solid' | 'dotted' | 'thick';
+export interface MermaidSubgraph {
+    id: string;
+    label: string;
+    nodeIds: string[];
+    children: MermaidSubgraph[];
+    /** Optional direction override for this subgraph's internal layout */
+    direction?: Direction;
+}
+export interface PositionedGraph {
+    width: number;
+    height: number;
+    nodes: PositionedNode[];
+    edges: PositionedEdge[];
+    groups: PositionedGroup[];
+}
+export interface PositionedNode {
+    id: string;
+    label: string;
+    shape: NodeShape;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Inline styles resolved from classDef + explicit `style` statements — override theme defaults */
+    inlineStyle?: Record<string, string>;
+}
+export interface PositionedEdge {
+    source: string;
+    target: string;
+    label?: string;
+    style: EdgeStyle;
+    hasArrowStart: boolean;
+    hasArrowEnd: boolean;
+    /** Full path including bends — array of {x, y} points */
+    points: Point[];
+    /** Layout-computed label center position (avoids label-label collisions) */
+    labelPosition?: Point;
+    /** Inline styles resolved from `linkStyle` directives — override theme defaults */
+    inlineStyle?: Record<string, string>;
+}
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface PositionedGroup {
+    id: string;
+    label: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    children: PositionedGroup[];
+}
+export interface RenderOptions {
+    /** Background color → CSS variable --bg. Default: '#FFFFFF' */
+    bg?: string;
+    /** Foreground / primary text color → CSS variable --fg. Default: '#27272A' */
+    fg?: string;
+    /** Edge/connector color → CSS variable --line */
+    line?: string;
+    /** Arrow heads, highlights → CSS variable --accent */
+    accent?: string;
+    /** Secondary text, edge labels → CSS variable --muted */
+    muted?: string;
+    /** Node/box fill tint → CSS variable --surface */
+    surface?: string;
+    /** Node/group stroke color → CSS variable --border */
+    border?: string;
+    /** Font family for all text. Default: 'Inter' */
+    font?: string;
+    /** Canvas padding in px. Default: 40 */
+    padding?: number;
+    /** Horizontal spacing between sibling nodes. Default: 24 */
+    nodeSpacing?: number;
+    /** Vertical spacing between layers. Default: 40 */
+    layerSpacing?: number;
+    /** Spacing between disconnected components. Default: nodeSpacing (24) */
+    componentSpacing?: number;
+    /** Render with transparent background (no background style on SVG). Default: false */
+    transparent?: boolean;
+    /** Enable hover tooltips on chart data points (xychart only). Default: false */
+    interactive?: boolean;
+}

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

@@ -0,0 +1,25 @@
+/** Default accent for charts when the theme doesn't provide one. */
+export declare const CHART_ACCENT_FALLBACK = "#3b82f6";
+/** Check whether a string is a valid 6-digit hex color (e.g. "#3b82f6"). */
+export declare function isValidHex(color: string): boolean;
+/**
+ * Detect whether a background color is dark (lightness < 50%).
+ */
+export declare function isDarkBackground(bgHex: string): boolean;
+/**
+ * Mix two hex colors in RGB space.
+ * `ratio` controls how much of `fgHex` shows: 0 = pure bg, 1 = pure fg.
+ * Equivalent to alpha-compositing fg over bg at the given opacity.
+ */
+export declare function mixHexColors(bgHex: string, fgHex: string, ratio: number): string;
+/**
+ * Get the hex color for a series index.
+ * Index 0 returns the accent color as-is.
+ * Index 1+ alternate between darker and lighter shades of the same hue
+ * with subtle hue drift (±8-12° per tier) to stay in the same family.
+ *
+ * When `bgColor` is provided, shade direction adapts to the background:
+ *   - Light bg: odd = darker, even = lighter (default)
+ *   - Dark bg:  odd = lighter, even = darker (so shades stay visible)
+ */
+export declare function getSeriesColor(index: number, accentColor: string, bgColor?: string): string;

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

@@ -0,0 +1,6 @@
+import type { XYChart } from './types';
+/**
+ * Parse a Mermaid xychart-beta diagram from preprocessed lines.
+ * Lines should already be trimmed and comment-stripped.
+ */
+export declare function parseXYChart(lines: string[]): XYChart;

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

@@ -0,0 +1,145 @@
+/** Parsed XY chart — logical structure from mermaid text */
+export interface XYChart {
+    /** Optional chart title */
+    title?: string;
+    /** Chart orientation: vertical (default) or horizontal */
+    horizontal: boolean;
+    /** X-axis configuration */
+    xAxis: XYAxis;
+    /** Y-axis configuration */
+    yAxis: XYAxis;
+    /** Data series (bar and/or line) */
+    series: XYChartSeries[];
+}
+/** Axis configuration — categorical (labels) or numeric (range) */
+export interface XYAxis {
+    /** Optional axis title/label */
+    title?: string;
+    /** Categorical labels (e.g., ["jan", "feb", "mar"]) — mutually exclusive with range */
+    categories?: string[];
+    /** Numeric range — mutually exclusive with categories */
+    range?: {
+        min: number;
+        max: number;
+    };
+}
+/** A single data series (bar or line) */
+export interface XYChartSeries {
+    /** Series type */
+    type: 'bar' | 'line';
+    /** Data values — one per category, or evenly spaced across numeric range */
+    data: number[];
+}
+export interface PositionedXYChart {
+    width: number;
+    height: number;
+    /** Whether this is a horizontal (rotated) chart */
+    horizontal?: boolean;
+    /** Title text and position (if present) */
+    title?: PositionedTitle;
+    /** Positioned x-axis with tick marks and labels */
+    xAxis: PositionedAxis;
+    /** Positioned y-axis with tick marks and labels */
+    yAxis: PositionedAxis;
+    /** The plot area bounds (inside axes) */
+    plotArea: PlotArea;
+    /** Positioned bar groups */
+    bars: PositionedBar[];
+    /** Positioned line polylines */
+    lines: PositionedLine[];
+    /** Horizontal grid lines for readability */
+    gridLines: GridLine[];
+    /** Legend items (shown when multiple series) */
+    legend: LegendItem[];
+}
+export interface LegendItem {
+    /** Display label */
+    label: string;
+    /** Position of the swatch/icon */
+    x: number;
+    y: number;
+    /** Series type determines swatch shape (rect for bar, line+dot for line) */
+    type: 'bar' | 'line';
+    /** Series index within its type (for layout grouping) */
+    seriesIndex: number;
+    /** Global color index across all series (for unified color assignment) */
+    colorIndex: number;
+}
+export interface PositionedTitle {
+    text: string;
+    x: number;
+    y: number;
+}
+export interface PositionedAxis {
+    /** Optional axis title text and position */
+    title?: {
+        text: string;
+        x: number;
+        y: number;
+        rotate?: number;
+    };
+    /** Tick positions along the axis */
+    ticks: AxisTick[];
+    /** Axis line: start and end coordinates */
+    line: {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    };
+}
+export interface AxisTick {
+    /** Label text for this tick */
+    label: string;
+    /** Position of the tick mark on the axis */
+    x: number;
+    y: number;
+    /** End of the tick mark (short perpendicular line) */
+    tx: number;
+    ty: number;
+    /** Label anchor position */
+    labelX: number;
+    labelY: number;
+    /** Text anchor for label */
+    textAnchor: 'start' | 'middle' | 'end';
+}
+export interface PlotArea {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface PositionedBar {
+    /** Bar rectangle in SVG coordinates */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Original data value */
+    value: number;
+    /** Category label for this bar (e.g. "Jan") */
+    label?: string;
+    /** Series index within bar type (for layout grouping) */
+    seriesIndex: number;
+    /** Global color index across all series */
+    colorIndex: number;
+}
+export interface PositionedLine {
+    /** Polyline points */
+    points: Array<{
+        x: number;
+        y: number;
+        value: number;
+        label?: string;
+    }>;
+    /** Series index within line type (for layout grouping) */
+    seriesIndex: number;
+    /** Global color index across all series */
+    colorIndex: number;
+}
+export interface GridLine {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}