jekyll-ham 1.0.4 → 1.1.1

data/assets/mermaid/createText-ca0c5216.js

@@ -0,0 +1,251 @@
+import { l as log, M as decodeEntities } from "./mermaid-6dc72991.js";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { dedent } from "ts-dedent";
+function preprocessMarkdown(markdown) {
+  const withoutMultipleNewlines = markdown.replace(/\n{2,}/g, "\n");
+  const withoutExtraSpaces = dedent(withoutMultipleNewlines);
+  return withoutExtraSpaces;
+}
+function markdownToLines(markdown) {
+  const preprocessedMarkdown = preprocessMarkdown(markdown);
+  const { children } = fromMarkdown(preprocessedMarkdown);
+  const lines = [[]];
+  let currentLine = 0;
+  function processNode(node, parentType = "normal") {
+    if (node.type === "text") {
+      const textLines = node.value.split("\n");
+      textLines.forEach((textLine, index) => {
+        if (index !== 0) {
+          currentLine++;
+          lines.push([]);
+        }
+        textLine.split(" ").forEach((word) => {
+          if (word) {
+            lines[currentLine].push({ content: word, type: parentType });
+          }
+        });
+      });
+    } else if (node.type === "strong" || node.type === "emphasis") {
+      node.children.forEach((contentNode) => {
+        processNode(contentNode, node.type);
+      });
+    }
+  }
+  children.forEach((treeNode) => {
+    if (treeNode.type === "paragraph") {
+      treeNode.children.forEach((contentNode) => {
+        processNode(contentNode);
+      });
+    }
+  });
+  return lines;
+}
+function markdownToHTML(markdown) {
+  const { children } = fromMarkdown(markdown);
+  function output(node) {
+    if (node.type === "text") {
+      return node.value.replace(/\n/g, "<br/>");
+    } else if (node.type === "strong") {
+      return `<strong>${node.children.map(output).join("")}</strong>`;
+    } else if (node.type === "emphasis") {
+      return `<em>${node.children.map(output).join("")}</em>`;
+    } else if (node.type === "paragraph") {
+      return `<p>${node.children.map(output).join("")}</p>`;
+    }
+    return `Unsupported markdown: ${node.type}`;
+  }
+  return children.map(output).join("");
+}
+function splitTextToChars(text) {
+  if (Intl.Segmenter) {
+    return [...new Intl.Segmenter().segment(text)].map((s) => s.segment);
+  }
+  return [...text];
+}
+function splitWordToFitWidth(checkFit, word) {
+  const characters = splitTextToChars(word.content);
+  return splitWordToFitWidthRecursion(checkFit, [], characters, word.type);
+}
+function splitWordToFitWidthRecursion(checkFit, usedChars, remainingChars, type) {
+  if (remainingChars.length === 0) {
+    return [
+      { content: usedChars.join(""), type },
+      { content: "", type }
+    ];
+  }
+  const [nextChar, ...rest] = remainingChars;
+  const newWord = [...usedChars, nextChar];
+  if (checkFit([{ content: newWord.join(""), type }])) {
+    return splitWordToFitWidthRecursion(checkFit, newWord, rest, type);
+  }
+  if (usedChars.length === 0 && nextChar) {
+    usedChars.push(nextChar);
+    remainingChars.shift();
+  }
+  return [
+    { content: usedChars.join(""), type },
+    { content: remainingChars.join(""), type }
+  ];
+}
+function splitLineToFitWidth(line, checkFit) {
+  if (line.some(({ content }) => content.includes("\n"))) {
+    throw new Error("splitLineToFitWidth does not support newlines in the line");
+  }
+  return splitLineToFitWidthRecursion(line, checkFit);
+}
+function splitLineToFitWidthRecursion(words, checkFit, lines = [], newLine = []) {
+  if (words.length === 0) {
+    if (newLine.length > 0) {
+      lines.push(newLine);
+    }
+    return lines.length > 0 ? lines : [];
+  }
+  let joiner = "";
+  if (words[0].content === " ") {
+    joiner = " ";
+    words.shift();
+  }
+  const nextWord = words.shift() ?? { content: " ", type: "normal" };
+  const lineWithNextWord = [...newLine];
+  if (joiner !== "") {
+    lineWithNextWord.push({ content: joiner, type: "normal" });
+  }
+  lineWithNextWord.push(nextWord);
+  if (checkFit(lineWithNextWord)) {
+    return splitLineToFitWidthRecursion(words, checkFit, lines, lineWithNextWord);
+  }
+  if (newLine.length > 0) {
+    lines.push(newLine);
+    words.unshift(nextWord);
+  } else if (nextWord.content) {
+    const [line, rest] = splitWordToFitWidth(checkFit, nextWord);
+    lines.push([line]);
+    if (rest.content) {
+      words.unshift(rest);
+    }
+  }
+  return splitLineToFitWidthRecursion(words, checkFit, lines);
+}
+function applyStyle(dom, styleFn) {
+  if (styleFn) {
+    dom.attr("style", styleFn);
+  }
+}
+function addHtmlSpan(element, node, width, classes, addBackground = false) {
+  const fo = element.append("foreignObject");
+  const div = fo.append("xhtml:div");
+  const label = node.label;
+  const labelClass = node.isNode ? "nodeLabel" : "edgeLabel";
+  div.html(
+    `
+    <span class="${labelClass} ${classes}" ` + (node.labelStyle ? 'style="' + node.labelStyle + '"' : "") + ">" + label + "</span>"
+  );
+  applyStyle(div, node.labelStyle);
+  div.style("display", "table-cell");
+  div.style("white-space", "nowrap");
+  div.style("max-width", width + "px");
+  div.attr("xmlns", "http://www.w3.org/1999/xhtml");
+  if (addBackground) {
+    div.attr("class", "labelBkg");
+  }
+  let bbox = div.node().getBoundingClientRect();
+  if (bbox.width === width) {
+    div.style("display", "table");
+    div.style("white-space", "break-spaces");
+    div.style("width", width + "px");
+    bbox = div.node().getBoundingClientRect();
+  }
+  fo.style("width", bbox.width);
+  fo.style("height", bbox.height);
+  return fo.node();
+}
+function createTspan(textElement, lineIndex, lineHeight) {
+  return textElement.append("tspan").attr("class", "text-outer-tspan").attr("x", 0).attr("y", lineIndex * lineHeight - 0.1 + "em").attr("dy", lineHeight + "em");
+}
+function computeWidthOfText(parentNode, lineHeight, line) {
+  const testElement = parentNode.append("text");
+  const testSpan = createTspan(testElement, 1, lineHeight);
+  updateTextContentAndStyles(testSpan, line);
+  const textLength = testSpan.node().getComputedTextLength();
+  testElement.remove();
+  return textLength;
+}
+function computeDimensionOfText(parentNode, lineHeight, text) {
+  var _a;
+  const testElement = parentNode.append("text");
+  const testSpan = createTspan(testElement, 1, lineHeight);
+  updateTextContentAndStyles(testSpan, [{ content: text, type: "normal" }]);
+  const textDimension = (_a = testSpan.node()) == null ? void 0 : _a.getBoundingClientRect();
+  if (textDimension) {
+    testElement.remove();
+  }
+  return textDimension;
+}
+function createFormattedText(width, g, structuredText, addBackground = false) {
+  const lineHeight = 1.1;
+  const labelGroup = g.append("g");
+  const bkg = labelGroup.insert("rect").attr("class", "background");
+  const textElement = labelGroup.append("text").attr("y", "-10.1");
+  let lineIndex = 0;
+  for (const line of structuredText) {
+    const checkWidth = (line2) => computeWidthOfText(labelGroup, lineHeight, line2) <= width;
+    const linesUnderWidth = checkWidth(line) ? [line] : splitLineToFitWidth(line, checkWidth);
+    for (const preparedLine of linesUnderWidth) {
+      const tspan = createTspan(textElement, lineIndex, lineHeight);
+      updateTextContentAndStyles(tspan, preparedLine);
+      lineIndex++;
+    }
+  }
+  if (addBackground) {
+    const bbox = textElement.node().getBBox();
+    const padding = 2;
+    bkg.attr("x", -padding).attr("y", -padding).attr("width", bbox.width + 2 * padding).attr("height", bbox.height + 2 * padding);
+    return labelGroup.node();
+  } else {
+    return textElement.node();
+  }
+}
+function updateTextContentAndStyles(tspan, wrappedLine) {
+  tspan.text("");
+  wrappedLine.forEach((word, index) => {
+    const innerTspan = tspan.append("tspan").attr("font-style", word.type === "emphasis" ? "italic" : "normal").attr("class", "text-inner-tspan").attr("font-weight", word.type === "strong" ? "bold" : "normal");
+    if (index === 0) {
+      innerTspan.text(word.content);
+    } else {
+      innerTspan.text(" " + word.content);
+    }
+  });
+}
+const createText = (el, text = "", {
+  style = "",
+  isTitle = false,
+  classes = "",
+  useHtmlLabels = true,
+  isNode = true,
+  width = 200,
+  addSvgBackground = false
+} = {}) => {
+  log.info("createText", text, style, isTitle, classes, useHtmlLabels, isNode, addSvgBackground);
+  if (useHtmlLabels) {
+    const htmlText = markdownToHTML(text);
+    const node = {
+      isNode,
+      label: decodeEntities(htmlText).replace(
+        /fa[blrs]?:fa-[\w-]+/g,
+        // cspell: disable-line
+        (s) => `<i class='${s.replace(":", " ")}'></i>`
+      ),
+      labelStyle: style.replace("fill:", "color:")
+    };
+    const vertexNode = addHtmlSpan(el, node, width, classes, addSvgBackground);
+    return vertexNode;
+  } else {
+    const structuredText = markdownToLines(text);
+    const svgLabel = createFormattedText(width, el, structuredText, addSvgBackground);
+    return svgLabel;
+  }
+};
+export {
+  createText as a,
+  computeDimensionOfText as c
+};

data/assets/mermaid/dagre-wrapper/blockArrowHelper.d.ts

@@ -0,0 +1,8 @@
+import type { Direction } from '../../src/diagrams/block/blockTypes.js';
+export declare const getArrowPoints: (duplicatedDirections: Direction[], bbox: {
+    width: number;
+    height: number;
+}, node: any) => {
+    x: any;
+    y: number;
+}[];

data/assets/mermaid/dagre-wrapper/clusters.d.ts

@@ -0,0 +1,4 @@
+export function insertCluster(elem: any, node: any): void;
+export function getClusterTitleWidth(elem: any, node: any): number;
+export function clear(): void;
+export function positionCluster(node: any): void;

data/assets/mermaid/dagre-wrapper/createLabel.d.ts

@@ -0,0 +1,9 @@
+export default createLabel;
+/**
+ * @param _vertexText
+ * @param style
+ * @param isTitle
+ * @param isNode
+ * @deprecated svg-util/createText instead
+ */
+declare function createLabel(_vertexText: any, style: any, isTitle: any, isNode: any): SVGTextElement | SVGForeignObjectElement;

data/assets/mermaid/dagre-wrapper/edgeMarker.d.ts

@@ -0,0 +1,12 @@
+import type { SVG } from '../diagram-api/types.js';
+import type { EdgeData } from '../types.js';
+/**
+ * Adds SVG markers to a path element based on the arrow types specified in the edge.
+ *
+ * @param svgPath - The SVG path element to add markers to.
+ * @param edge - The edge data object containing the arrow types.
+ * @param url - The URL of the SVG marker definitions.
+ * @param id - The ID prefix for the SVG marker definitions.
+ * @param diagramType - The type of diagram being rendered.
+ */
+export declare const addEdgeMarkers: (svgPath: SVG, edge: Pick<EdgeData, 'arrowTypeStart' | 'arrowTypeEnd'>, url: string, id: string, diagramType: string) => void;

data/assets/mermaid/dagre-wrapper/edgeMarker.spec.d.ts

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

data/assets/mermaid/dagre-wrapper/edges.d.ts

@@ -0,0 +1,14 @@
+export function clear(): void;
+export function insertEdgeLabel(elem: any, edge: any): any;
+export function positionEdgeLabel(edge: any, paths: any): void;
+export function intersection(node: any, outsidePoint: any, insidePoint: any): {
+    x: any;
+    y: number;
+} | {
+    x: number;
+    y: any;
+};
+export function insertEdge(elem: any, e: any, edge: any, clusterDb: any, diagramType: any, graph: any, id: any): {
+    updatedPath: any;
+    originalPath: any;
+};

data/assets/mermaid/dagre-wrapper/index.d.ts

@@ -0,0 +1 @@
+export function render(elem: any, graph: any, markers: any, diagramType: any, id: any): Promise<void>;

data/assets/mermaid/dagre-wrapper/intersect/index.d.ts

@@ -0,0 +1,13 @@
+declare namespace _default {
+    export { node };
+    export { circle };
+    export { ellipse };
+    export { polygon };
+    export { rect };
+}
+export default _default;
+import node from './intersect-node.js';
+import circle from './intersect-circle.js';
+import ellipse from './intersect-ellipse.js';
+import polygon from './intersect-polygon.js';
+import rect from './intersect-rect.js';

data/assets/mermaid/dagre-wrapper/intersect/intersect-circle.d.ts

@@ -0,0 +1,10 @@
+export default intersectCircle;
+/**
+ * @param node
+ * @param rx
+ * @param point
+ */
+declare function intersectCircle(node: any, rx: any, point: any): {
+    x: any;
+    y: any;
+};

data/assets/mermaid/dagre-wrapper/intersect/intersect-ellipse.d.ts

@@ -0,0 +1,11 @@
+export default intersectEllipse;
+/**
+ * @param node
+ * @param rx
+ * @param ry
+ * @param point
+ */
+declare function intersectEllipse(node: any, rx: any, ry: any, point: any): {
+    x: any;
+    y: any;
+};

data/assets/mermaid/dagre-wrapper/intersect/intersect-line.d.ts

@@ -0,0 +1,13 @@
+export default intersectLine;
+/**
+ * Returns the point at which two lines, p and q, intersect or returns undefined if they do not intersect.
+ *
+ * @param p1
+ * @param p2
+ * @param q1
+ * @param q2
+ */
+declare function intersectLine(p1: any, p2: any, q1: any, q2: any): {
+    x: number;
+    y: number;
+} | undefined;

data/assets/mermaid/dagre-wrapper/intersect/intersect-node.d.ts

@@ -0,0 +1,6 @@
+export default intersectNode;
+/**
+ * @param node
+ * @param point
+ */
+declare function intersectNode(node: any, point: any): any;

data/assets/mermaid/dagre-wrapper/intersect/intersect-polygon.d.ts

@@ -0,0 +1,10 @@
+export default intersectPolygon;
+/**
+ * Returns the point ({x, y}) at which the point argument intersects with the node argument assuming
+ * that it has the shape specified by polygon.
+ *
+ * @param node
+ * @param polyPoints
+ * @param point
+ */
+declare function intersectPolygon(node: any, polyPoints: any, point: any): any;

data/assets/mermaid/dagre-wrapper/intersect/intersect-rect.d.ts

@@ -0,0 +1,5 @@
+export default intersectRect;
+declare function intersectRect(node: any, point: any): {
+    x: any;
+    y: any;
+};

data/assets/mermaid/dagre-wrapper/markers.d.ts

@@ -0,0 +1,2 @@
+export default insertMarkers;
+declare function insertMarkers(elem: any, markerArray: any, type: any, id: any): void;

data/assets/mermaid/dagre-wrapper/mermaid-graphlib.d.ts

@@ -0,0 +1,8 @@
+export let clusterDb: {};
+export function clear(): void;
+export function extractDescendants(id: any, graph: any): any[];
+export function validate(graph: any): boolean;
+export function findNonClusterChild(id: any, graph: any): any;
+export function adjustClustersAndEdges(graph: any, depth: any): void;
+export function extractor(graph: any, depth: any): void;
+export function sortNodesByHierarchy(graph: any): any;

data/assets/mermaid/dagre-wrapper/nodes.d.ts

@@ -0,0 +1,4 @@
+export function insertNode(elem: any, node: any, dir: any): Promise<any>;
+export function setNodeElem(elem: any, node: any): void;
+export function clear(): void;
+export function positionNode(node: any): any;

data/assets/mermaid/dagre-wrapper/shapes/note.d.ts

@@ -0,0 +1,2 @@
+export default note;
+declare function note(parent: any, node: any): Promise<any>;

data/assets/mermaid/dagre-wrapper/shapes/util.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @param parent
+ * @param w
+ * @param h
+ * @param points
+ */
+export function insertPolygonShape(parent: any, w: any, h: any, points: any): any;
+export function labelHelper(parent: any, node: any, _classes: any, isNode: any): Promise<{
+    shapeSvg: any;
+    bbox: any;
+    halfPadding: number;
+    label: any;
+}>;
+export function updateNodeBounds(node: any, element: any): void;

data/assets/mermaid/defaultConfig.d.ts

@@ -0,0 +1,12 @@
+import type { RequiredDeep } from 'type-fest';
+import type { MermaidConfig } from './config.type.js';
+/**
+ * Default mermaid configuration options.
+ *
+ * Please see the Mermaid config JSON Schema for the default JSON values.
+ * Non-JSON JS default values are listed in this file, e.g. functions, or
+ * `undefined` (explicitly set so that `configKeys` finds them).
+ */
+declare const config: RequiredDeep<MermaidConfig>;
+export declare const configKeys: Set<string>;
+export default config;

data/assets/mermaid/diagram-api/comments.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Remove all lines starting with `%%` from the text that don't contain a `%%{`
+ * @param text - The text to remove comments from
+ * @returns cleaned text
+ */
+export declare const cleanupComments: (text: string) => string;

data/assets/mermaid/diagram-api/comments.spec.d.ts

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

data/assets/mermaid/diagram-api/detectType.d.ts

@@ -0,0 +1,42 @@
+import type { MermaidConfig } from '../config.type.js';
+import type { DetectorRecord, DiagramDetector, DiagramLoader, ExternalDiagramDefinition } from './types.js';
+export declare const detectors: Record<string, DetectorRecord>;
+/**
+ * Detects the type of the graph text.
+ *
+ * Takes into consideration the possible existence of an `%%init` directive
+ *
+ * @param text - The text defining the graph. For example:
+ *
+ * ```mermaid
+ *   %%{initialize: {"startOnLoad": true, logLevel: "fatal" }}%%
+ *   graph LR
+ *    a-->b
+ *    b-->c
+ *    c-->d
+ *    d-->e
+ *    e-->f
+ *    f-->g
+ *    g-->h
+ * ```
+ *
+ * @param config - The mermaid config.
+ * @returns A graph definition key
+ */
+export declare const detectType: (text: string, config?: MermaidConfig) => string;
+/**
+ * Registers lazy-loaded diagrams to Mermaid.
+ *
+ * The diagram function is loaded asynchronously, so that diagrams are only loaded
+ * if the diagram is detected.
+ *
+ * @remarks
+ * Please note that the order of diagram detectors is important.
+ * The first detector to return `true` is the diagram that will be loaded
+ * and used, so put more specific detectors at the beginning!
+ *
+ * @param diagrams - Diagrams to lazy load, and their detectors, in order of importance.
+ */
+export declare const registerLazyLoadedDiagrams: (...diagrams: ExternalDiagramDefinition[]) => void;
+export declare const addDetector: (key: string, detector: DiagramDetector, loader?: DiagramLoader) => void;
+export declare const getDiagramLoader: (key: string) => DiagramLoader | undefined;

data/assets/mermaid/diagram-api/diagram-orchestration.d.ts

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

data/assets/mermaid/diagram-api/diagram-orchestration.spec.d.ts

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

data/assets/mermaid/diagram-api/diagramAPI.d.ts

@@ -0,0 +1,31 @@
+import type { DiagramDefinition, DiagramDetector } from './types.js';
+import * as _commonDb from '../diagrams/common/commonDb.js';
+export declare const log: Record<import("../logger.js").LogLevel, {
+    (...data: any[]): void;
+    (message?: any, ...optionalParams: any[]): void;
+}>;
+export declare const setLogLevel: (level?: string | number) => void;
+export declare const getConfig: () => import("../config.type.js").MermaidConfig;
+export declare const setConfig: (conf: import("../config.type.js").MermaidConfig) => import("../config.type.js").MermaidConfig;
+export declare const defaultConfig: import("../config.type.js").MermaidConfig;
+export declare const setSiteConfig: (conf: import("../config.type.js").MermaidConfig) => import("../config.type.js").MermaidConfig;
+export declare const sanitizeText: (text: string) => string;
+export declare const setupGraphViewbox: (graph: any, svgElem: any, padding: any, useMaxWidth: any) => void;
+export declare const getCommonDb: () => typeof _commonDb;
+export interface Detectors {
+    [key: string]: DiagramDetector;
+}
+/**
+ * Registers the given diagram with Mermaid.
+ *
+ * Can be used for third-party custom diagrams.
+ *
+ * @param id - A unique ID for the given diagram.
+ * @param diagram - The diagram definition.
+ * @param detector - Function that returns `true` if a given mermaid text is this diagram definition.
+ */
+export declare const registerDiagram: (id: string, diagram: DiagramDefinition, detector?: DiagramDetector) => void;
+export declare const getDiagram: (name: string) => DiagramDefinition;
+export declare class DiagramNotFoundError extends Error {
+    constructor(name: string);
+}

data/assets/mermaid/diagram-api/diagramAPI.spec.d.ts

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

data/assets/mermaid/diagram-api/frontmatter.d.ts

@@ -0,0 +1,18 @@
+import type { MermaidConfig } from '../config.type.js';
+interface FrontMatterMetadata {
+    title?: string;
+    displayMode?: string;
+    config?: MermaidConfig;
+}
+export interface FrontMatterResult {
+    text: string;
+    metadata: FrontMatterMetadata;
+}
+/**
+ * Extract and parse frontmatter from text, if present, and sets appropriate
+ * properties in the provided db.
+ * @param text - The text that may have a YAML frontmatter.
+ * @returns text with frontmatter stripped out
+ */
+export declare function extractFrontMatter(text: string): FrontMatterResult;
+export {};

data/assets/mermaid/diagram-api/frontmatter.spec.d.ts

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

data/assets/mermaid/diagram-api/loadDiagram.d.ts

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

data/assets/mermaid/diagram-api/regexes.d.ts

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

data/assets/mermaid/diagram-api/types.d.ts

@@ -0,0 +1,84 @@
+import type { Diagram } from '../Diagram.js';
+import type { BaseDiagramConfig, MermaidConfig } from '../config.type.js';
+import type * as d3 from 'd3';
+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;
+    setDisplayMode?: (title: string) => void;
+    bindFunctions?: (element: Element) => void;
+}
+export interface DiagramStyleClassDef {
+    id: string;
+    styles?: string[];
+    textStyles?: string[];
+}
+export interface DiagramRenderer {
+    draw: DrawDefinition;
+    getClasses?: (text: string, diagram: Pick<DiagramDefinition, 'db'>) => Record<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 DetectorRecord {
+    detector: DiagramDetector;
+    loader?: DiagramLoader;
+}
+export interface ExternalDiagramDefinition {
+    id: string;
+    detector: DiagramDetector;
+    loader: DiagramLoader;
+}
+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;
+    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 Group = d3.Selection<SVGGElement, unknown, Element | null, unknown>;
+export type DiagramStylesProvider = (options?: any) => string;

data/assets/mermaid/diagram.spec.d.ts

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