1 files changed, 251 insertions, 0 deletions
diff --git a/themes/blowfish/assets/lib/mermaid/createText-ca0c5216.js b/themes/blowfish/assets/lib/mermaid/createText-ca0c5216.js
new file mode 100644
index 0000000..f0810a2
--- /dev/null
+++ b/themes/blowfish/assets/lib/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
+};