onchain-lexical-markdown 0.0.13 → 0.0.14

package/dist/OnchainLexicalMarkdown.js

@@ -18,6 +18,8 @@ var link = require('@lexical/link');
 var LexicalHorizontalRuleNode = require('@lexical/react/LexicalHorizontalRuleNode');
 var selection = require('@lexical/selection');
 var table = require('@lexical/table');
+var onchainUtility = require('onchain-utility');
+var base64 = require('onchain-utility/base64');
 var file = require('@lexical/file');
 
 /**
@@ -1183,6 +1185,80 @@ function $convertToMarkdownString(transformers = TransFormerGather.value, node,
  *
  */
 
+function getHtmlTagAttrValue(tagStart, attrName) {
+  const match = tagStart.match(new RegExp(`${attrName}=("|')(.*?)\\1`)) || [];
+  return match[2];
+}
+// 简化的解析器
+function parseHtmlToCustomStructure(htmlString) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(htmlString, 'text/html');
+  function processNode(node) {
+    // 处理文本节点
+    if (node.nodeType === Node.TEXT_NODE) {
+      const text = node.textContent;
+      return text ? {
+        children: [],
+        content: text,
+        dom: node,
+        tag: 'text'
+      } : null;
+    }
+
+    // 处理元素节点
+    if (node.nodeType === Node.ELEMENT_NODE) {
+      const tagName = node.tagName.toLowerCase();
+      const children = [];
+
+      // 处理子节点
+      for (const child of node.childNodes) {
+        const childResult = processNode(child);
+        if (childResult) {
+          children.push(childResult);
+        }
+      }
+
+      // 获取元素内容（不包含子元素的纯文本内容）
+      const textContent = Array.from(node.childNodes).filter(n => n.nodeType === Node.TEXT_NODE).map(n => n.textContent).filter(text => text.length > 0).join(' ');
+      return {
+        children: children,
+        content: textContent || node.textContent || '',
+        dom: node,
+        tag: tagName
+      };
+    }
+    return null;
+  }
+
+  // 处理文档中的主要元素
+  const result = [];
+  const bodyChildren = Array.from(doc.body.children);
+  for (const element of bodyChildren) {
+    const processed = processNode(element);
+    if (processed) {
+      result.push(processed);
+    }
+  }
+  return result;
+}
+
+/** html 标签分块单行排列 */
+function htmlTagSingleLine(htmlString) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(htmlString, 'text/html');
+  return Array.from(doc.body.children).map(element => {
+    return element.outerHTML.replace(/(>)\s+(<)/g, '$1$2');
+  }).join('\n');
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+const interval = '{-|-}';
 const HTML_TABLE_START = /^[\u0020\t]*<table.*?>/;
 const HTML_TABLE_END = /[\u0020\t]*<\/table>$/;
 const SINGLE_LINE_ROW_STYLES = /<tr.*?style=(["|'](.+?)["|']).*?>/;
@@ -1266,10 +1342,10 @@ const HTML_TABLE = {
 
 const HTML_PARAGRAPH_TRANSFORMER = [{
   end: /[\u0020\t]*<\/p>$/,
-  start: /[\u0020\t]*<p.*?>/
+  start: /^[\u0020\t]*<p[^a-z]+(?:[^>]*?)>/
 }, {
   end: /[\u0020\t]*<\/div>$/,
-  start: /[\u0020\t]*<div.*?>/
+  start: /^[\u0020\t]*<div(?:[^>]*?)>/
 }].map(({
   start,
   end
@@ -1277,23 +1353,296 @@ const HTML_PARAGRAPH_TRANSFORMER = [{
   return {
     dependencies: [],
     regExpEnd: {
+      optional: true,
       regExp: end
     },
     regExpStart: start,
     replace: (rootNode, children, startMatch, endMatch, linesInBetween) => {
       if (linesInBetween) {
         const context = linesInBetween.join('\n');
-        const paragraph = onchainLexicalInstance.$createInstanceParagraphNode();
-        $convertFromMarkdownString(context, TransFormerGather.value, paragraph);
+        // console.log('PARAGRAPH CONTEXT', context);
+        const paragraph = optimizeNesting(onchainLexicalInstance.$createInstanceParagraphNode(), context);
         rootNode.append(paragraph);
       }
     },
     type: 'multiline-element'
   };
 });
+const HTML_LIST_TRANSFORMER = [...[{
+  end: /[\u0020\t]*<\/ul>$/,
+  start: /^[\u0020\t]*<ul(?:[^>]*?)>/
+}, {
+  end: /[\u0020\t]*<\/ol>$/,
+  start: /^[\u0020\t]*<ol(?:[^>]*?)>/
+}].map(({
+  start,
+  end
+}) => {
+  const TRANSFORMER = {
+    dependencies: [],
+    regExpEnd: {
+      optional: true,
+      regExp: end
+    },
+    regExpStart: start,
+    replace: (rootNode, children, startMatch, endMatch, linesInBetween) => {
+      // console.log('LIST', linesInBetween);
+      const type = getHtmlTagAttrValue(startMatch[0], 'list-type') || 'bullet';
+      if (linesInBetween) {
+        const context = linesInBetween.join('\n');
+        const list = onchainLexicalInstance.$createInstanceListNode(type);
+        $convertFromMarkdownString(context, TransFormerGather.value, list);
+        rootNode.append(list);
+      }
+    },
+    type: 'multiline-element'
+  };
+  return TRANSFORMER;
+}), {
+  dependencies: [],
+  regExpEnd: {
+    optional: true,
+    regExp: /[\u0020\t]*<\/li>$/
+  },
+  regExpStart: /^[\u0020\t]*<li(?:[^>]*?)>/,
+  replace: (rootNode, children, startMatch, endMatch, linesInBetween) => {
+    const checked = getHtmlTagAttrValue(startMatch[0], 'aria-checked') || 'false';
+    if (linesInBetween) {
+      const context = linesInBetween.join('\n');
+      const listItem = onchainLexicalInstance.$createInstanceListItemNode(checked === 'true');
+      const nodes = parseTagContent(context);
+      listItem.append(...nodes);
+      rootNode.append(listItem);
+    }
+  },
+  type: 'multiline-element'
+}];
+const HTML_QUOTE_TRANSFORMER = [{
+  end: /[\u0020\t]*<\/blockquote>$/,
+  start: /^[\u0020\t]*<blockquote(?:[^>]*?)>/
+}].map(({
+  start,
+  end
+}) => {
+  return {
+    dependencies: [],
+    regExpEnd: {
+      optional: true,
+      regExp: end
+    },
+    regExpStart: start,
+    replace: (rootNode, children, startMatch, endMatch, linesInBetween) => {
+      // console.log('QUOTE', linesInBetween);
+      if (linesInBetween) {
+        const context = linesInBetween.join('\n');
+        const quote = onchainLexicalInstance.$createInstanceQuoteNode();
+        const nodes = parseTagContent(context);
+        quote.append(...nodes);
+        rootNode.append(quote);
+      }
+    },
+    type: 'multiline-element'
+  };
+});
+const HTML_CODE_TRANSFORMER = [{
+  end: /[\u0020\t]*<\/pre>$/,
+  start: /^[\u0020\t]*<pre(?:[^>]*?)>/
+}].map(({
+  start,
+  end
+}) => {
+  return {
+    dependencies: [],
+    regExpEnd: {
+      optional: true,
+      regExp: end
+    },
+    regExpStart: start,
+    replace: (rootNode, children, startMatch, endMatch, linesInBetween) => {
+      // console.log('CODE', linesInBetween);
+      const language = getHtmlTagAttrValue(startMatch[0], 'data-language') || 'text';
+      if (linesInBetween) {
+        const context = linesInBetween.join('\n');
+        const code = onchainLexicalInstance.$createInstanceCodeNode(language);
+        const nodes = parseTagContent(context);
+        code.append(...nodes);
+        rootNode.append(code);
+      }
+    },
+    type: 'multiline-element'
+  };
+});
+const HTML_LINK_TRANSFORMER = [{
+  end: /[\u0020\t]*<\/a>$/,
+  start: /^[\u0020\t]*<a[^a-z]+(?:[^>]*?)>/
+}].map(({
+  start,
+  end
+}) => {
+  return {
+    dependencies: [],
+    regExpEnd: {
+      optional: true,
+      regExp: end
+    },
+    regExpStart: start,
+    replace: (rootNode, children, startMatch, endMatch, linesInBetween) => {
+      // console.log('LINK', linesInBetween);
+      const url = getHtmlTagAttrValue(startMatch[0], 'href') || '';
+      if (linesInBetween) {
+        const context = linesInBetween.join('\n');
+        const link$1 = link.$createLinkNode(url);
+        const nodes = parseTagContent(context);
+        link$1.append(...nodes);
+        rootNode.append(link$1);
+      }
+    },
+    type: 'multiline-element'
+  };
+});
+const HTML_HEADING_TRANSFORMER = [{
+  end: /[\u0020\t]*<\/h[1-6]{1}>$/,
+  start: /^[\u0020\t]*<h[1-6]{1}(?:[^>]*?)>/
+}].map(({
+  start,
+  end
+}) => {
+  return {
+    dependencies: [],
+    regExpEnd: {
+      optional: true,
+      regExp: end
+    },
+    regExpStart: start,
+    replace: (rootNode, children, startMatch, endMatch, linesInBetween) => {
+      // console.log('HEADING', linesInBetween);
+      if (linesInBetween) {
+        const tag = `h${(startMatch[0] || '11')[2]}`;
+        const context = linesInBetween.join('\n');
+        const heading = onchainLexicalInstance.$createInstanceHeadingNode(tag);
+        const nodes = parseTagContent(context);
+        heading.append(...nodes);
+        rootNode.append(heading);
+      }
+    },
+    type: 'multiline-element'
+  };
+});
+const HTML_EQUATION_TRANSFORMER = [{
+  end: /[\u0020\t]*<\/equation>$/,
+  start: /^[\u0020\t]*<equation(?:[^>]*?)>/
+}].map(({
+  start,
+  end
+}) => {
+  return {
+    dependencies: [],
+    regExpEnd: {
+      optional: true,
+      regExp: end
+    },
+    regExpStart: start,
+    replace: (rootNode, children, startMatch, endMatch, linesInBetween) => {
+      const equation = getHtmlTagAttrValue(startMatch[0], 'data-lexical-equation') || '';
+      const inline = getHtmlTagAttrValue(startMatch[0], 'data-lexical-inline') === 'true';
+      const node = onchainLexicalInstance.$createInstanceEquationNode(base64.fromBase64UTF8(equation), inline);
+      rootNode.append(node);
+    },
+    type: 'multiline-element'
+  };
+});
+
+// details
+
+const HTML_COLLAPSIBLE_TRANSFORMER = [{
+  end: /[\u0020\t]*<\/details>$/,
+  start: /^[\u0020\t]*<details(?:[^>]*?)>/
+}].map(({
+  start,
+  end
+}) => {
+  return {
+    dependencies: [],
+    regExpEnd: {
+      optional: true,
+      regExp: end
+    },
+    regExpStart: start,
+    replace: (rootNode, children, startMatch, endMatch, linesInBetween) => {
+      if (linesInBetween) {
+        const [title, content] = linesInBetween.join('\n').replace(/<summary(?:[^>]*?)>((.|[\n])*)<\/summary>((.|[\n])*)/, `$1${interval}$3`).split(interval).map(part => parseTagContent(part)).flat(1);
+        const isOpen = getHtmlTagAttrValue(startMatch[0], 'open') === 'true';
+        const node = onchainLexicalInstance.$createCollapsibleContainerNode(isOpen).append(onchainLexicalInstance.$createCollapsibleTitleNode().append(title), onchainLexicalInstance.$createCollapsibleContentNode().append(content));
+        rootNode.append(node);
+      }
+    },
+    type: 'multiline-element'
+  };
+});
+const HTML_FIGURE_TRANSFORMER = [{
+  end: /[\u0020\t]*<\/figure>$/,
+  start: /^[\u0020\t]*<figure(?:[^>]*?)>/
+}].map(({
+  start,
+  end
+}) => {
+  return {
+    dependencies: [],
+    regExpEnd: {
+      optional: true,
+      regExp: end
+    },
+    regExpStart: start,
+    replace: (rootNode, children, startMatch, endMatch, linesInBetween) => {
+      if (linesInBetween) {
+        const node = onchainLexicalInstance.$createPageBreakNode();
+        rootNode.append(node);
+      }
+    },
+    type: 'multiline-element'
+  };
+});
+const HTML_INTERNAL_LINK_TRANSFORMER = {
+  dependencies: [],
+  regExpEnd: {
+    regExp: /[\u0020\t]*<\/section>$/
+  },
+  regExpStart: /^[\u0020\t]*<section internal-link(?:[^>]*?)>/,
+  replace: (rootNode, children, startMatch, endMatch, linesInBetween) => {
+    // console.log('INTERNAL LINK MATCH', linesInBetween);
+    const number = getHtmlTagAttrValue(startMatch[0], 'data-internal-link-number');
+    if (number) {
+      const internalLinkNode = onchainLexicalInstance.$createInternalLinkNode(number);
+      rootNode.append(internalLinkNode);
+    }
+  },
+  type: 'multiline-element'
+};
+const HTML_PARAMETERS_TRANSFORMER = {
+  dependencies: [],
+  regExpEnd: {
+    regExp: /[\u0020\t]*<\/section>$/
+  },
+  regExpStart: /^[\u0020\t]*<section parameter(?:[^>]*?)>/,
+  replace: (rootNode, children, startMatch, endMatch, linesInBetween) => {
+    // console.log('INTERNAL PARAMETERS MATCH', linesInBetween);
+    const parameter = JSON.parse(base64.fromBase64UTF8(getHtmlTagAttrValue(startMatch[0], 'data-parameter') || ''));
+    if (parameter) {
+      const parameterNode = onchainLexicalInstance.$createParametersNode(parameter);
+      rootNode.append(parameterNode);
+    }
+  },
+  type: 'multiline-element'
+};
 const HTML_TEXT_TRANSFORMER = [{
   end: /[\u0020\t]*<\/span>$/,
-  start: /[\u0020\t]*<span.*?>/
+  start: /^[\u0020\t]*<span(?:[^>]*?)>/
+}, {
+  end: /[\u0020\t]*<\/em>$/,
+  start: /^[\u0020\t]*<em(?:[^>]*?)>/
+}, {
+  end: /[\u0020\t]*<\/strong>$/,
+  start: /^[\u0020\t]*<strong(?:[^>]*?)>/
 }].map(({
   start,
   end
@@ -1305,24 +1654,100 @@ const HTML_TEXT_TRANSFORMER = [{
     },
     regExpStart: start,
     replace: (rootNode, children, startMatch, endMatch, linesInBetween) => {
+      const input = startMatch.input || '';
+      const nodes = parseTagContent(input);
+      rootNode.append(...nodes);
+    },
+    type: 'multiline-element'
+  };
+});
+const HTML_TEXT_STYLES_TRANSFORMER = [{
+  end: /[\u0020\t]*<\/b>$/,
+  start: /^[\u0020\t]*<b>/
+}, {
+  end: /[\u0020\t]*<\/i>$/,
+  start: /^[\u0020\t]*<i>/
+}, {
+  end: /[\u0020\t]*<\/u>$/,
+  start: /^[\u0020\t]*<u>/
+}, {
+  end: /[\u0020\t]*<\/s>$/,
+  start: /^[\u0020\t]*<s>/
+}, {
+  end: /[\u0020\t]*<\/code>$/,
+  start: /^[\u0020\t]*<code(?:[^>]*?)>/
+}, {
+  end: /[\u0020\t]*<\/sub>$/,
+  start: /^[\u0020\t]*<sub(?:[^>]*?)>/
+}, {
+  end: /[\u0020\t]*<\/sup>$/,
+  start: /^[\u0020\t]*<sup(?:[^>]*?)>/
+}].map(({
+  start,
+  end
+}) => {
+  return {
+    dependencies: [],
+    regExpEnd: {
+      optional: true,
+      regExp: end
+    },
+    regExpStart: start,
+    replace: (rootNode, children, startMatch, endMatch, linesInBetween) => {
+      // console.log('TEXT_STYLES', linesInBetween);
       if (linesInBetween) {
-        const context = linesInBetween.join('\n').replace(/<br.*?\/>/g, '\n');
-        if (/<([a-z]+).*?>(.*?)<\/\1>/g.test(context)) {
-          const fragment = onchainLexicalInstance.$createFragmentNode();
-          $convertFromMarkdownString(context, TransFormerGather.value, fragment);
-          const children = fragment.getChildren();
-          rootNode.append(...children);
-        } else {
-          const text = lexical.$createTextNode();
-          text.setTextContent(context);
-          if (lexical.$isRootNode(rootNode)) {
-            const paragraph = onchainLexicalInstance.$createInstanceParagraphNode();
-            paragraph.append(text);
-            rootNode.append(paragraph);
-          } else {
-            rootNode.append(text);
+        const [isBold, isItalic, isUnderline, isStrikethrough, isCode, isSup, isSub] = [startMatch[0].includes('<b'), startMatch[0].includes('<i'), startMatch[0].includes('<u'), startMatch[0].includes('<s'), startMatch[0].includes('<code'), startMatch[0].includes('<sup'), startMatch[0].includes('<sub')];
+        const context = linesInBetween.join('\n');
+        const fragment = onchainLexicalInstance.$createFragmentNode();
+        $convertFromMarkdownString(context, TransFormerGather.value, fragment);
+        const nodes = fragment.getChildren();
+        nodes.forEach(node => {
+          if (lexical.$isTextNode(node)) {
+            if (isBold) {
+              if (node.hasFormat('bold')) {
+                return;
+              }
+              node.setFormat(node.getFormat() | lexical.TEXT_TYPE_TO_FORMAT.bold);
+            }
+            if (isItalic) {
+              if (node.hasFormat('italic')) {
+                return;
+              }
+              node.setFormat(node.getFormat() | lexical.TEXT_TYPE_TO_FORMAT.italic);
+            }
+            if (isUnderline) {
+              if (node.hasFormat('underline')) {
+                return;
+              }
+              node.setFormat(node.getFormat() | lexical.TEXT_TYPE_TO_FORMAT.underline);
+            }
+            if (isStrikethrough) {
+              if (node.hasFormat('strikethrough')) {
+                return;
+              }
+              node.setFormat(node.getFormat() | lexical.TEXT_TYPE_TO_FORMAT.strikethrough);
+            }
+            if (isCode) {
+              if (node.hasFormat('code')) {
+                return;
+              }
+              node.setFormat(node.getFormat() | lexical.TEXT_TYPE_TO_FORMAT.code);
+            }
+            if (isSup) {
+              if (node.hasFormat('superscript')) {
+                return;
+              }
+              node.setFormat(node.getFormat() | lexical.TEXT_TYPE_TO_FORMAT.superscript);
+            }
+            if (isSub) {
+              if (node.hasFormat('subscript')) {
+                return;
+              }
+              node.setFormat(node.getFormat() | lexical.TEXT_TYPE_TO_FORMAT.subscript);
+            }
           }
-        }
+        });
+        rootNode.append(...nodes);
       }
     },
     type: 'multiline-element'
@@ -1336,28 +1761,103 @@ const HTML_BR = {
     }
     return null;
   },
-  regExp: /^<br.*?\/>$/,
+  regExp: /^<br(?:[^>]*?)\/{0,1}>/,
   replace: (parentNode, _1, _2, isImport) => {
     const line = lexical.$createLineBreakNode();
-    const paragraph = onchainLexicalInstance.$createInstanceParagraphNode();
-    paragraph.append(line);
     if (isImport || parentNode.getNextSibling() != null) {
-      if (lexical.$isRootNode(parentNode.getParent())) {
-        parentNode.replace(paragraph);
-      } else {
-        parentNode.replace(line);
-      }
+      parentNode.replace(line);
     } else {
-      if (lexical.$isRootNode(parentNode.getParent())) {
-        parentNode.insertBefore(paragraph);
-      } else {
-        parentNode.insertBefore(line);
-      }
+      parentNode.insertBefore(line);
     }
-    line.selectNext();
   },
   type: 'element'
 };
+const HTML_IMAGE = {
+  dependencies: [],
+  export: node => {
+    if (onchainLexicalInstance.$isImageNode(node)) {
+      return `![${node.getAltText()}](${node.getSrc()})`;
+    }
+    return null;
+  },
+  regExp: /^<img(?:[^>]*?)\/{0,1}>/,
+  replace: (parentNode, _1, match, isImport) => {
+    const input = match.input || '';
+    const url = getHtmlTagAttrValue(input, 'href') || '';
+    const alt = getHtmlTagAttrValue(input, 'alt') || '';
+    const image = onchainLexicalInstance.$createImageNode({
+      altText: alt,
+      src: url
+    });
+    if (isImport || parentNode.getNextSibling() != null) {
+      parentNode.replace(image);
+    } else {
+      parentNode.insertBefore(image);
+    }
+  },
+  type: 'element'
+};
+const HTML_HR = {
+  dependencies: [],
+  export: node => {
+    if (LexicalHorizontalRuleNode.$isHorizontalRuleNode(node)) {
+      return '***';
+    }
+    return null;
+  },
+  regExp: /^<hr(?:[^>]*?)\/{0,1}>/,
+  replace: (parentNode, _1, match, isImport) => {
+    const horizontal = onchainLexicalInstance.$createInstanceHorizontalRuleNode();
+    if (isImport || parentNode.getNextSibling() != null) {
+      parentNode.replace(horizontal);
+    } else {
+      parentNode.insertBefore(horizontal);
+    }
+  },
+  type: 'element'
+};
+function optimizeNesting(node, context) {
+  const nodes = parseTagContent(context);
+  if (nodes.length === 1 && nodes[0] instanceof node.constructor) {
+    node = nodes[0];
+  } else {
+    node.append(...nodes);
+  }
+  return node;
+}
+function parseTagContent(input) {
+  // console.log(input, 'PARSE TAG CONTENT');
+  const structure = parseHtmlToCustomStructure(input);
+  let htmlFragment = document.createElement('div');
+  onchainUtility.dfs(structure, (object, parent) => {
+    if (['span', 'em', 'strong'].includes(object.tag)) {
+      const text = lexical.$createTextNode();
+      object.node = text;
+    } else if (object.tag === 'text') {
+      if (parent && parent.node) {
+        if (lexical.$isElementNode(parent.node)) {
+          const text = lexical.$createTextNode();
+          text.setTextContent(object.content);
+          parent.node.append(text);
+        } else {
+          if (lexical.$isTextNode(parent.node)) {
+            parent.node.setTextContent(object.content);
+          }
+        }
+      }
+    } else {
+      htmlFragment.childNodes.forEach(element => element.remove());
+      htmlFragment.append(object.dom);
+      const fragment = onchainLexicalInstance.$createFragmentNode();
+      $convertFromMarkdownString(htmlFragment.innerHTML, TransFormerGather.value, fragment);
+      object.node = fragment.getChildren()[0];
+      object.dom = null;
+    }
+    return object.children;
+  });
+  htmlFragment = null;
+  return structure.map(object => object.node).filter(Boolean);
+}
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -1684,7 +2184,7 @@ TransFormerGather.register(BLOCK_EQUATION);
 TransFormerGather.register(IMAGE);
 TransFormerGather.register(PAGE_BREAK);
 TransFormerGather.register(PAGE_BREAK);
-[...HTML_PARAGRAPH_TRANSFORMER, ...HTML_TEXT_TRANSFORMER, HTML_BR].forEach(item => {
+[...HTML_CODE_TRANSFORMER, ...HTML_QUOTE_TRANSFORMER, ...HTML_LIST_TRANSFORMER, ...HTML_HEADING_TRANSFORMER, ...HTML_LINK_TRANSFORMER, ...HTML_EQUATION_TRANSFORMER, ...HTML_COLLAPSIBLE_TRANSFORMER, ...HTML_FIGURE_TRANSFORMER, ...HTML_PARAGRAPH_TRANSFORMER, HTML_INTERNAL_LINK_TRANSFORMER, HTML_PARAMETERS_TRANSFORMER, ...HTML_TEXT_STYLES_TRANSFORMER, ...HTML_TEXT_TRANSFORMER, HTML_BR, HTML_IMAGE, HTML_HR].forEach(item => {
   TransFormerGather.register(item);
 });
 function getInstanceTransformers() {
@@ -1721,6 +2221,14 @@ function $convertFromMarkdownString(markdown, transformers = TransFormerGather.v
  */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+/** reqIf xmlns 子标签单行排列 */
+function xmlnsSingleLine(markdown) {
+  if (/^<div xmlns(?:[^>]*?)>/.test(markdown)) {
+    const mks = markdown.split('\n');
+    markdown = htmlTagSingleLine(mks.slice(1, mks.length - 1).join('\n'));
+  }
+  return markdown;
+}
 const markdownToSerializedNode = async ({
   nodes,
   markdown
@@ -1731,8 +2239,10 @@ const markdownToSerializedNode = async ({
         namespace: 'temporary',
         nodes
       }).update(() => {
-        $convertFromMarkdownString(markdown, getInstanceTransformers());
-        resolve(lexical.exportNodeToJSON(lexical.$getRoot()).children || []);
+        const fragment = onchainLexicalInstance.$createFragmentNode();
+        markdown = xmlnsSingleLine(markdown);
+        $convertFromMarkdownString(markdown, getInstanceTransformers(), fragment);
+        resolve(lexical.exportNodeToJSON(fragment).children || []);
       });
     } catch (e) {
       const _console = console;
@@ -1833,6 +2343,7 @@ async function _textToSerializedNode(nodes, childrenText) {
     if (jsonRegExp.test(childrenText)) {
       return JSON.parse(childrenText.replace(jsonRegExp, '$1'));
     } else {
+      childrenText = xmlnsSingleLine(childrenText);
       return await markdownToSerializedNode({
         markdown: childrenText,
         nodes
@@ -1846,6 +2357,7 @@ function $textToRichNodes(node, childrenText) {
       const serializedNodeList = [JSON.parse(childrenText.replace(jsonRegExp, '$1'))];
       return node.append(...serializedNodeList.flat(1).map(serializedNode => file.$advanceParseSerializedNode(serializedNode)));
     } else {
+      childrenText = xmlnsSingleLine(childrenText);
       return $convertFromMarkdownString(childrenText, getInstanceTransformers(), node);
     }
   }