@chengchenccc/tui 0.1.1-rc.1

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../../src/vendor/mermaid-ascii/class/parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAA+E,MAAM,YAAY,CAAA;AAsB3H;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,YAAY,CAwI/D"}

package/dist/vendor/mermaid-ascii/class/parser.js

@@ -0,0 +1,265 @@
+import { normalizeBrTags } from "../multiline-utils.js";
+// ============================================================================
+// Class diagram parser
+//
+// Parses Mermaid classDiagram syntax into a ClassDiagram structure.
+//
+// Supported syntax:
+//   class Animal { +String name; +eat() void }
+//   class Shape { <<abstract>> }
+//   Animal <|-- Dog           (inheritance)
+//   Car *-- Engine            (composition)
+//   Car o-- Wheel             (aggregation)
+//   A --> B                   (association)
+//   A ..> B                   (dependency)
+//   A ..|> B                  (realization)
+//   A "1" --> "*" B : label   (with cardinality + label)
+//   Animal : +String name     (inline attribute)
+//   namespace MyNamespace { class A { } }
+// ============================================================================
+/**
+ * Parse a Mermaid class diagram.
+ * Expects the first line to be "classDiagram".
+ */
+export function parseClassDiagram(lines) {
+    const diagram = {
+        classes: [],
+        relationships: [],
+        namespaces: [],
+    };
+    // Track classes by ID for deduplication
+    const classMap = new Map();
+    // Track namespace nesting
+    let currentNamespace = null;
+    // Track class body parsing
+    let currentClass = null;
+    let braceDepth = 0;
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        // --- Inside a class body block ---
+        if (currentClass && braceDepth > 0) {
+            if (line === '}') {
+                braceDepth--;
+                if (braceDepth === 0) {
+                    currentClass = null;
+                }
+                continue;
+            }
+            // Check for annotation like <<interface>>
+            const annotMatch = line.match(/^<<(\w+)>>$/);
+            if (annotMatch) {
+                currentClass.annotation = annotMatch[1];
+                continue;
+            }
+            // Parse member: visibility, name, type, optional parens for method
+            const member = parseMember(line);
+            if (member) {
+                if (member.isMethod) {
+                    currentClass.methods.push(member.member);
+                }
+                else {
+                    currentClass.attributes.push(member.member);
+                }
+            }
+            continue;
+        }
+        // --- Namespace block start ---
+        const nsMatch = line.match(/^namespace\s+(\S+)\s*\{$/);
+        if (nsMatch) {
+            currentNamespace = { name: nsMatch[1], classIds: [] };
+            continue;
+        }
+        // --- Namespace end ---
+        if (line === '}' && currentNamespace) {
+            diagram.namespaces.push(currentNamespace);
+            currentNamespace = null;
+            continue;
+        }
+        // --- Class block start: `class ClassName {` or `class ClassName` ---
+        const classBlockMatch = line.match(/^class\s+(\S+?)(?:\s*~(\w+)~)?\s*\{$/);
+        if (classBlockMatch) {
+            const id = classBlockMatch[1];
+            const generic = classBlockMatch[2];
+            const cls = ensureClass(classMap, id);
+            if (generic) {
+                cls.label = `${id}<${generic}>`;
+            }
+            currentClass = cls;
+            braceDepth = 1;
+            if (currentNamespace) {
+                currentNamespace.classIds.push(id);
+            }
+            continue;
+        }
+        // --- Standalone class declaration (no body): `class ClassName` ---
+        const classOnlyMatch = line.match(/^class\s+(\S+?)(?:\s*~(\w+)~)?\s*$/);
+        if (classOnlyMatch) {
+            const id = classOnlyMatch[1];
+            const generic = classOnlyMatch[2];
+            const cls = ensureClass(classMap, id);
+            if (generic) {
+                cls.label = `${id}<${generic}>`;
+            }
+            if (currentNamespace) {
+                currentNamespace.classIds.push(id);
+            }
+            continue;
+        }
+        // --- Inline annotation: `class ClassName { <<interface>> }` (single line) ---
+        const inlineAnnotMatch = line.match(/^class\s+(\S+?)\s*\{\s*<<(\w+)>>\s*\}$/);
+        if (inlineAnnotMatch) {
+            const cls = ensureClass(classMap, inlineAnnotMatch[1]);
+            cls.annotation = inlineAnnotMatch[2];
+            continue;
+        }
+        // --- Inline attribute: `ClassName : +String name` ---
+        const inlineAttrMatch = line.match(/^(\S+?)\s*:\s*(.+)$/);
+        if (inlineAttrMatch) {
+            // Make sure this isn't a relationship line (those have arrows)
+            const rest = inlineAttrMatch[2];
+            if (!rest.match(/<\|--|--|\*--|o--|-->|\.\.>|\.\.\|>/)) {
+                const cls = ensureClass(classMap, inlineAttrMatch[1]);
+                const member = parseMember(rest);
+                if (member) {
+                    if (member.isMethod) {
+                        cls.methods.push(member.member);
+                    }
+                    else {
+                        cls.attributes.push(member.member);
+                    }
+                }
+                continue;
+            }
+        }
+        // --- Relationship ---
+        // Pattern: [FROM] ["card"] ARROW ["card"] [TO] [: label]
+        // Arrows: <|--, *--, o--, -->, ..|>, ..>
+        // Can also be reversed: --o, --*, --|>
+        const rel = parseRelationship(line);
+        if (rel) {
+            // Ensure both classes exist
+            ensureClass(classMap, rel.from);
+            ensureClass(classMap, rel.to);
+            diagram.relationships.push(rel);
+            continue;
+        }
+    }
+    diagram.classes = [...classMap.values()];
+    return diagram;
+}
+/** Ensure a class exists in the map, creating a default if needed */
+function ensureClass(classMap, id) {
+    let cls = classMap.get(id);
+    if (!cls) {
+        cls = { id, label: id, attributes: [], methods: [] };
+        classMap.set(id, cls);
+    }
+    return cls;
+}
+/** Parse a class member line (attribute or method) */
+function parseMember(line) {
+    const trimmed = line.trim().replace(/;$/, '');
+    if (!trimmed)
+        return null;
+    // Extract visibility prefix
+    let visibility = '';
+    let rest = trimmed;
+    if (/^[+\-#~]/.test(rest)) {
+        visibility = rest[0];
+        rest = rest.slice(1).trim();
+    }
+    // Check if it's a method (has parentheses)
+    const methodMatch = rest.match(/^(.+?)\(([^)]*)\)(?:\s*(.+))?$/);
+    if (methodMatch) {
+        const name = methodMatch[1].trim();
+        const params = methodMatch[2]?.trim() || undefined; // Store the parameter string
+        const type = methodMatch[3]?.trim();
+        // Check for static ($) or abstract (*) markers
+        const isStatic = name.endsWith('$') || rest.includes('$');
+        const isAbstract = name.endsWith('*') || rest.includes('*');
+        return {
+            member: {
+                visibility,
+                name: name.replace(/[$*]$/, ''),
+                type: type || undefined,
+                isStatic,
+                isAbstract,
+                isMethod: true,
+                params,
+            },
+            isMethod: true,
+        };
+    }
+    // It's an attribute: [Type] name or name Type
+    // Common patterns: "String name", "+int age", "name"
+    const parts = rest.split(/\s+/);
+    let name;
+    let type;
+    if (parts.length >= 2) {
+        // "Type name" pattern
+        type = parts[0];
+        name = parts.slice(1).join(' ');
+    }
+    else {
+        name = parts[0] ?? rest;
+    }
+    const isStatic = name.endsWith('$');
+    const isAbstract = name.endsWith('*');
+    return {
+        member: {
+            visibility,
+            name: name.replace(/[$*]$/, ''),
+            type: type || undefined,
+            isStatic,
+            isAbstract,
+            isMethod: false,
+        },
+        isMethod: false,
+    };
+}
+/** Parse a relationship line into a ClassRelationship */
+function parseRelationship(line) {
+    // Relationship regex — handles all arrow types with optional cardinality and labels
+    // Pattern: FROM ["card"] ARROW ["card"] TO [: label]
+    const match = line.match(/^(\S+?)\s+(?:"([^"]*?)"\s+)?(<\|--|<\|\.\.|\*--|o--|-->|--\*|--o|--\|>|\.\.>|\.\.\|>|<--|<\.\.?|--)\s+(?:"([^"]*?)"\s+)?(\S+?)(?:\s*:\s*(.+))?$/);
+    if (!match)
+        return null;
+    const from = match[1];
+    const rawFromCardinality = match[2];
+    const fromCardinality = rawFromCardinality ? normalizeBrTags(rawFromCardinality) : undefined;
+    const arrow = match[3].trim();
+    const rawToCardinality = match[4];
+    const toCardinality = rawToCardinality ? normalizeBrTags(rawToCardinality) : undefined;
+    const to = match[5];
+    const rawLabel = match[6]?.trim();
+    const label = rawLabel ? normalizeBrTags(rawLabel) : undefined;
+    const parsed = parseArrow(arrow);
+    if (!parsed)
+        return null;
+    return { from, to, type: parsed.type, markerAt: parsed.markerAt, label, fromCardinality, toCardinality };
+}
+/**
+ * Map arrow syntax to relationship type and marker placement side.
+ * Prefix markers (`<|--`, `*--`, `o--`) place the UML shape at the 'from' end.
+ * Suffix markers (`..|>`, `-->`, `..>`, `--*`, `--o`) place it at the 'to' end.
+ */
+function parseArrow(arrow) {
+    // Trim whitespace that might be captured by the regex
+    const a = arrow.trim();
+    switch (a) {
+        case '<|--': return { type: 'inheritance', markerAt: 'from' };
+        case '--|>': return { type: 'inheritance', markerAt: 'to' };
+        case '<|..': return { type: 'realization', markerAt: 'from' };
+        case '..|>': return { type: 'realization', markerAt: 'to' };
+        case '*--': return { type: 'composition', markerAt: 'from' };
+        case '--*': return { type: 'composition', markerAt: 'to' };
+        case 'o--': return { type: 'aggregation', markerAt: 'from' };
+        case '--o': return { type: 'aggregation', markerAt: 'to' };
+        case '-->': return { type: 'association', markerAt: 'to' };
+        case '<--': return { type: 'association', markerAt: 'from' };
+        case '..>': return { type: 'dependency', markerAt: 'to' };
+        case '<..': return { type: 'dependency', markerAt: 'from' };
+        case '--': return { type: 'association', markerAt: 'to' };
+        default: return null;
+    }
+}

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

@@ -0,0 +1,103 @@
+/** 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;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/vendor/mermaid-ascii/class/types.ts"],"names":[],"mappings":"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"}

package/dist/vendor/mermaid-ascii/class/types.js

@@ -0,0 +1,7 @@
+// ============================================================================
+// Class diagram types
+//
+// Models the parsed and positioned representations of a Mermaid class diagram.
+// Class diagrams show UML class relationships, inheritance, composition, etc.
+// ============================================================================
+export {};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../../src/vendor/mermaid-ascii/er/parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAsD,MAAM,YAAY,CAAA;AA2B/F;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,SAAS,CAmDzD"}

package/dist/vendor/mermaid-ascii/er/parser.js

@@ -0,0 +1,162 @@
+import { normalizeBrTags } from "../multiline-utils.js";
+// ============================================================================
+// ER diagram parser
+//
+// Parses Mermaid erDiagram syntax into an ErDiagram structure.
+//
+// Supported syntax:
+//   CUSTOMER ||--o{ ORDER : places
+//   CUSTOMER {
+//     string name PK
+//     int age
+//     string email UK "user email"
+//   }
+//
+// Cardinality notation:
+//   ||  exactly one
+//   o|  zero or one (also |o)
+//   }|  one or more (also |{)
+//   o{  zero or more (also {o)
+//
+// Line style:
+//   --  identifying (solid line)
+//   ..  non-identifying (dashed line)
+// ============================================================================
+/**
+ * Parse a Mermaid ER diagram.
+ * Expects the first line to be "erDiagram".
+ */
+export function parseErDiagram(lines) {
+    const diagram = {
+        entities: [],
+        relationships: [],
+    };
+    // Track entities by ID for deduplication
+    const entityMap = new Map();
+    // Track entity body parsing
+    let currentEntity = null;
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        // --- Inside entity body ---
+        if (currentEntity) {
+            if (line === '}') {
+                currentEntity = null;
+                continue;
+            }
+            // Attribute line: type name [PK|FK|UK] ["comment"]
+            const attr = parseAttribute(line);
+            if (attr) {
+                currentEntity.attributes.push(attr);
+            }
+            continue;
+        }
+        // --- Entity block start: `ENTITY_NAME {` ---
+        const entityBlockMatch = line.match(/^(\S+)\s*\{$/);
+        if (entityBlockMatch) {
+            const id = entityBlockMatch[1];
+            const entity = ensureEntity(entityMap, id);
+            currentEntity = entity;
+            continue;
+        }
+        // --- Relationship: `ENTITY1 cardinality1--cardinality2 ENTITY2 : label` ---
+        const rel = parseRelationshipLine(line);
+        if (rel) {
+            // Ensure both entities exist
+            ensureEntity(entityMap, rel.entity1);
+            ensureEntity(entityMap, rel.entity2);
+            diagram.relationships.push(rel);
+            continue;
+        }
+    }
+    diagram.entities = [...entityMap.values()];
+    return diagram;
+}
+/** Ensure an entity exists in the map */
+function ensureEntity(entityMap, id) {
+    let entity = entityMap.get(id);
+    if (!entity) {
+        entity = { id, label: id, attributes: [] };
+        entityMap.set(id, entity);
+    }
+    return entity;
+}
+/** Parse an attribute line inside an entity block */
+function parseAttribute(line) {
+    // Format: type name [PK|FK|UK [...]] ["comment"]
+    const match = line.match(/^(\S+)\s+(\S+)(?:\s+(.+))?$/);
+    if (!match)
+        return null;
+    const type = match[1];
+    const name = match[2];
+    const rest = match[3]?.trim() ?? '';
+    // Extract key constraints (PK, FK, UK) and optional comment
+    const keys = [];
+    let comment;
+    // Extract quoted comment first (supports <br> tags)
+    const commentMatch = rest.match(/"([^"]*)"/);
+    if (commentMatch) {
+        comment = normalizeBrTags(commentMatch[1]);
+    }
+    // Extract key constraints
+    const restWithoutComment = rest.replace(/"[^"]*"/, '').trim();
+    for (const part of restWithoutComment.split(/\s+/)) {
+        const upper = part.toUpperCase();
+        if (upper === 'PK' || upper === 'FK' || upper === 'UK') {
+            keys.push(upper);
+        }
+    }
+    return { type, name, keys, comment };
+}
+/**
+ * Parse a relationship line.
+ *
+ * Cardinality symbols on each side of the line style:
+ *   Left side (entity1):  ||  |o  o|  }|  |{  o{  {o
+ *   Line:                 --  (identifying) or  ..  (non-identifying)
+ *   Right side (entity2): ||  o|  |o  |{  }|  {o  o{
+ *
+ * Full pattern example: CUSTOMER ||--o{ ORDER : places
+ */
+function parseRelationshipLine(line) {
+    // Match: ENTITY1 <cardinality_and_line> ENTITY2 : label
+    const match = line.match(/^(\S+)\s+([|o}{]+(?:--|\.\.)[|o}{]+)\s+(\S+)\s*:\s*(.+)$/);
+    if (!match)
+        return null;
+    const entity1 = match[1];
+    const cardinalityStr = match[2];
+    const entity2 = match[3];
+    // Strip surrounding quotes if present, then normalize br tags
+    const rawLabel = match[4].trim().replace(/^["']|["']$/g, '');
+    const label = normalizeBrTags(rawLabel);
+    // Split the cardinality string into left side, line style, right side
+    const lineMatch = cardinalityStr.match(/^([|o}{]+)(--|\.\.?)([|o}{]+)$/);
+    if (!lineMatch)
+        return null;
+    const leftStr = lineMatch[1];
+    const lineStyle = lineMatch[2];
+    const rightStr = lineMatch[3];
+    const cardinality1 = parseCardinality(leftStr);
+    const cardinality2 = parseCardinality(rightStr);
+    const identifying = lineStyle === '--';
+    if (!cardinality1 || !cardinality2)
+        return null;
+    return { entity1, entity2, cardinality1, cardinality2, label, identifying };
+}
+/** Parse a cardinality notation string into a Cardinality type */
+function parseCardinality(str) {
+    // Normalize: sort the characters to handle both orders (e.g., |o and o|)
+    const sorted = str.split('').sort().join('');
+    // Exact one: || → sorted "||"
+    if (sorted === '||')
+        return 'one';
+    // Zero or one: o| or |o → sorted "o|" (o=111 < |=124 in char codes)
+    if (sorted === 'o|')
+        return 'zero-one';
+    // One or more: }| or |{ → sorted "|}" or "{|"
+    if (sorted === '|}' || sorted === '{|')
+        return 'many';
+    // Zero or more: o{ or {o → sorted "{o" or "o{"
+    if (sorted === '{o' || sorted === 'o{')
+        return 'zero-many';
+    return null;
+}

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

@@ -0,0 +1,77 @@
+/** 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;
+    }>;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/vendor/mermaid-ascii/er/types.ts"],"names":[],"mappings":"AAOA,8DAA8D;AAC9D,MAAM,WAAW,SAAS;IACxB,6BAA6B;IAC7B,QAAQ,EAAE,QAAQ,EAAE,CAAA;IACpB,qCAAqC;IACrC,aAAa,EAAE,cAAc,EAAE,CAAA;CAChC;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAA;IACV,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAA;IACb,kCAAkC;IAClC,UAAU,EAAE,WAAW,EAAE,CAAA;CAC1B;AAED,MAAM,WAAW,WAAW;IAC1B,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAA;IACZ,qBAAqB;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,kCAAkC;IAClC,IAAI,EAAE,KAAK,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC,CAAA;IAC/B,uBAAuB;IACvB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,UAAU,GAAG,MAAM,GAAG,WAAW,CAAA;AAEnE,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,mCAAmC;IACnC,YAAY,EAAE,WAAW,CAAA;IACzB,mCAAmC;IACnC,YAAY,EAAE,WAAW,CAAA;IACzB,2DAA2D;IAC3D,KAAK,EAAE,MAAM,CAAA;IACb,uFAAuF;IACvF,WAAW,EAAE,OAAO,CAAA;CACrB;AAMD,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,kBAAkB,EAAE,CAAA;IAC9B,aAAa,EAAE,wBAAwB,EAAE,CAAA;CAC1C;AAED,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,WAAW,EAAE,CAAA;IACzB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,+BAA+B;IAC/B,YAAY,EAAE,MAAM,CAAA;IACpB,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,EAAE,WAAW,CAAA;IACzB,YAAY,EAAE,WAAW,CAAA;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,OAAO,CAAA;IACpB,0CAA0C;IAC1C,MAAM,EAAE,KAAK,CAAC;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACxC"}

package/dist/vendor/mermaid-ascii/er/types.js

@@ -0,0 +1,7 @@
+// ============================================================================
+// ER diagram types
+//
+// Models the parsed and positioned representations of a Mermaid ER diagram.
+// ER diagrams show database entities, their attributes, and relationships.
+// ============================================================================
+export {};

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

@@ -0,0 +1,2 @@
+export * from './ascii/index.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/vendor/mermaid-ascii/index.ts"],"names":[],"mappings":"AAaA,cAAc,kBAAkB,CAAA"}