@vizel/core 0.0.1-alpha.5 → 1.0.0

package/dist/index42.js

@@ -1,6 +1,696 @@
-import { TaskList as a } from "./index53.js";
-var e = a;
+import { Extension as H, commands as y, flattenExtensions as z, getExtensionField as C, generateJSON as L } from "@tiptap/core";
+import { marked as P } from "./index54.js";
+function _(e, n) {
+  const s = n.split(`
+`).flatMap((r) => [r, ""]).map((r) => `${e}${r}`).join(`
+`);
+  return s.slice(0, s.length - 1);
+}
+function O(e, n) {
+  const t = [];
+  return Array.from(e.keys()).forEach((s) => {
+    (!n || !n.marks || !n.marks.map((r) => r.type).includes(s)) && t.push(s);
+  }), t;
+}
+function F(e, n) {
+  const t = [];
+  return Array.from(n.entries()).forEach(([s, r]) => {
+    e.has(s) || t.push({ type: s, mark: r });
+  }), t;
+}
+function $(e, n, t, s) {
+  const r = !t, i = t && t.type === "text" && (!t.marks || t.marks.length === 0), o = t && t.type === "text" && t.marks && !s(n, new Map(t.marks.map((d) => [d.type, d]))), l = [];
+  if (r || i || o)
+    if (t && t.type === "text" && t.marks) {
+      const d = new Map(t.marks.map((a) => [a.type, a]));
+      Array.from(e.keys()).forEach((a) => {
+        d.has(a) || l.push(a);
+      });
+    } else (r || i) && l.push(...Array.from(e.keys()));
+  return l;
+}
+function N(e, n) {
+  let t = "";
+  return Array.from(e.keys()).reverse().forEach((s) => {
+    const r = e.get(s), i = n(s, r);
+    i && (t = i + t);
+  }), e.clear(), t;
+}
+function S(e, n, t) {
+  let s = "";
+  return Array.from(e.entries()).forEach(([r, i]) => {
+    const o = t(r, i);
+    o && (s += o), n.set(r, i);
+  }), s;
+}
+function R(e) {
+  const t = (e.raw || e.text || "").match(/^(\s*)[-+*]\s+\[([ xX])\]\s+/);
+  return t ? { isTask: !0, checked: t[2].toLowerCase() === "x", indentLevel: t[1].length } : { isTask: !1, indentLevel: 0 };
+}
+function E(e, n) {
+  return typeof e != "string" ? "json" : n;
+}
+var j = class {
+  /**
+   * Create a MarkdownManager.
+   * @param options.marked Optional marked instance to use (injected).
+   * @param options.markedOptions Optional options to pass to marked.setOptions
+   * @param options.indentation Indentation settings (style and size).
+   * @param options.extensions An array of Tiptap extensions to register for markdown parsing and rendering.
+   */
+  constructor(e) {
+    this.baseExtensions = [], this.extensions = [], this.lastParseResult = null;
+    var n, t, s, r, i;
+    this.markedInstance = (n = e?.marked) != null ? n : P, this.lexer = new this.markedInstance.Lexer(), this.indentStyle = (s = (t = e?.indentation) == null ? void 0 : t.style) != null ? s : "space", this.indentSize = (i = (r = e?.indentation) == null ? void 0 : r.size) != null ? i : 2, this.baseExtensions = e?.extensions || [], e?.markedOptions && typeof this.markedInstance.setOptions == "function" && this.markedInstance.setOptions(e.markedOptions), this.registry = /* @__PURE__ */ new Map(), this.nodeTypeRegistry = /* @__PURE__ */ new Map(), e?.extensions && (this.baseExtensions = e.extensions, z(e.extensions).forEach((l) => this.registerExtension(l, !1))), this.lexer = new this.markedInstance.Lexer();
+  }
+  /** Returns the underlying marked instance. */
+  get instance() {
+    return this.markedInstance;
+  }
+  /** Returns the correct indentCharacter (space or tab) */
+  get indentCharacter() {
+    return this.indentStyle === "space" ? " " : "	";
+  }
+  /** Returns the correct indentString repeated X times */
+  get indentString() {
+    return this.indentCharacter.repeat(this.indentSize);
+  }
+  /** Helper to quickly check whether a marked instance is available. */
+  hasMarked() {
+    return !!this.markedInstance;
+  }
+  /**
+   * Register a Tiptap extension (Node/Mark/Extension). This will read
+   * `markdownName`, `parseMarkdown`, `renderMarkdown` and `priority` from the
+   * extension config (using the same resolution used across the codebase).
+   */
+  registerExtension(e, n = !0) {
+    var t, s;
+    this.extensions.push(e);
+    const r = e.name, i = C(e, "markdownTokenName") || r, o = C(e, "parseMarkdown"), l = C(e, "renderMarkdown"), d = C(e, "markdownTokenizer"), a = (t = C(e, "markdownOptions")) != null ? t : null, c = (s = a?.indentsContent) != null ? s : !1, p = {
+      tokenName: i,
+      nodeName: r,
+      parseMarkdown: o,
+      renderMarkdown: l,
+      isIndenting: c,
+      tokenizer: d
+    };
+    if (i && o) {
+      const u = this.registry.get(i) || [];
+      u.push(p), this.registry.set(i, u);
+    }
+    if (l) {
+      const u = this.nodeTypeRegistry.get(r) || [];
+      u.push(p), this.nodeTypeRegistry.set(r, u);
+    }
+    d && this.hasMarked() && (this.registerTokenizer(d), n && (this.lexer = new this.markedInstance.Lexer()));
+  }
+  /**
+   * Register a custom tokenizer with marked.js for parsing non-standard markdown syntax.
+   */
+  registerTokenizer(e) {
+    if (!this.hasMarked())
+      return;
+    const { name: n, start: t, level: s = "inline", tokenize: r } = e, l = {
+      inlineTokens: (c) => this.lexer.inlineTokens(c),
+      blockTokens: (c) => this.lexer.blockTokens(c)
+    };
+    let d;
+    t ? d = typeof t == "function" ? t : (c) => c.indexOf(t) : d = (c) => {
+      const p = r(c, [], l);
+      return p && p.raw ? c.indexOf(p.raw) : -1;
+    };
+    const a = {
+      name: n,
+      level: s,
+      start: d,
+      tokenizer: (c, p) => {
+        const u = r(c, p, l);
+        if (u && u.type)
+          return {
+            ...u,
+            type: u.type || n,
+            raw: u.raw || "",
+            tokens: u.tokens || []
+          };
+      },
+      childTokens: []
+    };
+    this.markedInstance.use({
+      extensions: [a]
+    });
+  }
+  /** Get registered handlers for a token type and try each until one succeeds. */
+  getHandlersForToken(e) {
+    try {
+      return this.registry.get(e) || [];
+    } catch {
+      return [];
+    }
+  }
+  /** Get the first handler for a token type (for backwards compatibility). */
+  getHandlerForToken(e) {
+    const n = this.getHandlersForToken(e);
+    if (n.length > 0)
+      return n[0];
+    const t = this.getHandlersForNodeType(e);
+    return t.length > 0 ? t[0] : void 0;
+  }
+  /** Get registered handlers for a node type (for rendering). */
+  getHandlersForNodeType(e) {
+    try {
+      return this.nodeTypeRegistry.get(e) || [];
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Serialize a ProseMirror-like JSON document (or node array) to a Markdown string
+   * using registered renderers and fallback renderers.
+   */
+  serialize(e) {
+    return e ? Array.isArray(e) ? this.renderNodes(e, e) : this.renderNodes(e, e) : "";
+  }
+  /**
+   * Parse markdown string into Tiptap JSON document using registered extension handlers.
+   */
+  parse(e) {
+    if (!this.hasMarked())
+      throw new Error("No marked instance available for parsing");
+    const n = this.markedInstance.lexer(e);
+    return {
+      type: "doc",
+      content: this.parseTokens(n)
+    };
+  }
+  /**
+   * Convert an array of marked tokens into Tiptap JSON nodes using registered extension handlers.
+   */
+  parseTokens(e) {
+    return e.map((n) => this.parseToken(n)).filter((n) => n !== null).flatMap((n) => Array.isArray(n) ? n : [n]);
+  }
+  /**
+   * Parse a single token into Tiptap JSON using the appropriate registered handler.
+   */
+  parseToken(e) {
+    if (!e.type)
+      return null;
+    if (e.type === "list")
+      return this.parseListToken(e);
+    const n = this.getHandlersForToken(e.type), t = this.createParseHelpers();
+    if (n.find((r) => {
+      if (!r.parseMarkdown)
+        return !1;
+      const i = r.parseMarkdown(e, t), o = this.normalizeParseResult(i);
+      return o && (!Array.isArray(o) || o.length > 0) ? (this.lastParseResult = o, !0) : !1;
+    }) && this.lastParseResult) {
+      const r = this.lastParseResult;
+      return this.lastParseResult = null, r;
+    }
+    return this.parseFallbackToken(e);
+  }
+  /**
+   * Parse a list token, handling mixed bullet and task list items by splitting them into separate lists.
+   * This ensures that consecutive task items and bullet items are grouped and parsed as separate list nodes.
+   *
+   * @param token The list token to parse
+   * @returns Array of parsed list nodes, or null if parsing fails
+   */
+  parseListToken(e) {
+    if (!e.items || e.items.length === 0)
+      return this.parseTokenWithHandlers(e);
+    const n = e.items.some((l) => R(l).isTask), t = e.items.some((l) => !R(l).isTask);
+    if (!n || !t || this.getHandlersForToken("taskList").length === 0)
+      return this.parseTokenWithHandlers(e);
+    const s = [];
+    let r = [], i = null;
+    for (let l = 0; l < e.items.length; l += 1) {
+      const d = e.items[l], { isTask: a, checked: c, indentLevel: p } = R(d);
+      let u = d;
+      if (a) {
+        const m = (d.raw || d.text || "").split(`
+`), g = m[0].match(/^\s*[-+*]\s+\[([ xX])\]\s+(.*)$/), h = g ? g[2] : "";
+        let k = [];
+        if (m.length > 1 && m.slice(1).join(`
+`).trim()) {
+          const T = m.slice(1), v = T.filter((A) => A.trim());
+          if (v.length > 0) {
+            const A = Math.min(...v.map((x) => x.length - x.trimStart().length)), b = T.map((x) => x.trim() ? x.slice(A) : "").join(`
+`).trim();
+            b && (k = this.markedInstance.lexer(`${b}
+`));
+          }
+        }
+        u = {
+          type: "taskItem",
+          raw: "",
+          mainContent: h,
+          indentLevel: p,
+          checked: c ?? !1,
+          text: h,
+          tokens: this.lexer.inlineTokens(h),
+          nestedTokens: k
+        };
+      }
+      const w = a ? "taskList" : "list";
+      i !== w ? (r.length > 0 && s.push({ type: i, items: r }), r = [u], i = w) : r.push(u);
+    }
+    r.length > 0 && s.push({ type: i, items: r });
+    const o = [];
+    for (let l = 0; l < s.length; l += 1) {
+      const d = s[l], a = { ...e, type: d.type, items: d.items }, c = this.parseToken(a);
+      c && (Array.isArray(c) ? o.push(...c) : o.push(c));
+    }
+    return o.length > 0 ? o : null;
+  }
+  /**
+   * Parse a token using registered handlers (extracted for reuse).
+   */
+  parseTokenWithHandlers(e) {
+    if (!e.type)
+      return null;
+    const n = this.getHandlersForToken(e.type), t = this.createParseHelpers();
+    if (n.find((r) => {
+      if (!r.parseMarkdown)
+        return !1;
+      const i = r.parseMarkdown(e, t), o = this.normalizeParseResult(i);
+      return o && (!Array.isArray(o) || o.length > 0) ? (this.lastParseResult = o, !0) : !1;
+    }) && this.lastParseResult) {
+      const r = this.lastParseResult;
+      return this.lastParseResult = null, r;
+    }
+    return this.parseFallbackToken(e);
+  }
+  /**
+   * Creates helper functions for parsing markdown tokens.
+   * @returns An object containing helper functions for parsing.
+   */
+  createParseHelpers() {
+    return {
+      parseInline: (e) => this.parseInlineTokens(e),
+      parseChildren: (e) => this.parseTokens(e),
+      createTextNode: (e, n) => ({
+        type: "text",
+        text: e,
+        marks: n || void 0
+      }),
+      createNode: (e, n, t) => {
+        const s = {
+          type: e,
+          attrs: n || void 0,
+          content: t || void 0
+        };
+        return (!n || Object.keys(n).length === 0) && delete s.attrs, s;
+      },
+      applyMark: (e, n, t) => ({
+        mark: e,
+        content: n,
+        attrs: t && Object.keys(t).length > 0 ? t : void 0
+      })
+    };
+  }
+  /**
+   * Escape special regex characters in a string.
+   */
+  escapeRegex(e) {
+    return e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  /**
+   * Parse inline tokens (bold, italic, links, etc.) into text nodes with marks.
+   * This is the complex part that handles mark nesting and boundaries.
+   */
+  parseInlineTokens(e) {
+    var n, t, s, r;
+    const i = [];
+    for (let o = 0; o < e.length; o += 1) {
+      const l = e[o];
+      if (l.type === "text")
+        i.push({
+          type: "text",
+          text: l.text || ""
+        });
+      else if (l.type === "html") {
+        const d = ((t = (n = l.raw) != null ? n : l.text) != null ? t : "").toString(), a = /^<\/[\s]*[\w-]+/i.test(d), c = d.match(/^<[\s]*([\w-]+)(\s|>|\/|$)/i);
+        if (!a && c && !/\/>$/.test(d)) {
+          const u = c[1], w = this.escapeRegex(u), M = new RegExp(`^<\\/\\s*${w}\\b`, "i");
+          let m = -1;
+          const g = [d];
+          for (let h = o + 1; h < e.length; h += 1) {
+            const k = e[h], f = ((r = (s = k.raw) != null ? s : k.text) != null ? r : "").toString();
+            if (g.push(f), k.type === "html" && M.test(f)) {
+              m = h;
+              break;
+            }
+          }
+          if (m !== -1) {
+            const h = g.join(""), k = {
+              type: "html",
+              raw: h,
+              text: h,
+              block: !1
+            }, f = this.parseHTMLToken(k);
+            if (f) {
+              const T = this.normalizeParseResult(f);
+              Array.isArray(T) ? i.push(...T) : T && i.push(T);
+            }
+            o = m;
+            continue;
+          }
+        }
+        const p = this.parseHTMLToken(l);
+        if (p) {
+          const u = this.normalizeParseResult(p);
+          Array.isArray(u) ? i.push(...u) : u && i.push(u);
+        }
+      } else if (l.type) {
+        const d = this.getHandlerForToken(l.type);
+        if (d && d.parseMarkdown) {
+          const a = this.createParseHelpers(), c = d.parseMarkdown(l, a);
+          if (this.isMarkResult(c)) {
+            const p = this.applyMarkToContent(c.mark, c.content, c.attrs);
+            i.push(...p);
+          } else {
+            const p = this.normalizeParseResult(c);
+            Array.isArray(p) ? i.push(...p) : p && i.push(p);
+          }
+        } else l.tokens && i.push(...this.parseInlineTokens(l.tokens));
+      }
+    }
+    return i;
+  }
+  /**
+   * Apply a mark to content nodes.
+   */
+  applyMarkToContent(e, n, t) {
+    return n.map((s) => {
+      if (s.type === "text") {
+        const r = s.marks || [], i = t ? { type: e, attrs: t } : { type: e };
+        return {
+          ...s,
+          marks: [...r, i]
+        };
+      }
+      return {
+        ...s,
+        content: s.content ? this.applyMarkToContent(e, s.content, t) : void 0
+      };
+    });
+  }
+  /**
+  * Check if a parse result represents a mark to be applied.
+  */
+  isMarkResult(e) {
+    return e && typeof e == "object" && "mark" in e;
+  }
+  /**
+   * Normalize parse results to ensure they're valid JSONContent.
+   */
+  normalizeParseResult(e) {
+    return e ? this.isMarkResult(e) ? e.content : e : null;
+  }
+  /**
+   * Fallback parsing for common tokens when no specific handler is registered.
+   */
+  parseFallbackToken(e) {
+    switch (e.type) {
+      case "paragraph":
+        return {
+          type: "paragraph",
+          content: e.tokens ? this.parseInlineTokens(e.tokens) : []
+        };
+      case "heading":
+        return {
+          type: "heading",
+          attrs: { level: e.depth || 1 },
+          content: e.tokens ? this.parseInlineTokens(e.tokens) : []
+        };
+      case "text":
+        return {
+          type: "text",
+          text: e.text || ""
+        };
+      case "html":
+        return this.parseHTMLToken(e);
+      case "space":
+        return null;
+      default:
+        return e.tokens ? this.parseTokens(e.tokens) : null;
+    }
+  }
+  /**
+   * Parse HTML tokens using extensions' parseHTML methods.
+   * This allows HTML within markdown to be parsed according to extension rules.
+   */
+  parseHTMLToken(e) {
+    const n = e.text || e.raw || "";
+    if (!n.trim())
+      return null;
+    if (typeof window > "u")
+      return e.block ? {
+        type: "paragraph",
+        content: [
+          {
+            type: "text",
+            text: n
+          }
+        ]
+      } : {
+        type: "text",
+        text: n
+      };
+    try {
+      const t = L(n, this.baseExtensions);
+      return t.type === "doc" && t.content ? e.block ? t.content : t.content.length === 1 && t.content[0].type === "paragraph" && t.content[0].content ? t.content[0].content : t.content : t;
+    } catch (t) {
+      throw new Error(`Failed to parse HTML in markdown: ${t}`);
+    }
+  }
+  renderNodeToMarkdown(e, n, t = 0, s = 0) {
+    var r;
+    if (e.type === "text")
+      return e.text || "";
+    if (!e.type)
+      return "";
+    const i = this.getHandlerForToken(e.type);
+    if (!i)
+      return "";
+    const o = {
+      renderChildren: (a, c) => {
+        const p = i.isIndenting ? s + 1 : s;
+        return !Array.isArray(a) && a.content ? this.renderNodes(a.content, e, c || "", t, p) : this.renderNodes(a, e, c || "", t, p);
+      },
+      indent: (a) => this.indentString + a,
+      wrapInBlock: _
+    }, l = {
+      index: t,
+      level: s,
+      parentType: n?.type,
+      meta: {
+        parentAttrs: n?.attrs
+      }
+    };
+    return ((r = i.renderMarkdown) == null ? void 0 : r.call(i, e, o, l)) || "";
+  }
+  /**
+   * Render a node or an array of nodes. Parent type controls how children
+   * are joined (which determines newline insertion between children).
+   */
+  renderNodes(e, n, t = "", s = 0, r = 0) {
+    return Array.isArray(e) ? this.renderNodesWithMarkBoundaries(e, n, t, r) : e.type ? this.renderNodeToMarkdown(e, n, s, r) : "";
+  }
+  /**
+   * Render an array of nodes while properly tracking mark boundaries.
+   * This handles cases where marks span across multiple text nodes.
+   */
+  renderNodesWithMarkBoundaries(e, n, t = "", s = 0) {
+    const r = [], i = /* @__PURE__ */ new Map();
+    return e.forEach((o, l) => {
+      const d = l < e.length - 1 ? e[l + 1] : null;
+      if (o.type)
+        if (o.type === "text") {
+          let a = o.text || "";
+          const c = new Map((o.marks || []).map((h) => [h.type, h])), p = F(i, c), u = O(c, d);
+          let w = "";
+          if (u.length > 0) {
+            const h = a.match(/(\s+)$/);
+            h && (w = h[1], a = a.slice(0, -w.length));
+          }
+          u.forEach((h) => {
+            const k = c.get(h), f = this.getMarkClosing(h, k);
+            f && (a += f), i.has(h) && i.delete(h);
+          });
+          let M = "";
+          if (p.length > 0) {
+            const h = a.match(/^(\s+)/);
+            h && (M = h[1], a = a.slice(M.length));
+          }
+          p.forEach(({ type: h, mark: k }) => {
+            const f = this.getMarkOpening(h, k);
+            f && (a = f + a), u.includes(h) || i.set(h, k);
+          }), a = M + a;
+          const m = $(
+            i,
+            c,
+            d,
+            this.markSetsEqual.bind(this)
+          );
+          let g = "";
+          if (m.length > 0) {
+            const h = a.match(/(\s+)$/);
+            h && (g = h[1], a = a.slice(0, -g.length));
+          }
+          m.forEach((h) => {
+            const k = i.get(h), f = this.getMarkClosing(h, k);
+            f && (a += f), i.delete(h);
+          }), a += g, a += w, r.push(a);
+        } else {
+          const a = new Map(i), c = N(i, this.getMarkClosing.bind(this)), p = this.renderNodeToMarkdown(o, n, l, s), u = o.type === "hardBreak" ? "" : S(a, i, this.getMarkOpening.bind(this));
+          r.push(c + p + u);
+        }
+    }), r.join(t);
+  }
+  /**
+   * Get the opening markdown syntax for a mark type.
+   */
+  getMarkOpening(e, n) {
+    const t = this.getHandlersForNodeType(e), s = t.length > 0 ? t[0] : void 0;
+    if (!s || !s.renderMarkdown)
+      return "";
+    const r = "__TIPTAP_MARKDOWN_PLACEHOLDER__", i = {
+      type: e,
+      attrs: n.attrs || {},
+      content: [{ type: "text", text: r }]
+    };
+    try {
+      const o = s.renderMarkdown(
+        i,
+        {
+          renderChildren: () => r,
+          indent: (d) => d,
+          wrapInBlock: (d, a) => d + a
+        },
+        { index: 0, level: 0, parentType: "text", meta: {} }
+      ), l = o.indexOf(r);
+      return l >= 0 ? o.substring(0, l) : "";
+    } catch (o) {
+      throw new Error(`Failed to get mark opening for ${e}: ${o}`);
+    }
+  }
+  /**
+   * Get the closing markdown syntax for a mark type.
+   */
+  getMarkClosing(e, n) {
+    const t = this.getHandlersForNodeType(e), s = t.length > 0 ? t[0] : void 0;
+    if (!s || !s.renderMarkdown)
+      return "";
+    const r = "__TIPTAP_MARKDOWN_PLACEHOLDER__", i = {
+      type: e,
+      attrs: n.attrs || {},
+      content: [{ type: "text", text: r }]
+    };
+    try {
+      const o = s.renderMarkdown(
+        i,
+        {
+          renderChildren: () => r,
+          indent: (a) => a,
+          wrapInBlock: (a, c) => a + c
+        },
+        { index: 0, level: 0, parentType: "text", meta: {} }
+      ), l = o.indexOf(r), d = l + r.length;
+      return l >= 0 ? o.substring(d) : "";
+    } catch (o) {
+      throw new Error(`Failed to get mark closing for ${e}: ${o}`);
+    }
+  }
+  /**
+   * Check if two mark sets are equal.
+   */
+  markSetsEqual(e, n) {
+    return e.size !== n.size ? !1 : Array.from(e.keys()).every((t) => n.has(t));
+  }
+}, I = j, q = H.create({
+  name: "markdown",
+  addOptions() {
+    return {
+      indentation: { style: "space", size: 2 },
+      marked: void 0,
+      markedOptions: {}
+    };
+  },
+  addCommands() {
+    return {
+      setContent: (e, n) => {
+        if (!n?.contentType)
+          return y.setContent(e, n);
+        if (E(e, n?.contentType) !== "markdown" || !this.editor.markdown)
+          return y.setContent(e, n);
+        const s = this.editor.markdown.parse(e);
+        return y.setContent(s, n);
+      },
+      insertContent: (e, n) => {
+        if (!n?.contentType)
+          return y.insertContent(e, n);
+        if (E(e, n?.contentType) !== "markdown" || !this.editor.markdown)
+          return y.insertContent(e, n);
+        const s = this.editor.markdown.parse(e);
+        return y.insertContent(s, n);
+      },
+      insertContentAt: (e, n, t) => {
+        if (!t?.contentType)
+          return y.insertContentAt(e, n, t);
+        if (E(n, t?.contentType) !== "markdown" || !this.editor.markdown)
+          return y.insertContentAt(e, n, t);
+        const r = this.editor.markdown.parse(n);
+        return y.insertContentAt(e, r, t);
+      }
+    };
+  },
+  addStorage() {
+    return {
+      manager: new I({
+        indentation: this.options.indentation,
+        marked: this.options.marked,
+        markedOptions: this.options.markedOptions,
+        extensions: []
+      })
+    };
+  },
+  onBeforeCreate() {
+    if (this.editor.markdown) {
+      console.error(
+        "[tiptap][markdown]: There is already a `markdown` property on the editor instance. This might lead to unexpected behavior."
+      );
+      return;
+    }
+    if (this.storage.manager = new I({
+      indentation: this.options.indentation,
+      marked: this.options.marked,
+      markedOptions: this.options.markedOptions,
+      extensions: this.editor.extensionManager.baseExtensions
+    }), this.editor.markdown = this.storage.manager, this.editor.getMarkdown = () => this.storage.manager.serialize(this.editor.getJSON()), !this.editor.options.contentType || E(this.editor.options.content, this.editor.options.contentType) !== "markdown")
+      return;
+    if (!this.editor.markdown)
+      throw new Error(
+        '[tiptap][markdown]: The `contentType` option is set to "markdown", but the Markdown extension is not added to the editor. Please add the Markdown extension to use this feature.'
+      );
+    if (this.editor.options.content === void 0 || typeof this.editor.options.content != "string")
+      throw new Error(
+        '[tiptap][markdown]: The `contentType` option is set to "markdown", but the initial content is not a string. Please provide the initial content as a markdown string.'
+      );
+    const n = this.editor.markdown.parse(this.editor.options.content);
+    this.editor.options.content = n;
+  }
+});
 export {
-  a as TaskList,
-  e as default
+  q as Markdown,
+  j as MarkdownManager,
+  E as assumeContentType,
+  N as closeMarksBeforeNode,
+  O as findMarksToClose,
+  $ as findMarksToCloseAtEnd,
+  F as findMarksToOpen,
+  R as isTaskItem,
+  S as reopenMarksAfterNode,
+  _ as wrapInMarkdownBlock
 };