Upload folder using huggingface_hub (part 44)

.gitattributes

@@ -105,3 +105,5 @@ tools/ui/node_modules/@tailwindcss/oxide-linux-x64-gnu/tailwindcss-oxide.linux-x
 tools/ui/node_modules/@tailwindcss/oxide-linux-x64-musl/tailwindcss-oxide.linux-x64-musl.node filter=lfs diff=lfs merge=lfs -text
 tools/ui/node_modules/lightningcss-linux-x64-gnu/lightningcss.linux-x64-gnu.node filter=lfs diff=lfs merge=lfs -text
 tools/ui/node_modules/lightningcss-linux-x64-musl/lightningcss.linux-x64-musl.node filter=lfs diff=lfs merge=lfs -text
+tools/ui/node_modules/mermaid/dist/mermaid.js.map filter=lfs diff=lfs merge=lfs -text
+tools/ui/node_modules/mermaid/dist/mermaid.min.js.map filter=lfs diff=lfs merge=lfs -text

tools/ui/node_modules/mermaid/dist/diagram-api/loadDiagram.d.ts

@@ -0,0 +1 @@
+export declare const loadRegisteredDiagrams: () => Promise<void>;

tools/ui/node_modules/mermaid/dist/diagram-api/regexes.d.ts

@@ -0,0 +1,3 @@
+export declare const frontMatterRegex: RegExp;
+export declare const directiveRegex: RegExp;
+export declare const anyCommentRegex: RegExp;

tools/ui/node_modules/mermaid/dist/diagram-api/types.d.ts

@@ -0,0 +1,99 @@
+import type * as d3 from 'd3';
+import type { SetOptional, SetRequired } from 'type-fest';
+import type { Diagram } from '../Diagram.js';
+import type { BaseDiagramConfig, MermaidConfig } from '../config.type.js';
+import type { DiagramOrientation } from '../diagrams/git/gitGraphTypes.js';
+export interface DiagramMetadata {
+    title?: string;
+    config?: MermaidConfig;
+}
+export interface InjectUtils {
+    _log: any;
+    _setLogLevel: any;
+    _getConfig: any;
+    _sanitizeText: any;
+    _setupGraphViewbox: any;
+    _commonDb: any;
+    /** @deprecated as directives will be pre-processed since https://github.com/mermaid-js/mermaid/pull/4759 */
+    _parseDirective: any;
+}
+/**
+ * Generic Diagram DB that may apply to any diagram type.
+ */
+export interface DiagramDB {
+    getConfig?: () => BaseDiagramConfig | undefined;
+    clear?: () => void;
+    setDiagramTitle?: (title: string) => void;
+    getDiagramTitle?: () => string;
+    setAccTitle?: (title: string) => void;
+    getAccTitle?: () => string;
+    setAccDescription?: (description: string) => void;
+    getAccDescription?: () => string;
+    getDirection?: () => string | undefined;
+    setDirection?: (dir: DiagramOrientation) => void;
+    setDisplayMode?: (title: string) => void;
+    setDiagramId?: (svgElementId: string) => void;
+    bindFunctions?: (element: Element) => void;
+}
+/**
+ * DiagramDB with fields that is required for all new diagrams.
+ */
+export type DiagramDBBase<T extends BaseDiagramConfig> = {
+    getConfig: () => Required<T>;
+} & SetRequired<DiagramDB, 'clear' | 'getAccTitle' | 'getDiagramTitle' | 'getAccDescription' | 'setAccDescription' | 'setAccTitle' | 'setDiagramTitle'>;
+export interface DiagramStyleClassDef {
+    id: string;
+    /**
+     * The styles to apply to the class for HTML rendering.
+     * These are expected to be CSS property declarations without a trailing semicolon, e.g. `color: red`.
+     */
+    styles?: string[];
+    /**
+     * The styles to apply to `<tspan>` elements with the given class.
+     */
+    textStyles?: string[];
+}
+export interface DiagramRenderer {
+    draw: DrawDefinition;
+    getClasses?: (text: string, diagram: Pick<DiagramDefinition, 'db'>) => Map<string, DiagramStyleClassDef>;
+}
+export interface DiagramDefinition {
+    db: DiagramDB;
+    renderer: DiagramRenderer;
+    parser: ParserDefinition;
+    styles?: any;
+    init?: (config: MermaidConfig) => void;
+    injectUtils?: (_log: InjectUtils['_log'], _setLogLevel: InjectUtils['_setLogLevel'], _getConfig: InjectUtils['_getConfig'], _sanitizeText: InjectUtils['_sanitizeText'], _setupGraphViewbox: InjectUtils['_setupGraphViewbox'], _commonDb: InjectUtils['_commonDb'], 
+    /** @deprecated as directives will be pre-processed since https://github.com/mermaid-js/mermaid/pull/4759 */
+    _parseDirective: InjectUtils['_parseDirective']) => void;
+}
+export interface ExternalDiagramDefinition {
+    id: string;
+    detector: DiagramDetector;
+    loader: DiagramLoader;
+}
+export type DetectorRecord = SetOptional<Omit<ExternalDiagramDefinition, 'id'>, 'loader'>;
+export type DiagramDetector = (text: string, config?: MermaidConfig) => boolean;
+export type DiagramLoader = () => Promise<{
+    id: string;
+    diagram: DiagramDefinition;
+}>;
+/**
+ * Type for function draws diagram in the tag with id: id based on the graph definition in text.
+ *
+ * @param text - The text of the diagram.
+ * @param id - The id of the diagram which will be used as a DOM element id.
+ * @param version - MermaidJS version from package.json.
+ * @param diagramObject - A standard diagram containing the DB and the text and type etc of the diagram.
+ */
+export type DrawDefinition = (text: string, id: string, version: string, diagramObject: Diagram) => void | Promise<void>;
+export interface ParserDefinition {
+    parse: (text: string) => void | Promise<void>;
+    parser?: {
+        yy: DiagramDB;
+    };
+}
+export type HTML = d3.Selection<HTMLIFrameElement, unknown, Element | null, unknown>;
+export type SVG = d3.Selection<SVGSVGElement, unknown, Element | null, unknown>;
+export type SVGGroup = d3.Selection<SVGGElement, unknown, Element | null, unknown>;
+export type DiagramStylesProvider = (options?: any, svgId?: string) => string;

tools/ui/node_modules/mermaid/dist/diagram.spec.d.ts

@@ -0,0 +1 @@
+export {};

tools/ui/node_modules/mermaid/dist/diagrams/architecture/architecture.spec.d.ts

@@ -0,0 +1 @@
+export {};

tools/ui/node_modules/mermaid/dist/diagrams/architecture/architectureDb.d.ts

@@ -0,0 +1,48 @@
+import type { ArchitectureDiagramConfig } from '../../config.type.js';
+import type { DiagramDB } from '../../diagram-api/types.js';
+import type { D3Element } from '../../types.js';
+import type { ArchitectureEdge, ArchitectureGroup, ArchitectureJunction, ArchitectureNode, ArchitectureService } from './architectureTypes.js';
+export declare class ArchitectureDB implements DiagramDB {
+    private nodes;
+    private groups;
+    private edges;
+    private registeredIds;
+    private dataStructures?;
+    private elements;
+    private diagramId;
+    constructor();
+    setDiagramId(id: string): void;
+    getDiagramId(): string;
+    clear(): void;
+    addService({ id, icon, in: parent, title, iconText, }: Omit<ArchitectureService, 'edges'>): void;
+    getServices(): ArchitectureService[];
+    addJunction({ id, in: parent }: Omit<ArchitectureJunction, 'edges'>): void;
+    getJunctions(): ArchitectureJunction[];
+    getNodes(): ArchitectureNode[];
+    getNode(id: string): ArchitectureNode | null;
+    addGroup({ id, icon, in: parent, title }: ArchitectureGroup): void;
+    getGroups(): ArchitectureGroup[];
+    addEdge({ lhsId, rhsId, lhsDir, rhsDir, lhsInto, rhsInto, lhsGroup, rhsGroup, title, }: ArchitectureEdge): void;
+    getEdges(): ArchitectureEdge[];
+    /**
+     * Returns the current diagram's adjacency list, spatial map, & group alignments.
+     * If they have not been created, run the algorithms to generate them.
+     * @returns
+     */
+    getDataStructures(): import("./architectureTypes.js").ArchitectureDataStructures;
+    setElementForId(id: string, element: D3Element): void;
+    getElementById(id: string): D3Element;
+    getConfig(): Required<ArchitectureDiagramConfig>;
+    getConfigField<T extends keyof ArchitectureDiagramConfig>(field: T): Required<ArchitectureDiagramConfig>[T];
+    setAccTitle: (txt: string) => void;
+    getAccTitle: () => string;
+    setDiagramTitle: (txt: string) => void;
+    getDiagramTitle: () => string;
+    getAccDescription: () => string;
+    setAccDescription: (txt: string) => void;
+}
+/**
+ * Typed wrapper for resolving an architecture diagram's config fields. Returns the default value if undefined
+ * @param field - the config field to access
+ * @returns
+ */

tools/ui/node_modules/mermaid/dist/diagrams/architecture/architectureDetector.d.ts

@@ -0,0 +1,3 @@
+import type { ExternalDiagramDefinition } from '../../diagram-api/types.js';
+declare const architecture: ExternalDiagramDefinition;
+export default architecture;

tools/ui/node_modules/mermaid/dist/diagrams/architecture/architectureDiagram.d.ts

@@ -0,0 +1,2 @@
+import type { DiagramDefinition } from '../../diagram-api/types.js';
+export declare const diagram: DiagramDefinition;

tools/ui/node_modules/mermaid/dist/diagrams/architecture/architectureIcons.d.ts

@@ -0,0 +1,2 @@
+import type { IconifyJSON } from '@iconify/types';
+export declare const architectureIcons: IconifyJSON;

tools/ui/node_modules/mermaid/dist/diagrams/architecture/architectureParser.d.ts

@@ -0,0 +1,2 @@
+import type { ParserDefinition } from '../../diagram-api/types.js';
+export declare const parser: ParserDefinition;

tools/ui/node_modules/mermaid/dist/diagrams/architecture/architectureRenderer.d.ts

@@ -0,0 +1,5 @@
+import type { DrawDefinition } from '../../diagram-api/types.js';
+export declare const draw: DrawDefinition;
+export declare const renderer: {
+    draw: DrawDefinition;
+};

tools/ui/node_modules/mermaid/dist/diagrams/architecture/architectureStyles.d.ts

@@ -0,0 +1,3 @@
+import type { DiagramStylesProvider } from '../../diagram-api/types.js';
+declare const getStyles: DiagramStylesProvider;
+export default getStyles;

tools/ui/node_modules/mermaid/dist/diagrams/architecture/architectureTypes.d.ts

@@ -0,0 +1,227 @@
+import type { DiagramDBBase } from '../../diagram-api/types.js';
+import type { ArchitectureDiagramConfig } from '../../config.type.js';
+import type { D3Element } from '../../types.js';
+import type cytoscape from 'cytoscape';
+export type ArchitectureAlignment = 'vertical' | 'horizontal' | 'bend';
+export type ArchitectureDirection = 'L' | 'R' | 'T' | 'B';
+export type ArchitectureDirectionX = Extract<ArchitectureDirection, 'L' | 'R'>;
+export type ArchitectureDirectionY = Extract<ArchitectureDirection, 'T' | 'B'>;
+/**
+ * Contains LL, RR, TT, BB which are impossible connections
+ */
+export type InvalidArchitectureDirectionPair = `${ArchitectureDirection}${ArchitectureDirection}`;
+export type ArchitectureDirectionPair = Exclude<InvalidArchitectureDirectionPair, 'LL' | 'RR' | 'TT' | 'BB'>;
+export type ArchitectureDirectionPairXY = Exclude<InvalidArchitectureDirectionPair, 'LL' | 'RR' | 'TT' | 'BB' | 'LR' | 'RL' | 'TB' | 'BT'>;
+export declare const ArchitectureDirectionName: {
+    readonly L: "left";
+    readonly R: "right";
+    readonly T: "top";
+    readonly B: "bottom";
+};
+export declare const ArchitectureDirectionArrow: {
+    readonly L: (scale: number) => string;
+    readonly R: (scale: number) => string;
+    readonly T: (scale: number) => string;
+    readonly B: (scale: number) => string;
+};
+export declare const ArchitectureDirectionArrowShift: {
+    readonly L: (orig: number, arrowSize: number) => number;
+    readonly R: (orig: number, _arrowSize: number) => number;
+    readonly T: (orig: number, arrowSize: number) => number;
+    readonly B: (orig: number, _arrowSize: number) => number;
+};
+export declare const getOppositeArchitectureDirection: (x: ArchitectureDirection) => ArchitectureDirection;
+export declare const isArchitectureDirection: (x: unknown) => x is ArchitectureDirection;
+export declare const isArchitectureDirectionX: (x: ArchitectureDirection) => x is ArchitectureDirectionX;
+export declare const isArchitectureDirectionY: (x: ArchitectureDirection) => x is ArchitectureDirectionY;
+export declare const isArchitectureDirectionXY: (a: ArchitectureDirection, b: ArchitectureDirection) => boolean;
+export declare const isArchitecturePairXY: (pair: ArchitectureDirectionPair) => pair is ArchitectureDirectionPairXY;
+/**
+ * Verifies that the architecture direction pair does not contain an invalid match (LL, RR, TT, BB)
+ * @param x - architecture direction pair which could potentially be invalid
+ * @returns true if the pair is not LL, RR, TT, or BB
+ */
+export declare const isValidArchitectureDirectionPair: (x: InvalidArchitectureDirectionPair) => x is ArchitectureDirectionPair;
+export type ArchitectureDirectionPairMap = Partial<Record<ArchitectureDirectionPair, string>>;
+/**
+ * Creates a pair of the directions of each side of an edge. This function should be used instead of manually creating it to ensure that the source is always the first character.
+ *
+ * Note: Undefined is returned when sourceDir and targetDir are the same. In theory this should never happen since the diagram parser throws an error if a user defines it as such.
+ * @param sourceDir - source direction
+ * @param targetDir - target direction
+ * @returns
+ */
+export declare const getArchitectureDirectionPair: (sourceDir: ArchitectureDirection, targetDir: ArchitectureDirection) => ArchitectureDirectionPair | undefined;
+/**
+ * Given an x,y position for an arrow and the direction of the edge it belongs to, return a factor for slightly shifting the edge
+ * @param param0 - [x, y] coordinate pair
+ * @param pair - architecture direction pair
+ * @returns a new [x, y] coordinate pair
+ */
+export declare const shiftPositionByArchitectureDirectionPair: ([x, y]: number[], pair: ArchitectureDirectionPair) => number[];
+/**
+ * Given the directional pair of an XY edge, get the scale factors necessary to shift the coordinates inwards towards the edge
+ * @param pair - XY pair of an edge
+ * @returns - number[] containing [+/- 1, +/- 1]
+ */
+export declare const getArchitectureDirectionXYFactors: (pair: ArchitectureDirectionPairXY) => number[];
+export declare const getArchitectureDirectionAlignment: (a: ArchitectureDirection, b: ArchitectureDirection) => ArchitectureAlignment;
+export interface ArchitectureStyleOptions {
+    archEdgeColor: string;
+    archEdgeArrowColor: string;
+    archEdgeWidth: string;
+    archGroupBorderColor: string;
+    archGroupBorderWidth: string;
+}
+export interface ArchitectureService {
+    id: string;
+    type: 'service';
+    edges: ArchitectureEdge[];
+    icon?: string;
+    iconText?: string;
+    title?: string;
+    in?: string;
+    width?: number;
+    height?: number;
+}
+export interface ArchitectureJunction {
+    id: string;
+    type: 'junction';
+    edges: ArchitectureEdge[];
+    in?: string;
+    width?: number;
+    height?: number;
+}
+export type ArchitectureNode = ArchitectureService | ArchitectureJunction;
+export declare const isArchitectureService: (x: ArchitectureNode) => x is ArchitectureService;
+export declare const isArchitectureJunction: (x: ArchitectureNode) => x is ArchitectureJunction;
+export interface ArchitectureGroup {
+    id: string;
+    icon?: string;
+    title?: string;
+    in?: string;
+}
+export interface ArchitectureEdge<DT = ArchitectureDirection> {
+    lhsId: string;
+    lhsDir: DT;
+    lhsInto?: boolean;
+    lhsGroup?: boolean;
+    rhsId: string;
+    rhsDir: DT;
+    rhsInto?: boolean;
+    rhsGroup?: boolean;
+    title?: string;
+}
+export interface ArchitectureDB extends DiagramDBBase<ArchitectureDiagramConfig> {
+    clear: () => void;
+    addService: (service: Omit<ArchitectureService, 'edges'>) => void;
+    getServices: () => ArchitectureService[];
+    addJunction: (service: Omit<ArchitectureJunction, 'edges'>) => void;
+    getJunctions: () => ArchitectureJunction[];
+    getNodes: () => ArchitectureNode[];
+    getNode: (id: string) => ArchitectureNode | null;
+    addGroup: (group: ArchitectureGroup) => void;
+    getGroups: () => ArchitectureGroup[];
+    addEdge: (edge: ArchitectureEdge) => void;
+    getEdges: () => ArchitectureEdge[];
+    setElementForId: (id: string, element: D3Element) => void;
+    getElementById: (id: string) => D3Element;
+    getDataStructures: () => ArchitectureDataStructures;
+}
+export type ArchitectureAdjacencyList = Record<string, ArchitectureDirectionPairMap>;
+export type ArchitectureSpatialMap = Record<string, number[]>;
+/**
+ * Maps the direction that groups connect from.
+ *
+ * **Outer key**: ID of group A
+ *
+ * **Inner key**: ID of group B
+ *
+ * **Value**: 'vertical' or 'horizontal'
+ *
+ * Note: tmp[groupA][groupB] == tmp[groupB][groupA]
+ */
+export type ArchitectureGroupAlignments = Record<string, Record<string, Exclude<ArchitectureAlignment, 'bend'>>>;
+export interface ArchitectureDataStructures {
+    adjList: ArchitectureAdjacencyList;
+    spatialMaps: ArchitectureSpatialMap[];
+    groupAlignments: ArchitectureGroupAlignments;
+}
+export interface ArchitectureState extends Record<string, unknown> {
+    nodes: Record<string, ArchitectureNode>;
+    groups: Record<string, ArchitectureGroup>;
+    edges: ArchitectureEdge[];
+    registeredIds: Record<string, 'node' | 'group'>;
+    dataStructures?: ArchitectureDataStructures;
+    elements: Record<string, D3Element>;
+    config: ArchitectureDiagramConfig;
+}
+export interface EdgeSingularData {
+    id: string;
+    label?: string;
+    source: string;
+    sourceDir: ArchitectureDirection;
+    sourceArrow?: boolean;
+    sourceGroup?: boolean;
+    target: string;
+    targetDir: ArchitectureDirection;
+    targetArrow?: boolean;
+    targetGroup?: boolean;
+    [key: string]: any;
+}
+export declare const edgeData: (edge: cytoscape.EdgeSingular) => EdgeSingularData;
+export interface EdgeSingular extends cytoscape.EdgeSingular {
+    _private: {
+        bodyBounds: unknown;
+        rscratch: {
+            startX: number;
+            startY: number;
+            midX: number;
+            midY: number;
+            endX: number;
+            endY: number;
+        };
+    };
+    data(): EdgeSingularData;
+    data<T extends keyof EdgeSingularData>(key: T): EdgeSingularData[T];
+}
+export type NodeSingularData = {
+    type: 'service';
+    id: string;
+    icon?: string;
+    label?: string;
+    parent?: string;
+    width: number;
+    height: number;
+    [key: string]: any;
+} | {
+    type: 'junction';
+    id: string;
+    parent?: string;
+    width: number;
+    height: number;
+    [key: string]: any;
+} | {
+    type: 'group';
+    id: string;
+    icon?: string;
+    label?: string;
+    parent?: string;
+    [key: string]: any;
+};
+export declare const nodeData: (node: cytoscape.NodeSingular) => NodeSingularData;
+export interface NodeSingular extends cytoscape.NodeSingular {
+    _private: {
+        bodyBounds: {
+            h: number;
+            w: number;
+            x1: number;
+            x2: number;
+            y1: number;
+            y2: number;
+        };
+        children: cytoscape.NodeSingular[];
+    };
+    data(): NodeSingularData;
+    data<T extends keyof NodeSingularData>(key: T): NodeSingularData[T];
+}

tools/ui/node_modules/mermaid/dist/diagrams/architecture/svgDraw.d.ts

@@ -0,0 +1,8 @@
+import type cytoscape from 'cytoscape';
+import type { D3Element } from '../../types.js';
+import type { ArchitectureDB } from './architectureDb.js';
+import { type ArchitectureJunction, type ArchitectureService } from './architectureTypes.js';
+export declare const drawEdges: (edgesEl: D3Element, cy: cytoscape.Core, db: ArchitectureDB, diagramId: string) => Promise<void>;
+export declare const drawGroups: (groupsEl: D3Element, cy: cytoscape.Core, db: ArchitectureDB, diagramId: string) => Promise<void>;
+export declare const drawServices: (db: ArchitectureDB, elem: D3Element, services: ArchitectureService[], diagramId: string) => Promise<number>;
+export declare const drawJunctions: (db: ArchitectureDB, elem: D3Element, junctions: ArchitectureJunction[], diagramId: string) => void;

tools/ui/node_modules/mermaid/dist/diagrams/architecture/svgDraw.spec.d.ts

@@ -0,0 +1 @@
+export {};

tools/ui/node_modules/mermaid/dist/diagrams/block/blockDB.d.ts

@@ -0,0 +1,65 @@
+import type { DiagramDB } from '../../diagram-api/types.js';
+import type { Block, ClassDef } from './blockTypes.js';
+/**
+ * Called when the parser comes across a (style) class definition
+ * @example classDef my-style fill:#f96;
+ *
+ * @param id - the id of this (style) class
+ * @param styleAttributes - the string with 1 or more style attributes (each separated by a comma)
+ */
+export declare const addStyleClass: (id: string, styleAttributes?: string) => void;
+/**
+ * Called when the parser comes across a style definition
+ * @example style my-block-id fill:#f96;
+ *
+ * @param id - the id of the block to style
+ * @param styles - the string with 1 or more style attributes (each separated by a comma)
+ */
+export declare const addStyle2Node: (id: string, styles?: string) => void;
+/**
+ * Add a CSS/style class to the block with the given id.
+ * If the block isn't already in the list of known blocks, add it.
+ * Might be called by parser when a CSS/style class should be applied to a block
+ *
+ * @param itemIds - The id or a list of ids of the item(s) to apply the css class to
+ * @param cssClassName - CSS class name
+ */
+export declare const setCssClass: (itemIds: string, cssClassName: string) => void;
+export declare function typeStr2Type(typeStr: string): "stadium" | "subroutine" | "cylinder" | "circle" | "diamond" | "hexagon" | "lean_right" | "lean_left" | "trapezoid" | "inv_trapezoid" | "doublecircle" | "rect_left_inv_arrow" | "square" | "round" | "na" | "block_arrow";
+export declare function edgeTypeStr2Type(typeStr: string): string;
+export declare function edgeStrToEdgeData(typeStr: string): string;
+export declare function edgeStrToEdgeStartData(typeStr: string): string;
+export declare function edgeStrToThickness(typeStr: string): string;
+export declare function edgeStrToPattern(typeStr: string): string;
+export declare const generateId: () => string;
+/**
+ * Return all of the style classes
+ */
+export declare const getClasses: () => Map<string, ClassDef>;
+declare const db: {
+    readonly getConfig: () => import("./blockTypes.js").BlockConfig | undefined;
+    readonly typeStr2Type: typeof typeStr2Type;
+    readonly edgeTypeStr2Type: typeof edgeTypeStr2Type;
+    readonly edgeStrToEdgeData: typeof edgeStrToEdgeData;
+    readonly edgeStrToEdgeStartData: typeof edgeStrToEdgeStartData;
+    readonly edgeStrToThickness: typeof edgeStrToThickness;
+    readonly edgeStrToPattern: typeof edgeStrToPattern;
+    readonly getLogger: () => Record<import("../../logger.js").LogLevel, {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    }>;
+    readonly getBlocksFlat: () => Block[];
+    readonly getBlocks: () => Block[];
+    readonly getEdges: () => Block[];
+    readonly setHierarchy: (block: Block[]) => void;
+    readonly getBlock: (id: string) => Block | undefined;
+    readonly setBlock: (block: Block) => void;
+    readonly getColumns: (blockId: string) => number;
+    readonly getClasses: () => Map<string, ClassDef>;
+    readonly clear: () => void;
+    readonly generateId: () => string;
+    readonly setDiagramId: (id: string) => void;
+    readonly getDiagramId: () => string;
+};
+export type BlockDB = typeof db & DiagramDB;
+export default db;

tools/ui/node_modules/mermaid/dist/diagrams/block/blockDB.spec.d.ts

@@ -0,0 +1 @@
+export {};

tools/ui/node_modules/mermaid/dist/diagrams/block/blockDetector.d.ts

@@ -0,0 +1,3 @@
+import type { ExternalDiagramDefinition } from '../../diagram-api/types.js';
+declare const plugin: ExternalDiagramDefinition;
+export default plugin;

tools/ui/node_modules/mermaid/dist/diagrams/block/blockDiagram.d.ts

@@ -0,0 +1,2 @@
+import type { DiagramDefinition } from '../../diagram-api/types.js';
+export declare const diagram: DiagramDefinition;

tools/ui/node_modules/mermaid/dist/diagrams/block/blockRenderer.d.ts

@@ -0,0 +1,8 @@
+import type { Diagram } from '../../Diagram.js';
+export declare const getClasses: (text: any, diagObj: any) => any;
+export declare const draw: (text: string, id: string, _version: string, diagObj: Diagram) => Promise<void>;
+declare const _default: {
+    draw: (text: string, id: string, _version: string, diagObj: Diagram) => Promise<void>;
+    getClasses: (text: any, diagObj: any) => any;
+};
+export default _default;

tools/ui/node_modules/mermaid/dist/diagrams/block/blockTypes.d.ts

@@ -0,0 +1,38 @@
+export type { BlockDiagramConfig as BlockConfig } from '../../config.type.js';
+export type BlockType = 'na' | 'column-setting' | 'edge' | 'round' | 'block_arrow' | 'space' | 'square' | 'diamond' | 'hexagon' | 'odd' | 'lean_right' | 'lean_left' | 'trapezoid' | 'inv_trapezoid' | 'rect_left_inv_arrow' | 'odd_right' | 'circle' | 'ellipse' | 'stadium' | 'subroutine' | 'cylinder' | 'group' | 'doublecircle' | 'classDef' | 'applyClass' | 'applyStyles' | 'composite';
+export interface Block {
+    start?: string;
+    end?: string;
+    arrowTypeEnd?: string;
+    arrowTypeStart?: string;
+    thickness?: string;
+    pattern?: string;
+    width?: number;
+    id: string;
+    label?: string;
+    intersect?: any;
+    parent?: Block;
+    type?: BlockType;
+    children: Block[];
+    size?: {
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+    };
+    node?: any;
+    columns?: number;
+    classes?: string[];
+    directions?: string[];
+    css?: string;
+    styleClass?: string;
+    styles?: string[];
+    stylesStr?: string;
+    widthInColumns?: number;
+}
+export interface ClassDef {
+    id: string;
+    textStyles: string[];
+    styles: string[];
+}
+export type Direction = 'up' | 'down' | 'left' | 'right' | 'x' | 'y';

tools/ui/node_modules/mermaid/dist/diagrams/block/blockUtils.d.ts

@@ -0,0 +1 @@
+export declare const prepareTextForParsing: (text: string) => string;

tools/ui/node_modules/mermaid/dist/diagrams/block/layout.d.ts

@@ -0,0 +1,13 @@
+import type { BlockDB } from './blockDB.js';
+interface BlockPosition {
+    px: number;
+    py: number;
+}
+export declare function calculateBlockPosition(columns: number, position: number): BlockPosition;
+export declare function layout(db: BlockDB): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | undefined;
+export {};

tools/ui/node_modules/mermaid/dist/diagrams/block/layout.spec.d.ts

@@ -0,0 +1 @@
+export {};

tools/ui/node_modules/mermaid/dist/diagrams/block/parser/block.spec.d.ts

@@ -0,0 +1 @@
+export {};

tools/ui/node_modules/mermaid/dist/diagrams/block/renderHelpers.d.ts

@@ -0,0 +1,10 @@
+import type { BlockDB } from './blockDB.js';
+import type { Block } from './blockTypes.js';
+declare function calculateBlockSize(elem: d3.Selection<SVGGElement, unknown, HTMLElement, any>, block: any, db: any): Promise<void>;
+type ActionFun = typeof calculateBlockSize;
+export declare function insertBlockPositioned(elem: any, block: Block, db: any): Promise<void>;
+export declare function performOperations(elem: d3.Selection<SVGGElement, unknown, HTMLElement, any>, blocks: Block[], db: BlockDB, operation: ActionFun): Promise<void>;
+export declare function calculateBlockSizes(elem: any, blocks: Block[], db: BlockDB): Promise<void>;
+export declare function insertBlocks(elem: d3.Selection<SVGGElement, unknown, HTMLElement, any>, blocks: Block[], db: BlockDB): Promise<void>;
+export declare function insertEdges(elem: any, edges: Block[], blocks: Block[], db: BlockDB, id: string): Promise<void>;
+export {};

tools/ui/node_modules/mermaid/dist/diagrams/block/styles.d.ts

@@ -0,0 +1,18 @@
+/** Returns the styles given options */
+export interface BlockChartStyleOptions {
+    arrowheadColor: string;
+    border2: string;
+    clusterBkg: string;
+    clusterBorder: string;
+    edgeLabelBackground: string;
+    fontFamily: string;
+    lineColor: string;
+    mainBkg: string;
+    nodeBorder: string;
+    nodeTextColor: string;
+    tertiaryColor: string;
+    textColor: string;
+    titleColor: string;
+}
+declare const getStyles: (options: BlockChartStyleOptions) => string;
+export default getStyles;

tools/ui/node_modules/mermaid/dist/diagrams/c4/c4Db.d.ts

@@ -0,0 +1,127 @@
+export function getC4Type(): any;
+export function setC4Type(c4TypeParam: any): void;
+export function addRel(type: any, from: any, to: any, label: any, techn: any, descr: any, sprite: any, tags: any, link: any): void;
+export function addPersonOrSystem(typeC4Shape: any, alias: any, label: any, descr: any, sprite: any, tags: any, link: any): void;
+export function addContainer(typeC4Shape: any, alias: any, label: any, techn: any, descr: any, sprite: any, tags: any, link: any): void;
+export function addComponent(typeC4Shape: any, alias: any, label: any, techn: any, descr: any, sprite: any, tags: any, link: any): void;
+export function addPersonOrSystemBoundary(alias: any, label: any, type: any, tags: any, link: any): void;
+export function addContainerBoundary(alias: any, label: any, type: any, tags: any, link: any): void;
+export function addDeploymentNode(nodeType: any, alias: any, label: any, type: any, descr: any, sprite: any, tags: any, link: any): void;
+export function popBoundaryParseStack(): void;
+export function updateElStyle(typeC4Shape: any, elementName: any, bgColor: any, fontColor: any, borderColor: any, shadowing: any, shape: any, sprite: any, techn: any, legendText: any, legendSprite: any): void;
+export function updateRelStyle(typeC4Shape: any, from: any, to: any, textColor: any, lineColor: any, offsetX: any, offsetY: any): void;
+export function updateLayoutConfig(typeC4Shape: any, c4ShapeInRowParam: any, c4BoundaryInRowParam: any): void;
+export function getC4ShapeInRow(): number;
+export function getC4BoundaryInRow(): number;
+export function getCurrentBoundaryParse(): string;
+export function getParentBoundaryParse(): string;
+export function getC4ShapeArray(parentBoundary: any): any[];
+export function getC4Shape(alias: any): any;
+export function getC4ShapeKeys(parentBoundary: any): string[];
+export function getBoundaries(parentBoundary: any): {
+    alias: string;
+    label: {
+        text: string;
+    };
+    type: {
+        text: string;
+    };
+    tags: null;
+    link: null;
+    parentBoundary: string;
+}[];
+export function getBoundarys(parentBoundary: any): {
+    alias: string;
+    label: {
+        text: string;
+    };
+    type: {
+        text: string;
+    };
+    tags: null;
+    link: null;
+    parentBoundary: string;
+}[];
+export function getRels(): any[];
+export function getTitle(): string;
+export function setWrap(wrapSetting: any): void;
+export function autoWrap(): boolean;
+export function clear(): void;
+export namespace LINETYPE {
+    let SOLID: number;
+    let DOTTED: number;
+    let NOTE: number;
+    let SOLID_CROSS: number;
+    let DOTTED_CROSS: number;
+    let SOLID_OPEN: number;
+    let DOTTED_OPEN: number;
+    let LOOP_START: number;
+    let LOOP_END: number;
+    let ALT_START: number;
+    let ALT_ELSE: number;
+    let ALT_END: number;
+    let OPT_START: number;
+    let OPT_END: number;
+    let ACTIVE_START: number;
+    let ACTIVE_END: number;
+    let PAR_START: number;
+    let PAR_AND: number;
+    let PAR_END: number;
+    let RECT_START: number;
+    let RECT_END: number;
+    let SOLID_POINT: number;
+    let DOTTED_POINT: number;
+}
+export namespace ARROWTYPE {
+    let FILLED: number;
+    let OPEN: number;
+}
+export namespace PLACEMENT {
+    let LEFTOF: number;
+    let RIGHTOF: number;
+    let OVER: number;
+}
+export function setTitle(txt: any): void;
+declare namespace _default {
+    export { addPersonOrSystem };
+    export { addPersonOrSystemBoundary };
+    export { addContainer };
+    export { addContainerBoundary };
+    export { addComponent };
+    export { addDeploymentNode };
+    export { popBoundaryParseStack };
+    export { addRel };
+    export { updateElStyle };
+    export { updateRelStyle };
+    export { updateLayoutConfig };
+    export { autoWrap };
+    export { setWrap };
+    export { getC4ShapeArray };
+    export { getC4Shape };
+    export { getC4ShapeKeys };
+    export { getBoundaries };
+    export { getBoundarys };
+    export { getCurrentBoundaryParse };
+    export { getParentBoundaryParse };
+    export { getRels };
+    export { getTitle };
+    export { getC4Type };
+    export { getC4ShapeInRow };
+    export { getC4BoundaryInRow };
+    export { setAccTitle };
+    export { getAccTitle };
+    export { getAccDescription };
+    export { setAccDescription };
+    export function getConfig(): import("../../config.type.js").C4DiagramConfig | undefined;
+    export { clear };
+    export { LINETYPE };
+    export { ARROWTYPE };
+    export { PLACEMENT };
+    export { setTitle };
+    export { setC4Type };
+}
+export default _default;
+import { setAccTitle } from '../common/commonDb.js';
+import { getAccTitle } from '../common/commonDb.js';
+import { getAccDescription } from '../common/commonDb.js';
+import { setAccDescription } from '../common/commonDb.js';

tools/ui/node_modules/mermaid/dist/diagrams/c4/c4Detector.d.ts

@@ -0,0 +1,3 @@
+import type { ExternalDiagramDefinition } from '../../diagram-api/types.js';
+declare const plugin: ExternalDiagramDefinition;
+export default plugin;

tools/ui/node_modules/mermaid/dist/diagrams/c4/c4Diagram.d.ts

@@ -0,0 +1,2 @@
+import type { DiagramDefinition } from '../../diagram-api/types.js';
+export declare const diagram: DiagramDefinition;

tools/ui/node_modules/mermaid/dist/diagrams/c4/c4Renderer.d.ts

@@ -0,0 +1,12 @@
+export function setConf(cnf: any): void;
+export function drawBoundary(diagram: any, boundary: any, bounds: any): void;
+export function drawC4ShapeArray(currentBounds: any, diagram: any, c4ShapeArray: any, c4ShapeKeys: any): void;
+export function drawRels(diagram: any, rels: any, getC4ShapeObj: any, diagObj: any, diagramId: any): void;
+export function draw(_text: any, id: any, _version: any, diagObj: any): void;
+declare namespace _default {
+    export { drawC4ShapeArray as drawPersonOrSystemArray };
+    export { drawBoundary };
+    export { setConf };
+    export { draw };
+}
+export default _default;

tools/ui/node_modules/mermaid/dist/diagrams/c4/styles.d.ts

@@ -0,0 +1,2 @@
+export default getStyles;
+declare function getStyles(options: any): string;

tools/ui/node_modules/mermaid/dist/diagrams/c4/svgDraw.d.ts

@@ -0,0 +1,34 @@
+export function drawRect(elem: any, rectData: any): import("../common/commonTypes.js").D3RectElement;
+export function drawImage(elem: any, width: any, height: any, x: any, y: any, link: any): void;
+export function drawRels(elem: any, rels: any, conf: any, diagramId: any): void;
+export function drawC4Shape(elem: any, c4Shape: any, conf: any): any;
+export function insertDatabaseIcon(elem: any, id: any): void;
+export function insertComputerIcon(elem: any, id: any): void;
+export function insertClockIcon(elem: any, id: any): void;
+export function insertArrowHead(elem: any, id: any): void;
+export function insertArrowEnd(elem: any, id: any): void;
+export function insertArrowFilledHead(elem: any, id: any): void;
+export function insertArrowCrossHead(elem: any, id: any): void;
+declare namespace _default {
+    export { drawRect };
+    export { drawBoundary };
+    export { drawC4Shape };
+    export { drawRels };
+    export { drawImage };
+    export { insertArrowHead };
+    export { insertArrowEnd };
+    export { insertArrowFilledHead };
+    export { insertArrowCrossHead };
+    export { insertDatabaseIcon };
+    export { insertComputerIcon };
+    export { insertClockIcon };
+}
+export default _default;
+/**
+ * Draws a boundary in the diagram
+ *
+ * @param {any} elem - The diagram we'll draw to.
+ * @param {any} boundary - The boundary to draw.
+ * @param {any} conf - DrawText implementation discriminator object
+ */
+declare function drawBoundary(elem: any, boundary: any, conf: any): void;

tools/ui/node_modules/mermaid/dist/diagrams/class/classDb.d.ts

@@ -0,0 +1,163 @@
+import type { ClassRelation, ClassNode, ClassNote, ClassNoteMap, ClassMap, NamespaceMap, NamespaceNode } from './classTypes.js';
+import type { Node, Edge } from '../../rendering-util/types.js';
+import type { DiagramDB } from '../../diagram-api/types.js';
+export declare class ClassDB implements DiagramDB {
+    private relations;
+    private classes;
+    private readonly styleClasses;
+    private notes;
+    private interfaces;
+    private namespaces;
+    private namespaceCounter;
+    private namespaceStack;
+    private diagramId;
+    private functions;
+    constructor();
+    private splitClassNameAndType;
+    setClassLabel(_id: string, label: string): void;
+    /**
+     * Function called by parser when a node definition has been found.
+     *
+     * @param id - ID of the class to add
+     * @public
+     */
+    addClass(_id: string): void;
+    private addInterface;
+    /**
+     * Sets the diagram's SVG element ID, used to prefix domIds for uniqueness
+     * across multiple diagrams on the same page.
+     */
+    setDiagramId(svgElementId: string): void;
+    /**
+     * Function to lookup domId from id in the graph definition.
+     * When diagramId is set, returns the prefixed version for DOM uniqueness.
+     *
+     * @param id - class ID to lookup
+     * @public
+     */
+    lookUpDomId(_id: string): string;
+    clear(): void;
+    getClass(id: string): ClassNode;
+    getClasses(): ClassMap;
+    getRelations(): ClassRelation[];
+    getNote(id: string | number): ClassNote;
+    getNotes(): ClassNoteMap;
+    addRelation(classRelation: ClassRelation): void;
+    /**
+     * Adds an annotation to the specified class Annotations mark special properties of the given type
+     * (like 'interface' or 'service')
+     *
+     * @param className - The class name
+     * @param annotation - The name of the annotation without any brackets
+     * @public
+     */
+    addAnnotation(className: string, annotation: string): void;
+    /**
+     * Adds a member to the specified class
+     *
+     * @param className - The class name
+     * @param member - The full name of the member. If the member is enclosed in `<<brackets>>` it is
+     *   treated as an annotation If the member is ending with a closing bracket ) it is treated as a
+     *   method Otherwise the member will be treated as a normal property
+     * @public
+     */
+    addMember(className: string, member: string): void;
+    addMembers(className: string, members: string[]): void;
+    addNote(text: string, className: string): string;
+    cleanupLabel(label: string): string;
+    /**
+     * Called by parser when assigning cssClass to a class
+     *
+     * @param ids - Comma separated list of ids
+     * @param className - Class to add
+     */
+    setCssClass(ids: string, className: string): void;
+    defineClass(ids: string[], style: string[]): void;
+    /**
+     * Called by parser when a tooltip is found, e.g. a clickable element.
+     *
+     * @param ids - Comma separated list of ids
+     * @param tooltip - Tooltip to add
+     */
+    setTooltip(ids: string, tooltip?: string): void;
+    getTooltip(id: string, namespace?: string): string | undefined;
+    /**
+     * Called by parser when a link is found. Adds the URL to the vertex data.
+     *
+     * @param ids - Comma separated list of ids
+     * @param linkStr - URL to create a link for
+     * @param target - Target of the link, _blank by default as originally defined in the svgDraw.js file
+     */
+    setLink(ids: string, linkStr: string, target: string): void;
+    /**
+     * Called by parser when a click definition is found. Registers an event handler.
+     *
+     * @param ids - Comma separated list of ids
+     * @param functionName - Function to be called on click
+     * @param functionArgs - Function args the function should be called with
+     */
+    setClickEvent(ids: string, functionName: string, functionArgs: string): void;
+    private setClickFunc;
+    bindFunctions(element: Element): void;
+    readonly lineType: {
+        LINE: number;
+        DOTTED_LINE: number;
+    };
+    readonly relationType: {
+        AGGREGATION: number;
+        EXTENSION: number;
+        COMPOSITION: number;
+        DEPENDENCY: number;
+        LOLLIPOP: number;
+    };
+    private escapeHtml;
+    private readonly setupToolTips;
+    private direction;
+    getDirection(): string;
+    setDirection(dir: string): void;
+    private static resolveQualifiedId;
+    private static getAncestorIds;
+    private createNamespaceNode;
+    private linkParentChild;
+    addNamespace(id: string, label?: string): string;
+    popNamespace(): void;
+    getNamespace(name: string): NamespaceNode;
+    getNamespaces(): NamespaceMap;
+    /**
+     * Function called by parser when a namespace definition has been found.
+     *
+     * @param id - ID of the namespace to add
+     * @param classNames - IDs of the class to add
+     * @param noteNames - IDs of the notes to add
+     * @public
+     */
+    addClassesToNamespace(id: string, classNames: string[], noteNames: string[]): void;
+    setCssStyle(id: string, styles: string[]): void;
+    /**
+     * Gets the arrow marker for a type index
+     *
+     * @param type - The type to look for
+     * @returns The arrow marker
+     */
+    private getArrowMarker;
+    /**
+     * Walks up the namespace tree from the given id and returns the nearest ancestor
+     * (or the id itself) that is marked as explicit. Used by compact rendering mode
+     * to reassign children to the nearest user-declared namespace.
+     */
+    private resolveExplicitAncestor;
+    getData(): {
+        nodes: Node[];
+        edges: Edge[];
+        other: {};
+        config: import("../../config.type.js").MermaidConfig;
+        direction: string;
+    };
+    setAccTitle: (txt: string) => void;
+    getAccTitle: () => string;
+    setAccDescription: (txt: string) => void;
+    getAccDescription: () => string;
+    setDiagramTitle: (txt: string) => void;
+    getDiagramTitle: () => string;
+    getConfig: () => import("../../config.type.js").ClassDiagramConfig | undefined;
+}

tools/ui/node_modules/mermaid/dist/diagrams/class/classDetector-V2.d.ts

@@ -0,0 +1,3 @@
+import type { ExternalDiagramDefinition } from '../../diagram-api/types.js';
+declare const plugin: ExternalDiagramDefinition;
+export default plugin;

tools/ui/node_modules/mermaid/dist/diagrams/class/classDetector.d.ts

@@ -0,0 +1,3 @@
+import type { ExternalDiagramDefinition } from '../../diagram-api/types.js';
+declare const plugin: ExternalDiagramDefinition;
+export default plugin;

tools/ui/node_modules/mermaid/dist/diagrams/class/classDiagram-v2.d.ts

@@ -0,0 +1,2 @@
+import type { DiagramDefinition } from '../../diagram-api/types.js';
+export declare const diagram: DiagramDefinition;

tools/ui/node_modules/mermaid/dist/diagrams/class/classDiagram.d.ts

@@ -0,0 +1,2 @@
+import type { DiagramDefinition } from '../../diagram-api/types.js';
+export declare const diagram: DiagramDefinition;

tools/ui/node_modules/mermaid/dist/diagrams/class/classDiagram.spec.d.ts

@@ -0,0 +1 @@
+export {};

tools/ui/node_modules/mermaid/dist/diagrams/class/classRenderer-v2.d.ts

@@ -0,0 +1,57 @@
+import * as graphlib from 'dagre-d3-es/src/graphlib/index.js';
+import type { ClassRelation, ClassMap, ClassNoteMap, NamespaceMap } from './classTypes.js';
+/**
+ * Function that adds the vertices found during parsing to the graph to be rendered.
+ *
+ * @param namespaces - Object containing the vertices.
+ * @param g - The graph that is to be drawn.
+ * @param _id - id of the graph
+ * @param diagObj - The diagram object
+ */
+export declare const addNamespaces: (namespaces: NamespaceMap, g: graphlib.Graph, _id: string, diagObj: any) => void;
+/**
+ * Function that adds the vertices found during parsing to the graph to be rendered.
+ *
+ * @param classes - Object containing the vertices.
+ * @param g - The graph that is to be drawn.
+ * @param _id - id of the graph
+ * @param diagObj - The diagram object
+ * @param parent - id of the parent namespace, if it exists
+ */
+export declare const addClasses: (classes: ClassMap, g: graphlib.Graph, _id: string, diagObj: any, parent?: string) => void;
+/**
+ * Function that adds the additional vertices (notes) found during parsing to the graph to be rendered.
+ *
+ * @param notes - Object containing the additional vertices (notes).
+ * @param g - The graph that is to be drawn.
+ * @param startEdgeId - starting index for note edge
+ * @param classes - Classes
+ */
+export declare const addNotes: (notes: ClassNoteMap, g: graphlib.Graph, startEdgeId: number, classes: ClassMap, parent?: string) => void;
+/**
+ * Add edges to graph based on parsed graph definition
+ *
+ * @param relations -
+ * @param g - The graph object
+ */
+export declare const addRelations: (relations: ClassRelation[], g: graphlib.Graph) => void;
+/**
+ * Merges the value of `conf` with the passed `cnf`
+ *
+ * @param cnf - Config to merge
+ */
+export declare const setConf: (cnf: any) => void;
+/**
+ * Draws a class diagram in the tag with id: id based on the definition in text.
+ *
+ * @param text -
+ * @param id -
+ * @param _version -
+ * @param diagObj -
+ */
+export declare const draw: (text: string, id: string, _version: string, diagObj: any) => Promise<void>;
+declare const _default: {
+    setConf: (cnf: any) => void;
+    draw: (text: string, id: string, _version: string, diagObj: any) => Promise<void>;
+};
+export default _default;

tools/ui/node_modules/mermaid/dist/diagrams/class/classRenderer-v3-unified.d.ts

@@ -0,0 +1,18 @@
+import type { DiagramStyleClassDef } from '../../diagram-api/types.js';
+/**
+ * Get the direction from the statement items.
+ * Look through all of the documents (docs) in the parsedItems
+ * Because is a _document_ direction, the default direction is not necessarily the same as the overall default _diagram_ direction.
+ * @param parsedItem - the parsed statement item to look through
+ * @param defaultDir - the direction to use if none is found
+ * @returns The direction to use
+ */
+export declare const getDir: (parsedItem: any, defaultDir?: string) => string;
+export declare const getClasses: (text: string, diagramObj: any) => Map<string, DiagramStyleClassDef>;
+export declare const draw: (text: string, id: string, _version: string, diag: any) => Promise<void>;
+declare const _default: {
+    getClasses: (text: string, diagramObj: any) => Map<string, DiagramStyleClassDef>;
+    draw: (text: string, id: string, _version: string, diag: any) => Promise<void>;
+    getDir: (parsedItem: any, defaultDir?: string) => string;
+};
+export default _default;

tools/ui/node_modules/mermaid/dist/diagrams/class/classRenderer.d.ts

@@ -0,0 +1,5 @@
+export function draw(text: string, id: string, _version: any, diagObj: any): void;
+declare namespace _default {
+    export { draw };
+}
+export default _default;

tools/ui/node_modules/mermaid/dist/diagrams/class/classTypes.d.ts

@@ -0,0 +1,104 @@
+export interface ClassNode {
+    id: string;
+    type: string;
+    label: string;
+    shape: 'classBox';
+    text: string;
+    cssClasses: string;
+    methods: ClassMember[];
+    members: ClassMember[];
+    annotations: string[];
+    domId: string;
+    styles: string[];
+    parent?: string;
+    link?: string;
+    linkTarget?: string;
+    haveCallback?: boolean;
+    tooltip?: string;
+    look?: string;
+}
+export type Visibility = '#' | '+' | '~' | '-' | '';
+export declare const visibilityValues: string[];
+/**
+ * Parses and stores class diagram member variables/methods.
+ *
+ */
+export declare class ClassMember {
+    id: string;
+    cssStyle: string;
+    memberType: 'method' | 'attribute';
+    visibility: Visibility;
+    text: string;
+    /**
+     * denote if static or to determine which css class to apply to the node
+     * @defaultValue ''
+     */
+    classifier: string;
+    /**
+     * parameters for method
+     * @defaultValue ''
+     */
+    parameters: string;
+    /**
+     * return type for method
+     * @defaultValue ''
+     */
+    returnType: string;
+    constructor(input: string, memberType: 'method' | 'attribute');
+    getDisplayDetails(): {
+        displayText: string;
+        cssStyle: string;
+    };
+    parseMember(input: string): void;
+    parseClassifier(): "" | "font-style:italic;" | "text-decoration:underline;";
+}
+export interface ClassNote {
+    id: string;
+    class: string;
+    text: string;
+    index: number;
+    parent?: string;
+}
+export interface ClassRelation {
+    id1: string;
+    id2: string;
+    relationTitle1: string;
+    relationTitle2: string;
+    type: string;
+    title: string;
+    text: string;
+    style: string[];
+    relation: {
+        type1: number;
+        type2: number;
+        lineType: number;
+    };
+}
+export interface Interface {
+    id: string;
+    label: string;
+    classId: string;
+}
+export interface NamespaceNode {
+    id: string;
+    label: string;
+    domId: string;
+    classes: ClassMap;
+    notes: ClassNoteMap;
+    children: NamespaceMap;
+    parent?: string;
+    /**
+     * True if this namespace was explicitly declared by the user (e.g. `namespace A.B { ... }`).
+     * False for intermediate ancestors auto-created when parsing a dotted name.
+     * Used by compact (non-hierarchical) rendering mode to only emit declared namespaces.
+     */
+    explicit: boolean;
+}
+export interface StyleClass {
+    id: string;
+    styles: string[];
+    textStyles: string[];
+}
+export type ClassMap = Map<string, ClassNode>;
+export type ClassNoteMap = Map<string, ClassNote>;
+export type NamespaceMap = Map<string, NamespaceNode>;

tools/ui/node_modules/mermaid/dist/diagrams/class/classTypes.spec.d.ts

@@ -0,0 +1 @@
+export {};

tools/ui/node_modules/mermaid/dist/diagrams/class/shapeUtil.d.ts

@@ -0,0 +1,6 @@
+import type { MermaidConfig } from '../../config.type.js';
+import type { D3Selection } from '../../types.js';
+export declare function textHelper<T extends SVGGraphicsElement>(parent: D3Selection<T>, node: any, config: MermaidConfig, useHtmlLabels: boolean, GAP?: number): Promise<{
+    shapeSvg: import("d3-selection").Selection<SVGGElement, unknown, Element | null, unknown>;
+    bbox: DOMRect;
+}>;

tools/ui/node_modules/mermaid/dist/diagrams/class/styles.d.ts

@@ -0,0 +1,2 @@
+export default getStyles;
+declare function getStyles(options: any): string;

tools/ui/node_modules/mermaid/dist/diagrams/class/svgDraw.d.ts

@@ -0,0 +1,25 @@
+export function drawEdge(elem: any, path: any, relation: any, conf: any, diagObj: any): void;
+export function drawClass(elem: SVGSVGElement, classDef: any, conf: any, diagObj: any): {
+    id: any;
+    label: any;
+    width: number;
+    height: number;
+};
+export function getClassTitleString(classDef: any): any;
+export function drawNote(elem: SVGSVGElement, note: {
+    id: string;
+    text: string;
+    class: string;
+}, conf: any, _diagObj: any): {
+    id: string;
+    text: string;
+    width: number;
+    height: number;
+};
+declare namespace _default {
+    export { getClassTitleString };
+    export { drawClass };
+    export { drawEdge };
+    export { drawNote };
+}
+export default _default;

tools/ui/node_modules/mermaid/dist/diagrams/common/common.d.ts

@@ -0,0 +1,112 @@
+import { evaluate } from '../../config.js';
+import type { MermaidConfig } from '../../config.type.js';
+export declare const lineBreakRegex: RegExp;
+/**
+ * Gets the rows of lines in a string
+ *
+ * @param s - The string to check the lines for
+ * @returns The rows in that string
+ */
+export declare const getRows: (s?: string) => string[];
+/**
+ * Removes script tags from a text
+ *
+ * @param txt - The text to sanitize
+ * @returns The safer text
+ */
+export declare const removeScript: (txt: string) => string;
+export declare const sanitizeText: (text: string, config: MermaidConfig) => string;
+export declare const sanitizeTextOrArray: (a: string | string[] | string[][], config: MermaidConfig) => string | string[];
+/**
+ * Whether or not a text has any line breaks
+ *
+ * @param text - The text to test
+ * @returns Whether or not the text has breaks
+ */
+export declare const hasBreaks: (text: string) => boolean;
+/**
+ * Splits on <br> tags
+ *
+ * @param text - Text to split
+ * @returns List of lines as strings
+ */
+export declare const splitBreaks: (text: string) => string[];
+/**
+ * Gets the current URL
+ *
+ * @param useAbsolute - Whether to return the absolute URL or not
+ * @returns The current URL
+ */
+export declare const getUrl: (useAbsolute: boolean) => string;
+export { evaluate };
+/**
+ * Wrapper around Math.max which removes non-numeric values
+ * Returns the larger of a set of supplied numeric expressions.
+ * @param values - Numeric expressions to be evaluated
+ * @returns The smaller value
+ */
+export declare const getMax: (...values: number[]) => number;
+/**
+ * Wrapper around Math.min which removes non-numeric values
+ * Returns the smaller of a set of supplied numeric expressions.
+ * @param values - Numeric expressions to be evaluated
+ * @returns The smaller value
+ */
+export declare const getMin: (...values: number[]) => number;
+/**
+ * Makes generics in typescript syntax
+ *
+ * @example
+ * Array of array of strings in typescript syntax
+ *
+ * ```js
+ * // returns "Array<Array<string>>"
+ * parseGenericTypes('Array~Array~string~~');
+ * ```
+ * @param text - The text to convert
+ * @returns The converted string
+ */
+export declare const parseGenericTypes: (input: string) => string;
+export declare const countOccurrence: (string: string, substring: string) => number;
+export declare const isMathMLSupported: () => boolean;
+export declare const katexRegex: RegExp;
+/**
+ * Whether or not a text has KaTeX delimiters
+ *
+ * @param text - The text to test
+ * @returns Whether or not the text has KaTeX delimiters
+ */
+export declare const hasKatex: (text: string) => boolean;
+/**
+ * Computes the minimum dimensions needed to display a div containing MathML
+ *
+ * @param text - The text to test
+ * @param config - Configuration for Mermaid
+ * @returns Object containing \{width, height\}
+ */
+export declare const calculateMathMLDimensions: (text: string, config: MermaidConfig) => Promise<{
+    width: number;
+    height: number;
+}>;
+/**
+ * Attempts to render and return the KaTeX portion of a string with MathML
+ *
+ * @param text - The text to test
+ * @param config - Configuration for Mermaid
+ * @returns String containing MathML if KaTeX is supported, or an error message if it is not and stylesheets aren't present
+ */
+export declare const renderKatexSanitized: (text: string, config: MermaidConfig) => Promise<string>;
+declare const _default: {
+    getRows: (s?: string) => string[];
+    sanitizeText: (text: string, config: MermaidConfig) => string;
+    sanitizeTextOrArray: (a: string | string[] | string[][], config: MermaidConfig) => string | string[];
+    hasBreaks: (text: string) => boolean;
+    splitBreaks: (text: string) => string[];
+    lineBreakRegex: RegExp;
+    removeScript: (txt: string) => string;
+    getUrl: (useAbsolute: boolean) => string;
+    evaluate: (val?: string | boolean | null) => boolean;
+    getMax: (...values: number[]) => number;
+    getMin: (...values: number[]) => number;
+};
+export default _default;

tools/ui/node_modules/mermaid/dist/diagrams/common/common.spec.d.ts

@@ -0,0 +1 @@
+export {};