@vizel/core 0.0.1-alpha.1 → 0.0.1-alpha.3

package/dist/index40.js

@@ -1,329 +1,681 @@
-import { Node as L, createBlockMarkdownSpec as N, isActive as F, findChildren as b, defaultBlockAt as x, findParentNode as w, mergeAttributes as v } from "@tiptap/core";
-import { Plugin as z, PluginKey as G, TextSelection as R, Selection as D } from "./index41.js";
-import { GapCursor as H } from "./index52.js";
-var S = (t, s) => s.view.domAtPos(t).node.offsetParent !== null, W = (t, s, o) => {
-  for (let e = t.depth; e > 0; e -= 1) {
-    const n = t.node(e), c = s(n), r = S(t.start(e), o);
-    if (c && r)
-      return {
-        pos: e > 0 ? t.before(e) : 0,
-        start: t.start(e),
-        depth: e,
-        node: n
-      };
+import { Extension as H, commands as y, flattenExtensions as z, getExtensionField as C, generateJSON as L } from "@tiptap/core";
+import { marked as P } from "./index52.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 N(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 $(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();
   }
-}, O = (t, s) => {
-  const { state: o, view: e, extensionManager: n } = t, { schema: c, selection: r } = o, { empty: d, $anchor: l } = r, i = !!n.extensions.find((u) => u.name === "gapCursor");
-  if (!d || l.parent.type !== c.nodes.detailsSummary || !i || s === "right" && l.parentOffset !== l.parent.nodeSize - 2)
-    return !1;
-  const a = w((u) => u.type === c.nodes.details)(r);
-  if (!a)
-    return !1;
-  const p = b(a.node, (u) => u.type === c.nodes.detailsContent);
-  if (!p.length || S(a.start + p[0].pos + 1, t))
-    return !1;
-  const m = o.doc.resolve(a.pos + a.node.nodeSize), h = H.findFrom(m, 1, !1);
-  if (!h)
-    return !1;
-  const { tr: y } = o, C = new H(h);
-  return y.setSelection(C), y.scrollIntoView(), e.dispatch(y), !0;
-}, j = L.create({
-  name: "details",
-  content: "detailsSummary detailsContent",
-  group: "block",
-  defining: !0,
-  isolating: !0,
-  // @ts-ignore reason: `allowGapCursor` is not a valid property by default, but the `GapCursor` extension adds it to the Nodeconfig type
-  allowGapCursor: !1,
-  addOptions() {
+  /** 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 {
-      persist: !1,
-      openClassName: "is-open",
-      HTMLAttributes: {}
+      type: "doc",
+      content: this.parseTokens(n)
     };
-  },
-  addAttributes() {
-    return this.options.persist ? {
-      open: {
-        default: !1,
-        parseHTML: (t) => t.hasAttribute("open"),
-        renderHTML: ({ open: t }) => t ? { open: "" } : {}
-      }
-    } : [];
-  },
-  parseHTML() {
-    return [
-      {
-        tag: "details"
+  }
+  /**
+   * 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)), I = T.map((x) => x.trim() ? x.slice(A) : "").join(`
+`).trim();
+            I && (k = this.markedInstance.lexer(`${I}
+`));
+          }
+        }
+        u = {
+          type: "taskItem",
+          raw: "",
+          mainContent: h,
+          indentLevel: p,
+          checked: c ?? !1,
+          text: h,
+          tokens: this.lexer.inlineTokens(h),
+          nestedTokens: k
+        };
       }
-    ];
-  },
-  renderHTML({ HTMLAttributes: t }) {
-    return ["details", v(this.options.HTMLAttributes, t), 0];
-  },
-  ...N({
-    nodeName: "details",
-    content: "block"
-  }),
-  addNodeView() {
-    return ({ editor: t, getPos: s, node: o, HTMLAttributes: e }) => {
-      const n = document.createElement("div"), c = v(this.options.HTMLAttributes, e, {
-        "data-type": this.name
-      });
-      Object.entries(c).forEach(([i, a]) => n.setAttribute(i, a));
-      const r = document.createElement("button");
-      r.type = "button", n.append(r);
-      const d = document.createElement("div");
-      n.append(d);
-      const l = (i) => {
-        if (i !== void 0)
-          if (i) {
-            if (n.classList.contains(this.options.openClassName))
-              return;
-            n.classList.add(this.options.openClassName);
-          } else {
-            if (!n.classList.contains(this.options.openClassName))
-              return;
-            n.classList.remove(this.options.openClassName);
+      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;
           }
-        else
-          n.classList.toggle(this.options.openClassName);
-        const a = new Event("toggleDetailsContent"), p = d.querySelector(':scope > div[data-type="detailsContent"]');
-        p?.dispatchEvent(a);
-      };
-      return o.attrs.open && setTimeout(() => l()), r.addEventListener("click", () => {
-        if (l(), !this.options.persist) {
-          t.commands.focus(void 0, { scrollIntoView: !1 });
-          return;
         }
-        if (t.isEditable && typeof s == "function") {
-          const { from: i, to: a } = t.state.selection;
-          t.chain().command(({ tr: p }) => {
-            const f = s();
-            if (!f)
-              return !1;
-            const m = p.doc.nodeAt(f);
-            return m?.type !== this.type ? !1 : (p.setNodeMarkup(f, void 0, {
-              open: !m.attrs.open
-            }), !0);
-          }).setTextSelection({
-            from: i,
-            to: a
-          }).focus(void 0, { scrollIntoView: !1 }).run();
+        const p = this.parseHTMLToken(l);
+        if (p) {
+          const u = this.normalizeParseResult(p);
+          Array.isArray(u) ? i.push(...u) : u && i.push(u);
         }
-      }), {
-        dom: n,
-        contentDOM: d,
-        ignoreMutation(i) {
-          return i.type === "selection" ? !1 : !n.contains(i.target) || n === i.target;
-        },
-        update: (i) => i.type !== this.type ? !1 : (i.attrs.open !== void 0 && l(i.attrs.open), !0)
-      };
-    };
-  },
-  addCommands() {
-    return {
-      setDetails: () => ({ state: t, chain: s }) => {
-        var o;
-        const { schema: e, selection: n } = t, { $from: c, $to: r } = n, d = c.blockRange(r);
-        if (!d)
-          return !1;
-        const l = t.doc.slice(d.start, d.end);
-        if (!e.nodes.detailsContent.contentMatch.matchFragment(l.content))
-          return !1;
-        const a = ((o = l.toJSON()) == null ? void 0 : o.content) || [];
-        return s().insertContentAt(
-          { from: d.start, to: d.end },
-          {
-            type: this.name,
-            content: [
-              {
-                type: "detailsSummary"
-              },
-              {
-                type: "detailsContent",
-                content: a
-              }
-            ]
+      } 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);
           }
-        ).setTextSelection(d.start + 2).run();
-      },
-      unsetDetails: () => ({ state: t, chain: s }) => {
-        const { selection: o, schema: e } = t, n = w((u) => u.type === this.type)(o);
-        if (!n)
-          return !1;
-        const c = b(n.node, (u) => u.type === e.nodes.detailsSummary), r = b(n.node, (u) => u.type === e.nodes.detailsContent);
-        if (!c.length || !r.length)
-          return !1;
-        const d = c[0], l = r[0], i = n.pos, a = t.doc.resolve(i), p = i + n.node.nodeSize, f = { from: i, to: p }, m = l.node.content.toJSON() || [], h = a.parent.type.contentMatch.defaultType, C = [h?.create(null, d.node.content).toJSON(), ...m];
-        return s().insertContentAt(f, C).setTextSelection(i + 1).run();
+        } else l.tokens && i.push(...this.parseInlineTokens(l.tokens));
       }
-    };
-  },
-  addKeyboardShortcuts() {
-    return {
-      Backspace: () => {
-        const { schema: t, selection: s } = this.editor.state, { empty: o, $anchor: e } = s;
-        return !o || e.parent.type !== t.nodes.detailsSummary ? !1 : e.parentOffset !== 0 ? this.editor.commands.command(({ tr: n }) => {
-          const c = e.pos - 1, r = e.pos;
-          return n.delete(c, r), !0;
-        }) : this.editor.commands.unsetDetails();
-      },
-      // Creates a new node below it if it is closed.
-      // Otherwise inside `DetailsContent`.
-      Enter: ({ editor: t }) => {
-        const { state: s, view: o } = t, { schema: e, selection: n } = s, { $head: c } = n;
-        if (c.parent.type !== e.nodes.detailsSummary)
-          return !1;
-        const r = S(c.after() + 1, t), d = r ? s.doc.nodeAt(c.after()) : c.node(-2);
-        if (!d)
-          return !1;
-        const l = r ? 0 : c.indexAfter(-1), i = x(d.contentMatchAt(l));
-        if (!i || !d.canReplaceWith(l, l, i))
-          return !1;
-        const a = i.createAndFill();
-        if (!a)
-          return !1;
-        const p = r ? c.after() + 1 : c.after(-1), f = s.tr.replaceWith(p, p, a), m = f.doc.resolve(p), h = D.near(m, 1);
-        return f.setSelection(h), f.scrollIntoView(), o.dispatch(f), !0;
+    }
+    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;
+    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);
       },
-      // The default gapcursor implementation can’t handle hidden content, so we need to fix this.
-      ArrowRight: ({ editor: t }) => O(t, "right"),
-      // The default gapcursor implementation can’t handle hidden content, so we need to fix this.
-      ArrowDown: ({ editor: t }) => O(t, "down")
+      indent: (a) => this.indentString + a,
+      wrapInBlock: _
+    }, l = {
+      index: t,
+      level: s,
+      parentType: n?.type,
+      meta: {}
     };
-  },
-  addProseMirrorPlugins() {
-    return [
-      // This plugin prevents text selections within the hidden content in `DetailsContent`.
-      // The cursor is moved to the next visible position.
-      new z({
-        key: new G("detailsSelection"),
-        appendTransaction: (t, s, o) => {
-          const { editor: e, type: n } = this;
-          if (e.view.composing || !t.some((u) => u.selectionSet) || !s.selection.empty || !o.selection.empty || !F(o, n.name))
-            return;
-          const { $from: l } = o.selection;
-          if (S(l.pos, e))
-            return;
-          const a = W(l, (u) => u.type === n, e);
-          if (!a)
-            return;
-          const p = b(
-            a.node,
-            (u) => u.type === o.schema.nodes.detailsSummary
+    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 = N(
+            i,
+            c,
+            d,
+            this.markSetsEqual.bind(this)
           );
-          if (!p.length)
-            return;
-          const f = p[0], h = (s.selection.from < o.selection.from ? "forward" : "backward") === "forward" ? a.start + f.pos : a.pos + f.pos + f.node.nodeSize, y = R.create(o.doc, h);
-          return o.tr.setSelection(y);
+          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 = $(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);
   }
-}), q = L.create({
-  name: "detailsContent",
-  content: "block+",
-  defining: !0,
-  selectable: !1,
-  addOptions() {
-    return {
-      HTMLAttributes: {}
+  /**
+   * 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 }]
     };
-  },
-  parseHTML() {
-    return [
-      {
-        tag: `div[data-type="${this.name}"]`
-      }
-    ];
-  },
-  renderHTML({ HTMLAttributes: t }) {
-    return ["div", v(this.options.HTMLAttributes, t, { "data-type": this.name }), 0];
-  },
-  addNodeView() {
-    return ({ HTMLAttributes: t }) => {
-      const s = document.createElement("div"), o = v(this.options.HTMLAttributes, t, {
-        "data-type": this.name,
-        hidden: "hidden"
-      });
-      return Object.entries(o).forEach(([e, n]) => s.setAttribute(e, n)), s.addEventListener("toggleDetailsContent", () => {
-        s.toggleAttribute("hidden");
-      }), {
-        dom: s,
-        contentDOM: s,
-        ignoreMutation(e) {
-          return e.type === "selection" ? !1 : !s.contains(e.target) || s === e.target;
+    try {
+      const o = s.renderMarkdown(
+        i,
+        {
+          renderChildren: () => r,
+          indent: (d) => d,
+          wrapInBlock: (d, a) => d + a
         },
-        update: (e) => e.type === this.type
-      };
+        { 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));
+  }
+}, b = j, q = H.create({
+  name: "markdown",
+  addOptions() {
+    return {
+      indentation: { style: "space", size: 2 },
+      marked: void 0,
+      markedOptions: {}
     };
   },
-  addKeyboardShortcuts() {
+  addCommands() {
     return {
-      // Escape node on double enter
-      Enter: ({ editor: t }) => {
-        const { state: s, view: o } = t, { selection: e } = s, { $from: n, empty: c } = e, r = w(($) => $.type === this.type)(e);
-        if (!c || !r || !r.node.childCount)
-          return !1;
-        const d = n.index(r.depth), { childCount: l } = r.node;
-        if (!(l === d + 1))
-          return !1;
-        const a = r.node.type.contentMatch.defaultType, p = a?.createAndFill();
-        if (!p)
-          return !1;
-        const f = s.doc.resolve(r.pos + 1), m = l - 1, h = r.node.child(m), y = f.posAtIndex(m, r.depth);
-        if (!h.eq(p))
-          return !1;
-        const u = n.node(-3);
-        if (!u)
-          return !1;
-        const A = n.indexAfter(-3), M = x(u.contentMatchAt(A));
-        if (!M || !u.canReplaceWith(A, A, M))
-          return !1;
-        const E = M.createAndFill();
-        if (!E)
-          return !1;
-        const { tr: g } = s, T = n.after(-2);
-        g.replaceWith(T, T, E);
-        const k = g.doc.resolve(T), I = D.near(k, 1);
-        g.setSelection(I);
-        const V = y, P = y + h.nodeSize;
-        return g.delete(V, P), g.scrollIntoView(), o.dispatch(g), !0;
+      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);
       }
     };
   },
-  ...N({
-    nodeName: "detailsContent"
-  })
-}), _ = L.create({
-  name: "detailsSummary",
-  content: "text*",
-  defining: !0,
-  selectable: !1,
-  isolating: !0,
-  addOptions() {
+  addStorage() {
     return {
-      HTMLAttributes: {}
+      manager: new b({
+        indentation: this.options.indentation,
+        marked: this.options.marked,
+        markedOptions: this.options.markedOptions,
+        extensions: []
+      })
     };
   },
-  parseHTML() {
-    return [
-      {
-        tag: "summary"
-      }
-    ];
-  },
-  renderHTML({ HTMLAttributes: t }) {
-    return ["summary", v(this.options.HTMLAttributes, t), 0];
-  },
-  ...N({
-    nodeName: "detailsSummary",
-    content: "inline"
-  })
+  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 b({
+      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 {
-  j as Details,
-  q as DetailsContent,
-  _ as DetailsSummary
+  q as Markdown,
+  j as MarkdownManager,
+  E as assumeContentType,
+  $ as closeMarksBeforeNode,
+  O as findMarksToClose,
+  N as findMarksToCloseAtEnd,
+  F as findMarksToOpen,
+  R as isTaskItem,
+  S as reopenMarksAfterNode,
+  _ as wrapInMarkdownBlock
 };