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

package/dist/index43.js

@@ -1,681 +1,240 @@
-import { Extension as H, commands as y, flattenExtensions as z, getExtensionField as C, generateJSON as L } from "@tiptap/core";
-import { marked as P } from "./index50.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;
+import { Mark as y, mergeAttributes as p, Extension as l } from "@tiptap/core";
+var d = 20, u = (t, e = 0) => {
+  const r = [];
+  return !t.children.length || e > d || Array.from(t.children).forEach((o) => {
+    o.tagName === "SPAN" ? r.push(o) : o.children.length && r.push(...u(o, e + 1));
+  }), r;
+}, f = (t) => {
+  if (!t.children.length)
+    return;
+  const e = u(t);
+  e && e.forEach((r) => {
+    var o, n;
+    const s = r.getAttribute("style"), i = (n = (o = r.parentElement) == null ? void 0 : o.closest("span")) == null ? void 0 : n.getAttribute("style");
+    r.setAttribute("style", `${i};${s}`);
+  });
+}, c = y.create({
+  name: "textStyle",
+  priority: 101,
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      mergeNestedSpanStyles: !0
     };
-    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: []
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "span",
+        consuming: !1,
+        getAttrs: (t) => t.hasAttribute("style") ? (this.options.mergeNestedSpanStyles && f(t), {}) : !1
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["span", p(this.options.HTMLAttributes, t), 0];
+  },
+  addCommands() {
+    return {
+      toggleTextStyle: (t) => ({ commands: e }) => e.toggleMark(this.name, t),
+      removeEmptyTextStyle: () => ({ tr: t }) => {
+        const { selection: e } = t;
+        return t.doc.nodesBetween(e.from, e.to, (r, o) => {
+          if (r.isTextblock)
+            return !0;
+          r.marks.filter((n) => n.type === this.type).some((n) => Object.values(n.attrs).some((s) => !!s)) || t.removeMark(o, o + r.nodeSize, this.type);
+        }), !0;
+      }
     };
-    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);
+}), m = l.create({
+  name: "backgroundColor",
+  addOptions() {
     return {
-      type: "doc",
-      content: this.parseTokens(n)
+      types: ["textStyle"]
     };
-  }
-  /**
-   * 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}
-`));
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          backgroundColor: {
+            default: null,
+            parseHTML: (t) => {
+              var e;
+              const r = t.getAttribute("style");
+              if (r) {
+                const o = r.split(";").map((n) => n.trim()).filter(Boolean);
+                for (let n = o.length - 1; n >= 0; n -= 1) {
+                  const s = o[n].split(":");
+                  if (s.length >= 2) {
+                    const i = s[0].trim().toLowerCase(), a = s.slice(1).join(":").trim();
+                    if (i === "background-color")
+                      return a.replace(/['"]+/g, "");
+                  }
+                }
+              }
+              return (e = t.style.backgroundColor) == null ? void 0 : e.replace(/['"]+/g, "");
+            },
+            renderHTML: (t) => t.backgroundColor ? {
+              style: `background-color: ${t.backgroundColor}`
+            } : {}
           }
         }
-        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() {
+    ];
+  },
+  addCommands() {
     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
-      })
+      setBackgroundColor: (t) => ({ chain: e }) => e().setMark("textStyle", { backgroundColor: t }).run(),
+      unsetBackgroundColor: () => ({ chain: t }) => t().setMark("textStyle", { backgroundColor: null }).removeEmptyTextStyle().run()
     };
   }
-  /**
-   * 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;
+}), g = l.create({
+  name: "color",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          color: {
+            default: null,
+            parseHTML: (t) => {
+              var e;
+              const r = t.getAttribute("style");
+              if (r) {
+                const o = r.split(";").map((n) => n.trim()).filter(Boolean);
+                for (let n = o.length - 1; n >= 0; n -= 1) {
+                  const s = o[n].split(":");
+                  if (s.length >= 2) {
+                    const i = s[0].trim().toLowerCase(), a = s.slice(1).join(":").trim();
+                    if (i === "color")
+                      return a.replace(/['"]+/g, "");
+                  }
+                }
+              }
+              return (e = t.style.color) == null ? void 0 : e.replace(/['"]+/g, "");
+            },
+            renderHTML: (t) => t.color ? {
+              style: `color: ${t.color}`
+            } : {}
           }
         }
-        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;
-    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: {}
+    ];
+  },
+  addCommands() {
+    return {
+      setColor: (t) => ({ chain: e }) => e().setMark("textStyle", { color: t }).run(),
+      unsetColor: () => ({ chain: t }) => t().setMark("textStyle", { color: null }).removeEmptyTextStyle().run()
     };
-    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)
-          );
-          let g = "";
-          if (m.length > 0) {
-            const h = a.match(/(\s+)$/);
-            h && (g = h[1], a = a.slice(0, -g.length));
+}), h = l.create({
+  name: "fontFamily",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          fontFamily: {
+            default: null,
+            parseHTML: (t) => t.style.fontFamily,
+            renderHTML: (t) => t.fontFamily ? {
+              style: `font-family: ${t.fontFamily}`
+            } : {}
           }
-          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);
-  }
-  /**
-   * 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 }]
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      setFontFamily: (t) => ({ chain: e }) => e().setMark("textStyle", { fontFamily: t }).run(),
+      unsetFontFamily: () => ({ chain: t }) => t().setMark("textStyle", { fontFamily: null }).removeEmptyTextStyle().run()
     };
-    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",
+}), S = l.create({
+  name: "fontSize",
   addOptions() {
     return {
-      indentation: { style: "space", size: 2 },
-      marked: void 0,
-      markedOptions: {}
+      types: ["textStyle"]
     };
   },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          fontSize: {
+            default: null,
+            parseHTML: (t) => t.style.fontSize,
+            renderHTML: (t) => t.fontSize ? {
+              style: `font-size: ${t.fontSize}`
+            } : {}
+          }
+        }
+      }
+    ];
+  },
   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);
-      }
+      setFontSize: (t) => ({ chain: e }) => e().setMark("textStyle", { fontSize: t }).run(),
+      unsetFontSize: () => ({ chain: t }) => t().setMark("textStyle", { fontSize: null }).removeEmptyTextStyle().run()
     };
-  },
-  addStorage() {
+  }
+}), b = l.create({
+  name: "lineHeight",
+  addOptions() {
     return {
-      manager: new b({
-        indentation: this.options.indentation,
-        marked: this.options.marked,
-        markedOptions: this.options.markedOptions,
-        extensions: []
-      })
+      types: ["textStyle"]
     };
   },
-  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;
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          lineHeight: {
+            default: null,
+            parseHTML: (t) => t.style.lineHeight,
+            renderHTML: (t) => t.lineHeight ? {
+              style: `line-height: ${t.lineHeight}`
+            } : {}
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      setLineHeight: (t) => ({ chain: e }) => e().setMark("textStyle", { lineHeight: t }).run(),
+      unsetLineHeight: () => ({ chain: t }) => t().setMark("textStyle", { lineHeight: null }).removeEmptyTextStyle().run()
+    };
+  }
+});
+l.create({
+  name: "textStyleKit",
+  addExtensions() {
+    const t = [];
+    return this.options.backgroundColor !== !1 && t.push(m.configure(this.options.backgroundColor)), this.options.color !== !1 && t.push(g.configure(this.options.color)), this.options.fontFamily !== !1 && t.push(h.configure(this.options.fontFamily)), this.options.fontSize !== !1 && t.push(S.configure(this.options.fontSize)), this.options.lineHeight !== !1 && t.push(b.configure(this.options.lineHeight)), this.options.textStyle !== !1 && t.push(c.configure(this.options.textStyle)), t;
   }
 });
 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
+  m as BackgroundColor,
+  g as Color,
+  h as FontFamily,
+  S as FontSize,
+  b as LineHeight,
+  c as TextStyle
 };