@vizel/core 0.0.1-alpha.5 → 0.0.1-alpha.6

package/dist/index40.js

@@ -1,681 +1,329 @@
-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();
-  }
-  /** 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) : "";
+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 "./index51.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
+      };
   }
-  /**
-   * 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);
+}, 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() {
     return {
-      type: "doc",
-      content: this.parseTokens(n)
+      persist: !1,
+      openClassName: "is-open",
+      HTMLAttributes: {}
     };
-  }
-  /**
-   * 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
-        };
+  },
+  addAttributes() {
+    return this.options.persist ? {
+      open: {
+        default: !1,
+        parseHTML: (t) => t.hasAttribute("open"),
+        renderHTML: ({ open: t }) => t ? { open: "" } : {}
       }
-      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;
+    } : [];
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "details"
+      }
+    ];
+  },
+  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);
           }
+        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;
         }
-        const p = this.parseHTMLToken(l);
-        if (p) {
-          const u = this.normalizeParseResult(p);
-          Array.isArray(u) ? i.push(...u) : u && i.push(u);
+        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();
         }
-      } 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);
+      }), {
+        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 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]
-        };
+        ).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();
       }
-      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);
+    };
+  },
+  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;
       },
-      indent: (a) => this.indentString + a,
-      wrapInBlock: _
-    }, l = {
-      index: t,
-      level: s,
-      parentType: n?.type,
-      meta: {}
+      // 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")
     };
-    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)
+  },
+  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
           );
-          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);
+          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);
         }
-    }), 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));
+      })
+    ];
   }
-}, b = j, q = H.create({
-  name: "markdown",
+}), q = L.create({
+  name: "detailsContent",
+  content: "block+",
+  defining: !0,
+  selectable: !1,
   addOptions() {
     return {
-      indentation: { style: "space", size: 2 },
-      marked: void 0,
-      markedOptions: {}
+      HTMLAttributes: {}
     };
   },
-  addCommands() {
+  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;
+        },
+        update: (e) => e.type === this.type
+      };
+    };
+  },
+  addKeyboardShortcuts() {
     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);
+      // 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;
       }
     };
   },
-  addStorage() {
+  ...N({
+    nodeName: "detailsContent"
+  })
+}), _ = L.create({
+  name: "detailsSummary",
+  content: "text*",
+  defining: !0,
+  selectable: !1,
+  isolating: !0,
+  addOptions() {
     return {
-      manager: new b({
-        indentation: this.options.indentation,
-        marked: this.options.marked,
-        markedOptions: this.options.markedOptions,
-        extensions: []
-      })
+      HTMLAttributes: {}
     };
   },
-  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;
-  }
+  parseHTML() {
+    return [
+      {
+        tag: "summary"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["summary", v(this.options.HTMLAttributes, t), 0];
+  },
+  ...N({
+    nodeName: "detailsSummary",
+    content: "inline"
+  })
 });
 export {
-  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
+  j as Details,
+  q as DetailsContent,
+  _ as DetailsSummary
 };