@ant-design/agentic-ui 2.0.0

package/dist/MarkdownEditor/editor/parser/parserMdToSchema.d.ts

@@ -0,0 +1,10 @@
+import { Elements } from '../../el';
+import { MarkdownEditorPlugin } from '../../plugin';
+export type ParserResult = {
+    schema: Elements[];
+    links: {
+        path: number[];
+        target: string;
+    }[];
+};
+export declare const parserMdToSchema: (code: string, plugins?: MarkdownEditorPlugin[]) => ParserResult;

package/dist/MarkdownEditor/editor/parser/parserMdToSchema.js

@@ -0,0 +1,23 @@
+// src/MarkdownEditor/editor/parser/parserMdToSchema.ts
+import { parserMarkdownToSlateNode } from "./parserMarkdownToSlateNode";
+var transformResult = (result) => {
+  var _a;
+  return {
+    schema: (_a = result.schema) == null ? void 0 : _a.filter((s) => {
+      if (s.language === "html" && (s == null ? void 0 : s.isConfig)) {
+        return false;
+      }
+      if (!s.type && !(s == null ? void 0 : s.text)) {
+        return false;
+      }
+      return true;
+    }),
+    links: result.links || []
+  };
+};
+var parserMdToSchema = (code, plugins) => {
+  return transformResult(parserMarkdownToSlateNode(code, plugins));
+};
+export {
+  parserMdToSchema
+};

package/dist/MarkdownEditor/editor/parser/parserSlateNodeToMarkdown.d.ts

@@ -0,0 +1,16 @@
+import { Text } from 'slate';
+import type { MarkdownEditorPlugin } from '../../plugin';
+/**
+ * 将 Slate 节点树解析为 Markdown 字符串。
+ *
+ * @param tree - Slate 节点树。
+ * @param preString - 前缀字符串，默认为空字符串。
+ * @param parent - 父节点数组，默认为包含一个根节点的数组。
+ * @returns 解析后的 Markdown 字符串。
+ *
+ * 该函数遍历 Slate 节点树，并根据节点类型和属性生成相应的 Markdown 字符串。
+ * 对于具有其他属性的节点，会将这些属性转换为 JSON 字符串并作为注释插入。
+ * 对于列表项、引用块、段落等不同类型的节点，会根据其特定的格式生成相应的 Markdown。
+ */
+export declare const parserSlateNodeToMarkdown: (tree: any[], preString?: string, parent?: any[], plugins?: MarkdownEditorPlugin[]) => string;
+export declare const isMix: (t: Text) => boolean;

package/dist/MarkdownEditor/editor/parser/parserSlateNodeToMarkdown.js

@@ -0,0 +1,642 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/MarkdownEditor/editor/parser/parserSlateNodeToMarkdown.ts
+import { Node } from "slate";
+import stringWidth from "string-width";
+import { getMediaType } from "../utils/dom";
+var inlineNode = /* @__PURE__ */ new Set(["break"]);
+var parserNode = (node, preString = "", parent, plugins) => {
+  var _a;
+  let str = "";
+  if (!node)
+    return str;
+  if (plugins == null ? void 0 : plugins.length) {
+    for (const plugin of plugins) {
+      const rule = (_a = plugin.toMarkdown) == null ? void 0 : _a.find((r) => r.match(node));
+      if (rule) {
+        const converted = rule.convert(node);
+        if (converted.type === "code") {
+          const codeNode = converted;
+          const language = codeNode.lang || "";
+          const value = codeNode.value || "";
+          if (!(value == null ? void 0 : value.trim())) {
+            return `${preString}\`\`\`${language}
+${preString}\`\`\``;
+          }
+          const codeLines = value.split("\n");
+          const indentedCode = codeLines.map((line, index) => {
+            if (index === 0 || index === codeLines.length - 1) {
+              return line;
+            }
+            return preString + line;
+          }).join("\n");
+          return `${preString}\`\`\`${language}
+${indentedCode}
+${preString}\`\`\``;
+        } else if (converted.type === "blockquote") {
+          const blockquoteNode = converted;
+          return "> " + parserSlateNodeToMarkdown(
+            blockquoteNode.children || [],
+            preString,
+            [...parent, __spreadProps(__spreadValues({}, blockquoteNode), { converted: true })],
+            plugins
+          );
+        } else if (converted.type === "paragraph") {
+          const paragraphNode = converted;
+          return preString + parserSlateNodeToMarkdown(
+            paragraphNode.children || [],
+            preString,
+            [...parent, __spreadProps(__spreadValues({}, paragraphNode), { converted: true })],
+            plugins
+          );
+        } else if (converted.type === "heading") {
+          const headingNode = converted;
+          const level = headingNode.depth || 1;
+          const content = parserSlateNodeToMarkdown(
+            headingNode.children || [],
+            preString,
+            [...parent, __spreadProps(__spreadValues({}, headingNode), { converted: true })],
+            plugins
+          );
+          return "#".repeat(level) + " " + content.replace(/\n+$/, "");
+        } else if (converted.type === "text") {
+          return converted.value || "";
+        }
+        return "";
+      }
+    }
+  }
+  switch (node.type) {
+    case "card-before":
+    case "card-after":
+      break;
+    case "card":
+      str += handleCard(node, preString, parent, plugins);
+      break;
+    case "paragraph":
+      str += handleParagraph(node, preString, parent, plugins);
+      break;
+    case "head":
+      str += handleHead(node, preString, parent, plugins);
+      break;
+    case "code":
+    case "apaasify":
+      str += handleCode(node, preString);
+      break;
+    case "attach":
+      str += handleAttach(node);
+      break;
+    case "blockquote":
+      str += handleBlockquote(node, preString, parent, plugins);
+      break;
+    case "image":
+      str += handleImage(node);
+      break;
+    case "media":
+      str += handleMedia(node);
+      break;
+    case "list":
+      str += "\n" + handleList(node, preString, parent, plugins) + "\n\n";
+      break;
+    case "list-item":
+      str += handleListItem(node, preString, parent, plugins);
+      break;
+    case "table":
+      str += table(node, parent, plugins);
+      break;
+    case "chart":
+      str += table(node, parent, plugins);
+      break;
+    case "schema":
+      str += handleSchema(node);
+      break;
+    case "link-card":
+      str += handleLinkCard(node);
+      break;
+    case "hr":
+      str += handleHr(preString);
+      break;
+    case "break":
+      str += handleBreak(preString);
+      break;
+    case "footnoteDefinition":
+      str += handleFootnoteDefinition(node);
+      break;
+    default:
+      str += handleDefault(node, parent);
+      break;
+  }
+  return str;
+};
+var parserSlateNodeToMarkdown = (tree, preString = "", parent = [{ root: true }], plugins) => {
+  var _a, _b, _c, _d, _e;
+  let str = "";
+  for (let i = 0; i < tree.length; i++) {
+    const node = tree[i];
+    if (node.otherProps && Object.keys(node.otherProps).length) {
+      let configProps = __spreadValues({}, node.otherProps);
+      delete configProps["columns"];
+      delete configProps["dataSource"];
+      if (node.type === "link-card") {
+        configProps.type = "card";
+        configProps.url = encodeURI(node == null ? void 0 : node.url);
+        configProps.name = node.name || node.title || configProps.name;
+        configProps.description = node.description || configProps.description;
+        configProps.icon = node.icon || configProps.icon;
+      }
+      Object.keys(configProps).forEach((key) => {
+        if (typeof configProps[key] === "object" && configProps[key]) {
+          if (Array.isArray(configProps[key]) && configProps[key].length === 0) {
+            delete configProps[key];
+            return;
+          }
+          if (Object.keys(configProps[key]).length === 0) {
+            delete configProps[key];
+            return;
+          }
+        }
+      });
+      if (Object.keys(configProps).length > 0) {
+        str += `<!--${JSON.stringify(configProps)}-->
+`;
+      }
+    }
+    const p = parent.at(-1) || {};
+    if (p.type === "list-item") {
+      str += parserNode(node, "", parent, plugins);
+    } else if (p.type === "blockquote") {
+      str += parserNode(node, preString + "> ", parent, plugins);
+      if (i !== tree.length - 1) {
+        str += "\n" + preString + "> ";
+      }
+    } else if (node.type === "blockquote") {
+      const blockquoteContent = node.children.map((child) => {
+        if (child.type === "blockquote") {
+          return parserNode(child, "> ", [...parent, node], plugins);
+        } else {
+          const content = parserNode(child, "", [...parent, node], plugins);
+          if (!content.trim()) {
+            return ">";
+          }
+          return content.split("\n").map((line) => "> " + line).join("\n");
+        }
+      }).join("\n");
+      str += blockquoteContent;
+    } else if (node.type === "list") {
+      const listItems = node.children.map((item, index) => {
+        const prefix = node.order ? `${index + (node.start || 1)}.` : "-";
+        return prefix + " " + parserNode(item, "", [...parent, node], plugins).trimEnd();
+      }).join("\n");
+      if (listItems.trim()) {
+        str += "\n\n";
+        str += listItems;
+        if (i !== tree.length - 1) {
+          str += "\n\n";
+        }
+      }
+    } else if (node.type === "paragraph" && ((_a = tree[i - 1]) == null ? void 0 : _a.type) === "list" && ((_b = tree[i + 1]) == null ? void 0 : _b.type) === "list") {
+      if (!((_c = Node.string(node)) == null ? void 0 : _c.replace(/\s|\t/g, ""))) {
+        str += "<br/>\n\n";
+      } else {
+        str += preString + ((_d = parserNode(node, preString, parent, plugins)) == null ? void 0 : _d.replace(
+          /^[\s\t]+/g,
+          ""
+        )) + "\n\n";
+      }
+    } else {
+      str += parserNode(node, preString, parent, plugins);
+      if (node.type && !inlineNode.has(node.type)) {
+        if (node.type === "table-row") {
+          str += "\n";
+        } else if (node.type === "code" || node.type === "media") {
+          str += "\n\n";
+        } else if (node.type === "list") {
+          str += "\n\n";
+        } else if (i !== tree.length - 1) {
+          if (node.type !== "card") {
+            str += "\n\n";
+          }
+        }
+      }
+    }
+  }
+  if (str) {
+    str = str.replace(/\n+$/, "");
+    const lastNode = tree[tree.length - 1];
+    const isRoot = parent.length === 1 && parent[0].root;
+    const isConverted = lastNode == null ? void 0 : lastNode.converted;
+    const parentType = (_e = parent[parent.length - 1]) == null ? void 0 : _e.type;
+    const nextNode = tree[tree.indexOf(lastNode) + 1];
+    const isLastNodeInParent = !nextNode;
+    if (lastNode && lastNode.type && !isConverted) {
+      if (parentType === "blockquote") {
+        if (!isLastNodeInParent || parent.some(
+          (p) => p.type === "blockquote" && p !== parent[parent.length - 1]
+        )) {
+          str += "\n> ";
+        }
+      } else if (lastNode.type === "table") {
+        str = str.replace(/\n+$/, "");
+      } else if (lastNode.type === "code" || lastNode.type === "media") {
+        if (!isLastNodeInParent) {
+          str += "\n\n";
+        }
+      } else if (!inlineNode.has(lastNode.type) && !isRoot && !["list-item", "table-row"].includes(lastNode.type)) {
+        if (!(lastNode.type === "head" && (nextNode == null ? void 0 : nextNode.type) === "head")) {
+          str += "\n\n";
+        }
+      }
+    }
+  }
+  str = str.replace(/\n{3,}/g, "\n\n");
+  if (parent.length === 1 && parent[0].root) {
+    str = str.replace(/^\n+/, "");
+  }
+  return str;
+};
+var isMix = (t) => {
+  return Object.keys(t).filter(
+    (key) => ["bold", "code", "italic", "strikethrough"].includes(key)
+  ).length > 1;
+};
+var textHtml = (t) => {
+  let str = t.text || "";
+  if (t.highColor)
+    str = `<span style="color:${t.highColor}">${str}</span>`;
+  if (t.code)
+    str = `<code>${str}</code>`;
+  if (t.italic)
+    str = `<i>${str}</i>`;
+  if (t.bold)
+    str = `<b>${str}</b>`;
+  if (t.strikethrough)
+    str = `<del>${str}</del>`;
+  if (t == null ? void 0 : t.url)
+    str = `<a href="${t == null ? void 0 : t.url}">${str}</a>`;
+  if ((t == null ? void 0 : t.identifier) || (t == null ? void 0 : t.fnc))
+    str = `[^${str}]`;
+  return str;
+};
+var textStyle = (t) => {
+  var _a, _b, _c;
+  if (!t.text && !t.tag)
+    return "";
+  let str = ((_a = t == null ? void 0 : t.text) == null ? void 0 : _a.replace(new RegExp("(?<!\\\\)\\\\", "g"), "\\").replace(/\n/g, "  \n")) || "";
+  let preStr = "", afterStr = "";
+  if (t.code || t.bold || t.strikethrough || t.italic) {
+    preStr = ((_b = str.match(/^\s+/)) == null ? void 0 : _b[0]) || "";
+    afterStr = ((_c = str.match(/\s+$/)) == null ? void 0 : _c[0]) || "";
+    str = str.trim();
+  }
+  if (t.code && !t.tag) {
+    str = `\`${str}\``;
+  } else if (t.tag) {
+    if (t.value) {
+      str = `\`${`\${placeholder:${(t == null ? void 0 : t.placeholder) || "-"},value:${t.value}}` || ""}\``;
+    } else {
+      str = `\`${str || `\${placeholder:${(t == null ? void 0 : t.placeholder) || "-"}}` || ""}\``;
+    }
+  }
+  if (t.bold && t.italic) {
+    str = `***${str}***`;
+  } else {
+    if (t.bold)
+      str = `**${str}**`;
+    if (t.italic)
+      str = `*${str}*`;
+  }
+  if (t.strikethrough)
+    str = `~~${str}~~`;
+  return preStr + str + afterStr;
+};
+var composeText = (t, parent) => {
+  var _a;
+  if (!t.text && !t.tag)
+    return "";
+  if (t.highColor || t.identifier || t.fnc || t.strikethrough && (t.bold || t.italic || t.code))
+    return textHtml(t);
+  const siblings = (_a = parent[parent.length - 1]) == null ? void 0 : _a.children;
+  const index = siblings == null ? void 0 : siblings.findIndex((n) => n === t);
+  let str = textStyle(t);
+  if (t == null ? void 0 : t.url) {
+    str = `[${t.text}](${encodeURI(t == null ? void 0 : t.url)})`;
+  } else if (isMix(t) && index !== -1) {
+    const next = siblings[index + 1];
+    if (!str.endsWith(" ") && next && !Node.string(next).startsWith(" ")) {
+      str += " ";
+    }
+  }
+  return str;
+};
+var table = (el, parent, plugins) => {
+  var _a, _b, _c, _d;
+  const children = el.children;
+  const head = (_a = children[0]) == null ? void 0 : _a.children;
+  if (!children.length || !head.length)
+    return "";
+  const data = new Array(children.length);
+  let maxColumns = 0;
+  const tableProcessors = {
+    default: () => {
+      let rowIndex = 0;
+      for (const c of children) {
+        if (!c)
+          continue;
+        const processRow = (cells, processCell) => {
+          const row = new Array(cells.length);
+          for (let i = 0; i < cells.length; i++) {
+            const cell = cells[i];
+            const content = processCell(cell);
+            row[i] = content;
+          }
+          if (cells.length > 0) {
+            data[rowIndex] = row;
+            maxColumns = Math.max(maxColumns, cells.length);
+            rowIndex++;
+          }
+        };
+        const cellProcessor = (cell) => {
+          if (cell.type !== "table-cell")
+            return "";
+          return cell.children.map((child) => {
+            if (child.type === "paragraph") {
+              return parserSlateNodeToMarkdown(
+                child.children,
+                "",
+                [...parent, cell, child],
+                plugins
+              );
+            }
+            return parserSlateNodeToMarkdown(
+              [child],
+              "",
+              [...parent, cell],
+              plugins
+            );
+          }).join("").trim();
+        };
+        if (c.type === "table-row" && (c == null ? void 0 : c.children)) {
+          processRow(c.children, cellProcessor);
+        } else if (c.type === "table-cell") {
+          processRow([c], cellProcessor);
+        }
+      }
+      return rowIndex;
+    }
+  };
+  const processor = tableProcessors[el.type] || tableProcessors.default;
+  const rowCount = processor();
+  data.length = rowCount;
+  const colLength = new Array(maxColumns).fill(0);
+  for (const row of data) {
+    for (let i = 0; i < row.length; i++) {
+      colLength[i] = Math.max(colLength[i], stringWidth(row[i] || ""));
+    }
+  }
+  const alignStrategies = {
+    right: (str, diff) => " ".repeat(diff) + str,
+    center: (str, diff) => {
+      const pre = Math.floor(diff / 2);
+      return " ".repeat(pre) + str + " ".repeat(diff - pre);
+    },
+    left: (str, diff) => str + " ".repeat(diff),
+    default: (str, diff) => str + " ".repeat(diff)
+  };
+  const separatorStrategies = {
+    left: (length) => ":" + "-".repeat(Math.max(3, length - 1)),
+    center: (length) => ":" + "-".repeat(Math.max(3, length - 2)) + ":",
+    right: (length) => "-".repeat(Math.max(3, length - 1)) + ":",
+    default: (length) => ":" + "-".repeat(Math.max(3, length - 1))
+    // 默认使用左对齐
+  };
+  const output = [];
+  for (let i = 0; i < data.length; i++) {
+    const cells = new Array(maxColumns);
+    const row = data[i];
+    for (let j = 0; j < maxColumns; j++) {
+      let str = row[j] || "";
+      const strLength = stringWidth(str);
+      const length = Math.max(3, colLength[j]);
+      const diff = length - strLength;
+      const hasExplicitAlignment = ((_b = head[j]) == null ? void 0 : _b.align) !== void 0;
+      str = diff > 0 && hasExplicitAlignment ? (alignStrategies[(_c = head[j]) == null ? void 0 : _c.align] || alignStrategies.default)(str, diff) : str;
+      cells[j] = str.replace(/\|/g, "\\|");
+    }
+    output.push(`| ${cells.join(" | ")} |`);
+    if (i === 0) {
+      const separators = new Array(maxColumns);
+      for (let j = 0; j < maxColumns; j++) {
+        const minLength = Math.max(3, colLength[j]);
+        separators[j] = (separatorStrategies[(_d = head[j]) == null ? void 0 : _d.align] || separatorStrategies.default)(minLength);
+      }
+      output.push(`| ${separators.join(" | ")} |`);
+    }
+  }
+  return output.join("\n");
+};
+var handleCard = (node, preString, parent, plugins) => {
+  return parserSlateNodeToMarkdown(
+    node == null ? void 0 : node.children,
+    preString,
+    [...parent, node],
+    plugins
+  );
+};
+var handleParagraph = (node, preString, parent, plugins) => {
+  let str = "";
+  if (node.align) {
+    str += `<!--${JSON.stringify({ align: node.align })}-->
+${preString}`;
+  }
+  str += parserSlateNodeToMarkdown(
+    node == null ? void 0 : node.children,
+    preString,
+    [...parent, node],
+    plugins
+  );
+  return str;
+};
+var handleHead = (node, preString, parent, plugins) => {
+  let str = "";
+  if (node.align) {
+    str += `<!--${JSON.stringify({ align: node.align })}-->
+${preString}`;
+  }
+  str += "#".repeat(node.level) + " " + parserSlateNodeToMarkdown(
+    node == null ? void 0 : node.children,
+    preString,
+    [...parent, node],
+    plugins
+  );
+  return str;
+};
+var handleCode = (node, preString) => {
+  let code = (node == null ? void 0 : node.value) || "";
+  if (typeof code === "object") {
+    try {
+      code = JSON.stringify(code, null, 2);
+    } catch (e) {
+      console.warn("Invalid code object", e);
+    }
+  }
+  if (node.language === "think") {
+    const marker = "​";
+    const restoredCode = code.replace(
+      new RegExp(
+        `${marker}【CODE_BLOCK:([\\w]*)】\\n?([\\s\\S]*?)\\n?【/CODE_BLOCK】${marker}`,
+        "g"
+      ),
+      (_, lang, codeContent) => {
+        return `\`\`\`${lang}
+${codeContent}
+\`\`\``;
+      }
+    );
+    return `<think>${restoredCode}</think>`;
+  }
+  if (node.language === "html" && node.render) {
+    return code;
+  }
+  if (node.frontmatter) {
+    return `${preString}---
+${code}
+${preString}---`;
+  }
+  const language = node.language || "";
+  if (!code.trim()) {
+    return `${preString}\`\`\`${language}
+${preString}\`\`\``;
+  }
+  const codeLines = code.split("\n");
+  const indentedCode = codeLines.map((line, index) => {
+    if (index === 0 || index === codeLines.length - 1) {
+      return line;
+    }
+    return preString + line;
+  }).join("\n");
+  return `${preString}\`\`\`${language}
+${indentedCode}
+${preString}\`\`\``;
+};
+var handleAttach = (node) => {
+  return `<a href="${encodeURI(node == null ? void 0 : node.url)}" download data-size="${node.size}">${node.name}</a>`;
+};
+var handleBlockquote = (node, preString, parent, plugins) => {
+  if (!node.children || node.children.length === 0) {
+    return "> ";
+  }
+  const blockquoteContent = node.children.map((child) => {
+    if (child.type === "blockquote") {
+      const nestedContent = parserNode(child, "", [...parent, node], plugins);
+      return nestedContent.split("\n").map((line) => "> " + line).join("\n");
+    } else {
+      const content = parserNode(child, "", [...parent, node], plugins);
+      if (!content.trim()) {
+        return "> ";
+      }
+      return content.split("\n").map((line) => "> " + line).join("\n");
+    }
+  }).join("\n");
+  return blockquoteContent;
+};
+var handleImage = (node) => {
+  try {
+    let nodeImageUrl = new URL(node == null ? void 0 : node.url);
+    if (node.width) {
+      nodeImageUrl.searchParams.set("width", node.width);
+    }
+    if (node.height) {
+      nodeImageUrl.searchParams.set("height", node.height);
+    }
+    if (node.block) {
+      nodeImageUrl.searchParams.set("block", node.block);
+    }
+    return `![${node.alt || ""}](${nodeImageUrl.toString()})`;
+  } catch (e) {
+    console.warn("Invalid image URL:", node == null ? void 0 : node.url, e);
+    return `![${node.alt || ""}](${encodeURI(node == null ? void 0 : node.url)})`;
+  }
+};
+var handleMedia = (node) => {
+  let nodeUrl = node == null ? void 0 : node.url;
+  let type = node.mediaType || getMediaType(nodeUrl, node == null ? void 0 : node.alt);
+  if (node.height) {
+    if (type === "video") {
+      return `<video src="${encodeURI(nodeUrl)}" alt="" height="${node.height || ""}"/>`;
+    } else if (type === "image" || type === "media") {
+      return `<img src="${encodeURI(nodeUrl)}" alt="" height="${node.height || ""}" ${node.align ? `data-align="${node.align}"` : ""}/>`;
+    }
+  } else {
+    if (type === "video") {
+      return `<video src="${encodeURI(nodeUrl)}"/>`;
+    } else if (type === "image" || type === "media") {
+      if (node.align) {
+        return `<img src="${encodeURI(nodeUrl)}" alt="" ${node.align ? `data-align="${node.align}"` : ""}/>`;
+      } else {
+        return `![${node.alt || ""}](${encodeURI(nodeUrl)})`;
+      }
+    } else {
+      return `<iframe src="${encodeURI(nodeUrl)}"/>`;
+    }
+  }
+  return "";
+};
+var handleList = (node, preString, parent, plugins) => {
+  return parserSlateNodeToMarkdown(
+    node.children,
+    preString,
+    [...parent, node],
+    plugins
+  );
+};
+var handleListItem = (node, preString, parent, plugins) => {
+  return parserSlateNodeToMarkdown(
+    node.children,
+    preString,
+    [...parent, node],
+    plugins
+  );
+};
+var handleSchema = (node) => {
+  return "```schema\n" + JSON.stringify(node.otherProps, null, 2) + "\n```";
+};
+var handleLinkCard = (node) => {
+  return `[${node.name}](${node == null ? void 0 : node.url} "${node.name}")`;
+};
+var handleHr = (preString) => {
+  return preString + "***";
+};
+var handleBreak = (preString) => {
+  return preString + "<br/>";
+};
+var handleFootnoteDefinition = (node) => {
+  return `[^${node.identifier}]: [${node.value}](${node.url})
+`;
+};
+var handleDefault = (node, parent) => {
+  if (node.text || node.tag)
+    return composeText(node, parent);
+  return "";
+};
+export {
+  isMix,
+  parserSlateNodeToMarkdown
+};

package/dist/MarkdownEditor/editor/parser/remarkParse.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Plugin to fix bold text containing special characters like **$9.698M**, **57%**, etc.
+ *
+ * @returns {(tree: any) => void}
+ *   Transformer function.
+ */
+export declare function fixStrongWithSpecialChars(): (tree: any) => void;
+declare const markdownParser: import("unified").Processor<import("mdast").Root, import("hast").Root, import("hast").Root, import("mdast").Root, string>;
+export default markdownParser;