@pod-os/elements 0.41.0-rc.fcadbb6.0 → 0.41.0

package/dist/cjs/pos-markdown-document.cjs.entry.js

@@ -1,8 +1,8 @@
 'use strict';
 
-var index$1 = require('./index-CFcC3IGM.js');
+var index$1 = require('./index-CjKppELa.js');
 var index = require('./index-DlHQ3blV.js');
-require('./chunk.ZGGPD2XJ-BhNheC5q.js');
+require('./chunk.ZGGPD2XJ-BvGHEYp6.js');
 
 // ::- Persistent data structure representing an ordered mapping from
 // strings to values, with some convenient update methods.
@@ -13880,7 +13880,6 @@ function isMarkInSet(marks, type, attributes = {}) {
   return !!findMarkInSet(marks, type, attributes);
 }
 function getMarkRange($pos, type, attributes) {
-  var _a;
   if (!$pos || !type) {
     return;
   }
@@ -13891,7 +13890,12 @@ function getMarkRange($pos, type, attributes) {
   if (!start.node || !start.node.marks.some((mark2) => mark2.type === type)) {
     return;
   }
-  attributes = attributes || ((_a = start.node.marks[0]) == null ? void 0 : _a.attrs);
+  if (!attributes) {
+    const firstMark = start.node.marks.find((mark2) => mark2.type === type);
+    if (firstMark) {
+      attributes = firstMark.attrs;
+    }
+  }
   const mark = findMarkInSet([...start.node.marks], type, attributes);
   if (!mark) {
     return;
@@ -13926,7 +13930,7 @@ function getMarkType(nameOrType, schema) {
 }
 
 // src/commands/extendMarkRange.ts
-var extendMarkRange = (typeOrName, attributes = {}) => ({ tr, state, dispatch }) => {
+var extendMarkRange = (typeOrName, attributes) => ({ tr, state, dispatch }) => {
   const type = getMarkType(typeOrName, state.schema);
   const { doc, selection } = tr;
   const { $from, from, to } = selection;
@@ -14261,7 +14265,7 @@ var insertContentAt = (position, value, options) => ({ tr, dispatch, editor }) =
       const fromSelectionAtStart = $from.parentOffset === 0;
       const isTextSelection2 = $fromNode.isText || $fromNode.isTextblock;
       const hasContent = $fromNode.content.size > 0;
-      if (fromSelectionAtStart && isTextSelection2 && hasContent) {
+      if (fromSelectionAtStart && isTextSelection2 && hasContent && isOnlyBlockContent) {
         from = Math.max(0, from - 1);
       }
       tr.replaceWith(from, to, newContent);
@@ -14819,6 +14823,67 @@ function getAttributesFromExtensions(extensions) {
 }
 
 // src/utilities/mergeAttributes.ts
+function splitStyleDeclarations(styles) {
+  const result = [];
+  let current = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let parenDepth = 0;
+  const length = styles.length;
+  for (let i = 0; i < length; i += 1) {
+    const char = styles[i];
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      current += char;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      current += char;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote) {
+      if (char === "(") {
+        parenDepth += 1;
+        current += char;
+        continue;
+      }
+      if (char === ")" && parenDepth > 0) {
+        parenDepth -= 1;
+        current += char;
+        continue;
+      }
+      if (char === ";" && parenDepth === 0) {
+        result.push(current);
+        current = "";
+        continue;
+      }
+    }
+    current += char;
+  }
+  if (current) {
+    result.push(current);
+  }
+  return result;
+}
+function parseStyleEntries(styles) {
+  const pairs = [];
+  const declarations = splitStyleDeclarations(styles || "");
+  const numDeclarations = declarations.length;
+  for (let i = 0; i < numDeclarations; i += 1) {
+    const declaration = declarations[i];
+    const firstColonIndex = declaration.indexOf(":");
+    if (firstColonIndex === -1) {
+      continue;
+    }
+    const property = declaration.slice(0, firstColonIndex).trim();
+    const value = declaration.slice(firstColonIndex + 1).trim();
+    if (property && value) {
+      pairs.push([property, value]);
+    }
+  }
+  return pairs;
+}
 function mergeAttributes(...objects) {
   return objects.filter((item) => !!item).reduce((items, item) => {
     const mergedAttributes = { ...items };
@@ -14834,17 +14899,7 @@ function mergeAttributes(...objects) {
         const insertClasses = valueClasses.filter((valueClass) => !existingClasses.includes(valueClass));
         mergedAttributes[key] = [...existingClasses, ...insertClasses].join(" ");
       } else if (key === "style") {
-        const newStyles = value ? value.split(";").map((style2) => style2.trim()).filter(Boolean) : [];
-        const existingStyles = mergedAttributes[key] ? mergedAttributes[key].split(";").map((style2) => style2.trim()).filter(Boolean) : [];
-        const styleMap = /* @__PURE__ */ new Map();
-        existingStyles.forEach((style2) => {
-          const [property, val] = style2.split(":").map((part) => part.trim());
-          styleMap.set(property, val);
-        });
-        newStyles.forEach((style2) => {
-          const [property, val] = style2.split(":").map((part) => part.trim());
-          styleMap.set(property, val);
-        });
+        const styleMap = new Map([...parseStyleEntries(mergedAttributes[key]), ...parseStyleEntries(value)]);
         mergedAttributes[key] = Array.from(styleMap.entries()).map(([property, val]) => `${property}: ${val}`).join("; ");
       } else {
         mergedAttributes[key] = value;
@@ -15442,7 +15497,7 @@ function isNodeEmpty(node, {
       return true;
     }
     if (node.isText) {
-      return /^\s*$/m.test((_a = node.text) != null ? _a : "");
+      return !/\S/.test((_a = node.text) != null ? _a : "");
     }
   }
   if (node.isText) {
@@ -15838,6 +15893,16 @@ var joinListForwards = (tr, listType) => {
   tr.join(after);
   return true;
 };
+function createInnerSelectionForWholeDocList(tr) {
+  const doc = tr.doc;
+  const list = doc.firstChild;
+  if (!list) {
+    return null;
+  }
+  const $start = doc.resolve(1);
+  const $end = doc.resolve(list.nodeSize - 1);
+  return TextSelection.between($start, $end);
+}
 var toggleList = (listTypeOrName, itemTypeOrName, keepMarks, attributes = {}) => ({ editor, tr, state, dispatch, chain, commands, can }) => {
   const { extensions, splittableMarks } = editor.extensionManager;
   const listType = getNodeType(listTypeOrName, state.schema);
@@ -15850,13 +15915,35 @@ var toggleList = (listTypeOrName, itemTypeOrName, keepMarks, attributes = {}) =>
     return false;
   }
   const parentList = findParentNode((node) => isList(node.type.name, extensions))(selection);
-  if (range.depth >= 1 && parentList && range.depth - parentList.depth <= 1) {
-    if (parentList.node.type === listType) {
+  const isAllSelection = selection.from === 0 && selection.to === state.doc.content.size;
+  const topLevelNodes = state.doc.content.content;
+  const soleTopLevelNode = topLevelNodes.length === 1 ? topLevelNodes[0] : null;
+  const allSelectionList = isAllSelection && soleTopLevelNode && isList(soleTopLevelNode.type.name, extensions) ? {
+    node: soleTopLevelNode,
+    pos: 0} : null;
+  const currentList = parentList != null ? parentList : allSelectionList;
+  const isInsideExistingList = !!parentList && range.depth >= 1 && range.depth - parentList.depth <= 1;
+  const hasWholeDocSelectedList = !!allSelectionList;
+  if ((isInsideExistingList || hasWholeDocSelectedList) && currentList) {
+    if (currentList.node.type === listType) {
+      if (isAllSelection && hasWholeDocSelectedList) {
+        return chain().command(({ tr: trx, dispatch: disp }) => {
+          const nextSelection = createInnerSelectionForWholeDocList(trx);
+          if (!nextSelection) {
+            return false;
+          }
+          trx.setSelection(nextSelection);
+          if (disp) {
+            disp(trx);
+          }
+          return true;
+        }).liftListItem(itemType).run();
+      }
       return commands.liftListItem(itemType);
     }
-    if (isList(parentList.node.type.name, extensions) && listType.validContent(parentList.node.content) && dispatch) {
+    if (isList(currentList.node.type.name, extensions) && listType.validContent(currentList.node.content)) {
       return chain().command(() => {
-        tr.setNodeMarkup(parentList.pos, listType);
+        tr.setNodeMarkup(currentList.pos, listType);
         return true;
       }).command(() => joinListBackwards(tr, listType)).command(() => joinListForwards(tr, listType)).run();
     }
@@ -17141,7 +17228,7 @@ var Delete = Extension.create({
           const newEnd = mapping.slice(index).map(step.to);
           const oldStart = mapping.invert().map(newStart, -1);
           const oldEnd = mapping.invert().map(newEnd);
-          const foundBeforeMark = (_a3 = nextTransaction.doc.nodeAt(newStart - 1)) == null ? void 0 : _a3.marks.some((mark) => mark.eq(step.mark));
+          const foundBeforeMark = newStart > 0 ? (_a3 = nextTransaction.doc.nodeAt(newStart - 1)) == null ? void 0 : _a3.marks.some((mark) => mark.eq(step.mark)) : false;
           const foundAfterMark = (_b3 = nextTransaction.doc.nodeAt(newEnd)) == null ? void 0 : _b3.marks.some((mark) => mark.eq(step.mark));
           this.editor.emit("delete", {
             type: "mark",
@@ -18639,7 +18726,7 @@ var ResizableNodeView = class {
     const element = document.createElement("div");
     element.dataset.resizeContainer = "";
     element.dataset.node = this.node.type.name;
-    element.style.display = "flex";
+    element.style.display = this.node.type.isInline ? "inline-flex" : "flex";
     if (this.classNames.container) {
       element.className = this.classNames.container;
     }
@@ -18979,6 +19066,14 @@ function canInsertNode(state, nodeType) {
   return false;
 }
 
+// src/utilities/htmlEntities.ts
+function decodeHtmlEntities(text) {
+  return text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&amp;/g, "&");
+}
+function encodeHtmlEntities(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
 // src/utilities/markdown/index.ts
 var markdown_exports = {};
 __export$1(markdown_exports, {
@@ -19455,17 +19550,21 @@ function renderNestedMarkdownContent(node, h2, prefixOrGenerator, ctx) {
   const prefix = typeof prefixOrGenerator === "function" ? prefixOrGenerator(ctx) : prefixOrGenerator;
   const [content, ...children] = node.content;
   const mainContent = h2.renderChildren([content]);
-  const output = [`${prefix}${mainContent}`];
+  let output = `${prefix}${mainContent}`;
   if (children && children.length > 0) {
-    children.forEach((child) => {
-      const childContent = h2.renderChildren([child]);
-      if (childContent) {
-        const indentedChild = childContent.split("\n").map((line) => line ? h2.indent(line) : "").join("\n");
-        output.push(indentedChild);
+    children.forEach((child, index) => {
+      var _a, _b;
+      const childContent = (_b = (_a = h2.renderChild) == null ? void 0 : _a.call(h2, child, index + 1)) != null ? _b : h2.renderChildren([child]);
+      if (childContent !== void 0 && childContent !== null) {
+        const indentedChild = childContent.split("\n").map((line) => line ? h2.indent(line) : h2.indent("")).join("\n");
+        output += child.type === "paragraph" ? `
+
+${indentedChild}` : `
+${indentedChild}`;
       }
     });
   }
-  return output.join("\n");
+  return output;
 }
 
 // src/MarkView.ts
@@ -19561,7 +19660,10 @@ function markPasteRule(config) {
         }
         markEnd = range.from + startSpaces + captureGroup.length;
         tr.addMark(range.from + startSpaces, markEnd, config.type.create(attributes || {}));
-        tr.removeStoredMark(config.type);
+        const isMatchAtEndOfText = match.index !== void 0 && match.input !== void 0 && match.index + match[0].length >= match.input.length;
+        if (!isMatchAtEndOfText) {
+          tr.removeStoredMark(config.type);
+        }
       }
     }
   });
@@ -19673,13 +19775,13 @@ function findMarksToCloseAtEnd(activeMarks, currentMarks, nextNode, markSetsEqua
   if (isLastNode || nextNodeHasNoMarks || nextNodeHasDifferentMarks) {
     if (nextNode && nextNode.type === "text" && nextNode.marks) {
       const nextMarks = new Map(nextNode.marks.map((mark) => [mark.type, mark]));
-      Array.from(activeMarks.keys()).forEach((markType) => {
+      Array.from(activeMarks.keys()).reverse().forEach((markType) => {
         if (!nextMarks.has(markType)) {
           marksToCloseAtEnd.push(markType);
         }
       });
     } else if (isLastNode || nextNodeHasNoMarks) {
-      marksToCloseAtEnd.push(...Array.from(activeMarks.keys()));
+      marksToCloseAtEnd.push(...Array.from(activeMarks.keys()).reverse());
     }
   }
   return marksToCloseAtEnd;
@@ -19732,12 +19834,14 @@ var MarkdownManager = class {
    * @param options.extensions An array of Tiptap extensions to register for markdown parsing and rendering.
    */
   constructor(options) {
+    this.activeParseLexer = null;
     this.baseExtensions = [];
     this.extensions = [];
+    /** Set of extension names whose `code` spec property is truthy (nodes and marks). */
+    this.codeTypes = /* @__PURE__ */ new Set();
     this.lastParseResult = null;
     var _a, _b, _c, _d, _e;
     this.markedInstance = (_a = options == null ? void 0 : options.marked) != null ? _a : g;
-    this.lexer = new this.markedInstance.Lexer();
     this.indentStyle = (_c = (_b = options == null ? void 0 : options.indentation) == null ? void 0 : _b.style) != null ? _c : "space";
     this.indentSize = (_e = (_d = options == null ? void 0 : options.indentation) == null ? void 0 : _d.size) != null ? _e : 2;
     this.baseExtensions = (options == null ? void 0 : options.extensions) || [];
@@ -19749,9 +19853,8 @@ var MarkdownManager = class {
     if (options == null ? void 0 : options.extensions) {
       this.baseExtensions = options.extensions;
       const flattened = flattenExtensions(options.extensions);
-      flattened.forEach((ext) => this.registerExtension(ext, false));
+      flattened.forEach((ext) => this.registerExtension(ext));
     }
-    this.lexer = new this.markedInstance.Lexer();
   }
   /** Returns the underlying marked instance. */
   get instance() {
@@ -19774,22 +19877,28 @@ var MarkdownManager = class {
    * `markdownName`, `parseMarkdown`, `renderMarkdown` and `priority` from the
    * extension config (using the same resolution used across the codebase).
    */
-  registerExtension(extension, recreateLexer = true) {
+  registerExtension(extension) {
     var _a, _b;
     this.extensions.push(extension);
+    const isCode = callOrReturn(getExtensionField(extension, "code"));
     const name = extension.name;
+    if (isCode) {
+      this.codeTypes.add(name);
+    }
     const tokenName = getExtensionField(extension, "markdownTokenName") || name;
     const parseMarkdown = getExtensionField(extension, "parseMarkdown");
     const renderMarkdown = getExtensionField(extension, "renderMarkdown");
     const tokenizer = getExtensionField(extension, "markdownTokenizer");
     const markdownCfg = (_a = getExtensionField(extension, "markdownOptions")) != null ? _a : null;
     const isIndenting = (_b = markdownCfg == null ? void 0 : markdownCfg.indentsContent) != null ? _b : false;
+    const htmlReopen = markdownCfg == null ? void 0 : markdownCfg.htmlReopen;
     const spec = {
       tokenName,
       nodeName: name,
       parseMarkdown,
       renderMarkdown,
       isIndenting,
+      htmlReopen,
       tokenizer
     };
     if (tokenName && parseMarkdown) {
@@ -19804,11 +19913,21 @@ var MarkdownManager = class {
     }
     if (tokenizer && this.hasMarked()) {
       this.registerTokenizer(tokenizer);
-      if (recreateLexer) {
-        this.lexer = new this.markedInstance.Lexer();
-      }
     }
   }
+  createLexer() {
+    return new this.markedInstance.Lexer();
+  }
+  createTokenizerHelpers(lexer) {
+    return {
+      inlineTokens: (src) => lexer.inlineTokens(src),
+      blockTokens: (src) => lexer.blockTokens(src)
+    };
+  }
+  tokenizeInline(src) {
+    var _a;
+    return ((_a = this.activeParseLexer) != null ? _a : this.createLexer()).inlineTokens(src);
+  }
   /**
    * Register a custom tokenizer with marked.js for parsing non-standard markdown syntax.
    */
@@ -19817,20 +19936,12 @@ var MarkdownManager = class {
       return;
     }
     const { name, start, level = "inline", tokenize } = tokenizer;
-    const tokenizeInline = (src) => {
-      return this.lexer.inlineTokens(src);
-    };
-    const tokenizeBlock = (src) => {
-      return this.lexer.blockTokens(src);
-    };
-    const helper = {
-      inlineTokens: tokenizeInline,
-      blockTokens: tokenizeBlock
-    };
+    const createTokenizerHelpers = this.createTokenizerHelpers.bind(this);
+    const createLexer = this.createLexer.bind(this);
     let startCb;
     if (!start) {
       startCb = (src) => {
-        const result = tokenize(src, [], helper);
+        const result = tokenize(src, [], this.createTokenizerHelpers(this.createLexer()));
         if (result && result.raw) {
           const index = src.indexOf(result.raw);
           return index;
@@ -19844,7 +19955,8 @@ var MarkdownManager = class {
       name,
       level,
       start: startCb,
-      tokenizer: (src, tokens) => {
+      tokenizer(src, tokens) {
+        const helper = this.lexer ? createTokenizerHelpers(this.lexer) : createTokenizerHelpers(createLexer());
         const result = tokenize(src, tokens, helper);
         if (result && result.type) {
           return {
@@ -19917,23 +20029,65 @@ var MarkdownManager = class {
     if (!this.hasMarked()) {
       throw new Error("No marked instance available for parsing");
     }
-    const tokens = this.markedInstance.lexer(markdown);
-    const content = this.parseTokens(tokens);
-    return {
-      type: "doc",
-      content
-    };
+    const previousParseLexer = this.activeParseLexer;
+    const parseLexer = this.createLexer();
+    this.activeParseLexer = parseLexer;
+    try {
+      const tokens = parseLexer.lex(markdown);
+      const content = this.parseTokens(tokens, true);
+      return {
+        type: "doc",
+        content
+      };
+    } finally {
+      this.activeParseLexer = previousParseLexer;
+    }
   }
   /**
    * Convert an array of marked tokens into Tiptap JSON nodes using registered extension handlers.
    */
-  parseTokens(tokens) {
-    return tokens.map((token) => this.parseToken(token)).filter((parsed) => parsed !== null).flatMap((parsed) => Array.isArray(parsed) ? parsed : [parsed]);
+  parseTokens(tokens, parseImplicitEmptyParagraphs = false) {
+    const nonSpaceTokenIndexes = tokens.reduce((indexes, token, index) => {
+      if (token.type !== "space") {
+        indexes.push(index);
+      }
+      return indexes;
+    }, []);
+    let previousNonSpaceTokenIndex = -1;
+    let nextNonSpaceTokenPointer = 0;
+    return tokens.flatMap((token, index) => {
+      var _a;
+      while (nextNonSpaceTokenPointer < nonSpaceTokenIndexes.length && nonSpaceTokenIndexes[nextNonSpaceTokenPointer] < index) {
+        previousNonSpaceTokenIndex = nonSpaceTokenIndexes[nextNonSpaceTokenPointer];
+        nextNonSpaceTokenPointer += 1;
+      }
+      if (parseImplicitEmptyParagraphs && token.type === "space") {
+        const nextNonSpaceTokenIndex = (_a = nonSpaceTokenIndexes[nextNonSpaceTokenPointer]) != null ? _a : -1;
+        return this.createImplicitEmptyParagraphsFromSpace(token, previousNonSpaceTokenIndex, nextNonSpaceTokenIndex);
+      }
+      const parsed = this.parseToken(token, parseImplicitEmptyParagraphs);
+      if (parsed === null) {
+        return [];
+      }
+      return Array.isArray(parsed) ? parsed : [parsed];
+    });
+  }
+  createImplicitEmptyParagraphsFromSpace(token, previousNonSpaceTokenIndex, nextNonSpaceTokenIndex) {
+    const separatorCount = this.countParagraphSeparators(token.raw || "");
+    if (separatorCount === 0) {
+      return [];
+    }
+    const isBoundarySpace = previousNonSpaceTokenIndex === -1 || nextNonSpaceTokenIndex === -1;
+    const emptyParagraphCount = Math.max(separatorCount - (isBoundarySpace ? 0 : 1), 0);
+    return Array.from({ length: emptyParagraphCount }, () => ({ type: "paragraph", content: [] }));
+  }
+  countParagraphSeparators(raw) {
+    return (raw.replace(/\r\n/g, "\n").match(/\n\n/g) || []).length;
   }
   /**
    * Parse a single token into Tiptap JSON using the appropriate registered handler.
    */
-  parseToken(token) {
+  parseToken(token, parseImplicitEmptyParagraphs = false) {
     if (!token.type) {
       return null;
     }
@@ -19959,7 +20113,7 @@ var MarkdownManager = class {
       this.lastParseResult = null;
       return toReturn;
     }
-    return this.parseFallbackToken(token);
+    return this.parseFallbackToken(token, parseImplicitEmptyParagraphs);
   }
   /**
    * Parse a list token, handling mixed bullet and task list items by splitting them into separate lists.
@@ -20018,7 +20172,7 @@ var MarkdownManager = class {
           indentLevel,
           checked: checked != null ? checked : false,
           text: mainContent,
-          tokens: this.lexer.inlineTokens(mainContent),
+          tokens: this.tokenizeInline(mainContent),
           nestedTokens
         };
       }
@@ -20087,6 +20241,7 @@ var MarkdownManager = class {
     return {
       parseInline: (tokens) => this.parseInlineTokens(tokens),
       parseChildren: (tokens) => this.parseTokens(tokens),
+      parseBlockChildren: (tokens) => this.parseTokens(tokens, true),
       createTextNode: (text, marks) => {
         const node = {
           type: "text",
@@ -20131,7 +20286,7 @@ var MarkdownManager = class {
       if (token.type === "text") {
         result.push({
           type: "text",
-          text: token.text || ""
+          text: decodeHtmlEntities(token.text || "")
         });
       } else if (token.type === "html") {
         const raw = ((_b = (_a = token.raw) != null ? _a : token.text) != null ? _b : "").toString();
@@ -20245,7 +20400,7 @@ var MarkdownManager = class {
   /**
    * Fallback parsing for common tokens when no specific handler is registered.
    */
-  parseFallbackToken(token) {
+  parseFallbackToken(token, parseImplicitEmptyParagraphs = false) {
     switch (token.type) {
       case "paragraph":
         return {
@@ -20261,7 +20416,7 @@ var MarkdownManager = class {
       case "text":
         return {
           type: "text",
-          text: token.text || ""
+          text: decodeHtmlEntities(token.text || "")
         };
       case "html":
         return this.parseHTMLToken(token);
@@ -20269,7 +20424,7 @@ var MarkdownManager = class {
         return null;
       default:
         if (token.tokens) {
-          return this.parseTokens(token.tokens);
+          return this.parseTokens(token.tokens, parseImplicitEmptyParagraphs);
         }
         return null;
     }
@@ -20316,10 +20471,18 @@ var MarkdownManager = class {
       throw new Error(`Failed to parse HTML in markdown: ${error}`);
     }
   }
-  renderNodeToMarkdown(node, parentNode, index = 0, level = 0) {
+  /**
+   * Encode HTML entities in text unless the node is inside a code context
+   * (code mark or code-block parent) where literal characters should be preserved.
+   */
+  encodeTextForMarkdown(text, node, parentNode) {
+    const isInsideCode = (parentNode == null ? void 0 : parentNode.type) != null && this.codeTypes.has(parentNode.type) || (node.marks || []).some((m) => this.codeTypes.has(typeof m === "string" ? m : m.type));
+    return isInsideCode ? text : encodeHtmlEntities(text);
+  }
+  renderNodeToMarkdown(node, parentNode, index = 0, level = 0, meta = {}) {
     var _a;
     if (node.type === "text") {
-      return node.text || "";
+      return this.encodeTextForMarkdown(node.text || "", node, parentNode);
     }
     if (!node.type) {
       return "";
@@ -20328,6 +20491,7 @@ var MarkdownManager = class {
     if (!handler) {
       return "";
     }
+    const previousNode = Array.isArray(parentNode == null ? void 0 : parentNode.content) && index > 0 ? parentNode.content[index - 1] : void 0;
     const helpers = {
       renderChildren: (nodes, separator) => {
         const childLevel = handler.isIndenting ? level + 1 : level;
@@ -20336,6 +20500,10 @@ var MarkdownManager = class {
         }
         return this.renderNodes(nodes, node, separator || "", index, childLevel);
       },
+      renderChild: (childNode, childIndex) => {
+        const childLevel = handler.isIndenting ? level + 1 : level;
+        return this.renderNodeToMarkdown(childNode, node, childIndex, childLevel);
+      },
       indent: (content) => {
         return this.indentString + content;
       },
@@ -20345,8 +20513,10 @@ var MarkdownManager = class {
       index,
       level,
       parentType: parentNode == null ? void 0 : parentNode.type,
+      previousNode,
       meta: {
-        parentAttrs: parentNode == null ? void 0 : parentNode.attrs
+        parentAttrs: parentNode == null ? void 0 : parentNode.attrs,
+        ...meta
       }
     };
     const rendered = ((_a = handler.renderMarkdown) == null ? void 0 : _a.call(handler, node, helpers, context)) || "";
@@ -20372,34 +20542,44 @@ var MarkdownManager = class {
   renderNodesWithMarkBoundaries(nodes, parentNode, separator = "", level = 0) {
     const result = [];
     const activeMarks = /* @__PURE__ */ new Map();
+    const reopenWithHtmlOnNextOpen = /* @__PURE__ */ new Set();
+    const markOpeningModes = /* @__PURE__ */ new Map();
     nodes.forEach((node, i) => {
       const nextNode = i < nodes.length - 1 ? nodes[i + 1] : null;
       if (!node.type) {
         return;
       }
       if (node.type === "text") {
-        let textContent = node.text || "";
+        let textContent = this.encodeTextForMarkdown(node.text || "", node, parentNode);
         const currentMarks = new Map((node.marks || []).map((mark) => [mark.type, mark]));
         const marksToOpen = findMarksToOpen(activeMarks, currentMarks);
         const marksToClose = findMarksToClose(currentMarks, nextNode);
+        const activeMarksClosingHere = marksToClose.filter((markType) => activeMarks.has(markType));
+        const hasCrossedBoundary = activeMarksClosingHere.length > 0 && marksToOpen.length > 0;
         let middleTrailingWhitespace = "";
-        if (marksToClose.length > 0) {
+        if (marksToClose.length > 0 && !hasCrossedBoundary) {
           const middleTrailingMatch = textContent.match(/(\s+)$/);
           if (middleTrailingMatch) {
             middleTrailingWhitespace = middleTrailingMatch[1];
             textContent = textContent.slice(0, -middleTrailingWhitespace.length);
           }
         }
-        marksToClose.forEach((markType) => {
-          const mark = currentMarks.get(markType);
-          const closeMarkdown = this.getMarkClosing(markType, mark);
-          if (closeMarkdown) {
-            textContent += closeMarkdown;
-          }
-          if (activeMarks.has(markType)) {
-            activeMarks.delete(markType);
-          }
-        });
+        if (!hasCrossedBoundary) {
+          marksToClose.forEach((markType) => {
+            if (!activeMarks.has(markType)) {
+              return;
+            }
+            const mark = currentMarks.get(markType);
+            const closeMarkdown = this.getMarkClosing(markType, mark, markOpeningModes.get(markType));
+            if (closeMarkdown) {
+              textContent += closeMarkdown;
+            }
+            if (activeMarks.has(markType)) {
+              activeMarks.delete(markType);
+              markOpeningModes.delete(markType);
+            }
+          });
+        }
         let leadingWhitespace = "";
         if (marksToOpen.length > 0) {
           const leadingMatch = textContent.match(/^(\s+)/);
@@ -20409,21 +20589,37 @@ var MarkdownManager = class {
           }
         }
         marksToOpen.forEach(({ type, mark }) => {
-          const openMarkdown = this.getMarkOpening(type, mark);
+          const openingMode = reopenWithHtmlOnNextOpen.has(type) ? "html" : "markdown";
+          const openMarkdown = this.getMarkOpening(type, mark, openingMode);
           if (openMarkdown) {
             textContent = openMarkdown + textContent;
           }
-          if (!marksToClose.includes(type)) {
-            activeMarks.set(type, mark);
-          }
+          markOpeningModes.set(type, openingMode);
+          reopenWithHtmlOnNextOpen.delete(type);
         });
+        if (!hasCrossedBoundary) {
+          marksToOpen.slice().reverse().forEach(({ type, mark }) => {
+            activeMarks.set(type, mark);
+          });
+        }
         textContent = leadingWhitespace + textContent;
-        const marksToCloseAtEnd = findMarksToCloseAtEnd(
-          activeMarks,
-          currentMarks,
-          nextNode,
-          this.markSetsEqual.bind(this)
-        );
+        let marksToCloseAtEnd;
+        if (hasCrossedBoundary) {
+          const nextMarkTypes = new Set(((nextNode == null ? void 0 : nextNode.marks) || []).map((mark) => mark.type));
+          marksToOpen.forEach(({ type }) => {
+            if (nextMarkTypes.has(type) && this.getHtmlReopenTags(type)) {
+              reopenWithHtmlOnNextOpen.add(type);
+            }
+          });
+          marksToCloseAtEnd = [
+            ...marksToOpen.map((m) => m.type),
+            // inner (opened here) — close first
+            ...activeMarksClosingHere
+            // outer (were active before) — close last
+          ];
+        } else {
+          marksToCloseAtEnd = findMarksToCloseAtEnd(activeMarks, currentMarks, nextNode, this.markSetsEqual.bind(this));
+        }
         let trailingWhitespace = "";
         if (marksToCloseAtEnd.length > 0) {
           const trailingMatch = textContent.match(/(\s+)$/);
@@ -20433,21 +20629,32 @@ var MarkdownManager = class {
           }
         }
         marksToCloseAtEnd.forEach((markType) => {
-          const mark = activeMarks.get(markType);
-          const closeMarkdown = this.getMarkClosing(markType, mark);
+          var _a;
+          const mark = (_a = activeMarks.get(markType)) != null ? _a : currentMarks.get(markType);
+          const closeMarkdown = this.getMarkClosing(markType, mark, markOpeningModes.get(markType));
           if (closeMarkdown) {
             textContent += closeMarkdown;
           }
           activeMarks.delete(markType);
+          markOpeningModes.delete(markType);
         });
         textContent += trailingWhitespace;
         textContent += middleTrailingWhitespace;
         result.push(textContent);
       } else {
         const marksToReopen = new Map(activeMarks);
-        const beforeMarkdown = closeMarksBeforeNode(activeMarks, this.getMarkClosing.bind(this));
+        const openingModesToReopen = new Map(markOpeningModes);
+        const beforeMarkdown = closeMarksBeforeNode(activeMarks, (markType, mark) => {
+          return this.getMarkClosing(markType, mark, markOpeningModes.get(markType));
+        });
+        markOpeningModes.clear();
         const nodeContent = this.renderNodeToMarkdown(node, parentNode, i, level);
-        const afterMarkdown = node.type === "hardBreak" ? "" : reopenMarksAfterNode(marksToReopen, activeMarks, this.getMarkOpening.bind(this));
+        const afterMarkdown = node.type === "hardBreak" ? "" : reopenMarksAfterNode(marksToReopen, activeMarks, (markType, mark) => {
+          var _a;
+          const openingMode = (_a = openingModesToReopen.get(markType)) != null ? _a : "markdown";
+          markOpeningModes.set(markType, openingMode);
+          return this.getMarkOpening(markType, mark, openingMode);
+        });
         result.push(beforeMarkdown + nodeContent + afterMarkdown);
       }
     });
@@ -20456,7 +20663,11 @@ var MarkdownManager = class {
   /**
    * Get the opening markdown syntax for a mark type.
    */
-  getMarkOpening(markType, mark) {
+  getMarkOpening(markType, mark, openingMode = "markdown") {
+    var _a;
+    if (openingMode === "html") {
+      return ((_a = this.getHtmlReopenTags(markType)) == null ? void 0 : _a.open) || "";
+    }
     const handlers = this.getHandlersForNodeType(markType);
     const handler = handlers.length > 0 ? handlers[0] : void 0;
     if (!handler || !handler.renderMarkdown) {
@@ -20473,6 +20684,7 @@ var MarkdownManager = class {
         syntheticNode,
         {
           renderChildren: () => placeholder,
+          renderChild: () => placeholder,
           indent: (content) => content,
           wrapInBlock: (prefix, content) => prefix + content
         },
@@ -20487,7 +20699,11 @@ var MarkdownManager = class {
   /**
    * Get the closing markdown syntax for a mark type.
    */
-  getMarkClosing(markType, mark) {
+  getMarkClosing(markType, mark, openingMode = "markdown") {
+    var _a;
+    if (openingMode === "html") {
+      return ((_a = this.getHtmlReopenTags(markType)) == null ? void 0 : _a.close) || "";
+    }
     const handlers = this.getHandlersForNodeType(markType);
     const handler = handlers.length > 0 ? handlers[0] : void 0;
     if (!handler || !handler.renderMarkdown) {
@@ -20504,6 +20720,7 @@ var MarkdownManager = class {
         syntheticNode,
         {
           renderChildren: () => placeholder,
+          renderChild: () => placeholder,
           indent: (content) => content,
           wrapInBlock: (prefix, content) => prefix + content
         },
@@ -20516,6 +20733,15 @@ var MarkdownManager = class {
       throw new Error(`Failed to get mark closing for ${markType}: ${err}`);
     }
   }
+  /**
+   * Returns the inline HTML tags an extension exposes for overlap-boundary
+   * reopen handling, if that mark explicitly opted into HTML reopen mode.
+   */
+  getHtmlReopenTags(markType) {
+    const handlers = this.getHandlersForNodeType(markType);
+    const handler = handlers.length > 0 ? handlers[0] : void 0;
+    return handler == null ? void 0 : handler.htmlReopen;
+  }
   /**
    * Check if two mark sets are equal.
    */
@@ -20658,7 +20884,9 @@ var Blockquote = Node3.create({
     return /* @__PURE__ */ h("blockquote", { ...mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), children: /* @__PURE__ */ h("slot", {}) });
   },
   parseMarkdown: (token, helpers) => {
-    return helpers.createNode("blockquote", void 0, helpers.parseChildren(token.tokens || []));
+    var _a;
+    const parseBlockChildren = (_a = helpers.parseBlockChildren) != null ? _a : helpers.parseChildren;
+    return helpers.createNode("blockquote", void 0, parseBlockChildren(token.tokens || []));
   },
   renderMarkdown: (node, h) => {
     if (!node.content) {
@@ -20666,8 +20894,9 @@ var Blockquote = Node3.create({
     }
     const prefix = ">";
     const result = [];
-    node.content.forEach((child) => {
-      const childContent = h.renderChildren([child]);
+    node.content.forEach((child, index) => {
+      var _a, _b;
+      const childContent = (_b = (_a = h.renderChild) == null ? void 0 : _a.call(h, child, index)) != null ? _b : h.renderChildren([child]);
       const lines = childContent.split("\n");
       const linesWithPrefix = lines.map((line) => {
         if (line.trim() === "") {
@@ -20747,6 +20976,12 @@ var Bold = Mark.create({
   parseMarkdown: (token, helpers) => {
     return helpers.applyMark("bold", helpers.parseInline(token.tokens || []));
   },
+  markdownOptions: {
+    htmlReopen: {
+      open: "<strong>",
+      close: "</strong>"
+    }
+  },
   renderMarkdown: (node, h) => {
     return `**${h.renderChildren(node)}**`;
   },
@@ -20927,8 +21162,8 @@ var CodeBlock = Node3.create({
   },
   markdownTokenName: "code",
   parseMarkdown: (token, helpers) => {
-    var _a;
-    if (((_a = token.raw) == null ? void 0 : _a.startsWith("```")) === false && token.codeBlockStyle !== "indented") {
+    var _a, _b;
+    if (((_a = token.raw) == null ? void 0 : _a.startsWith("```")) === false && ((_b = token.raw) == null ? void 0 : _b.startsWith("~~~")) === false && token.codeBlockStyle !== "indented") {
       return [];
     }
     return helpers.createNode(
@@ -21456,6 +21691,12 @@ var Italic = Mark.create({
   parseMarkdown: (token, helpers) => {
     return helpers.applyMark("italic", helpers.parseInline(token.tokens || []));
   },
+  markdownOptions: {
+    htmlReopen: {
+      open: "<em>",
+      close: "</em>"
+    }
+  },
   renderMarkdown: (node, h) => {
     return `*${h.renderChildren(node)}*`;
   },
@@ -23759,14 +24000,16 @@ var ListItem = Node3.create({
   },
   markdownTokenName: "list_item",
   parseMarkdown: (token, helpers) => {
+    var _a;
     if (token.type !== "list_item") {
       return [];
     }
+    const parseBlockChildren = (_a = helpers.parseBlockChildren) != null ? _a : helpers.parseChildren;
     let content = [];
     if (token.tokens && token.tokens.length > 0) {
       const hasParagraphTokens = token.tokens.some((t) => t.type === "paragraph");
       if (hasParagraphTokens) {
-        content = helpers.parseChildren(token.tokens);
+        content = parseBlockChildren(token.tokens);
       } else {
         const firstToken = token.tokens[0];
         if (firstToken && firstToken.type === "text" && firstToken.tokens && firstToken.tokens.length > 0) {
@@ -23779,11 +24022,11 @@ var ListItem = Node3.create({
           ];
           if (token.tokens.length > 1) {
             const remainingTokens = token.tokens.slice(1);
-            const additionalContent = helpers.parseChildren(remainingTokens);
+            const additionalContent = parseBlockChildren(remainingTokens);
             content.push(...additionalContent);
           }
         } else {
-          content = helpers.parseChildren(token.tokens);
+          content = parseBlockChildren(token.tokens);
         }
       }
     }
@@ -24088,6 +24331,36 @@ var ListKeymap = Extension.create({
 // src/ordered-list/utils.ts
 var ORDERED_LIST_ITEM_REGEX = /^(\s*)(\d+)\.\s+(.*)$/;
 var INDENTED_LINE_REGEX = /^\s/;
+function isBlockContentLine(line) {
+  const trimmedLine = line.trimStart();
+  return /^[-+*]\s+/.test(trimmedLine) || /^\d+\.\s+/.test(trimmedLine) || /^>\s?/.test(trimmedLine) || /^```/.test(trimmedLine) || /^~~~/.test(trimmedLine);
+}
+function splitItemContent(contentLines) {
+  const paragraphLines = [];
+  const blockLines = [];
+  let reachedBlockBoundary = false;
+  contentLines.forEach((line) => {
+    if (reachedBlockBoundary) {
+      blockLines.push(line);
+      return;
+    }
+    if (line.trim() === "") {
+      reachedBlockBoundary = true;
+      blockLines.push(line);
+      return;
+    }
+    if (paragraphLines.length > 0 && isBlockContentLine(line)) {
+      reachedBlockBoundary = true;
+      blockLines.push(line);
+      return;
+    }
+    paragraphLines.push(line);
+  });
+  return {
+    paragraphLines,
+    blockLines
+  };
+}
 function collectOrderedListItems(lines) {
   const listItems = [];
   let currentLineIndex = 0;
@@ -24100,9 +24373,10 @@ function collectOrderedListItems(lines) {
     }
     const [, indent, number, content] = match;
     const indentLevel = indent.length;
-    let itemContent = content;
+    const itemContentLines = [content];
     let nextLineIndex = currentLineIndex + 1;
     const itemLines = [line];
+    let sawBlankLine = false;
     while (nextLineIndex < lines.length) {
       const nextLine = lines[nextLineIndex];
       const nextMatch = nextLine.match(ORDERED_LIST_ITEM_REGEX);
@@ -24111,21 +24385,27 @@ function collectOrderedListItems(lines) {
       }
       if (nextLine.trim() === "") {
         itemLines.push(nextLine);
-        itemContent += "\n";
+        itemContentLines.push("");
+        sawBlankLine = true;
         nextLineIndex += 1;
       } else if (nextLine.match(INDENTED_LINE_REGEX)) {
         itemLines.push(nextLine);
-        itemContent += `
-${nextLine.slice(indentLevel + 2)}`;
+        itemContentLines.push(nextLine.slice(indentLevel + 2));
         nextLineIndex += 1;
       } else {
-        break;
+        if (sawBlankLine) {
+          break;
+        }
+        itemLines.push(nextLine);
+        itemContentLines.push(nextLine);
+        nextLineIndex += 1;
       }
     }
     listItems.push({
       indent: indentLevel,
       number: parseInt(number, 10),
-      content: itemContent.trim(),
+      content: itemContentLines.join("\n").trim(),
+      contentLines: itemContentLines,
       raw: itemLines.join("\n")
     });
     consumed = nextLineIndex;
@@ -24134,14 +24414,13 @@ ${nextLine.slice(indentLevel + 2)}`;
   return [listItems, consumed];
 }
 function buildNestedStructure(items, baseIndent, lexer) {
-  var _a;
   const result = [];
   let currentIndex = 0;
   while (currentIndex < items.length) {
     const item = items[currentIndex];
     if (item.indent === baseIndent) {
-      const contentLines = item.content.split("\n");
-      const mainText = ((_a = contentLines[0]) == null ? void 0 : _a.trim()) || "";
+      const { paragraphLines, blockLines } = splitItemContent(item.contentLines);
+      const mainText = paragraphLines.join("\n").trim();
       const tokens = [];
       if (mainText) {
         tokens.push({
@@ -24150,7 +24429,7 @@ function buildNestedStructure(items, baseIndent, lexer) {
           tokens: lexer.inlineTokens(mainText)
         });
       }
-      const additionalContent = contentLines.slice(1).join("\n").trim();
+      const additionalContent = blockLines.join("\n").trim();
       if (additionalContent) {
         const blockTokens = lexer.blockTokens(additionalContent);
         tokens.push(...blockTokens);
@@ -24727,18 +25006,22 @@ var Paragraph = Node3.create({
       return helpers.parseChildren([tokens[0]]);
     }
     const content = helpers.parseInline(tokens);
-    if (content.length === 1 && content[0].type === "text" && (content[0].text === EMPTY_PARAGRAPH_MARKDOWN || content[0].text === NBSP_CHAR)) {
+    const hasExplicitEmptyParagraphMarker = tokens.length === 1 && tokens[0].type === "text" && (tokens[0].raw === EMPTY_PARAGRAPH_MARKDOWN || tokens[0].text === EMPTY_PARAGRAPH_MARKDOWN || tokens[0].raw === NBSP_CHAR || tokens[0].text === NBSP_CHAR);
+    if (hasExplicitEmptyParagraphMarker && content.length === 1 && content[0].type === "text" && (content[0].text === EMPTY_PARAGRAPH_MARKDOWN || content[0].text === NBSP_CHAR)) {
       return helpers.createNode("paragraph", void 0, []);
     }
     return helpers.createNode("paragraph", void 0, content);
   },
-  renderMarkdown: (node, h) => {
+  renderMarkdown: (node, h, ctx) => {
+    var _a, _b;
     if (!node) {
       return "";
     }
     const content = Array.isArray(node.content) ? node.content : [];
     if (content.length === 0) {
-      return EMPTY_PARAGRAPH_MARKDOWN;
+      const previousContent = Array.isArray((_a = ctx == null ? void 0 : ctx.previousNode) == null ? void 0 : _a.content) ? ctx.previousNode.content : [];
+      const previousNodeIsEmptyParagraph = ((_b = ctx == null ? void 0 : ctx.previousNode) == null ? void 0 : _b.type) === "paragraph" && previousContent.length === 0;
+      return previousNodeIsEmptyParagraph ? EMPTY_PARAGRAPH_MARKDOWN : "";
     }
     return h.renderChildren(content);
   },
@@ -25870,7 +26153,7 @@ function history(config = {}) {
                 beforeinput(view, e) {
                     let inputType = e.inputType;
                     let command = inputType == "historyUndo" ? undo : inputType == "historyRedo" ? redo : null;
-                    if (!command)
+                    if (!command || !view.editable)
                         return false;
                     e.preventDefault();
                     return command(view.state, view.dispatch);
@@ -26121,6 +26404,9 @@ Extension.create({
             doc.descendants((node, pos) => {
               const hasAnchor = anchor >= pos && anchor <= pos + node.nodeSize;
               const isEmpty = !node.isLeaf && isNodeEmpty(node);
+              if (!node.type.isTextblock) {
+                return this.options.includeChildren;
+              }
               if ((hasAnchor || !this.options.showOnlyCurrent) && isEmpty) {
                 const classes = [this.options.emptyNodeClass];
                 if (isEmptyDoc) {
@@ -26174,6 +26460,7 @@ Extension.create({
     ];
   }
 });
+var skipTrailingNodeMeta = "skipTrailingNode";
 function nodeEqualsType({ types, node }) {
   return node && Array.isArray(types) && types.includes(node.type) || (node == null ? void 0 : node.type) === types;
 }
@@ -26193,11 +26480,14 @@ var TrailingNode = Extension.create({
     return [
       new Plugin({
         key: plugin,
-        appendTransaction: (_, __, state) => {
+        appendTransaction: (transactions, __, state) => {
           const { doc, tr, schema } = state;
           const shouldInsertNodeAtEnd = plugin.getState(state);
           const endPosition = doc.content.size;
           const type = schema.nodes[defaultNode];
+          if (transactions.some((transaction) => transaction.getMeta(skipTrailingNodeMeta))) {
+            return;
+          }
           if (!shouldInsertNodeAtEnd) {
             return;
           }