@hywax/mdc-tiptap 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { stringifyMarkdown, parseMarkdown } from '@nuxtjs/mdc/runtime';
+import { parseMarkdown, stringifyMarkdown } from '@nuxtjs/mdc/runtime';
 import 'mdast-util-find-and-replace';
 import rehypeShiki from '@nuxtjs/mdc/dist/runtime/highlighter/rehype';
 import { createShikiHighlighter } from '@nuxtjs/mdc/runtime/highlighter/shiki';
@@ -11706,594 +11706,623 @@ function normalizeProps(nodeProps, extraProps) {
   }).filter(([key]) => Boolean(String(key).trim()));
 }
 
-const tagToMark = {
-  strong: "bold",
-  em: "italic",
-  del: "strike",
-  code: "code",
-  a: "link"
-};
-const defaultMDCToTiptapMap = {
-  ...Object.fromEntries(Object.entries(tagToMark).map(([key, value]) => [key, (node) => createMark(node, value)])),
-  root: (node) => ({ type: "doc", content: (node.children || []).flatMap((child) => mdcNodeToTiptap(child, node)) }),
-  text: (node) => createTextNode(node),
-  comment: (node) => createTipTapNode(node, "comment", { attrs: { text: node.value } }),
-  img: (node) => createTipTapNode(node, "image", { attrs: { props: node.props || {}, src: node.props?.src, alt: node.props?.alt } }),
-  video: (node) => createTipTapNode(node, "video"),
-  template: (node) => createTemplateNode(node),
-  pre: (node) => createPreNode(node),
-  p: (node) => createParagraphNode(node),
-  span: (node) => createSpanStyleNode(node),
-  h1: (node) => createTipTapNode(node, "heading", { attrs: { level: 1 } }),
-  h2: (node) => createTipTapNode(node, "heading", { attrs: { level: 2 } }),
-  h3: (node) => createTipTapNode(node, "heading", { attrs: { level: 3 } }),
-  h4: (node) => createTipTapNode(node, "heading", { attrs: { level: 4 } }),
-  h5: (node) => createTipTapNode(node, "heading", { attrs: { level: 5 } }),
-  h6: (node) => createTipTapNode(node, "heading", { attrs: { level: 6 } }),
-  ul: (node) => createTipTapNode(node, "bulletList"),
-  ol: (node) => createTipTapNode(node, "orderedList", { attrs: { start: node.props?.start } }),
-  li: (node) => createTipTapNode(node, "listItem", { children: [{ type: "element", tag: "p", children: node.children }] }),
-  blockquote: (node) => createTipTapNode(node, "blockquote"),
-  binding: (node) => createTipTapNode(node, "binding", { attrs: { value: node.props?.value, defaultValue: node.props?.defaultValue } }),
-  hr: (node) => createTipTapNode(node, "horizontalRule")
-};
-function mdcToTiptap(body, options) {
-  body.children = (body.children || []).filter((child) => child.type !== "text");
-  const tree = mdcNodeToTiptap(body, void 0, options?.mdcToTiptapMap);
-  tree.content = isEmpty(tree.content) ? [{ type: "paragraph", content: [] }] : tree.content;
-  return tree;
-}
-function mdcNodeToTiptap(node, parent, mdcToTiptapMap) {
-  const type = node.type === "element" ? node.tag : node.type;
-  const nodes = {
-    ...mdcToTiptapMap,
-    ...defaultMDCToTiptapMap || {}
+function createMDCToTiptap(options) {
+  const tagToMark = {
+    strong: "bold",
+    em: "italic",
+    del: "strike",
+    code: "code",
+    a: "link"
   };
-  if (nodes[type]) {
-    return nodes[type](node);
-  }
-  if (parent?.tag === "p") {
-    return createTipTapNode(node, "inline-element", { attrs: { tag: type } });
-  }
-  if (node.type === "element" && node.children?.[0]?.type === "text") {
-    node = {
-      ...node,
-      props: {
-        ...node.props,
-        __tiptapWrap: true
-      },
-      children: [{
-        type: "element",
-        tag: "p",
-        children: node.children,
-        props: {}
-      }]
-    };
+  const mdcToTiptapMap = {
+    ...Object.fromEntries(Object.entries(tagToMark).map(([key, value]) => [key, (node) => createMark(node, value)])),
+    root: (node) => ({ type: "doc", content: (node.children || []).flatMap((child) => mdcNodeToTiptap(child, node)) }),
+    text: (node) => createTextNode(node),
+    comment: (node) => createTipTapNode(node, "comment", { attrs: { text: node.value } }),
+    img: (node) => createTipTapNode(node, "image", { attrs: { props: node.props || {}, src: node.props?.src, alt: node.props?.alt } }),
+    video: (node) => createTipTapNode(node, "video"),
+    template: (node) => createTemplateNode(node),
+    pre: (node) => createPreNode(node),
+    p: (node) => createParagraphNode(node),
+    span: (node) => createSpanStyleNode(node),
+    h1: (node) => createTipTapNode(node, "heading", { attrs: { level: 1 } }),
+    h2: (node) => createTipTapNode(node, "heading", { attrs: { level: 2 } }),
+    h3: (node) => createTipTapNode(node, "heading", { attrs: { level: 3 } }),
+    h4: (node) => createTipTapNode(node, "heading", { attrs: { level: 4 } }),
+    h5: (node) => createTipTapNode(node, "heading", { attrs: { level: 5 } }),
+    h6: (node) => createTipTapNode(node, "heading", { attrs: { level: 6 } }),
+    ul: (node) => createTipTapNode(node, "bulletList"),
+    ol: (node) => createTipTapNode(node, "orderedList", { attrs: { start: node.props?.start } }),
+    li: (node) => createTipTapNode(node, "listItem", { children: [{ type: "element", tag: "p", children: node.children }] }),
+    blockquote: (node) => createTipTapNode(node, "blockquote"),
+    binding: (node) => createTipTapNode(node, "binding", { attrs: { value: node.props?.value, defaultValue: node.props?.defaultValue } }),
+    hr: (node) => createTipTapNode(node, "horizontalRule"),
+    ...options?.customMap || {}
+  };
+  function mdcToTiptap(body) {
+    body.children = (body.children || []).filter((child) => child.type !== "text");
+    const tree = mdcNodeToTiptap(body);
+    tree.content = [
+      ...isEmpty(tree.content) ? [{ type: "paragraph", content: [] }] : tree.content
+    ];
+    return tree;
   }
-  const children = wrapChildrenWithinSlot(node.children || []);
-  return createTipTapNode(node, "element", { attrs: { tag: type }, children });
-}
-function createMark(node, mark, accumulatedMarks = []) {
-  const attrs = { ...node.props };
-  if (mark === "link" && attrs.href) {
-    if (attrs.rel && Array.isArray(attrs.rel)) {
-      attrs.rel = attrs.rel.join(" ");
+  function mdcNodeToTiptap(node, parent) {
+    const type = node.type === "element" ? node.tag : node.type;
+    if (mdcToTiptapMap[type]) {
+      return mdcToTiptapMap[type](node);
     }
-    const href = String(attrs.href);
-    const isExternal = href.startsWith("http://") || href.startsWith("https://");
-    if (isExternal) {
-      attrs.target = attrs.target || "_blank";
-      attrs.rel = attrs.rel || "noopener noreferrer nofollow";
+    if (parent?.tag === "p") {
+      return createTipTapNode(node, "inline-element", { attrs: { tag: type } });
     }
-  }
-  const marks = [...accumulatedMarks, { type: mark, attrs }];
-  function getNodeContent(node2) {
-    if (node2.type === "text") {
-      return node2.value;
+    if (node.type === "element" && node.children?.[0]?.type === "text") {
+      node = {
+        ...node,
+        props: {
+          ...node.props,
+          __tiptapWrap: true
+        },
+        children: [{
+          type: "element",
+          tag: "p",
+          children: node.children,
+          props: {}
+        }]
+      };
     }
-    let content = "";
-    node2.children?.forEach((childNode) => {
-      content += getNodeContent(childNode);
-    });
-    return content;
-  }
-  if (node.type === "element" && node.tag === "code") {
-    return [{
-      type: "text",
-      text: getNodeContent(node),
-      marks: marks.slice().reverse()
-    }];
+    const children = wrapChildrenWithinSlot(node.children || []);
+    return createTipTapNode(node, "element", { attrs: { tag: type }, children });
   }
-  return (node.children || []).map((child) => {
-    if (child.type === "text") {
-      return {
+  function createMark(node, mark, accumulatedMarks = []) {
+    const attrs = { ...node.props };
+    if (mark === "link" && attrs.href) {
+      if (attrs.rel && Array.isArray(attrs.rel)) {
+        attrs.rel = attrs.rel.join(" ");
+      }
+      const href = String(attrs.href);
+      const isExternal = href.startsWith("http://") || href.startsWith("https://");
+      if (isExternal) {
+        attrs.target = attrs.target || "_blank";
+        attrs.rel = attrs.rel || "noopener noreferrer nofollow";
+      }
+    }
+    const marks = [...accumulatedMarks, { type: mark, attrs }];
+    function getNodeContent(node2) {
+      if (node2.type === "text") {
+        return node2.value;
+      }
+      let content = "";
+      node2.children?.forEach((childNode) => {
+        content += getNodeContent(childNode);
+      });
+      return content;
+    }
+    if (node.type === "element" && node.tag === "code") {
+      return [{
         type: "text",
-        text: getNodeContent(child),
+        text: getNodeContent(node),
         marks: marks.slice().reverse()
-      };
-    } else if (child.type === "element" && tagToMark[child.tag]) {
-      return createMark(child, tagToMark[child.tag], marks);
-    } else if (child.type === "element") {
-      const tiptapNode = mdcNodeToTiptap(child, node);
-      if (tiptapNode.content?.length) {
-        tiptapNode.content.forEach((c) => {
-          if (c.type === "text") {
-            c.marks = marks.slice().reverse();
-          }
-        });
+      }];
+    }
+    return (node.children || []).map((child) => {
+      if (child.type === "text") {
+        return {
+          type: "text",
+          text: getNodeContent(child),
+          marks: marks.slice().reverse()
+        };
+      } else if (child.type === "element" && tagToMark[child.tag]) {
+        return createMark(child, tagToMark[child.tag], marks);
+      } else if (child.type === "element") {
+        const tiptapNode = mdcNodeToTiptap(child, node);
+        if (tiptapNode.content?.length) {
+          tiptapNode.content.forEach((c) => {
+            if (c.type === "text") {
+              c.marks = marks.slice().reverse();
+            }
+          });
+        }
+        return tiptapNode;
+      }
+      return mdcNodeToTiptap(child, node);
+    }).flat();
+  }
+  function createTipTapNode(node, type, extra = {}) {
+    const { attrs = {}, children, ...rest } = extra;
+    const cleanProps = Object.entries({ ...attrs.props || {}, ...node.props || {} }).map(([key, value]) => {
+      if (key.startsWith("__mdc_")) {
+        return void 0;
       }
-      return tiptapNode;
+      return ["className", "class"].includes(key.trim()) ? ["class", typeof value === "string" ? value : value.join(" ")] : [key.trim(), value];
+    }).filter(Boolean);
+    const tiptapNode = {
+      type,
+      ...rest,
+      attrs
+    };
+    if (cleanProps.length) {
+      tiptapNode.attrs.props = Object.fromEntries(cleanProps);
     }
-    return mdcNodeToTiptap(child, node);
-  }).flat();
-}
-function createTipTapNode(node, type, extra = {}) {
-  const { attrs = {}, children, ...rest } = extra;
-  const cleanProps = Object.entries({ ...attrs.props || {}, ...node.props || {} }).map(([key, value]) => {
-    if (key.startsWith("__mdc_")) {
-      return void 0;
+    if (children || node.children) {
+      tiptapNode.content = (children || node.children || []).flatMap((child) => mdcNodeToTiptap(child, node));
     }
-    return ["className", "class"].includes(key.trim()) ? ["class", typeof value === "string" ? value : value.join(" ")] : [key.trim(), value];
-  }).filter(Boolean);
-  const tiptapNode = {
-    type,
-    ...rest,
-    attrs
-  };
-  if (cleanProps.length) {
-    tiptapNode.attrs.props = Object.fromEntries(cleanProps);
+    return tiptapNode;
   }
-  if (children || node.children) {
-    tiptapNode.content = (children || node.children || []).flatMap((child) => mdcNodeToTiptap(child, node));
-  }
-  return tiptapNode;
-}
-function createTemplateNode(node) {
-  const name = Object.keys(node.props || {}).find((prop) => prop?.startsWith("v-slot:"))?.replace("v-slot:", "") || "default";
-  if (node.children?.[0]?.type === "text") {
-    node.children = [{
-      type: "element",
-      tag: "p",
-      children: node.children,
-      props: {}
-    }];
+  function createTemplateNode(node) {
+    const name = Object.keys(node.props || {}).find((prop) => prop?.startsWith("v-slot:"))?.replace("v-slot:", "") || "default";
+    if (node.children?.[0]?.type === "text") {
+      node.children = [{
+        type: "element",
+        tag: "p",
+        children: node.children,
+        props: {}
+      }];
+    }
+    return createTipTapNode(node, "slot", { attrs: { name } });
   }
-  return createTipTapNode(node, "slot", { attrs: { name } });
-}
-function createPreNode(node) {
-  const tiptapNode = createTipTapNode(node, "codeBlock", {
-    attrs: {
-      language: node.props?.language || "text",
-      filename: node.props?.filename
+  function createPreNode(node) {
+    const tiptapNode = createTipTapNode(node, "codeBlock", {
+      attrs: {
+        language: node.props?.language || "text",
+        filename: node.props?.filename
+      }
+    });
+    if (tiptapNode.content.length === 1 && tiptapNode.content[0].text === "") {
+      tiptapNode.content = [];
     }
-  });
-  if (tiptapNode.content.length === 1 && tiptapNode.content[0].text === "") {
-    tiptapNode.content = [];
+    tiptapNode.content.forEach((child) => {
+      delete child.marks;
+    });
+    return tiptapNode;
   }
-  tiptapNode.content.forEach((child) => {
-    delete child.marks;
-  });
-  return tiptapNode;
-}
-function createParagraphNode(node) {
-  if (node.children?.length && node.children?.every((child) => child.tag === "img")) {
-    return node.children?.map((child) => defaultMDCToTiptapMap.img(child));
+  function createParagraphNode(node) {
+    if (node.children?.length && node.children?.every((child) => child.tag === "img")) {
+      return node.children?.map((child) => mdcToTiptapMap.img(child));
+    }
+    node.children = node.children?.filter((child) => !(child.type === "text" && !child.value)) || [];
+    const content = node.children.map((child) => mdcNodeToTiptap(child, node)).flat();
+    return {
+      type: "paragraph",
+      content,
+      attrs: isEmpty(node.props) ? void 0 : node.props
+    };
   }
-  node.children = node.children?.filter((child) => !(child.type === "text" && !child.value)) || [];
-  const content = node.children.map((child) => mdcNodeToTiptap(child, node)).flat();
-  return {
-    type: "paragraph",
-    content,
-    attrs: isEmpty(node.props) ? void 0 : node.props
-  };
-}
-function createTextNode(node) {
-  const text = node.value;
-  const nodes = [];
-  let lastIndex = 0;
-  text.replace(EMOJI_REGEXP, (match, offset) => {
-    if (lastIndex < offset) {
+  function createTextNode(node) {
+    const text = node.value;
+    const nodes = [];
+    let lastIndex = 0;
+    text.replace(EMOJI_REGEXP, (match, offset) => {
+      if (lastIndex < offset) {
+        nodes.push({
+          type: "text",
+          text: text.slice(lastIndex, offset)
+        });
+      }
+      const emojiUnicode = getEmojiUnicode(match.substring(1, match.length - 1));
       nodes.push({
         type: "text",
-        text: text.slice(lastIndex, offset)
+        text: emojiUnicode || match
       });
-    }
-    const emojiUnicode = getEmojiUnicode(match.substring(1, match.length - 1));
-    nodes.push({
-      type: "text",
-      text: emojiUnicode || match
-    });
-    lastIndex = offset + match.length;
-    return "";
-  });
-  if (lastIndex < text.length) {
-    nodes.push({
-      type: "text",
-      text: text.slice(lastIndex)
+      lastIndex = offset + match.length;
+      return "";
     });
+    if (lastIndex < text.length) {
+      nodes.push({
+        type: "text",
+        text: text.slice(lastIndex)
+      });
+    }
+    return nodes.length === 0 ? { type: "text", text } : nodes;
   }
-  return nodes.length === 0 ? { type: "text", text } : nodes;
-}
-function createSpanStyleNode(node) {
-  const spanStyle = node.props?.style;
-  const spanClass = node.props?.class || node.props?.className;
-  const spanAttrs = {
-    style: isValidAttr(spanStyle) ? String(spanStyle).trim() : void 0,
-    class: isValidAttr(spanClass) ? String(spanClass).trim() : void 0
-  };
-  const cleanedNode = { ...node, props: { ...node.props } };
-  delete cleanedNode.props.style;
-  delete cleanedNode.props.class;
-  delete cleanedNode.props.className;
-  return createTipTapNode(cleanedNode, "span-style", { attrs: spanAttrs });
-}
-function wrapChildrenWithinSlot(children) {
-  const noneSlotChildren = children.filter((child) => child.tag !== "template");
-  if (noneSlotChildren.length) {
-    children = children.filter((child) => child.tag === "template");
-    let defaultSlot = children.find((child) => child.props?.["v-slot:default"]);
-    if (!defaultSlot) {
-      defaultSlot = {
-        type: "element",
-        tag: "template",
-        props: {
-          "v-slot:default": ""
-        },
-        children: []
-      };
-      children.unshift(defaultSlot);
+  function createSpanStyleNode(node) {
+    const spanStyle = node.props?.style;
+    const spanClass = node.props?.class || node.props?.className;
+    const spanAttrs = {
+      style: isValidAttr(spanStyle) ? String(spanStyle).trim() : void 0,
+      class: isValidAttr(spanClass) ? String(spanClass).trim() : void 0
+    };
+    const cleanedNode = { ...node, props: { ...node.props } };
+    delete cleanedNode.props.style;
+    delete cleanedNode.props.class;
+    delete cleanedNode.props.className;
+    return createTipTapNode(cleanedNode, "span-style", { attrs: spanAttrs });
+  }
+  function wrapChildrenWithinSlot(children) {
+    const noneSlotChildren = children.filter((child) => child.tag !== "template");
+    if (noneSlotChildren.length) {
+      children = children.filter((child) => child.tag === "template");
+      let defaultSlot = children.find((child) => child.props?.["v-slot:default"]);
+      if (!defaultSlot) {
+        defaultSlot = {
+          type: "element",
+          tag: "template",
+          props: {
+            "v-slot:default": ""
+          },
+          children: []
+        };
+        children.unshift(defaultSlot);
+      }
+      defaultSlot.children = [
+        ...defaultSlot.children || [],
+        ...noneSlotChildren
+      ];
     }
-    defaultSlot.children = [
-      ...defaultSlot.children || [],
-      ...noneSlotChildren
-    ];
+    return children;
   }
-  return children;
+  return {
+    mdcToTiptap,
+    createMark,
+    createTipTapNode,
+    createTemplateNode,
+    createPreNode,
+    createParagraphNode,
+    createTextNode,
+    createSpanStyleNode
+  };
 }
 
-const markToTag = {
-  bold: "strong",
-  italic: "em",
-  strike: "del",
-  code: "code"
-};
-const defaultTiptapToMDCMap = {
-  "doc": (node) => ({ type: "root", children: (node.content || []).flatMap((child) => tiptapNodeToMDC(child)) }),
-  "element": createElement,
-  "inline-element": createElement,
-  "span-style": (node) => createElement(node, "span", { props: cleanSpanProps(node.attrs) }),
-  "link": createLinkElement,
-  // 'link-element': createElement,
-  // 'link-block-element': createElement,
-  "text": createTextElement,
-  "comment": (node) => ({ type: "comment", value: node.attrs.text }),
-  "listItem": createListItemElement,
-  "slot": (node) => createElement(node, "template", { props: { [`v-slot:${node.attrs?.name}`]: "" } }),
-  "paragraph": (node) => createElement(node, "p"),
-  "bulletList": (node) => createElement(node, "ul"),
-  "orderedList": (node) => createElement(node, "ol", { props: { start: node.attrs?.start } }),
-  "heading": (node) => createHeadingElement(node),
-  "blockquote": (node) => createElement(node, "blockquote"),
-  "horizontalRule": (node) => createElement(node, "hr"),
-  "bold": (node) => createElement(node, "strong"),
-  "italic": (node) => createElement(node, "em"),
-  "strike": (node) => createElement(node, "del"),
-  "code": (node) => createElement(node, "code", { props: node.attrs }),
-  "codeBlock": (node) => createCodeBlockElement(node),
-  "image": (node) => createImageElement(node),
-  "video": (node) => createElement(node, "video"),
-  "binding": (node) => {
-    const defaultValue = node.attrs?.defaultValue;
-    const value = node.attrs?.value;
-    return { type: "element", tag: "binding", props: { defaultValue, value }, children: [] };
-  },
-  "br": (node) => createElement(node, "br")
-};
-let slugs = new Slugger();
-let shikiHighlighter;
-async function tiptapToMdc(node, options) {
-  slugs = new Slugger();
-  const mdc = {
-    body: {},
-    data: {}
+function createTiptapToMDC(options) {
+  const markToTag = {
+    bold: "strong",
+    italic: "em",
+    strike: "del",
+    code: "code"
   };
-  const nodeCopy = JSON.parse(JSON.stringify(node));
-  const fmIndex = nodeCopy.content?.findIndex((child) => child.type === "frontmatter");
-  if (fmIndex > -1) {
-    const fm = nodeCopy.content?.[fmIndex];
-    nodeCopy.content?.splice(fmIndex, 1);
-    try {
-      if (fm.attrs?.frontmatter && typeof fm.attrs.frontmatter === "object") {
-        mdc.data = fm.attrs.frontmatter;
-      } else {
-        mdc.data = {};
+  const tiptapToMDCMap = {
+    "doc": (node) => ({ type: "root", children: (node.content || []).flatMap(tiptapNodeToMDC) }),
+    "element": createElement,
+    "inline-element": createElement,
+    "span-style": (node) => createElement(node, "span", { props: cleanSpanProps(node.attrs) }),
+    "link": createLinkElement,
+    // 'link-element': createElement,
+    // 'link-block-element': createElement,
+    "text": createTextElement,
+    "comment": (node) => ({ type: "comment", value: node.attrs.text }),
+    "listItem": createListItemElement,
+    "slot": (node) => createElement(node, "template", { props: { [`v-slot:${node.attrs?.name}`]: "" } }),
+    "paragraph": (node) => createElement(node, "p"),
+    "bulletList": (node) => createElement(node, "ul"),
+    "orderedList": (node) => createElement(node, "ol", { props: { start: node.attrs?.start } }),
+    "heading": (node) => createHeadingElement(node),
+    "blockquote": (node) => createElement(node, "blockquote"),
+    "horizontalRule": (node) => createElement(node, "hr"),
+    "bold": (node) => createElement(node, "strong"),
+    "italic": (node) => createElement(node, "em"),
+    "strike": (node) => createElement(node, "del"),
+    "code": (node) => createElement(node, "code", { props: node.attrs }),
+    "codeBlock": (node) => createCodeBlockElement(node),
+    "image": (node) => createImageElement(node),
+    "video": (node) => createElement(node, "video"),
+    "binding": (node) => {
+      const defaultValue = node.attrs?.defaultValue;
+      const value = node.attrs?.value;
+      return { type: "element", tag: "binding", props: { defaultValue, value }, children: [] };
+    },
+    "br": (node) => createElement(node, "br"),
+    ...options?.customMap || {}
+  };
+  let slugs = new Slugger();
+  let shikiHighlighter;
+  async function tiptapToMdc(node, options2) {
+    slugs = new Slugger();
+    const mdc = {
+      body: {},
+      data: {}
+    };
+    const nodeCopy = JSON.parse(JSON.stringify(node));
+    const fmIndex = nodeCopy.content?.findIndex((child) => child.type === "frontmatter");
+    if (fmIndex > -1) {
+      const fm = nodeCopy.content?.[fmIndex];
+      nodeCopy.content?.splice(fmIndex, 1);
+      try {
+        if (fm.attrs?.frontmatter && typeof fm.attrs.frontmatter === "object") {
+          mdc.data = fm.attrs.frontmatter;
+        } else {
+          mdc.data = {};
+        }
+      } catch (error) {
+        mdc.data = {
+          __error__: error
+        };
       }
-    } catch (error) {
-      mdc.data = {
-        __error__: error
-      };
     }
+    mdc.body = tiptapNodeToMDC(nodeCopy);
+    await applyShikiSyntaxHighlighting(mdc.body, options2?.highlightTheme);
+    return mdc;
   }
-  mdc.body = tiptapNodeToMDC(nodeCopy, options?.tiptapToMDCMap);
-  await applyShikiSyntaxHighlighting(mdc.body, options?.highlightTheme);
-  return mdc;
-}
-function tiptapNodeToMDC(node, tiptapToMDCMap) {
-  if (!node) {
+  function tiptapNodeToMDC(node) {
+    if (!node) {
+      return {
+        type: "element",
+        tag: "p",
+        children: [],
+        props: {}
+      };
+    }
+    if (tiptapToMDCMap[node.type]) {
+      return tiptapToMDCMap[node.type](node);
+    }
+    if (node.type === "emoji") {
+      return { type: "text", value: getEmojiUnicode(node.attrs?.name || "") };
+    }
     return {
       type: "element",
       tag: "p",
-      children: [],
+      children: [
+        {
+          type: "text",
+          value: `--- Unknown node: ${node.type} ---`
+        }
+      ],
       props: {}
     };
   }
-  const nodes = {
-    ...tiptapToMDCMap,
-    ...defaultTiptapToMDCMap || {}
-  };
-  if (nodes[node.type]) {
-    return nodes[node.type](node);
-  }
-  if (node.type === "emoji") {
-    return { type: "text", value: getEmojiUnicode(node.attrs?.name || "") };
-  }
-  return {
-    type: "element",
-    tag: "p",
-    children: [
-      {
-        type: "text",
-        value: `--- Unknown node: ${node.type} ---`
+  function createElement(node, tag, extra = {}) {
+    const { props = {}, ...rest } = extra;
+    let children = node.content || [];
+    if (node.attrs?.props?.__tiptapWrap) {
+      if (children.length === 1 && children[0]?.type === "slot") {
+        const slot = children[0];
+        slot.content = unwrapParagraph(slot.content || []);
       }
-    ],
-    props: {}
-  };
-}
-function createElement(node, tag, extra = {}) {
-  const { props = {}, ...rest } = extra;
-  let children = node.content || [];
-  if (node.attrs?.props?.__tiptapWrap) {
-    if (children.length === 1 && children[0]?.type === "slot") {
-      const slot = children[0];
-      slot.content = unwrapParagraph(slot.content || []);
-    }
-    delete node.attrs.props.__tiptapWrap;
-  }
-  children = unwrapParagraph(children);
-  const propsArray = normalizeProps(node.attrs?.props || {}, props);
-  if (node.type === "paragraph") {
-    if (!children || children.length === 0) {
-      return { type: "element", tag: "p", children: [], props: {} };
+      delete node.attrs.props.__tiptapWrap;
     }
-    return createParagraphElement(node, propsArray, rest);
-  }
-  children = unwrapDefaultSlot(children);
-  return {
-    type: "element",
-    tag: tag || node.attrs?.tag,
-    children: node.children || children.flatMap((child) => tiptapNodeToMDC(child)),
-    ...rest,
-    props: Object.fromEntries(propsArray)
-  };
-}
-function createParagraphElement(node, propsArray, rest = {}) {
-  const blocks = [];
-  let currentBlockContent = [];
-  let currentBlockMark = null;
-  const getMarkInfo = (child) => {
-    if (child.type === "text" && child.marks?.length === 1 && child.marks?.[0]?.type) {
-      return child.marks[0];
-    }
-    if (child.type === "link-element" && child.content && child.content.length === 1 && child.content[0].type === "text" && child.content[0].marks?.length === 1 && child.content[0].marks?.[0]?.type) {
-      return child.content[0].marks?.[0];
-    }
-    return null;
-  };
-  const sameMark = (markA, markB) => {
-    if (!markA && !markB) {
-      return true;
-    }
-    if (!markA || !markB) {
-      return false;
-    }
-    return markA.type === markB.type && JSON.stringify(markA.attrs || {}) === JSON.stringify(markB.attrs || {});
-  };
-  node.content.forEach((child) => {
-    const mark = getMarkInfo(child);
-    if (!sameMark(mark, currentBlockMark)) {
-      if (currentBlockContent.length > 0) {
-        blocks.push({ mark: currentBlockMark, content: currentBlockContent });
+    children = unwrapParagraph(children);
+    const propsArray = normalizeProps(node.attrs?.props || {}, props);
+    if (node.type === "paragraph") {
+      if (!children || children.length === 0) {
+        return { type: "element", tag: "p", children: [], props: {} };
       }
-      currentBlockContent = [];
-      currentBlockMark = mark;
+      return createParagraphElement(node, propsArray, rest);
     }
-    currentBlockContent.push(child);
-  });
-  if (currentBlockContent.length > 0) {
-    blocks.push({ mark: currentBlockMark, content: currentBlockContent });
+    children = unwrapDefaultSlot(children);
+    return {
+      type: "element",
+      tag: tag || node.attrs?.tag,
+      children: node.children || children.flatMap(tiptapNodeToMDC),
+      ...rest,
+      props: Object.fromEntries(propsArray)
+    };
   }
-  const children = blocks.map((block) => {
-    if (block.content.length > 1 && block.mark && markToTag[block.mark.type]) {
-      block.content.forEach((child) => {
-        if (child.type === "text") {
-          delete child.marks;
-        } else if (child.type === "link-element") {
-          delete child.content[0].marks;
+  function createParagraphElement(node, propsArray, rest = {}) {
+    const blocks = [];
+    let currentBlockContent = [];
+    let currentBlockMark = null;
+    const getMarkInfo = (child) => {
+      if (child.type === "text" && child.marks?.length === 1 && child.marks?.[0]?.type) {
+        return child.marks[0];
+      }
+      if (child.type === "link-element" && child.content && child.content.length === 1 && child.content[0].type === "text" && child.content[0].marks?.length === 1 && child.content[0].marks?.[0]?.type) {
+        return child.content[0].marks?.[0];
+      }
+      return null;
+    };
+    const sameMark = (markA, markB) => {
+      if (!markA && !markB) {
+        return true;
+      }
+      if (!markA || !markB) {
+        return false;
+      }
+      return markA.type === markB.type && JSON.stringify(markA.attrs || {}) === JSON.stringify(markB.attrs || {});
+    };
+    node.content.forEach((child) => {
+      const mark = getMarkInfo(child);
+      if (!sameMark(mark, currentBlockMark)) {
+        if (currentBlockContent.length > 0) {
+          blocks.push({ mark: currentBlockMark, content: currentBlockContent });
         }
-      });
-      const props = block.mark.attrs && Object.keys(block.mark.attrs).length > 0 ? { props: block.mark.attrs } : {};
-      return {
-        type: "element",
-        tag: markToTag[block.mark.type],
-        children: block.content.flatMap((child) => tiptapNodeToMDC(child)),
-        ...props
-      };
+        currentBlockContent = [];
+        currentBlockMark = mark;
+      }
+      currentBlockContent.push(child);
+    });
+    if (currentBlockContent.length > 0) {
+      blocks.push({ mark: currentBlockMark, content: currentBlockContent });
     }
-    return block.content.flatMap((child) => tiptapNodeToMDC(child));
-  });
-  const mergedChildren = mergeSiblingsWithSameTag(children.flat(), Object.values(markToTag));
-  return {
-    type: "element",
-    tag: "p",
-    ...rest,
-    props: Object.fromEntries(propsArray),
-    children: mergedChildren
-  };
-}
-function createHeadingElement(node) {
-  const mdcNode = createElement(node, `h${node.attrs?.level}`);
-  mdcNode.props.id = slugs.slug(getNodeContent(node)).replace(/-+/g, "-").replace(/^-|-$/g, "").replace(/^(\d)/, "_$1");
-  return mdcNode;
-}
-function createCodeBlockElement(node) {
-  const mdcNode = createElement(node, "pre");
-  mdcNode.props.code = node.attrs?.code || getNodeContent(node);
-  mdcNode.props.language = node.attrs.language;
-  mdcNode.props.filename = node.attrs.filename;
-  mdcNode.children = [{
-    type: "element",
-    tag: "code",
-    props: { __ignoreMap: "" },
-    children: [{ type: "text", value: mdcNode.props.code }]
-  }];
-  return mdcNode;
-}
-function createImageElement(node) {
-  if (["nuxt-img", "nuxt-picture"].includes(node.attrs?.tag)) {
-    return createElement(node, node.attrs?.tag, { props: { alt: node.attrs?.alt, src: node.attrs?.src } });
-  } else {
-    return createElement(node, "img", { props: { alt: node.attrs?.alt, src: node.attrs?.src } });
+    const children = blocks.map((block) => {
+      if (block.content.length > 1 && block.mark && markToTag[block.mark.type]) {
+        block.content.forEach((child) => {
+          if (child.type === "text") {
+            delete child.marks;
+          } else if (child.type === "link-element") {
+            delete child.content[0].marks;
+          }
+        });
+        const props = block.mark.attrs && Object.keys(block.mark.attrs).length > 0 ? { props: block.mark.attrs } : {};
+        return {
+          type: "element",
+          tag: markToTag[block.mark.type],
+          children: block.content.flatMap(tiptapNodeToMDC),
+          ...props
+        };
+      }
+      return block.content.flatMap(tiptapNodeToMDC);
+    });
+    const mergedChildren = mergeSiblingsWithSameTag(children.flat(), Object.values(markToTag));
+    return {
+      type: "element",
+      tag: "p",
+      ...rest,
+      props: Object.fromEntries(propsArray),
+      children: mergedChildren
+    };
   }
-}
-function createLinkElement(node) {
-  const { href, target, rel, class: className, ...otherAttrs } = node.attrs || {};
-  const linkProps = {};
-  if (href) {
-    linkProps.href = href;
+  function createHeadingElement(node) {
+    const mdcNode = createElement(node, `h${node.attrs?.level}`);
+    mdcNode.props.id = slugs.slug(getNodeContent(node)).replace(/-+/g, "-").replace(/^-|-$/g, "").replace(/^(\d)/, "_$1");
+    return mdcNode;
   }
-  if (target) {
-    linkProps.target = target;
+  function createCodeBlockElement(node) {
+    const mdcNode = createElement(node, "pre");
+    mdcNode.props.code = node.attrs?.code || getNodeContent(node);
+    mdcNode.props.language = node.attrs.language;
+    mdcNode.props.filename = node.attrs.filename;
+    mdcNode.children = [{
+      type: "element",
+      tag: "code",
+      props: { __ignoreMap: "" },
+      children: [{ type: "text", value: mdcNode.props.code }]
+    }];
+    return mdcNode;
   }
-  if (rel) {
-    if (Array.isArray(rel)) {
-      linkProps.rel = rel.join(" ");
+  function createImageElement(node) {
+    if (["nuxt-img", "nuxt-picture"].includes(node.attrs?.tag)) {
+      return createElement(node, node.attrs?.tag, { props: { alt: node.attrs?.alt, src: node.attrs?.src } });
     } else {
-      linkProps.rel = rel;
+      return createElement(node, "img", { props: { alt: node.attrs?.alt, src: node.attrs?.src } });
     }
   }
-  if (className) {
-    linkProps.class = className;
-  }
-  Object.assign(linkProps, otherAttrs);
-  return { type: "element", tag: "a", props: linkProps, children: node.children || [] };
-}
-function createTextElement(node) {
-  const prefix = node.text?.match(/^\s+/)?.[0] || "";
-  const suffix = node.text?.match(/\s+$/)?.[0] || "";
-  const text = node.text?.trim() || "";
-  if (!node.marks?.length) {
-    return { type: "text", value: node.text };
-  }
-  const res = node.marks.reduce((acc, mark) => {
-    if (defaultTiptapToMDCMap[mark.type]) {
-      return defaultTiptapToMDCMap[mark.type]({ ...mark, children: [acc] });
+  function createLinkElement(node) {
+    const { href, target, rel, class: className, ...otherAttrs } = node.attrs || {};
+    const linkProps = {};
+    if (href) {
+      linkProps.href = href;
     }
-    return acc;
-  }, { type: "text", value: text });
-  return [
-    prefix ? { type: "text", value: prefix } : null,
-    res,
-    suffix ? { type: "text", value: suffix } : null
-  ].filter(Boolean);
-}
-function createListItemElement(node) {
-  node.content = (node.content || []).flatMap((child) => {
-    if (child.type === "paragraph") {
-      return child.content;
+    if (target) {
+      linkProps.target = target;
     }
-    return child;
-  });
-  return createElement(node, "li");
-}
-async function applyShikiSyntaxHighlighting(mdc, theme = { default: "github-light", dark: "github-dark" }) {
-  visit(mdc, (n) => n.tag !== void 0, (n) => Object.assign(n, { tagName: n.tag, properties: n.props }));
-  if (!shikiHighlighter) {
-    shikiHighlighter = createShikiHighlighter({ bundledThemes, bundledLangs: bundledLanguages, engine: createJavaScriptRegexEngine({ forgiving: true }) });
+    if (rel) {
+      if (Array.isArray(rel)) {
+        linkProps.rel = rel.join(" ");
+      } else {
+        linkProps.rel = rel;
+      }
+    }
+    if (className) {
+      linkProps.class = className;
+    }
+    Object.assign(linkProps, otherAttrs);
+    return { type: "element", tag: "a", props: linkProps, children: node.children || [] };
   }
-  const shikit = rehypeShiki({ theme, highlighter: shikiHighlighter });
-  await shikit(mdc);
-  visit(
-    mdc,
-    (n) => n.tagName !== void 0,
-    (n) => {
-      Object.assign(n, { tag: n.tagName, props: n.properties, tagName: void 0, properties: void 0 });
+  function createTextElement(node) {
+    const prefix = node.text?.match(/^\s+/)?.[0] || "";
+    const suffix = node.text?.match(/\s+$/)?.[0] || "";
+    const text = node.text?.trim() || "";
+    if (!node.marks?.length) {
+      return { type: "text", value: node.text };
     }
-  );
-  visit(
-    mdc,
-    (n) => n.tag === "pre",
-    (n) => {
-      n.children[0].children = n.children[0].children.filter((child) => child.type !== "text" || child.value.trim());
+    const res = node.marks.reduce((acc, mark) => {
+      if (tiptapToMDCMap[mark.type]) {
+        return tiptapToMDCMap[mark.type]({ ...mark, children: [acc] });
+      }
+      return acc;
+    }, { type: "text", value: text });
+    return [
+      prefix ? { type: "text", value: prefix } : null,
+      res,
+      suffix ? { type: "text", value: suffix } : null
+    ].filter(Boolean);
+  }
+  function createListItemElement(node) {
+    node.content = (node.content || []).flatMap((child) => {
+      if (child.type === "paragraph") {
+        return child.content;
+      }
+      return child;
+    });
+    return createElement(node, "li");
+  }
+  async function applyShikiSyntaxHighlighting(mdc, theme = { default: "github-light", dark: "github-dark" }) {
+    visit(mdc, (n) => n.tag !== void 0, (n) => Object.assign(n, { tagName: n.tag, properties: n.props }));
+    if (!shikiHighlighter) {
+      shikiHighlighter = createShikiHighlighter({ bundledThemes, bundledLangs: bundledLanguages, engine: createJavaScriptRegexEngine({ forgiving: true }) });
     }
-  );
-}
-function unwrapParagraph(content) {
-  if (content.length === 1 && content[0]?.type === "paragraph") {
-    return content[0].content || [];
+    const shikit = rehypeShiki({ theme, highlighter: shikiHighlighter });
+    await shikit(mdc);
+    visit(
+      mdc,
+      (n) => n.tagName !== void 0,
+      (n) => {
+        Object.assign(n, { tag: n.tagName, props: n.properties, tagName: void 0, properties: void 0 });
+      }
+    );
+    visit(
+      mdc,
+      (n) => n.tag === "pre",
+      (n) => {
+        n.children[0].children = n.children[0].children.filter((child) => child.type !== "text" || child.value.trim());
+      }
+    );
   }
-  return content;
-}
-function unwrapDefaultSlot(content) {
-  if (content.length === 1 && content[0]?.type === "slot" && content[0].attrs?.name === "default") {
-    return content[0].content || [];
+  function unwrapParagraph(content) {
+    if (content.length === 1 && content[0]?.type === "paragraph") {
+      return content[0].content || [];
+    }
+    return content;
   }
-  return content;
-}
-function mergeSiblingsWithSameTag(children, allowedTags) {
-  if (!Array.isArray(children)) {
-    return children;
+  function unwrapDefaultSlot(content) {
+    if (content.length === 1 && content[0]?.type === "slot" && content[0].attrs?.name === "default") {
+      return content[0].content || [];
+    }
+    return content;
   }
-  const merged = [];
-  let i = 0;
-  while (i < children.length) {
-    const current = children[i];
-    const next = children[i + 1];
-    const afterNext = children[i + 2];
-    if (current && afterNext && current.type === "element" && afterNext.type === "element" && current.tag === afterNext.tag && allowedTags.includes(current.tag) && JSON.stringify(current.props || {}) === JSON.stringify(afterNext.props || {}) && next && next.type === "text" && next.value === " ") {
-      merged.push({
-        ...current,
-        children: [
-          ...current.children || [],
-          { type: "text", value: " " },
-          ...afterNext.children || []
-        ]
-      });
-      i += 3;
-    } else {
-      merged.push(current);
-      i++;
+  function mergeSiblingsWithSameTag(children, allowedTags) {
+    if (!Array.isArray(children)) {
+      return children;
+    }
+    const merged = [];
+    let i = 0;
+    while (i < children.length) {
+      const current = children[i];
+      const next = children[i + 1];
+      const afterNext = children[i + 2];
+      if (current && afterNext && current.type === "element" && afterNext.type === "element" && current.tag === afterNext.tag && allowedTags.includes(current.tag) && JSON.stringify(current.props || {}) === JSON.stringify(afterNext.props || {}) && next && next.type === "text" && next.value === " ") {
+        merged.push({
+          ...current,
+          children: [
+            ...current.children || [],
+            { type: "text", value: " " },
+            ...afterNext.children || []
+          ]
+        });
+        i += 3;
+      } else {
+        merged.push(current);
+        i++;
+      }
     }
+    return merged;
   }
-  return merged;
-}
-function getNodeContent(node) {
-  if (node.type === "text") {
-    return node.text;
+  function getNodeContent(node) {
+    if (node.type === "text") {
+      return node.text;
+    }
+    let content = "";
+    node.content?.forEach((childNode) => {
+      content += getNodeContent(childNode);
+    });
+    return content;
   }
-  let content = "";
-  node.content?.forEach((childNode) => {
-    content += getNodeContent(childNode);
-  });
-  return content;
+  return {
+    tiptapToMdc,
+    tiptapNodeToMDC,
+    createParagraphElement,
+    createHeadingElement,
+    createCodeBlockElement,
+    createImageElement,
+    createLinkElement,
+    createTextElement,
+    createListItemElement
+  };
 }
 
-async function tiptapToMarkdown(node, options) {
-  const mdc = await tiptapToMdc(node, options);
-  return stringifyMarkdown(mdc.body, mdc.data);
-}
-async function markdownToTiptap(markdown, options) {
-  const mdc = await parseMarkdown(markdown);
-  return mdcToTiptap(mdc.body, options);
+function createMarkdown(options) {
+  const mdcToTiptap = createMDCToTiptap(options?.mdcToTiptap);
+  const tiptapToMDC = createTiptapToMDC(options?.tiptapToMDC);
+  async function tiptapToMarkdown(node) {
+    const mdc = await tiptapToMDC.tiptapToMdc(node);
+    return stringifyMarkdown(mdc.body, mdc.data);
+  }
+  async function markdownToTiptap(markdown) {
+    const mdc = await parseMarkdown(markdown);
+    return mdcToTiptap.mdcToTiptap(mdc.body);
+  }
+  return {
+    tiptapToMarkdown,
+    markdownToTiptap
+  };
 }
 
-export { createElement, createMark, createParagraphElement, createTipTapNode, markdownToTiptap, mdcNodeToTiptap, mdcToTiptap, tiptapNodeToMDC, tiptapToMarkdown, tiptapToMdc };
+export { createMDCToTiptap, createMarkdown, createTiptapToMDC };