@pixerate/editor 0.4.4 → 0.5.0

package/dist/index.cjs

@@ -40,6 +40,7 @@ __export(src_exports, {
   GradientText: () => GradientText,
   INSTRUCTION_REGEX: () => INSTRUCTION_REGEX,
   LoadingNode: () => LoadingNode,
+  Markdown: () => Markdown2,
   Mention: () => Mention,
   SlashCommands: () => SlashCommands,
   SmilieReplacer: () => SmilieReplacer,
@@ -58,6 +59,7 @@ __export(src_exports, {
   extractTemplateNames: () => extractTemplateNames,
   extractVariableNames: () => extractVariableNames,
   findHexColors: () => findHexColors,
+  getEditorMarkdown: () => getEditorMarkdown,
   getEditorText: () => getEditorText,
   getLatestVersion: () => getLatestVersion,
   htmlToPlainText: () => htmlToPlainText,
@@ -65,6 +67,7 @@ __export(src_exports, {
   instructionRegex: () => instructionRegex,
   mapRawOffsetToResolved: () => mapRawOffsetToResolved,
   mapResolvedOffsetToRaw: () => mapResolvedOffsetToRaw,
+  markdownToTipTapHtml: () => markdownToTipTapHtml,
   parseCellReference: () => parseCellReference,
   parseFormula: () => parseFormula,
   parseRange: () => parseRange,
@@ -890,7 +893,7 @@ var FontSize = import_core7.Extension.create({
 });
 
 // src/extensions/rich-text-preset.ts
-var import_core8 = require("@tiptap/core");
+var import_core9 = require("@tiptap/core");
 var _StarterKit = __toESM(require("@tiptap/starter-kit"), 1);
 var _Color = __toESM(require("@tiptap/extension-color"), 1);
 var _Highlight = __toESM(require("@tiptap/extension-highlight"), 1);
@@ -949,20 +952,1033 @@ function createMentionExtension(options = {}) {
   });
 }
 
-// src/extensions/rich-text-preset.ts
+// ../../node_modules/.pnpm/tiptap-markdown@0.8.10_@tiptap+core@2.27.3_@tiptap+pm@2.27.3_/node_modules/tiptap-markdown/dist/tiptap-markdown.es.js
+var import_core8 = require("@tiptap/core");
+var import_prosemirror_markdown = require("prosemirror-markdown");
+var import_markdown_it = __toESM(require("markdown-it"), 1);
+var import_model = require("@tiptap/pm/model");
+var import_markdown_it_task_lists = __toESM(require("markdown-it-task-lists"), 1);
+var import_state4 = require("@tiptap/pm/state");
+var __defProp2 = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var MarkdownTightLists = import_core8.Extension.create({
+  name: "markdownTightLists",
+  addOptions: () => ({
+    tight: true,
+    tightClass: "tight",
+    listTypes: ["bulletList", "orderedList"]
+  }),
+  addGlobalAttributes() {
+    return [{
+      types: this.options.listTypes,
+      attributes: {
+        tight: {
+          default: this.options.tight,
+          parseHTML: (element) => element.getAttribute("data-tight") === "true" || !element.querySelector("p"),
+          renderHTML: (attributes) => ({
+            class: attributes.tight ? this.options.tightClass : null,
+            "data-tight": attributes.tight ? "true" : null
+          })
+        }
+      }
+    }];
+  },
+  addCommands() {
+    var _this = this;
+    return {
+      toggleTight: function() {
+        let tight = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null;
+        return (_ref) => {
+          let {
+            editor,
+            commands
+          } = _ref;
+          function toggleTight(name) {
+            if (!editor.isActive(name)) {
+              return false;
+            }
+            const attrs = editor.getAttributes(name);
+            return commands.updateAttributes(name, {
+              tight: tight !== null && tight !== void 0 ? tight : !(attrs !== null && attrs !== void 0 && attrs.tight)
+            });
+          }
+          return _this.options.listTypes.some((name) => toggleTight(name));
+        };
+      }
+    };
+  }
+});
+var md = (0, import_markdown_it.default)();
+function scanDelims(text, pos) {
+  md.inline.State.prototype.scanDelims.call({
+    src: text,
+    posMax: text.length
+  });
+  const state = new md.inline.State(text, null, null, []);
+  return state.scanDelims(pos, true);
+}
+function shiftDelim(text, delim, start, offset) {
+  let res = text.substring(0, start) + text.substring(start + delim.length);
+  res = res.substring(0, start + offset) + delim + res.substring(start + offset);
+  return res;
+}
+function trimStart(text, delim, from, to) {
+  let pos = from, res = text;
+  while (pos < to) {
+    if (scanDelims(res, pos).can_open) {
+      break;
+    }
+    res = shiftDelim(res, delim, pos, 1);
+    pos++;
+  }
+  return {
+    text: res,
+    from: pos,
+    to
+  };
+}
+function trimEnd(text, delim, from, to) {
+  let pos = to, res = text;
+  while (pos > from) {
+    if (scanDelims(res, pos).can_close) {
+      break;
+    }
+    res = shiftDelim(res, delim, pos, -1);
+    pos--;
+  }
+  return {
+    text: res,
+    from,
+    to: pos
+  };
+}
+function trimInline(text, delim, from, to) {
+  let state = {
+    text,
+    from,
+    to
+  };
+  state = trimStart(state.text, delim, state.from, state.to);
+  state = trimEnd(state.text, delim, state.from, state.to);
+  if (state.to - state.from < delim.length + 1) {
+    state.text = state.text.substring(0, state.from) + state.text.substring(state.to + delim.length);
+  }
+  return state.text;
+}
+var MarkdownSerializerState = class extends import_prosemirror_markdown.MarkdownSerializerState {
+  constructor(nodes, marks, options) {
+    super(nodes, marks, options !== null && options !== void 0 ? options : {});
+    __publicField(this, "inTable", false);
+    this.inlines = [];
+  }
+  render(node, parent, index) {
+    super.render(node, parent, index);
+    const top = this.inlines[this.inlines.length - 1];
+    if (top !== null && top !== void 0 && top.start && top !== null && top !== void 0 && top.end) {
+      const {
+        delimiter,
+        start,
+        end
+      } = this.normalizeInline(top);
+      this.out = trimInline(this.out, delimiter, start, end);
+      this.inlines.pop();
+    }
+  }
+  markString(mark, open, parent, index) {
+    const info = this.marks[mark.type.name];
+    if (info.expelEnclosingWhitespace) {
+      if (open) {
+        this.inlines.push({
+          start: this.out.length,
+          delimiter: info.open
+        });
+      } else {
+        const top = this.inlines.pop();
+        this.inlines.push({
+          ...top,
+          end: this.out.length
+        });
+      }
+    }
+    return super.markString(mark, open, parent, index);
+  }
+  normalizeInline(inline) {
+    let {
+      start,
+      end
+    } = inline;
+    while (this.out.charAt(start).match(/\s/)) {
+      start++;
+    }
+    return {
+      ...inline,
+      start
+    };
+  }
+};
+var HTMLMark = import_core8.Mark.create({
+  name: "markdownHTMLMark",
+  /**
+   * @return {{markdown: MarkdownMarkSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: {
+          open(state, mark) {
+            var _getMarkTags$, _getMarkTags;
+            if (!this.editor.storage.markdown.options.html) {
+              console.warn(`Tiptap Markdown: "${mark.type.name}" mark is only available in html mode`);
+              return "";
+            }
+            return (_getMarkTags$ = (_getMarkTags = getMarkTags(mark)) === null || _getMarkTags === void 0 ? void 0 : _getMarkTags[0]) !== null && _getMarkTags$ !== void 0 ? _getMarkTags$ : "";
+          },
+          close(state, mark) {
+            var _getMarkTags$2, _getMarkTags2;
+            if (!this.editor.storage.markdown.options.html) {
+              return "";
+            }
+            return (_getMarkTags$2 = (_getMarkTags2 = getMarkTags(mark)) === null || _getMarkTags2 === void 0 ? void 0 : _getMarkTags2[1]) !== null && _getMarkTags$2 !== void 0 ? _getMarkTags$2 : "";
+          }
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+function getMarkTags(mark) {
+  const schema = mark.type.schema;
+  const node = schema.text(" ", [mark]);
+  const html = (0, import_core8.getHTMLFromFragment)(import_model.Fragment.from(node), schema);
+  const match = html.match(/^(<.*?>) (<\/.*?>)$/);
+  return match ? [match[1], match[2]] : null;
+}
+function elementFromString(value) {
+  const wrappedValue = `<body>${value}</body>`;
+  return new window.DOMParser().parseFromString(wrappedValue, "text/html").body;
+}
+function escapeHTML(value) {
+  return value === null || value === void 0 ? void 0 : value.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function extractElement(node) {
+  const parent = node.parentElement;
+  const prepend = parent.cloneNode();
+  while (parent.firstChild && parent.firstChild !== node) {
+    prepend.appendChild(parent.firstChild);
+  }
+  if (prepend.childNodes.length > 0) {
+    parent.parentElement.insertBefore(prepend, parent);
+  }
+  parent.parentElement.insertBefore(node, parent);
+  if (parent.childNodes.length === 0) {
+    parent.remove();
+  }
+}
+function unwrapElement(node) {
+  const parent = node.parentNode;
+  while (node.firstChild)
+    parent.insertBefore(node.firstChild, node);
+  parent.removeChild(node);
+}
+var HTMLNode = import_core8.Node.create({
+  name: "markdownHTMLNode",
+  addStorage() {
+    return {
+      markdown: {
+        serialize(state, node, parent) {
+          if (this.editor.storage.markdown.options.html) {
+            state.write(serializeHTML(node, parent));
+          } else {
+            console.warn(`Tiptap Markdown: "${node.type.name}" node is only available in html mode`);
+            state.write(`[${node.type.name}]`);
+          }
+          if (node.isBlock) {
+            state.closeBlock(node);
+          }
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+function serializeHTML(node, parent) {
+  const schema = node.type.schema;
+  const html = (0, import_core8.getHTMLFromFragment)(import_model.Fragment.from(node), schema);
+  if (node.isBlock && (parent instanceof import_model.Fragment || parent.type.name === schema.topNodeType.name)) {
+    return formatBlock(html);
+  }
+  return html;
+}
+function formatBlock(html) {
+  const dom = elementFromString(html);
+  const element = dom.firstElementChild;
+  element.innerHTML = element.innerHTML.trim() ? `
+${element.innerHTML}
+` : `
+`;
+  return element.outerHTML;
+}
+var Blockquote = import_core8.Node.create({
+  name: "blockquote"
+});
+var Blockquote$1 = Blockquote.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: import_prosemirror_markdown.defaultMarkdownSerializer.nodes.blockquote,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var BulletList = import_core8.Node.create({
+  name: "bulletList"
+});
+var BulletList$1 = BulletList.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(state, node) {
+          return state.renderList(node, "  ", () => (this.editor.storage.markdown.options.bulletListMarker || "-") + " ");
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var CodeBlock = import_core8.Node.create({
+  name: "codeBlock"
+});
+var CodeBlock$1 = CodeBlock.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(state, node) {
+          state.write("```" + (node.attrs.language || "") + "\n");
+          state.text(node.textContent, false);
+          state.ensureNewLine();
+          state.write("```");
+          state.closeBlock(node);
+        },
+        parse: {
+          setup(markdownit2) {
+            var _this$options$languag;
+            markdownit2.set({
+              langPrefix: (_this$options$languag = this.options.languageClassPrefix) !== null && _this$options$languag !== void 0 ? _this$options$languag : "language-"
+            });
+          },
+          updateDOM(element) {
+            element.innerHTML = element.innerHTML.replace(/\n<\/code><\/pre>/g, "</code></pre>");
+          }
+        }
+      }
+    };
+  }
+});
+var HardBreak = import_core8.Node.create({
+  name: "hardBreak"
+});
+var HardBreak$1 = HardBreak.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(state, node, parent, index) {
+          for (let i = index + 1; i < parent.childCount; i++)
+            if (parent.child(i).type != node.type) {
+              state.write(state.inTable ? HTMLNode.storage.markdown.serialize.call(this, state, node, parent) : "\\\n");
+              return;
+            }
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var Heading = import_core8.Node.create({
+  name: "heading"
+});
+var Heading$1 = Heading.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: import_prosemirror_markdown.defaultMarkdownSerializer.nodes.heading,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var HorizontalRule = import_core8.Node.create({
+  name: "horizontalRule"
+});
+var HorizontalRule$1 = HorizontalRule.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: import_prosemirror_markdown.defaultMarkdownSerializer.nodes.horizontal_rule,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var Image = import_core8.Node.create({
+  name: "image"
+});
+var Image$1 = Image.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: import_prosemirror_markdown.defaultMarkdownSerializer.nodes.image,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var ListItem = import_core8.Node.create({
+  name: "listItem"
+});
+var ListItem$1 = ListItem.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: import_prosemirror_markdown.defaultMarkdownSerializer.nodes.list_item,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var OrderedList = import_core8.Node.create({
+  name: "orderedList"
+});
+function findIndexOfAdjacentNode(node, parent, index) {
+  let i = 0;
+  for (; index - i > 0; i++) {
+    if (parent.child(index - i - 1).type.name !== node.type.name) {
+      break;
+    }
+  }
+  return i;
+}
+var OrderedList$1 = OrderedList.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(state, node, parent, index) {
+          const start = node.attrs.start || 1;
+          const maxW = String(start + node.childCount - 1).length;
+          const space = state.repeat(" ", maxW + 2);
+          const adjacentIndex = findIndexOfAdjacentNode(node, parent, index);
+          const separator = adjacentIndex % 2 ? ") " : ". ";
+          state.renderList(node, space, (i) => {
+            const nStr = String(start + i);
+            return state.repeat(" ", maxW - nStr.length) + nStr + separator;
+          });
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var Paragraph = import_core8.Node.create({
+  name: "paragraph"
+});
+var Paragraph$1 = Paragraph.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: import_prosemirror_markdown.defaultMarkdownSerializer.nodes.paragraph,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+function childNodes(node) {
+  var _node$content$content, _node$content;
+  return (_node$content$content = node === null || node === void 0 || (_node$content = node.content) === null || _node$content === void 0 ? void 0 : _node$content.content) !== null && _node$content$content !== void 0 ? _node$content$content : [];
+}
+var Table = import_core8.Node.create({
+  name: "table"
+});
+var Table$1 = Table.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(state, node, parent) {
+          if (!isMarkdownSerializable(node)) {
+            HTMLNode.storage.markdown.serialize.call(this, state, node, parent);
+            return;
+          }
+          state.inTable = true;
+          node.forEach((row, p, i) => {
+            state.write("| ");
+            row.forEach((col, p2, j) => {
+              if (j) {
+                state.write(" | ");
+              }
+              const cellContent = col.firstChild;
+              if (cellContent.textContent.trim()) {
+                state.renderInline(cellContent);
+              }
+            });
+            state.write(" |");
+            state.ensureNewLine();
+            if (!i) {
+              const delimiterRow = Array.from({
+                length: row.childCount
+              }).map(() => "---").join(" | ");
+              state.write(`| ${delimiterRow} |`);
+              state.ensureNewLine();
+            }
+          });
+          state.closeBlock(node);
+          state.inTable = false;
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+function hasSpan(node) {
+  return node.attrs.colspan > 1 || node.attrs.rowspan > 1;
+}
+function isMarkdownSerializable(node) {
+  const rows = childNodes(node);
+  const firstRow = rows[0];
+  const bodyRows = rows.slice(1);
+  if (childNodes(firstRow).some((cell) => cell.type.name !== "tableHeader" || hasSpan(cell) || cell.childCount > 1)) {
+    return false;
+  }
+  if (bodyRows.some((row) => childNodes(row).some((cell) => cell.type.name === "tableHeader" || hasSpan(cell) || cell.childCount > 1))) {
+    return false;
+  }
+  return true;
+}
+var TaskItem = import_core8.Node.create({
+  name: "taskItem"
+});
+var TaskItem$1 = TaskItem.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(state, node) {
+          const check = node.attrs.checked ? "[x]" : "[ ]";
+          state.write(`${check} `);
+          state.renderContent(node);
+        },
+        parse: {
+          updateDOM(element) {
+            [...element.querySelectorAll(".task-list-item")].forEach((item) => {
+              const input = item.querySelector("input");
+              item.setAttribute("data-type", "taskItem");
+              if (input) {
+                item.setAttribute("data-checked", input.checked);
+                input.remove();
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+var TaskList = import_core8.Node.create({
+  name: "taskList"
+});
+var TaskList$1 = TaskList.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: BulletList$1.storage.markdown.serialize,
+        parse: {
+          setup(markdownit2) {
+            markdownit2.use(import_markdown_it_task_lists.default);
+          },
+          updateDOM(element) {
+            [...element.querySelectorAll(".contains-task-list")].forEach((list) => {
+              list.setAttribute("data-type", "taskList");
+            });
+          }
+        }
+      }
+    };
+  }
+});
+var Text = import_core8.Node.create({
+  name: "text"
+});
+var Text$1 = Text.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(state, node) {
+          state.text(escapeHTML(node.text));
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var Bold = import_core8.Mark.create({
+  name: "bold"
+});
+var Bold$1 = Bold.extend({
+  /**
+   * @return {{markdown: MarkdownMarkSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: import_prosemirror_markdown.defaultMarkdownSerializer.marks.strong,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var Code = import_core8.Mark.create({
+  name: "code"
+});
+var Code$1 = Code.extend({
+  /**
+   * @return {{markdown: MarkdownMarkSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: import_prosemirror_markdown.defaultMarkdownSerializer.marks.code,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var Italic = import_core8.Mark.create({
+  name: "italic"
+});
+var Italic$1 = Italic.extend({
+  /**
+   * @return {{markdown: MarkdownMarkSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: import_prosemirror_markdown.defaultMarkdownSerializer.marks.em,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var Link = import_core8.Mark.create({
+  name: "link"
+});
+var Link$1 = Link.extend({
+  /**
+   * @return {{markdown: MarkdownMarkSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: import_prosemirror_markdown.defaultMarkdownSerializer.marks.link,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var Strike = import_core8.Mark.create({
+  name: "strike"
+});
+var Strike$1 = Strike.extend({
+  /**
+   * @return {{markdown: MarkdownMarkSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: {
+          open: "~~",
+          close: "~~",
+          expelEnclosingWhitespace: true
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+var markdownExtensions = [Blockquote$1, BulletList$1, CodeBlock$1, HardBreak$1, Heading$1, HorizontalRule$1, HTMLNode, Image$1, ListItem$1, OrderedList$1, Paragraph$1, Table$1, TaskItem$1, TaskList$1, Text$1, Bold$1, Code$1, HTMLMark, Italic$1, Link$1, Strike$1];
+function getMarkdownSpec(extension) {
+  var _extension$storage, _markdownExtensions$f;
+  const markdownSpec = (_extension$storage = extension.storage) === null || _extension$storage === void 0 ? void 0 : _extension$storage.markdown;
+  const defaultMarkdownSpec = (_markdownExtensions$f = markdownExtensions.find((e) => e.name === extension.name)) === null || _markdownExtensions$f === void 0 ? void 0 : _markdownExtensions$f.storage.markdown;
+  if (markdownSpec || defaultMarkdownSpec) {
+    return {
+      ...defaultMarkdownSpec,
+      ...markdownSpec
+    };
+  }
+  return null;
+}
+var MarkdownSerializer = class {
+  constructor(editor) {
+    __publicField(this, "editor", null);
+    this.editor = editor;
+  }
+  serialize(content) {
+    const state = new MarkdownSerializerState(this.nodes, this.marks, {
+      hardBreakNodeName: HardBreak$1.name
+    });
+    state.renderContent(content);
+    return state.out;
+  }
+  get nodes() {
+    var _this$editor$extensio;
+    return {
+      ...Object.fromEntries(Object.keys(this.editor.schema.nodes).map((name) => [name, this.serializeNode(HTMLNode)])),
+      ...Object.fromEntries((_this$editor$extensio = this.editor.extensionManager.extensions.filter((extension) => extension.type === "node" && this.serializeNode(extension)).map((extension) => [extension.name, this.serializeNode(extension)])) !== null && _this$editor$extensio !== void 0 ? _this$editor$extensio : [])
+    };
+  }
+  get marks() {
+    var _this$editor$extensio2;
+    return {
+      ...Object.fromEntries(Object.keys(this.editor.schema.marks).map((name) => [name, this.serializeMark(HTMLMark)])),
+      ...Object.fromEntries((_this$editor$extensio2 = this.editor.extensionManager.extensions.filter((extension) => extension.type === "mark" && this.serializeMark(extension)).map((extension) => [extension.name, this.serializeMark(extension)])) !== null && _this$editor$extensio2 !== void 0 ? _this$editor$extensio2 : [])
+    };
+  }
+  serializeNode(node) {
+    var _getMarkdownSpec;
+    return (_getMarkdownSpec = getMarkdownSpec(node)) === null || _getMarkdownSpec === void 0 || (_getMarkdownSpec = _getMarkdownSpec.serialize) === null || _getMarkdownSpec === void 0 ? void 0 : _getMarkdownSpec.bind({
+      editor: this.editor,
+      options: node.options
+    });
+  }
+  serializeMark(mark) {
+    var _getMarkdownSpec2;
+    const serialize = (_getMarkdownSpec2 = getMarkdownSpec(mark)) === null || _getMarkdownSpec2 === void 0 ? void 0 : _getMarkdownSpec2.serialize;
+    return serialize ? {
+      ...serialize,
+      open: typeof serialize.open === "function" ? serialize.open.bind({
+        editor: this.editor,
+        options: mark.options
+      }) : serialize.open,
+      close: typeof serialize.close === "function" ? serialize.close.bind({
+        editor: this.editor,
+        options: mark.options
+      }) : serialize.close
+    } : null;
+  }
+};
+var MarkdownParser = class {
+  constructor(editor, _ref) {
+    __publicField(this, "editor", null);
+    __publicField(this, "md", null);
+    let {
+      html,
+      linkify,
+      breaks
+    } = _ref;
+    this.editor = editor;
+    this.md = this.withPatchedRenderer((0, import_markdown_it.default)({
+      html,
+      linkify,
+      breaks
+    }));
+  }
+  parse(content) {
+    let {
+      inline
+    } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    if (typeof content === "string") {
+      this.editor.extensionManager.extensions.forEach((extension) => {
+        var _getMarkdownSpec;
+        return (_getMarkdownSpec = getMarkdownSpec(extension)) === null || _getMarkdownSpec === void 0 || (_getMarkdownSpec = _getMarkdownSpec.parse) === null || _getMarkdownSpec === void 0 || (_getMarkdownSpec = _getMarkdownSpec.setup) === null || _getMarkdownSpec === void 0 ? void 0 : _getMarkdownSpec.call({
+          editor: this.editor,
+          options: extension.options
+        }, this.md);
+      });
+      const renderedHTML = this.md.render(content);
+      const element = elementFromString(renderedHTML);
+      this.editor.extensionManager.extensions.forEach((extension) => {
+        var _getMarkdownSpec2;
+        return (_getMarkdownSpec2 = getMarkdownSpec(extension)) === null || _getMarkdownSpec2 === void 0 || (_getMarkdownSpec2 = _getMarkdownSpec2.parse) === null || _getMarkdownSpec2 === void 0 || (_getMarkdownSpec2 = _getMarkdownSpec2.updateDOM) === null || _getMarkdownSpec2 === void 0 ? void 0 : _getMarkdownSpec2.call({
+          editor: this.editor,
+          options: extension.options
+        }, element);
+      });
+      this.normalizeDOM(element, {
+        inline,
+        content
+      });
+      return element.innerHTML;
+    }
+    return content;
+  }
+  normalizeDOM(node, _ref2) {
+    let {
+      inline,
+      content
+    } = _ref2;
+    this.normalizeBlocks(node);
+    node.querySelectorAll("*").forEach((el) => {
+      var _el$nextSibling;
+      if (((_el$nextSibling = el.nextSibling) === null || _el$nextSibling === void 0 ? void 0 : _el$nextSibling.nodeType) === Node.TEXT_NODE && !el.closest("pre")) {
+        el.nextSibling.textContent = el.nextSibling.textContent.replace(/^\n/, "");
+      }
+    });
+    if (inline) {
+      this.normalizeInline(node, content);
+    }
+    return node;
+  }
+  normalizeBlocks(node) {
+    const blocks = Object.values(this.editor.schema.nodes).filter((node2) => node2.isBlock);
+    const selector = blocks.map((block) => {
+      var _block$spec$parseDOM;
+      return (_block$spec$parseDOM = block.spec.parseDOM) === null || _block$spec$parseDOM === void 0 ? void 0 : _block$spec$parseDOM.map((spec) => spec.tag);
+    }).flat().filter(Boolean).join(",");
+    if (!selector) {
+      return;
+    }
+    [...node.querySelectorAll(selector)].forEach((el) => {
+      if (el.parentElement.matches("p")) {
+        extractElement(el);
+      }
+    });
+  }
+  normalizeInline(node, content) {
+    var _node$firstElementChi;
+    if ((_node$firstElementChi = node.firstElementChild) !== null && _node$firstElementChi !== void 0 && _node$firstElementChi.matches("p")) {
+      var _content$match$, _content$match, _content$match$2, _content$match2;
+      const firstParagraph = node.firstElementChild;
+      const {
+        nextElementSibling
+      } = firstParagraph;
+      const startSpaces = (_content$match$ = (_content$match = content.match(/^\s+/)) === null || _content$match === void 0 ? void 0 : _content$match[0]) !== null && _content$match$ !== void 0 ? _content$match$ : "";
+      const endSpaces = !nextElementSibling ? (_content$match$2 = (_content$match2 = content.match(/\s+$/)) === null || _content$match2 === void 0 ? void 0 : _content$match2[0]) !== null && _content$match$2 !== void 0 ? _content$match$2 : "" : "";
+      if (content.match(/^\n\n/)) {
+        firstParagraph.innerHTML = `${firstParagraph.innerHTML}${endSpaces}`;
+        return;
+      }
+      unwrapElement(firstParagraph);
+      node.innerHTML = `${startSpaces}${node.innerHTML}${endSpaces}`;
+    }
+  }
+  /**
+   * @param {markdownit} md
+   */
+  withPatchedRenderer(md22) {
+    const withoutNewLine = (renderer) => function() {
+      const rendered = renderer(...arguments);
+      if (rendered === "\n") {
+        return rendered;
+      }
+      if (rendered[rendered.length - 1] === "\n") {
+        return rendered.slice(0, -1);
+      }
+      return rendered;
+    };
+    md22.renderer.rules.hardbreak = withoutNewLine(md22.renderer.rules.hardbreak);
+    md22.renderer.rules.softbreak = withoutNewLine(md22.renderer.rules.softbreak);
+    md22.renderer.rules.fence = withoutNewLine(md22.renderer.rules.fence);
+    md22.renderer.rules.code_block = withoutNewLine(md22.renderer.rules.code_block);
+    md22.renderer.renderToken = withoutNewLine(md22.renderer.renderToken.bind(md22.renderer));
+    return md22;
+  }
+};
+var MarkdownClipboard = import_core8.Extension.create({
+  name: "markdownClipboard",
+  addOptions() {
+    return {
+      transformPastedText: false,
+      transformCopiedText: false
+    };
+  },
+  addProseMirrorPlugins() {
+    return [new import_state4.Plugin({
+      key: new import_state4.PluginKey("markdownClipboard"),
+      props: {
+        clipboardTextParser: (text, context, plainText) => {
+          if (plainText || !this.options.transformPastedText) {
+            return null;
+          }
+          const parsed = this.editor.storage.markdown.parser.parse(text, {
+            inline: true
+          });
+          return import_model.DOMParser.fromSchema(this.editor.schema).parseSlice(elementFromString(parsed), {
+            preserveWhitespace: true,
+            context
+          });
+        },
+        /**
+         * @param {import('prosemirror-model').Slice} slice
+         */
+        clipboardTextSerializer: (slice) => {
+          if (!this.options.transformCopiedText) {
+            return null;
+          }
+          return this.editor.storage.markdown.serializer.serialize(slice.content);
+        }
+      }
+    })];
+  }
+});
+var Markdown = import_core8.Extension.create({
+  name: "markdown",
+  priority: 50,
+  addOptions() {
+    return {
+      html: true,
+      tightLists: true,
+      tightListClass: "tight",
+      bulletListMarker: "-",
+      linkify: false,
+      breaks: false,
+      transformPastedText: false,
+      transformCopiedText: false
+    };
+  },
+  addCommands() {
+    const commands = import_core8.extensions.Commands.config.addCommands();
+    return {
+      setContent: (content, emitUpdate, parseOptions) => (props) => {
+        return commands.setContent(props.editor.storage.markdown.parser.parse(content), emitUpdate, parseOptions)(props);
+      },
+      insertContentAt: (range, content, options) => (props) => {
+        return commands.insertContentAt(range, props.editor.storage.markdown.parser.parse(content, {
+          inline: true
+        }), options)(props);
+      }
+    };
+  },
+  onBeforeCreate() {
+    this.editor.storage.markdown = {
+      options: {
+        ...this.options
+      },
+      parser: new MarkdownParser(this.editor, this.options),
+      serializer: new MarkdownSerializer(this.editor),
+      getMarkdown: () => {
+        return this.editor.storage.markdown.serializer.serialize(this.editor.state.doc);
+      }
+    };
+    this.editor.options.initialContent = this.editor.options.content;
+    this.editor.options.content = this.editor.storage.markdown.parser.parse(this.editor.options.content);
+  },
+  onCreate() {
+    this.editor.options.content = this.editor.options.initialContent;
+    delete this.editor.options.initialContent;
+  },
+  addStorage() {
+    return {
+      /// storage will be defined in onBeforeCreate() to prevent initial object overriding
+    };
+  },
+  addExtensions() {
+    return [MarkdownTightLists.configure({
+      tight: this.options.tightLists,
+      tightClass: this.options.tightListClass
+    }), MarkdownClipboard.configure({
+      transformPastedText: this.options.transformPastedText,
+      transformCopiedText: this.options.transformCopiedText
+    })];
+  }
+});
+
+// src/extensions/markdown.ts
 var resolveExt = (mod, name) => mod?.[name] || mod?.default?.[name] || mod?.default?.default || mod?.default || mod;
-var StarterKit = resolveExt(_StarterKit, "StarterKit");
-var Color = resolveExt(_Color, "Color");
-var Highlight = resolveExt(_Highlight, "Highlight");
-var Link = resolveExt(_Link, "Link");
-var TaskList = resolveExt(_TaskList, "TaskList");
-var TaskItem = resolveExt(_TaskItem, "TaskItem");
-var TextAlign = resolveExt(_TextAlign, "TextAlign");
-var TextStyle = resolveExt(_TextStyle, "TextStyle");
-var Typography = resolveExt(_Typography, "Typography");
-var Underline = resolveExt(_Underline, "Underline");
-var Placeholder = resolveExt(_Placeholder, "Placeholder");
-var CharacterCount = resolveExt(_CharacterCount, "CharacterCount");
+var Markdown2 = resolveExt(Markdown, "Markdown");
+
+// src/extensions/rich-text-preset.ts
+var resolveExt2 = (mod, name) => mod?.[name] || mod?.default?.[name] || mod?.default?.default || mod?.default || mod;
+var StarterKit = resolveExt2(_StarterKit, "StarterKit");
+var Color = resolveExt2(_Color, "Color");
+var Highlight = resolveExt2(_Highlight, "Highlight");
+var Link2 = resolveExt2(_Link, "Link");
+var TaskList2 = resolveExt2(_TaskList, "TaskList");
+var TaskItem2 = resolveExt2(_TaskItem, "TaskItem");
+var TextAlign = resolveExt2(_TextAlign, "TextAlign");
+var TextStyle = resolveExt2(_TextStyle, "TextStyle");
+var Typography = resolveExt2(_Typography, "Typography");
+var Underline = resolveExt2(_Underline, "Underline");
+var Placeholder = resolveExt2(_Placeholder, "Placeholder");
+var CharacterCount = resolveExt2(_CharacterCount, "CharacterCount");
 function createRichTextPreset(options = {}) {
   const {
     placeholder = "Start typing...",
@@ -972,7 +1988,7 @@ function createRichTextPreset(options = {}) {
     enableColorHighlighter = true,
     headingLevels = [1, 2, 3, 4]
   } = options;
-  const extensions = [
+  const extensions2 = [
     StarterKit.configure({
       orderedList: {
         HTMLAttributes: {
@@ -999,10 +2015,10 @@ function createRichTextPreset(options = {}) {
     TextAlign.configure({
       types: ["heading", "paragraph"]
     }),
-    Link.extend({
+    Link2.extend({
       addInputRules() {
         return [
-          (0, import_core8.markInputRule)({
+          (0, import_core9.markInputRule)({
             find: /(?:^|\s)\[([^\]]+)\]\(([^)]+)\)$/,
             type: this.type,
             getAttributes: (match) => ({
@@ -1021,11 +2037,11 @@ function createRichTextPreset(options = {}) {
         class: "text-blue-500 underline underline-offset-2"
       }
     }),
-    TaskList,
-    TaskItem.extend({
+    TaskList2,
+    TaskItem2.extend({
       addInputRules() {
         return [
-          (0, import_core8.wrappingInputRule)({
+          (0, import_core9.wrappingInputRule)({
             find: /^\s*(\[([ |x])?\])\s$/i,
             type: this.type,
             getAttributes: (match) => ({
@@ -1044,21 +2060,21 @@ function createRichTextPreset(options = {}) {
     })
   ];
   if (characterLimit) {
-    extensions.push(
+    extensions2.push(
       CharacterCount.configure({
         limit: characterLimit
       })
     );
   }
   if (enableSmilies) {
-    extensions.push(SmilieReplacer);
+    extensions2.push(SmilieReplacer);
   }
   if (enableColorHighlighter) {
-    extensions.push(ColorHighlighter);
+    extensions2.push(ColorHighlighter);
   }
   if (options.mention) {
     const mentionConfig = typeof options.mention === "object" ? options.mention : {};
-    extensions.push(
+    extensions2.push(
       Mention.configure({
         HTMLAttributes: {
           class: "pixerate-mention-node",
@@ -1068,7 +2084,23 @@ function createRichTextPreset(options = {}) {
       })
     );
   }
-  return extensions;
+  if (options.markdown) {
+    const markdownConfig = typeof options.markdown === "object" ? options.markdown : {};
+    extensions2.push(
+      Markdown2.configure({
+        html: true,
+        tightLists: true,
+        tightListClass: "tight",
+        bulletListMarker: "-",
+        linkify: true,
+        breaks: true,
+        transformPastedText: true,
+        transformCopiedText: true,
+        ...markdownConfig
+      })
+    );
+  }
+  return extensions2;
 }
 
 // src/serializers/plain-text.ts
@@ -1199,13 +2231,35 @@ function extractMentionsFromDoc(docOrEditor) {
   return mentions;
 }
 
+// src/serializers/markdown.ts
+var import_markdown_it2 = __toESM(require("markdown-it"), 1);
+var import_markdown_it_task_lists2 = __toESM(require("markdown-it-task-lists"), 1);
+var md2 = new import_markdown_it2.default({
+  html: true,
+  linkify: true,
+  breaks: true
+}).use(import_markdown_it_task_lists2.default);
+function markdownToTipTapHtml(markdown) {
+  if (!markdown) return "<p></p>";
+  return md2.render(markdown);
+}
+function getEditorMarkdown(editor) {
+  if (!editor) return "";
+  if (typeof editor.storage?.markdown?.getMarkdown === "function") {
+    return editor.storage.markdown.getMarkdown();
+  }
+  return getEditorText(editor);
+}
+
 // src/controller.ts
-var import_core9 = require("@tiptap/core");
-var import_model = require("@tiptap/pm/model");
+var import_core10 = require("@tiptap/core");
+var import_model2 = require("@tiptap/pm/model");
 var EditorController = class {
   editor;
   plainTextMode;
+  markdownMode;
   onPlainTextChange;
+  onMarkdownChange;
   onTokensChange;
   onSelectionChange;
   constructor(options = {}) {
@@ -1213,21 +2267,25 @@ var EditorController = class {
       element,
       content,
       plainTextMode = false,
-      extensions = [],
+      markdownMode = false,
+      extensions: extensions2 = [],
       onPlainTextChange,
+      onMarkdownChange,
       onTokensChange,
       onSelectionChange,
       ...editorOptions
     } = options;
     this.plainTextMode = plainTextMode;
+    this.markdownMode = markdownMode;
     this.onPlainTextChange = onPlainTextChange;
+    this.onMarkdownChange = onMarkdownChange;
     this.onTokensChange = onTokensChange;
     this.onSelectionChange = onSelectionChange;
-    const initialContent = plainTextMode && typeof content === "string" ? plainTextToTipTapHtml(content) : content;
-    this.editor = new import_core9.Editor({
+    const initialContent = plainTextMode && typeof content === "string" ? plainTextToTipTapHtml(content) : markdownMode && typeof content === "string" ? markdownToTipTapHtml(content) : content;
+    this.editor = new import_core10.Editor({
       element: element || void 0,
       content: initialContent,
-      extensions,
+      extensions: extensions2,
       ...editorOptions,
       onUpdate: (props) => {
         editorOptions.onUpdate?.(props);
@@ -1248,7 +2306,7 @@ var EditorController = class {
         ...this.editor.options.editorProps,
         clipboardTextParser: (text, context, _plain, view) => {
           const schema = context?.doc?.type?.schema || context?.schema || view?.state?.schema || this.editor.schema;
-          if (!schema) return import_model.Slice.empty;
+          if (!schema) return import_model2.Slice.empty;
           const blocks = text.replace(/\r\n?/g, "\n").split("\n");
           const nodes = [];
           blocks.forEach((line) => {
@@ -1257,12 +2315,12 @@ var EditorController = class {
               nodeJson.content = [{ type: "text", text: line }];
             }
             try {
-              const node = import_model.Node.fromJSON(schema, nodeJson);
+              const node = import_model2.Node.fromJSON(schema, nodeJson);
               nodes.push(node);
             } catch {
             }
           });
-          return import_model.Slice.maxOpen(import_model.Fragment.fromArray(nodes));
+          return import_model2.Slice.maxOpen(import_model2.Fragment.fromArray(nodes));
         }
       }
     });
@@ -1276,6 +2334,10 @@ var EditorController = class {
         this.onTokensChange(tokens);
       }
     }
+    if (this.markdownMode || this.onMarkdownChange) {
+      const markdown = this.getMarkdown();
+      this.onMarkdownChange?.(markdown);
+    }
   }
   handleSelectionUpdate() {
     if (this.onSelectionChange) {
@@ -1290,6 +2352,17 @@ var EditorController = class {
     const html = plainTextToTipTapHtml(text);
     this.editor.commands.setContent(html, emitUpdate);
   }
+  getMarkdown() {
+    return getEditorMarkdown(this.editor);
+  }
+  setMarkdown(markdown, emitUpdate = true) {
+    if (this.editor.storage?.markdown?.parser) {
+      this.editor.commands.setContent(markdown, emitUpdate);
+    } else {
+      const html = markdownToTipTapHtml(markdown);
+      this.editor.commands.setContent(html, emitUpdate);
+    }
+  }
   insertText(text) {
     this.editor.commands.insertContent(text);
   }
@@ -2501,6 +3574,24 @@ var SpreadsheetController = class {
       this.notifyChange();
     }
   }
+  autoFitColumnWidth(colId, customWidth) {
+    if (customWidth !== void 0) {
+      this.setColumnWidth(colId, customWidth);
+      return;
+    }
+    const col = this.document.columns.find((c) => c.id === colId);
+    if (!col) return;
+    let maxLen = (col.title || "").length + (col.key ? col.key.length + 3 : 0);
+    for (const row of this.document.rows) {
+      const cell = this.getCell(row.id, col.id);
+      const valStr = cell.value != null ? String(cell.value) : "";
+      if (valStr.length > maxLen) {
+        maxLen = valStr.length;
+      }
+    }
+    const estimatedWidth = Math.min(600, Math.max(50, Math.ceil(maxLen * 8.5 + 32)));
+    this.setColumnWidth(colId, estimatedWidth);
+  }
   // --- Clipboard TSV/CSV ---
   exportToTsv() {
     return this.document.rows.map(
@@ -2575,6 +3666,7 @@ var SpreadsheetController = class {
   GradientText,
   INSTRUCTION_REGEX,
   LoadingNode,
+  Markdown,
   Mention,
   SlashCommands,
   SmilieReplacer,
@@ -2593,6 +3685,7 @@ var SpreadsheetController = class {
   extractTemplateNames,
   extractVariableNames,
   findHexColors,
+  getEditorMarkdown,
   getEditorText,
   getLatestVersion,
   htmlToPlainText,
@@ -2600,6 +3693,7 @@ var SpreadsheetController = class {
   instructionRegex,
   mapRawOffsetToResolved,
   mapResolvedOffsetToRaw,
+  markdownToTipTapHtml,
   parseCellReference,
   parseFormula,
   parseRange,