@payloadcms/richtext-lexical 3.12.0 → 3.12.1-canary.7fea7e5

package/dist/features/link/markdownTransformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"markdownTransformer.d.ts","sourceRoot":"","sources":["../../../src/features/link/markdownTransformer.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0DAA0D,CAAA;AAKpG,eAAO,MAAM,uBAAuB,EAAE,oBAqCrC,CAAA"}
+{"version":3,"file":"markdownTransformer.d.ts","sourceRoot":"","sources":["../../../src/features/link/markdownTransformer.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0DAA0D,CAAA;AAKpG,eAAO,MAAM,uBAAuB,EAAE,oBAoCrC,CAAA"}

package/dist/features/link/markdownTransformer.js

@@ -3,13 +3,13 @@
  */ // Order of text transformers matters:
 //
 // - code should go first as it prevents any transformations inside
-import { $createTextNode, $isTextNode } from 'lexical';
+import { $createTextNode } from 'lexical';
 import { $createLinkNode, $isLinkNode, LinkNode } from './nodes/LinkNode.js';
 // - then longer tags match (e.g. ** or __ should go before * or _)
 export const LinkMarkdownTransformer = {
   type: 'text-match',
   dependencies: [LinkNode],
-  export: (_node, exportChildren, exportFormat) => {
+  export: (_node, exportChildren) => {
     if (!$isLinkNode(_node)) {
       return null;
     }
@@ -17,15 +17,9 @@ export const LinkMarkdownTransformer = {
     const {
       url
     } = node.getFields();
-    const linkContent = `[${node.getTextContent()}](${url})`;
-    const firstChild = node.getFirstChild();
-    // Add text styles only if link has single text node inside. If it's more
-    // then one we ignore it as markdown does not support nested styles for links
-    if (node.getChildrenSize() === 1 && $isTextNode(firstChild)) {
-      return exportFormat(firstChild, linkContent);
-    } else {
-      return linkContent;
-    }
+    const textContent = exportChildren(node);
+    const linkContent = `[${textContent}](${url})`;
+    return linkContent;
   },
   importRegExp: /\[([^[]+)\]\(([^()\s]+)(?:\s"((?:[^"]*\\")*[^"]*)"\s*)?\)/,
   regExp: /\[([^[]+)\]\(([^()\s]+)(?:\s"((?:[^"]*\\")*[^"]*)"\s*)?\)$/,
@@ -43,6 +37,7 @@ export const LinkMarkdownTransformer = {
     linkTextNode.setFormat(textNode.getFormat());
     linkNode.append(linkTextNode);
     textNode.replace(linkNode);
+    return linkTextNode;
   },
   trigger: ')'
 };

package/dist/features/link/markdownTransformer.js.map

@@ -1 +1 @@
-{"version":3,"file":"markdownTransformer.js","names":["$createTextNode","$isTextNode","$createLinkNode","$isLinkNode","LinkNode","LinkMarkdownTransformer","type","dependencies","export","_node","exportChildren","exportFormat","node","url","getFields","linkContent","getTextContent","firstChild","getFirstChild","getChildrenSize","importRegExp","regExp","replace","textNode","match","linkText","linkUrl","linkNode","fields","doc","linkType","newTab","linkTextNode","setFormat","getFormat","append","trigger"],"sources":["../../../src/features/link/markdownTransformer.ts"],"sourcesContent":["/**\n * Code taken from https://github.com/facebook/lexical/blob/main/packages/lexical-markdown/src/MarkdownTransformers.ts#L357\n */\n\n// Order of text transformers matters:\n//\n// - code should go first as it prevents any transformations inside\n\nimport { $createTextNode, $isTextNode } from 'lexical'\n\nimport type { TextMatchTransformer } from '../../packages/@lexical/markdown/MarkdownTransformers.js'\n\nimport { $createLinkNode, $isLinkNode, LinkNode } from './nodes/LinkNode.js'\n\n// - then longer tags match (e.g. ** or __ should go before * or _)\nexport const LinkMarkdownTransformer: TextMatchTransformer = {\n  type: 'text-match',\n  dependencies: [LinkNode],\n  export: (_node, exportChildren, exportFormat) => {\n    if (!$isLinkNode(_node)) {\n      return null\n    }\n    const node: LinkNode = _node\n    const { url } = node.getFields()\n    const linkContent = `[${node.getTextContent()}](${url})`\n    const firstChild = node.getFirstChild()\n    // Add text styles only if link has single text node inside. If it's more\n    // then one we ignore it as markdown does not support nested styles for links\n    if (node.getChildrenSize() === 1 && $isTextNode(firstChild)) {\n      return exportFormat(firstChild, linkContent)\n    } else {\n      return linkContent\n    }\n  },\n  importRegExp: /\\[([^[]+)\\]\\(([^()\\s]+)(?:\\s\"((?:[^\"]*\\\\\")*[^\"]*)\"\\s*)?\\)/,\n  regExp: /\\[([^[]+)\\]\\(([^()\\s]+)(?:\\s\"((?:[^\"]*\\\\\")*[^\"]*)\"\\s*)?\\)$/,\n  replace: (textNode, match) => {\n    const [, linkText, linkUrl] = match\n    const linkNode = $createLinkNode({\n      fields: {\n        doc: null,\n        linkType: 'custom',\n        newTab: false,\n        url: linkUrl,\n      },\n    })\n    const linkTextNode = $createTextNode(linkText)\n    linkTextNode.setFormat(textNode.getFormat())\n    linkNode.append(linkTextNode)\n    textNode.replace(linkNode)\n  },\n  trigger: ')',\n}\n"],"mappings":"AAAA;;GAAA,CAIA;AACA;AACA;AAEA,SAASA,eAAe,EAAEC,WAAW,QAAQ;AAI7C,SAASC,eAAe,EAAEC,WAAW,EAAEC,QAAQ,QAAQ;AAEvD;AACA,OAAO,MAAMC,uBAAA,GAAgD;EAC3DC,IAAA,EAAM;EACNC,YAAA,EAAc,CAACH,QAAA,CAAS;EACxBI,MAAA,EAAQA,CAACC,KAAA,EAAOC,cAAA,EAAgBC,YAAA;IAC9B,IAAI,CAACR,WAAA,CAAYM,KAAA,GAAQ;MACvB,OAAO;IACT;IACA,MAAMG,IAAA,GAAiBH,KAAA;IACvB,MAAM;MAAEI;IAAG,CAAE,GAAGD,IAAA,CAAKE,SAAS;IAC9B,MAAMC,WAAA,GAAc,IAAIH,IAAA,CAAKI,cAAc,OAAOH,GAAA,GAAM;IACxD,MAAMI,UAAA,GAAaL,IAAA,CAAKM,aAAa;IACrC;IACA;IACA,IAAIN,IAAA,CAAKO,eAAe,OAAO,KAAKlB,WAAA,CAAYgB,UAAA,GAAa;MAC3D,OAAON,YAAA,CAAaM,UAAA,EAAYF,WAAA;IAClC,OAAO;MACL,OAAOA,WAAA;IACT;EACF;EACAK,YAAA,EAAc;EACdC,MAAA,EAAQ;EACRC,OAAA,EAASA,CAACC,QAAA,EAAUC,KAAA;IAClB,MAAM,GAAGC,QAAA,EAAUC,OAAA,CAAQ,GAAGF,KAAA;IAC9B,MAAMG,QAAA,GAAWzB,eAAA,CAAgB;MAC/B0B,MAAA,EAAQ;QACNC,GAAA,EAAK;QACLC,QAAA,EAAU;QACVC,MAAA,EAAQ;QACRlB,GAAA,EAAKa;MACP;IACF;IACA,MAAMM,YAAA,GAAehC,eAAA,CAAgByB,QAAA;IACrCO,YAAA,CAAaC,SAAS,CAACV,QAAA,CAASW,SAAS;IACzCP,QAAA,CAASQ,MAAM,CAACH,YAAA;IAChBT,QAAA,CAASD,OAAO,CAACK,QAAA;EACnB;EACAS,OAAA,EAAS;AACX","ignoreList":[]}
+{"version":3,"file":"markdownTransformer.js","names":["$createTextNode","$createLinkNode","$isLinkNode","LinkNode","LinkMarkdownTransformer","type","dependencies","export","_node","exportChildren","node","url","getFields","textContent","linkContent","importRegExp","regExp","replace","textNode","match","linkText","linkUrl","linkNode","fields","doc","linkType","newTab","linkTextNode","setFormat","getFormat","append","trigger"],"sources":["../../../src/features/link/markdownTransformer.ts"],"sourcesContent":["/**\n * Code taken from https://github.com/facebook/lexical/blob/main/packages/lexical-markdown/src/MarkdownTransformers.ts#L357\n */\n\n// Order of text transformers matters:\n//\n// - code should go first as it prevents any transformations inside\n\nimport { $createTextNode, $isTextNode } from 'lexical'\n\nimport type { TextMatchTransformer } from '../../packages/@lexical/markdown/MarkdownTransformers.js'\n\nimport { $createLinkNode, $isLinkNode, LinkNode } from './nodes/LinkNode.js'\n\n// - then longer tags match (e.g. ** or __ should go before * or _)\nexport const LinkMarkdownTransformer: TextMatchTransformer = {\n  type: 'text-match',\n  dependencies: [LinkNode],\n  export: (_node, exportChildren) => {\n    if (!$isLinkNode(_node)) {\n      return null\n    }\n    const node: LinkNode = _node\n    const { url } = node.getFields()\n\n    const textContent = exportChildren(node)\n\n    const linkContent = `[${textContent}](${url})`\n\n    return linkContent\n  },\n  importRegExp: /\\[([^[]+)\\]\\(([^()\\s]+)(?:\\s\"((?:[^\"]*\\\\\")*[^\"]*)\"\\s*)?\\)/,\n  regExp: /\\[([^[]+)\\]\\(([^()\\s]+)(?:\\s\"((?:[^\"]*\\\\\")*[^\"]*)\"\\s*)?\\)$/,\n  replace: (textNode, match) => {\n    const [, linkText, linkUrl] = match\n    const linkNode = $createLinkNode({\n      fields: {\n        doc: null,\n        linkType: 'custom',\n        newTab: false,\n        url: linkUrl,\n      },\n    })\n    const linkTextNode = $createTextNode(linkText)\n    linkTextNode.setFormat(textNode.getFormat())\n    linkNode.append(linkTextNode)\n    textNode.replace(linkNode)\n\n    return linkTextNode\n  },\n  trigger: ')',\n}\n"],"mappings":"AAAA;;GAAA,CAIA;AACA;AACA;AAEA,SAASA,eAAe,QAAqB;AAI7C,SAASC,eAAe,EAAEC,WAAW,EAAEC,QAAQ,QAAQ;AAEvD;AACA,OAAO,MAAMC,uBAAA,GAAgD;EAC3DC,IAAA,EAAM;EACNC,YAAA,EAAc,CAACH,QAAA,CAAS;EACxBI,MAAA,EAAQA,CAACC,KAAA,EAAOC,cAAA;IACd,IAAI,CAACP,WAAA,CAAYM,KAAA,GAAQ;MACvB,OAAO;IACT;IACA,MAAME,IAAA,GAAiBF,KAAA;IACvB,MAAM;MAAEG;IAAG,CAAE,GAAGD,IAAA,CAAKE,SAAS;IAE9B,MAAMC,WAAA,GAAcJ,cAAA,CAAeC,IAAA;IAEnC,MAAMI,WAAA,GAAc,IAAID,WAAA,KAAgBF,GAAA,GAAM;IAE9C,OAAOG,WAAA;EACT;EACAC,YAAA,EAAc;EACdC,MAAA,EAAQ;EACRC,OAAA,EAASA,CAACC,QAAA,EAAUC,KAAA;IAClB,MAAM,GAAGC,QAAA,EAAUC,OAAA,CAAQ,GAAGF,KAAA;IAC9B,MAAMG,QAAA,GAAWrB,eAAA,CAAgB;MAC/BsB,MAAA,EAAQ;QACNC,GAAA,EAAK;QACLC,QAAA,EAAU;QACVC,MAAA,EAAQ;QACRf,GAAA,EAAKU;MACP;IACF;IACA,MAAMM,YAAA,GAAe3B,eAAA,CAAgBoB,QAAA;IACrCO,YAAA,CAAaC,SAAS,CAACV,QAAA,CAASW,SAAS;IACzCP,QAAA,CAASQ,MAAM,CAACH,YAAA;IAChBT,QAAA,CAASD,OAAO,CAACK,QAAA;IAEjB,OAAOK,YAAA;EACT;EACAI,OAAA,EAAS;AACX","ignoreList":[]}

package/dist/packages/@lexical/markdown/MarkdownExport.js

@@ -51,15 +51,28 @@ function exportTopLevelElements(node, elementTransformers, textTransformersIndex
     return null;
   }
 }
-function exportChildren(node, textTransformersIndex, textMatchTransformers) {
+function exportChildren(node, textTransformersIndex, textMatchTransformers, unclosedTags, unclosableTags) {
   const output = [];
   const children = node.getChildren();
+  // keep track of unclosed tags from the very beginning
+  if (!unclosedTags) {
+    unclosedTags = [];
+  }
+  if (!unclosableTags) {
+    unclosableTags = [];
+  }
   mainLoop: for (const child of children) {
     for (const transformer of textMatchTransformers) {
       if (!transformer.export) {
         continue;
       }
-      const result = transformer.export(child, parentNode => exportChildren(parentNode, textTransformersIndex, textMatchTransformers), (textNode, textContent) => exportTextFormat(textNode, textContent, textTransformersIndex));
+      const result = transformer.export(child, parentNode => exportChildren(parentNode, textTransformersIndex, textMatchTransformers, unclosedTags,
+      // Add current unclosed tags to the list of unclosable tags - we don't want nested tags from
+      // textmatch transformers to close the outer ones, as that may result in invalid markdown.
+      // E.g. **text [text**](https://lexical.io)
+      // is invalid markdown, as the closing ** is inside the link.
+      //
+      [...unclosableTags, ...unclosedTags]), (textNode, textContent) => exportTextFormat(textNode, textContent, textTransformersIndex, unclosedTags, unclosableTags));
       if (result != null) {
         output.push(result);
         continue mainLoop;
@@ -68,44 +81,85 @@ function exportChildren(node, textTransformersIndex, textMatchTransformers) {
     if ($isLineBreakNode(child)) {
       output.push('\n');
     } else if ($isTextNode(child)) {
-      output.push(exportTextFormat(child, child.getTextContent(), textTransformersIndex));
+      output.push(exportTextFormat(child, child.getTextContent(), textTransformersIndex, unclosedTags, unclosableTags));
     } else if ($isElementNode(child)) {
       // empty paragraph returns ""
-      output.push(exportChildren(child, textTransformersIndex, textMatchTransformers));
+      output.push(exportChildren(child, textTransformersIndex, textMatchTransformers, unclosedTags, unclosableTags));
     } else if ($isDecoratorNode(child)) {
       output.push(child.getTextContent());
     }
   }
   return output.join('');
 }
-function exportTextFormat(node, textContent, textTransformers) {
+function exportTextFormat(node, textContent, textTransformers,
+// unclosed tags include the markdown tags that haven't been closed yet, and their associated formats
+unclosedTags, unclosableTags) {
   // This function handles the case of a string looking like this: "   foo   "
   // Where it would be invalid markdown to generate: "**   foo   **"
   // We instead want to trim the whitespace out, apply formatting, and then
   // bring the whitespace back. So our returned string looks like this: "   **foo**   "
   const frozenString = textContent.trim();
   let output = frozenString;
+  // the opening tags to be added to the result
+  let openingTags = '';
+  // the closing tags to be added to the result
+  let closingTagsBefore = '';
+  let closingTagsAfter = '';
+  const prevNode = getTextSibling(node, true);
+  const nextNode = getTextSibling(node, false);
   const applied = new Set();
   for (const transformer of textTransformers) {
     const format = transformer.format[0];
     const tag = transformer.tag;
+    // dedup applied formats
     if (hasFormat(node, format) && !applied.has(format)) {
       // Multiple tags might be used for the same format (*, _)
       applied.add(format);
-      // Prevent adding opening tag is already opened by the previous sibling
-      const previousNode = getTextSibling(node, true);
-      if (!hasFormat(previousNode, format)) {
-        output = tag + output;
+      // append the tag to openningTags, if it's not applied to the previous nodes,
+      // or the nodes before that (which would result in an unclosed tag)
+      if (!hasFormat(prevNode, format) || !unclosedTags.find(element => element.tag === tag)) {
+        unclosedTags.push({
+          format,
+          tag
+        });
+        openingTags += tag;
+      }
+    }
+  }
+  // close any tags in the same order they were applied, if necessary
+  for (let i = 0; i < unclosedTags.length; i++) {
+    const nodeHasFormat = hasFormat(node, unclosedTags[i].format);
+    const nextNodeHasFormat = hasFormat(nextNode, unclosedTags[i].format);
+    // prevent adding closing tag if next sibling will do it
+    if (nodeHasFormat && nextNodeHasFormat) {
+      continue;
+    }
+    const unhandledUnclosedTags = [...unclosedTags] // Shallow copy to avoid modifying the original array
+    ;
+    while (unhandledUnclosedTags.length > i) {
+      const unclosedTag = unhandledUnclosedTags.pop();
+      // If tag is unclosable, don't close it and leave it in the original array,
+      // So that it can be closed when it's no longer unclosable
+      if (unclosableTags && unclosedTag && unclosableTags.find(element => element.tag === unclosedTag.tag)) {
+        continue;
       }
-      // Prevent adding closing tag if next sibling will do it
-      const nextNode = getTextSibling(node, false);
-      if (!hasFormat(nextNode, format)) {
-        output += tag;
+      if (unclosedTag && typeof unclosedTag.tag === 'string') {
+        if (!nodeHasFormat) {
+          // Handles cases where the tag has not been closed before, e.g. if the previous node
+          // was a text match transformer that did not account for closing tags of the next node (e.g. a link)
+          closingTagsBefore += unclosedTag.tag;
+        } else if (!nextNodeHasFormat) {
+          closingTagsAfter += unclosedTag.tag;
+        }
       }
+      // Mutate the original array to remove the closed tag
+      unclosedTags.pop();
     }
+    break;
   }
+  output = openingTags + output + closingTagsAfter;
   // Replace trimmed version of textContent ensuring surrounding whitespace is not modified
-  return textContent.replace(frozenString, () => output);
+  return closingTagsBefore + textContent.replace(frozenString, () => output);
 }
 // Get next or previous text sibling a text node, including cases
 // when it's a child of inline element (e.g. link)

package/dist/packages/@lexical/markdown/MarkdownExport.js.map

@@ -1 +1 @@
-{"version":3,"file":"MarkdownExport.js","names":["$getRoot","$isDecoratorNode","$isElementNode","$isLineBreakNode","$isTextNode","isEmptyParagraph","transformersByType","createMarkdownExport","transformers","shouldPreserveNewLines","byType","elementTransformers","multilineElement","element","isNewlineDelimited","textFormatTransformers","textFormat","filter","transformer","format","length","node","output","children","getChildren","i","child","result","exportTopLevelElements","textMatch","push","concat","join","textTransformersIndex","textMatchTransformers","export","_node","exportChildren","getTextContent","mainLoop","parentNode","textNode","textContent","exportTextFormat","textTransformers","frozenString","trim","applied","Set","tag","hasFormat","has","add","previousNode","getTextSibling","nextNode","replace","backward","sibling","getPreviousSibling","getNextSibling","parent","getParentOrThrow","isInline","descendant","getLastDescendant","getFirstDescendant"],"sources":["../../../../src/packages/@lexical/markdown/MarkdownExport.ts"],"sourcesContent":["/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport type { ElementNode, LexicalNode, TextFormatType, TextNode } from 'lexical'\n\nimport { $getRoot, $isDecoratorNode, $isElementNode, $isLineBreakNode, $isTextNode } from 'lexical'\n\nimport type {\n  ElementTransformer,\n  MultilineElementTransformer,\n  TextFormatTransformer,\n  TextMatchTransformer,\n  Transformer,\n} from './MarkdownTransformers.js'\n\nimport { isEmptyParagraph, transformersByType } from './utils.js'\n\n/**\n * Renders string from markdown. The selection is moved to the start after the operation.\n */\nexport function createMarkdownExport(\n  transformers: Array<Transformer>,\n  shouldPreserveNewLines: boolean = false,\n): (node?: ElementNode) => string {\n  const byType = transformersByType(transformers)\n  const elementTransformers = [...byType.multilineElement, ...byType.element]\n  const isNewlineDelimited = !shouldPreserveNewLines\n\n  // Export only uses text formats that are responsible for single format\n  // e.g. it will filter out *** (bold, italic) and instead use separate ** and *\n  const textFormatTransformers = byType.textFormat.filter(\n    (transformer) => transformer.format.length === 1,\n  )\n\n  return (node) => {\n    const output: string[] = []\n    const children = (node || $getRoot()).getChildren()\n\n    for (let i = 0; i < children.length; i++) {\n      const child = children[i]\n      const result = exportTopLevelElements(\n        child,\n        elementTransformers,\n        textFormatTransformers,\n        byType.textMatch,\n      )\n\n      if (result != null) {\n        output.push(\n          // separate consecutive group of texts with a line break: eg. [\"hello\", \"world\"] -> [\"hello\", \"/nworld\"]\n          isNewlineDelimited &&\n            i > 0 &&\n            !isEmptyParagraph(child) &&\n            !isEmptyParagraph(children[i - 1])\n            ? '\\n'.concat(result)\n            : result,\n        )\n      }\n    }\n    // Ensure consecutive groups of texts are at least \\n\\n apart while each empty paragraph render as a newline.\n    // Eg. [\"hello\", \"\", \"\", \"hi\", \"\\nworld\"] -> \"hello\\n\\n\\nhi\\n\\nworld\"\n    return output.join('\\n')\n  }\n}\n\nfunction exportTopLevelElements(\n  node: LexicalNode,\n  elementTransformers: Array<ElementTransformer | MultilineElementTransformer>,\n  textTransformersIndex: Array<TextFormatTransformer>,\n  textMatchTransformers: Array<TextMatchTransformer>,\n): null | string {\n  for (const transformer of elementTransformers) {\n    if (!transformer.export) {\n      continue\n    }\n    const result = transformer.export(node, (_node) =>\n      exportChildren(_node, textTransformersIndex, textMatchTransformers),\n    )\n\n    if (result != null) {\n      return result\n    }\n  }\n\n  if ($isElementNode(node)) {\n    return exportChildren(node, textTransformersIndex, textMatchTransformers)\n  } else if ($isDecoratorNode(node)) {\n    return node.getTextContent()\n  } else {\n    return null\n  }\n}\n\nfunction exportChildren(\n  node: ElementNode,\n  textTransformersIndex: Array<TextFormatTransformer>,\n  textMatchTransformers: Array<TextMatchTransformer>,\n): string {\n  const output: string[] = []\n  const children = node.getChildren()\n\n  mainLoop: for (const child of children) {\n    for (const transformer of textMatchTransformers) {\n      if (!transformer.export) {\n        continue\n      }\n\n      const result = transformer.export(\n        child,\n        (parentNode) => exportChildren(parentNode, textTransformersIndex, textMatchTransformers),\n        (textNode, textContent) => exportTextFormat(textNode, textContent, textTransformersIndex),\n      )\n\n      if (result != null) {\n        output.push(result)\n        continue mainLoop\n      }\n    }\n\n    if ($isLineBreakNode(child)) {\n      output.push('\\n')\n    } else if ($isTextNode(child)) {\n      output.push(exportTextFormat(child, child.getTextContent(), textTransformersIndex))\n    } else if ($isElementNode(child)) {\n      // empty paragraph returns \"\"\n      output.push(exportChildren(child, textTransformersIndex, textMatchTransformers))\n    } else if ($isDecoratorNode(child)) {\n      output.push(child.getTextContent())\n    }\n  }\n\n  return output.join('')\n}\n\nfunction exportTextFormat(\n  node: TextNode,\n  textContent: string,\n  textTransformers: Array<TextFormatTransformer>,\n): string {\n  // This function handles the case of a string looking like this: \"   foo   \"\n  // Where it would be invalid markdown to generate: \"**   foo   **\"\n  // We instead want to trim the whitespace out, apply formatting, and then\n  // bring the whitespace back. So our returned string looks like this: \"   **foo**   \"\n  const frozenString = textContent.trim()\n  let output = frozenString\n\n  const applied = new Set()\n\n  for (const transformer of textTransformers) {\n    const format = transformer.format[0]\n    const tag = transformer.tag\n\n    if (hasFormat(node, format) && !applied.has(format)) {\n      // Multiple tags might be used for the same format (*, _)\n      applied.add(format)\n      // Prevent adding opening tag is already opened by the previous sibling\n      const previousNode = getTextSibling(node, true)\n\n      if (!hasFormat(previousNode, format)) {\n        output = tag + output\n      }\n\n      // Prevent adding closing tag if next sibling will do it\n      const nextNode = getTextSibling(node, false)\n\n      if (!hasFormat(nextNode, format)) {\n        output += tag\n      }\n    }\n  }\n\n  // Replace trimmed version of textContent ensuring surrounding whitespace is not modified\n  return textContent.replace(frozenString, () => output)\n}\n\n// Get next or previous text sibling a text node, including cases\n// when it's a child of inline element (e.g. link)\nfunction getTextSibling(node: TextNode, backward: boolean): null | TextNode {\n  let sibling = backward ? node.getPreviousSibling() : node.getNextSibling()\n\n  if (!sibling) {\n    const parent = node.getParentOrThrow()\n\n    if (parent.isInline()) {\n      sibling = backward ? parent.getPreviousSibling() : parent.getNextSibling()\n    }\n  }\n\n  while (sibling) {\n    if ($isElementNode(sibling)) {\n      if (!sibling.isInline()) {\n        break\n      }\n\n      const descendant = backward ? sibling.getLastDescendant() : sibling.getFirstDescendant()\n\n      if ($isTextNode(descendant)) {\n        return descendant\n      } else {\n        sibling = backward ? sibling.getPreviousSibling() : sibling.getNextSibling()\n      }\n    }\n\n    if ($isTextNode(sibling)) {\n      return sibling\n    }\n\n    if (!$isElementNode(sibling)) {\n      return null\n    }\n  }\n\n  return null\n}\n\nfunction hasFormat(node: LexicalNode | null | undefined, format: TextFormatType): boolean {\n  return $isTextNode(node) && node.hasFormat(format)\n}\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"MarkdownExport.js","names":["$getRoot","$isDecoratorNode","$isElementNode","$isLineBreakNode","$isTextNode","isEmptyParagraph","transformersByType","createMarkdownExport","transformers","shouldPreserveNewLines","byType","elementTransformers","multilineElement","element","isNewlineDelimited","textFormatTransformers","textFormat","filter","transformer","format","length","node","output","children","getChildren","i","child","result","exportTopLevelElements","textMatch","push","concat","join","textTransformersIndex","textMatchTransformers","export","_node","exportChildren","getTextContent","unclosedTags","unclosableTags","mainLoop","parentNode","textNode","textContent","exportTextFormat","textTransformers","frozenString","trim","openingTags","closingTagsBefore","closingTagsAfter","prevNode","getTextSibling","nextNode","applied","Set","tag","hasFormat","has","add","find","nodeHasFormat","nextNodeHasFormat","unhandledUnclosedTags","unclosedTag","pop","replace","backward","sibling","getPreviousSibling","getNextSibling","parent","getParentOrThrow","isInline","descendant","getLastDescendant","getFirstDescendant"],"sources":["../../../../src/packages/@lexical/markdown/MarkdownExport.ts"],"sourcesContent":["/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport type { ElementNode, LexicalNode, TextFormatType, TextNode } from 'lexical'\n\nimport { $getRoot, $isDecoratorNode, $isElementNode, $isLineBreakNode, $isTextNode } from 'lexical'\n\nimport type {\n  ElementTransformer,\n  MultilineElementTransformer,\n  TextFormatTransformer,\n  TextMatchTransformer,\n  Transformer,\n} from './MarkdownTransformers.js'\n\nimport { isEmptyParagraph, transformersByType } from './utils.js'\n\n/**\n * Renders string from markdown. The selection is moved to the start after the operation.\n */\nexport function createMarkdownExport(\n  transformers: Array<Transformer>,\n  shouldPreserveNewLines: boolean = false,\n): (node?: ElementNode) => string {\n  const byType = transformersByType(transformers)\n  const elementTransformers = [...byType.multilineElement, ...byType.element]\n  const isNewlineDelimited = !shouldPreserveNewLines\n\n  // Export only uses text formats that are responsible for single format\n  // e.g. it will filter out *** (bold, italic) and instead use separate ** and *\n  const textFormatTransformers = byType.textFormat.filter(\n    (transformer) => transformer.format.length === 1,\n  )\n\n  return (node) => {\n    const output = []\n    const children = (node || $getRoot()).getChildren()\n\n    for (let i = 0; i < children.length; i++) {\n      const child = children[i]\n      const result = exportTopLevelElements(\n        child,\n        elementTransformers,\n        textFormatTransformers,\n        byType.textMatch,\n      )\n\n      if (result != null) {\n        output.push(\n          // separate consecutive group of texts with a line break: eg. [\"hello\", \"world\"] -> [\"hello\", \"/nworld\"]\n          isNewlineDelimited &&\n            i > 0 &&\n            !isEmptyParagraph(child) &&\n            !isEmptyParagraph(children[i - 1])\n            ? '\\n'.concat(result)\n            : result,\n        )\n      }\n    }\n    // Ensure consecutive groups of texts are at least \\n\\n apart while each empty paragraph render as a newline.\n    // Eg. [\"hello\", \"\", \"\", \"hi\", \"\\nworld\"] -> \"hello\\n\\n\\nhi\\n\\nworld\"\n    return output.join('\\n')\n  }\n}\n\nfunction exportTopLevelElements(\n  node: LexicalNode,\n  elementTransformers: Array<ElementTransformer | MultilineElementTransformer>,\n  textTransformersIndex: Array<TextFormatTransformer>,\n  textMatchTransformers: Array<TextMatchTransformer>,\n): null | string {\n  for (const transformer of elementTransformers) {\n    if (!transformer.export) {\n      continue\n    }\n    const result = transformer.export(node, (_node) =>\n      exportChildren(_node, textTransformersIndex, textMatchTransformers),\n    )\n\n    if (result != null) {\n      return result\n    }\n  }\n\n  if ($isElementNode(node)) {\n    return exportChildren(node, textTransformersIndex, textMatchTransformers)\n  } else if ($isDecoratorNode(node)) {\n    return node.getTextContent()\n  } else {\n    return null\n  }\n}\n\nfunction exportChildren(\n  node: ElementNode,\n  textTransformersIndex: Array<TextFormatTransformer>,\n  textMatchTransformers: Array<TextMatchTransformer>,\n  unclosedTags?: Array<{ format: TextFormatType; tag: string }>,\n  unclosableTags?: Array<{ format: TextFormatType; tag: string }>,\n): string {\n  const output = []\n  const children = node.getChildren()\n  // keep track of unclosed tags from the very beginning\n  if (!unclosedTags) {\n    unclosedTags = []\n  }\n  if (!unclosableTags) {\n    unclosableTags = []\n  }\n\n  mainLoop: for (const child of children) {\n    for (const transformer of textMatchTransformers) {\n      if (!transformer.export) {\n        continue\n      }\n\n      const result = transformer.export(\n        child,\n        (parentNode) =>\n          exportChildren(\n            parentNode,\n            textTransformersIndex,\n            textMatchTransformers,\n            unclosedTags,\n            // Add current unclosed tags to the list of unclosable tags - we don't want nested tags from\n            // textmatch transformers to close the outer ones, as that may result in invalid markdown.\n            // E.g. **text [text**](https://lexical.io)\n            // is invalid markdown, as the closing ** is inside the link.\n            //\n            [...unclosableTags, ...unclosedTags],\n          ),\n        (textNode, textContent) =>\n          exportTextFormat(\n            textNode,\n            textContent,\n            textTransformersIndex,\n            unclosedTags,\n            unclosableTags,\n          ),\n      )\n\n      if (result != null) {\n        output.push(result)\n        continue mainLoop\n      }\n    }\n\n    if ($isLineBreakNode(child)) {\n      output.push('\\n')\n    } else if ($isTextNode(child)) {\n      output.push(\n        exportTextFormat(\n          child,\n          child.getTextContent(),\n          textTransformersIndex,\n          unclosedTags,\n          unclosableTags,\n        ),\n      )\n    } else if ($isElementNode(child)) {\n      // empty paragraph returns \"\"\n      output.push(\n        exportChildren(\n          child,\n          textTransformersIndex,\n          textMatchTransformers,\n          unclosedTags,\n          unclosableTags,\n        ),\n      )\n    } else if ($isDecoratorNode(child)) {\n      output.push(child.getTextContent())\n    }\n  }\n\n  return output.join('')\n}\n\nfunction exportTextFormat(\n  node: TextNode,\n  textContent: string,\n  textTransformers: Array<TextFormatTransformer>,\n  // unclosed tags include the markdown tags that haven't been closed yet, and their associated formats\n  unclosedTags: Array<{ format: TextFormatType; tag: string }>,\n  unclosableTags?: Array<{ format: TextFormatType; tag: string }>,\n): string {\n  // This function handles the case of a string looking like this: \"   foo   \"\n  // Where it would be invalid markdown to generate: \"**   foo   **\"\n  // We instead want to trim the whitespace out, apply formatting, and then\n  // bring the whitespace back. So our returned string looks like this: \"   **foo**   \"\n  const frozenString = textContent.trim()\n  let output = frozenString\n  // the opening tags to be added to the result\n  let openingTags = ''\n  // the closing tags to be added to the result\n  let closingTagsBefore = ''\n  let closingTagsAfter = ''\n\n  const prevNode = getTextSibling(node, true)\n  const nextNode = getTextSibling(node, false)\n\n  const applied = new Set()\n\n  for (const transformer of textTransformers) {\n    const format = transformer.format[0]\n    const tag = transformer.tag\n\n    // dedup applied formats\n    if (hasFormat(node, format) && !applied.has(format)) {\n      // Multiple tags might be used for the same format (*, _)\n      applied.add(format)\n\n      // append the tag to openningTags, if it's not applied to the previous nodes,\n      // or the nodes before that (which would result in an unclosed tag)\n      if (!hasFormat(prevNode, format) || !unclosedTags.find((element) => element.tag === tag)) {\n        unclosedTags.push({ format, tag })\n        openingTags += tag\n      }\n    }\n  }\n\n  // close any tags in the same order they were applied, if necessary\n  for (let i = 0; i < unclosedTags.length; i++) {\n    const nodeHasFormat = hasFormat(node, unclosedTags[i].format)\n    const nextNodeHasFormat = hasFormat(nextNode, unclosedTags[i].format)\n\n    // prevent adding closing tag if next sibling will do it\n    if (nodeHasFormat && nextNodeHasFormat) {\n      continue\n    }\n\n    const unhandledUnclosedTags = [...unclosedTags] // Shallow copy to avoid modifying the original array\n\n    while (unhandledUnclosedTags.length > i) {\n      const unclosedTag = unhandledUnclosedTags.pop()\n\n      // If tag is unclosable, don't close it and leave it in the original array,\n      // So that it can be closed when it's no longer unclosable\n      if (\n        unclosableTags &&\n        unclosedTag &&\n        unclosableTags.find((element) => element.tag === unclosedTag.tag)\n      ) {\n        continue\n      }\n\n      if (unclosedTag && typeof unclosedTag.tag === 'string') {\n        if (!nodeHasFormat) {\n          // Handles cases where the tag has not been closed before, e.g. if the previous node\n          // was a text match transformer that did not account for closing tags of the next node (e.g. a link)\n          closingTagsBefore += unclosedTag.tag\n        } else if (!nextNodeHasFormat) {\n          closingTagsAfter += unclosedTag.tag\n        }\n      }\n      // Mutate the original array to remove the closed tag\n      unclosedTags.pop()\n    }\n    break\n  }\n\n  output = openingTags + output + closingTagsAfter\n  // Replace trimmed version of textContent ensuring surrounding whitespace is not modified\n  return closingTagsBefore + textContent.replace(frozenString, () => output)\n}\n\n// Get next or previous text sibling a text node, including cases\n// when it's a child of inline element (e.g. link)\nfunction getTextSibling(node: TextNode, backward: boolean): null | TextNode {\n  let sibling = backward ? node.getPreviousSibling() : node.getNextSibling()\n\n  if (!sibling) {\n    const parent = node.getParentOrThrow()\n\n    if (parent.isInline()) {\n      sibling = backward ? parent.getPreviousSibling() : parent.getNextSibling()\n    }\n  }\n\n  while (sibling) {\n    if ($isElementNode(sibling)) {\n      if (!sibling.isInline()) {\n        break\n      }\n\n      const descendant = backward ? sibling.getLastDescendant() : sibling.getFirstDescendant()\n\n      if ($isTextNode(descendant)) {\n        return descendant\n      } else {\n        sibling = backward ? sibling.getPreviousSibling() : sibling.getNextSibling()\n      }\n    }\n\n    if ($isTextNode(sibling)) {\n      return sibling\n    }\n\n    if (!$isElementNode(sibling)) {\n      return null\n    }\n  }\n\n  return null\n}\n\nfunction hasFormat(node: LexicalNode | null | undefined, format: TextFormatType): boolean {\n  return $isTextNode(node) && node.hasFormat(format)\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/packages/@lexical/markdown/MarkdownImport.d.ts

@@ -6,7 +6,12 @@
  *
  */
 import type { ElementNode } from 'lexical';
-import type { Transformer } from './MarkdownTransformers.js';
+import type { TextFormatTransformer, Transformer } from './MarkdownTransformers.js';
+export type TextFormatTransformersIndex = Readonly<{
+    fullMatchRegExpByTag: Readonly<Record<string, RegExp>>;
+    openTagsRegExp: RegExp;
+    transformersByTag: Readonly<Record<string, TextFormatTransformer>>;
+}>;
 /**
  * Renders markdown from a string. The selection is moved to the start after the operation.
  */

package/dist/packages/@lexical/markdown/MarkdownImport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MarkdownImport.d.ts","sourceRoot":"","sources":["../../../../src/packages/@lexical/markdown/MarkdownImport.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAY,MAAM,SAAS,CAAA;AAcpD,OAAO,KAAK,EAKV,WAAW,EACZ,MAAM,2BAA2B,CAAA;AAWlC;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,KAAK,CAAC,WAAW,CAAC,EAChC,sBAAsB,UAAQ,GAC7B,CAAC,cAAc,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,IAAI,CAyCtD"}
+{"version":3,"file":"MarkdownImport.d.ts","sourceRoot":"","sources":["../../../../src/packages/@lexical/markdown/MarkdownImport.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAc1C,OAAO,KAAK,EAGV,qBAAqB,EAErB,WAAW,EACZ,MAAM,2BAA2B,CAAA;AAMlC,MAAM,MAAM,2BAA2B,GAAG,QAAQ,CAAC;IACjD,oBAAoB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IACtD,cAAc,EAAE,MAAM,CAAA;IACtB,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC,CAAA;CACnE,CAAC,CAAA;AAEF;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,KAAK,CAAC,WAAW,CAAC,EAChC,sBAAsB,UAAQ,GAC7B,CAAC,cAAc,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,IAAI,CAyCtD"}

package/dist/packages/@lexical/markdown/MarkdownImport.js

@@ -9,7 +9,8 @@ import { $isQuoteNode } from '@lexical/rich-text';
 import { $findMatchingParent } from '@lexical/utils';
 import { $createLineBreakNode, $createParagraphNode, $createTextNode, $getRoot, $getSelection, $isParagraphNode } from 'lexical';
 import { IS_APPLE_WEBKIT, IS_IOS, IS_SAFARI } from '../../../lexical/utils/environment.js';
-import { isEmptyParagraph, PUNCTUATION_OR_SPACE, transformersByType } from './utils.js';
+import { importTextTransformers } from './importTextTransformers.js';
+import { isEmptyParagraph, transformersByType } from './utils.js';
 /**
  * Renders markdown from a string. The selection is moved to the start after the operation.
  */
@@ -146,7 +147,7 @@ function $importBlocks(lineText, rootNode, elementTransformers, textFormatTransf
       }
     }
   }
-  importTextFormatTransformers(textNode, textFormatTransformersIndex, textMatchTransformers);
+  importTextTransformers(textNode, textFormatTransformersIndex, textMatchTransformers);
   // If no transformer found and we left with original paragraph node
   // can check if its content can be appended to the previous node
   // if it's a paragraph, quote or list
@@ -169,123 +170,6 @@ function $importBlocks(lineText, rootNode, elementTransformers, textFormatTransf
     }
   }
 }
-// Processing text content and replaces text format tags.
-// It takes outermost tag match and its content, creates text node with
-// format based on tag and then recursively executed over node's content
-//
-// E.g. for "*Hello **world**!*" string it will create text node with
-// "Hello **world**!" content and italic format and run recursively over
-// its content to transform "**world**" part
-function importTextFormatTransformers(textNode, textFormatTransformersIndex, textMatchTransformers) {
-  const textContent = textNode.getTextContent();
-  const match = findOutermostMatch(textContent, textFormatTransformersIndex);
-  if (!match) {
-    // Once text format processing is done run text match transformers, as it
-    // only can span within single text node (unline formats that can cover multiple nodes)
-    importTextMatchTransformers(textNode, textMatchTransformers);
-    return;
-  }
-  let currentNode, leadingNode, remainderNode;
-  // If matching full content there's no need to run splitText and can reuse existing textNode
-  // to update its content and apply format. E.g. for **_Hello_** string after applying bold
-  // format (**) it will reuse the same text node to apply italic (_)
-  if (match[0] === textContent) {
-    currentNode = textNode;
-  } else {
-    const startIndex = match.index || 0;
-    const endIndex = startIndex + match[0].length;
-    if (startIndex === 0) {
-      [currentNode, remainderNode] = textNode.splitText(endIndex);
-    } else {
-      [leadingNode, currentNode, remainderNode] = textNode.splitText(startIndex, endIndex);
-    }
-  }
-  currentNode.setTextContent(match[2]);
-  const transformer = textFormatTransformersIndex.transformersByTag[match[1]];
-  if (transformer) {
-    for (const format of transformer.format) {
-      if (!currentNode.hasFormat(format)) {
-        currentNode.toggleFormat(format);
-      }
-    }
-  }
-  // Recursively run over inner text if it's not inline code
-  if (!currentNode.hasFormat('code')) {
-    importTextFormatTransformers(currentNode, textFormatTransformersIndex, textMatchTransformers);
-  }
-  // Run over leading/remaining text if any
-  if (leadingNode) {
-    importTextFormatTransformers(leadingNode, textFormatTransformersIndex, textMatchTransformers);
-  }
-  if (remainderNode) {
-    importTextFormatTransformers(remainderNode, textFormatTransformersIndex, textMatchTransformers);
-  }
-}
-function importTextMatchTransformers(textNode_, textMatchTransformers) {
-  let textNode = textNode_;
-  mainLoop: while (textNode) {
-    for (const transformer of textMatchTransformers) {
-      if (!transformer.replace || !transformer.importRegExp) {
-        continue;
-      }
-      const match = textNode.getTextContent().match(transformer.importRegExp);
-      if (!match) {
-        continue;
-      }
-      const startIndex = match.index || 0;
-      const endIndex = transformer.getEndIndex ? transformer.getEndIndex(textNode, match) : startIndex + match[0].length;
-      if (endIndex === false) {
-        continue;
-      }
-      let newTextNode, replaceNode;
-      if (startIndex === 0) {
-        [replaceNode, textNode] = textNode.splitText(endIndex);
-      } else {
-        [, replaceNode, newTextNode] = textNode.splitText(startIndex, endIndex);
-      }
-      if (newTextNode) {
-        importTextMatchTransformers(newTextNode, textMatchTransformers);
-      }
-      transformer.replace(replaceNode, match);
-      continue mainLoop;
-    }
-    break;
-  }
-}
-// Finds first "<tag>content<tag>" match that is not nested into another tag
-function findOutermostMatch(textContent, textTransformersIndex) {
-  const openTagsMatch = textContent.match(textTransformersIndex.openTagsRegExp);
-  if (openTagsMatch == null) {
-    return null;
-  }
-  for (const match of openTagsMatch) {
-    // Open tags reg exp might capture leading space so removing it
-    // before using match to find transformer
-    const tag = match.replace(/^\s/, '');
-    const fullMatchRegExp = textTransformersIndex.fullMatchRegExpByTag[tag];
-    if (fullMatchRegExp == null) {
-      continue;
-    }
-    const fullMatch = textContent.match(fullMatchRegExp);
-    const transformer = textTransformersIndex.transformersByTag[tag];
-    if (fullMatch != null && transformer != null) {
-      if (transformer.intraword !== false) {
-        return fullMatch;
-      }
-      // For non-intraword transformers checking if it's within a word
-      // or surrounded with space/punctuation/newline
-      const {
-        index = 0
-      } = fullMatch;
-      const beforeChar = textContent[index - 1];
-      const afterChar = textContent[index + fullMatch[0].length];
-      if ((!beforeChar || PUNCTUATION_OR_SPACE.test(beforeChar)) && (!afterChar || PUNCTUATION_OR_SPACE.test(afterChar))) {
-        return fullMatch;
-      }
-    }
-  }
-  return null;
-}
 function createTextFormatTransformersIndex(textTransformers) {
   const transformersByTag = {};
   const fullMatchRegExpByTag = {};

package/dist/packages/@lexical/markdown/MarkdownImport.js.map

@@ -1 +1 @@
-{"version":3,"file":"MarkdownImport.js","names":["$isListItemNode","$isListNode","$isQuoteNode","$findMatchingParent","$createLineBreakNode","$createParagraphNode","$createTextNode","$getRoot","$getSelection","$isParagraphNode","IS_APPLE_WEBKIT","IS_IOS","IS_SAFARI","isEmptyParagraph","PUNCTUATION_OR_SPACE","transformersByType","createMarkdownImport","transformers","shouldPreserveNewLines","byType","textFormatTransformersIndex","createTextFormatTransformersIndex","textFormat","markdownString","node","lines","split","linesLength","length","root","clear","i","lineText","imported","shiftedIndex","$importMultiline","multilineElement","$importBlocks","element","textMatch","children","getChildren","child","getChildrenSize","remove","selectStart","startLineIndex","multilineElementTransformers","rootNode","transformer","handleImportAfterStartMatch","regExpEnd","regExpStart","replace","startMatch","match","result","regexpEndRegex","regExp","isEndOptional","optional","endLineIndex","endMatch","index","linesInBetween","push","slice","text","elementTransformers","textMatchTransformers","textNode","elementNode","append","setTextContent","importTextFormatTransformers","isAttached","previousNode","getPreviousSibling","targetNode","lastDescendant","getLastDescendant","getTextContentSize","splice","textContent","getTextContent","findOutermostMatch","importTextMatchTransformers","currentNode","leadingNode","remainderNode","startIndex","endIndex","splitText","transformersByTag","format","hasFormat","toggleFormat","textNode_","mainLoop","importRegExp","getEndIndex","newTextNode","replaceNode","textTransformersIndex","openTagsMatch","openTagsRegExp","tag","fullMatchRegExp","fullMatchRegExpByTag","fullMatch","intraword","beforeChar","afterChar","test","textTransformers","escapeRegExp","tagRegExp","RegExp","join"],"sources":["../../../../src/packages/@lexical/markdown/MarkdownImport.ts"],"sourcesContent":["/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport type { ListItemNode } from '@lexical/list'\nimport type { ElementNode, TextNode } from 'lexical'\n\nimport { $isListItemNode, $isListNode } from '@lexical/list'\nimport { $isQuoteNode } from '@lexical/rich-text'\nimport { $findMatchingParent } from '@lexical/utils'\nimport {\n  $createLineBreakNode,\n  $createParagraphNode,\n  $createTextNode,\n  $getRoot,\n  $getSelection,\n  $isParagraphNode,\n} from 'lexical'\n\nimport type {\n  ElementTransformer,\n  MultilineElementTransformer,\n  TextFormatTransformer,\n  TextMatchTransformer,\n  Transformer,\n} from './MarkdownTransformers.js'\n\nimport { IS_APPLE_WEBKIT, IS_IOS, IS_SAFARI } from '../../../lexical/utils/environment.js'\nimport { isEmptyParagraph, PUNCTUATION_OR_SPACE, transformersByType } from './utils.js'\n\ntype TextFormatTransformersIndex = Readonly<{\n  fullMatchRegExpByTag: Readonly<Record<string, RegExp>>\n  openTagsRegExp: RegExp\n  transformersByTag: Readonly<Record<string, TextFormatTransformer>>\n}>\n\n/**\n * Renders markdown from a string. The selection is moved to the start after the operation.\n */\nexport function createMarkdownImport(\n  transformers: Array<Transformer>,\n  shouldPreserveNewLines = false,\n): (markdownString: string, node?: ElementNode) => void {\n  const byType = transformersByType(transformers)\n  const textFormatTransformersIndex = createTextFormatTransformersIndex(byType.textFormat)\n\n  return (markdownString, node) => {\n    const lines = markdownString.split('\\n')\n    const linesLength = lines.length\n    const root = node || $getRoot()\n    root.clear()\n\n    for (let i = 0; i < linesLength; i++) {\n      const lineText = lines[i]\n\n      const [imported, shiftedIndex] = $importMultiline(lines, i, byType.multilineElement, root)\n\n      if (imported) {\n        // If a multiline markdown element was imported, we don't want to process the lines that were part of it anymore.\n        // There could be other sub-markdown elements (both multiline and normal ones) matching within this matched multiline element's children.\n        // However, it would be the responsibility of the matched multiline transformer to decide how it wants to handle them.\n        // We cannot handle those, as there is no way for us to know how to maintain the correct order of generated lexical nodes for possible children.\n        i = shiftedIndex // Next loop will start from the line after the last line of the multiline element\n        continue\n      }\n\n      $importBlocks(lineText, root, byType.element, textFormatTransformersIndex, byType.textMatch)\n    }\n\n    // By default, removing empty paragraphs as md does not really\n    // allow empty lines and uses them as delimiter.\n    // If you need empty lines set shouldPreserveNewLines = true.\n    const children = root.getChildren()\n    for (const child of children) {\n      if (!shouldPreserveNewLines && isEmptyParagraph(child) && root.getChildrenSize() > 1) {\n        child.remove()\n      }\n    }\n\n    if ($getSelection() !== null) {\n      root.selectStart()\n    }\n  }\n}\n\n/**\n *\n * @returns first element of the returned tuple is a boolean indicating if a multiline element was imported. The second element is the index of the last line that was processed.\n */\nfunction $importMultiline(\n  lines: Array<string>,\n  startLineIndex: number,\n  multilineElementTransformers: Array<MultilineElementTransformer>,\n  rootNode: ElementNode,\n): [boolean, number] {\n  for (const transformer of multilineElementTransformers) {\n    const { handleImportAfterStartMatch, regExpEnd, regExpStart, replace } = transformer\n\n    const startMatch = lines[startLineIndex].match(regExpStart)\n    if (!startMatch) {\n      continue // Try next transformer\n    }\n\n    if (handleImportAfterStartMatch) {\n      const result = handleImportAfterStartMatch({\n        lines,\n        rootNode,\n        startLineIndex,\n        startMatch,\n        transformer,\n      })\n      if (result === null) {\n        continue\n      } else if (result) {\n        return result\n      }\n    }\n\n    const regexpEndRegex: RegExp | undefined =\n      typeof regExpEnd === 'object' && 'regExp' in regExpEnd ? regExpEnd.regExp : regExpEnd\n\n    const isEndOptional =\n      regExpEnd && typeof regExpEnd === 'object' && 'optional' in regExpEnd\n        ? regExpEnd.optional\n        : !regExpEnd\n\n    let endLineIndex = startLineIndex\n    const linesLength = lines.length\n\n    // check every single line for the closing match. It could also be on the same line as the opening match.\n    while (endLineIndex < linesLength) {\n      const endMatch = regexpEndRegex ? lines[endLineIndex].match(regexpEndRegex) : null\n      if (!endMatch) {\n        if (\n          !isEndOptional ||\n          (isEndOptional && endLineIndex < linesLength - 1) // Optional end, but didn't reach the end of the document yet => continue searching for potential closing match\n        ) {\n          endLineIndex++\n          continue // Search next line for closing match\n        }\n      }\n\n      // Now, check if the closing match matched is the same as the opening match.\n      // If it is, we need to continue searching for the actual closing match.\n      if (endMatch && startLineIndex === endLineIndex && endMatch.index === startMatch.index) {\n        endLineIndex++\n        continue // Search next line for closing match\n      }\n\n      // At this point, we have found the closing match. Next: calculate the lines in between open and closing match\n      // This should not include the matches themselves, and be split up by lines\n      const linesInBetween: string[] = []\n\n      if (endMatch && startLineIndex === endLineIndex) {\n        linesInBetween.push(lines[startLineIndex].slice(startMatch[0].length, -endMatch[0].length))\n      } else {\n        for (let i = startLineIndex; i <= endLineIndex; i++) {\n          if (i === startLineIndex) {\n            const text = lines[i].slice(startMatch[0].length)\n            linesInBetween.push(text) // Also include empty text\n          } else if (i === endLineIndex && endMatch) {\n            const text = lines[i].slice(0, -endMatch[0].length)\n            linesInBetween.push(text) // Also include empty text\n          } else {\n            linesInBetween.push(lines[i])\n          }\n        }\n      }\n\n      if (replace(rootNode, null, startMatch, endMatch, linesInBetween, true) !== false) {\n        // Return here. This $importMultiline function is run line by line and should only process a single multiline element at a time.\n        return [true, endLineIndex]\n      }\n\n      // The replace function returned false, despite finding the matching open and close tags => this transformer does not want to handle it.\n      // Thus, we continue letting the remaining transformers handle the passed lines of text from the beginning\n      break\n    }\n  }\n\n  // No multiline transformer handled this line successfully\n  return [false, startLineIndex]\n}\n\nfunction $importBlocks(\n  lineText: string,\n  rootNode: ElementNode,\n  elementTransformers: Array<ElementTransformer>,\n  textFormatTransformersIndex: TextFormatTransformersIndex,\n  textMatchTransformers: Array<TextMatchTransformer>,\n) {\n  const textNode = $createTextNode(lineText)\n  const elementNode = $createParagraphNode()\n  elementNode.append(textNode)\n  rootNode.append(elementNode)\n\n  for (const { regExp, replace } of elementTransformers) {\n    const match = lineText.match(regExp)\n\n    if (match) {\n      textNode.setTextContent(lineText.slice(match[0].length))\n      if (replace(elementNode, [textNode], match, true) !== false) {\n        break\n      }\n    }\n  }\n\n  importTextFormatTransformers(textNode, textFormatTransformersIndex, textMatchTransformers)\n\n  // If no transformer found and we left with original paragraph node\n  // can check if its content can be appended to the previous node\n  // if it's a paragraph, quote or list\n  if (elementNode.isAttached() && lineText.length > 0) {\n    const previousNode = elementNode.getPreviousSibling()\n    if ($isParagraphNode(previousNode) || $isQuoteNode(previousNode) || $isListNode(previousNode)) {\n      let targetNode: ListItemNode | null | typeof previousNode = previousNode\n\n      if ($isListNode(previousNode)) {\n        const lastDescendant = previousNode.getLastDescendant()\n        if (lastDescendant == null) {\n          targetNode = null\n        } else {\n          targetNode = $findMatchingParent(lastDescendant, $isListItemNode)\n        }\n      }\n\n      if (targetNode != null && targetNode.getTextContentSize() > 0) {\n        targetNode.splice(targetNode.getChildrenSize(), 0, [\n          $createLineBreakNode(),\n          ...elementNode.getChildren(),\n        ])\n        elementNode.remove()\n      }\n    }\n  }\n}\n\n// Processing text content and replaces text format tags.\n// It takes outermost tag match and its content, creates text node with\n// format based on tag and then recursively executed over node's content\n//\n// E.g. for \"*Hello **world**!*\" string it will create text node with\n// \"Hello **world**!\" content and italic format and run recursively over\n// its content to transform \"**world**\" part\nfunction importTextFormatTransformers(\n  textNode: TextNode,\n  textFormatTransformersIndex: TextFormatTransformersIndex,\n  textMatchTransformers: Array<TextMatchTransformer>,\n) {\n  const textContent = textNode.getTextContent()\n  const match = findOutermostMatch(textContent, textFormatTransformersIndex)\n\n  if (!match) {\n    // Once text format processing is done run text match transformers, as it\n    // only can span within single text node (unline formats that can cover multiple nodes)\n    importTextMatchTransformers(textNode, textMatchTransformers)\n    return\n  }\n\n  let currentNode, leadingNode, remainderNode\n\n  // If matching full content there's no need to run splitText and can reuse existing textNode\n  // to update its content and apply format. E.g. for **_Hello_** string after applying bold\n  // format (**) it will reuse the same text node to apply italic (_)\n  if (match[0] === textContent) {\n    currentNode = textNode\n  } else {\n    const startIndex = match.index || 0\n    const endIndex = startIndex + match[0].length\n\n    if (startIndex === 0) {\n      ;[currentNode, remainderNode] = textNode.splitText(endIndex)\n    } else {\n      ;[leadingNode, currentNode, remainderNode] = textNode.splitText(startIndex, endIndex)\n    }\n  }\n\n  currentNode.setTextContent(match[2])\n  const transformer = textFormatTransformersIndex.transformersByTag[match[1]]\n\n  if (transformer) {\n    for (const format of transformer.format) {\n      if (!currentNode.hasFormat(format)) {\n        currentNode.toggleFormat(format)\n      }\n    }\n  }\n\n  // Recursively run over inner text if it's not inline code\n  if (!currentNode.hasFormat('code')) {\n    importTextFormatTransformers(currentNode, textFormatTransformersIndex, textMatchTransformers)\n  }\n\n  // Run over leading/remaining text if any\n  if (leadingNode) {\n    importTextFormatTransformers(leadingNode, textFormatTransformersIndex, textMatchTransformers)\n  }\n\n  if (remainderNode) {\n    importTextFormatTransformers(remainderNode, textFormatTransformersIndex, textMatchTransformers)\n  }\n}\n\nfunction importTextMatchTransformers(\n  textNode_: TextNode,\n  textMatchTransformers: Array<TextMatchTransformer>,\n) {\n  let textNode = textNode_\n\n  mainLoop: while (textNode) {\n    for (const transformer of textMatchTransformers) {\n      if (!transformer.replace || !transformer.importRegExp) {\n        continue\n      }\n      const match = textNode.getTextContent().match(transformer.importRegExp)\n\n      if (!match) {\n        continue\n      }\n\n      const startIndex = match.index || 0\n      const endIndex = transformer.getEndIndex\n        ? transformer.getEndIndex(textNode, match)\n        : startIndex + match[0].length\n\n      if (endIndex === false) {\n        continue\n      }\n\n      let newTextNode, replaceNode\n\n      if (startIndex === 0) {\n        ;[replaceNode, textNode] = textNode.splitText(endIndex)\n      } else {\n        ;[, replaceNode, newTextNode] = textNode.splitText(startIndex, endIndex)\n      }\n\n      if (newTextNode) {\n        importTextMatchTransformers(newTextNode, textMatchTransformers)\n      }\n      transformer.replace(replaceNode, match)\n      continue mainLoop\n    }\n\n    break\n  }\n}\n\n// Finds first \"<tag>content<tag>\" match that is not nested into another tag\nfunction findOutermostMatch(\n  textContent: string,\n  textTransformersIndex: TextFormatTransformersIndex,\n): null | RegExpMatchArray {\n  const openTagsMatch = textContent.match(textTransformersIndex.openTagsRegExp)\n\n  if (openTagsMatch == null) {\n    return null\n  }\n\n  for (const match of openTagsMatch) {\n    // Open tags reg exp might capture leading space so removing it\n    // before using match to find transformer\n    const tag = match.replace(/^\\s/, '')\n    const fullMatchRegExp = textTransformersIndex.fullMatchRegExpByTag[tag]\n    if (fullMatchRegExp == null) {\n      continue\n    }\n\n    const fullMatch = textContent.match(fullMatchRegExp)\n    const transformer = textTransformersIndex.transformersByTag[tag]\n    if (fullMatch != null && transformer != null) {\n      if (transformer.intraword !== false) {\n        return fullMatch\n      }\n\n      // For non-intraword transformers checking if it's within a word\n      // or surrounded with space/punctuation/newline\n      const { index = 0 } = fullMatch\n      const beforeChar = textContent[index - 1]\n      const afterChar = textContent[index + fullMatch[0].length]\n\n      if (\n        (!beforeChar || PUNCTUATION_OR_SPACE.test(beforeChar)) &&\n        (!afterChar || PUNCTUATION_OR_SPACE.test(afterChar))\n      ) {\n        return fullMatch\n      }\n    }\n  }\n\n  return null\n}\n\nfunction createTextFormatTransformersIndex(\n  textTransformers: Array<TextFormatTransformer>,\n): TextFormatTransformersIndex {\n  const transformersByTag: Record<string, TextFormatTransformer> = {}\n  const fullMatchRegExpByTag: Record<string, RegExp> = {}\n  const openTagsRegExp: string[] = []\n  const escapeRegExp = `(?<![\\\\\\\\])`\n\n  for (const transformer of textTransformers) {\n    const { tag } = transformer\n    transformersByTag[tag] = transformer\n    const tagRegExp = tag.replace(/([*^+])/g, '\\\\$1')\n    openTagsRegExp.push(tagRegExp)\n\n    if (IS_SAFARI || IS_IOS || IS_APPLE_WEBKIT) {\n      fullMatchRegExpByTag[tag] = new RegExp(\n        `(${tagRegExp})(?![${tagRegExp}\\\\s])(.*?[^${tagRegExp}\\\\s])${tagRegExp}(?!${tagRegExp})`,\n      )\n    } else {\n      fullMatchRegExpByTag[tag] = new RegExp(\n        `(?<![\\\\\\\\${tagRegExp}])(${tagRegExp})((\\\\\\\\${tagRegExp})?.*?[^${tagRegExp}\\\\s](\\\\\\\\${tagRegExp})?)((?<!\\\\\\\\)|(?<=\\\\\\\\\\\\\\\\))(${tagRegExp})(?![\\\\\\\\${tagRegExp}])`,\n      )\n    }\n  }\n\n  return {\n    // Reg exp to find open tag + content + close tag\n    fullMatchRegExpByTag,\n    // Reg exp to find opening tags\n    openTagsRegExp: new RegExp(\n      (IS_SAFARI || IS_IOS || IS_APPLE_WEBKIT ? '' : `${escapeRegExp}`) +\n        '(' +\n        openTagsRegExp.join('|') +\n        ')',\n      'g',\n    ),\n    transformersByTag,\n  }\n}\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"MarkdownImport.js","names":["$isListItemNode","$isListNode","$isQuoteNode","$findMatchingParent","$createLineBreakNode","$createParagraphNode","$createTextNode","$getRoot","$getSelection","$isParagraphNode","IS_APPLE_WEBKIT","IS_IOS","IS_SAFARI","importTextTransformers","isEmptyParagraph","transformersByType","createMarkdownImport","transformers","shouldPreserveNewLines","byType","textFormatTransformersIndex","createTextFormatTransformersIndex","textFormat","markdownString","node","lines","split","linesLength","length","root","clear","i","lineText","imported","shiftedIndex","$importMultiline","multilineElement","$importBlocks","element","textMatch","children","getChildren","child","getChildrenSize","remove","selectStart","startLineIndex","multilineElementTransformers","rootNode","transformer","handleImportAfterStartMatch","regExpEnd","regExpStart","replace","startMatch","match","result","regexpEndRegex","regExp","isEndOptional","optional","endLineIndex","endMatch","index","linesInBetween","push","slice","text","elementTransformers","textMatchTransformers","textNode","elementNode","append","setTextContent","isAttached","previousNode","getPreviousSibling","targetNode","lastDescendant","getLastDescendant","getTextContentSize","splice","textTransformers","transformersByTag","fullMatchRegExpByTag","openTagsRegExp","escapeRegExp","tag","tagRegExp","RegExp","join"],"sources":["../../../../src/packages/@lexical/markdown/MarkdownImport.ts"],"sourcesContent":["/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport type { ListItemNode } from '@lexical/list'\nimport type { ElementNode } from 'lexical'\n\nimport { $isListItemNode, $isListNode } from '@lexical/list'\nimport { $isQuoteNode } from '@lexical/rich-text'\nimport { $findMatchingParent } from '@lexical/utils'\nimport {\n  $createLineBreakNode,\n  $createParagraphNode,\n  $createTextNode,\n  $getRoot,\n  $getSelection,\n  $isParagraphNode,\n} from 'lexical'\n\nimport type {\n  ElementTransformer,\n  MultilineElementTransformer,\n  TextFormatTransformer,\n  TextMatchTransformer,\n  Transformer,\n} from './MarkdownTransformers.js'\n\nimport { IS_APPLE_WEBKIT, IS_IOS, IS_SAFARI } from '../../../lexical/utils/environment.js'\nimport { importTextTransformers } from './importTextTransformers.js'\nimport { isEmptyParagraph, transformersByType } from './utils.js'\n\nexport type TextFormatTransformersIndex = Readonly<{\n  fullMatchRegExpByTag: Readonly<Record<string, RegExp>>\n  openTagsRegExp: RegExp\n  transformersByTag: Readonly<Record<string, TextFormatTransformer>>\n}>\n\n/**\n * Renders markdown from a string. The selection is moved to the start after the operation.\n */\nexport function createMarkdownImport(\n  transformers: Array<Transformer>,\n  shouldPreserveNewLines = false,\n): (markdownString: string, node?: ElementNode) => void {\n  const byType = transformersByType(transformers)\n  const textFormatTransformersIndex = createTextFormatTransformersIndex(byType.textFormat)\n\n  return (markdownString, node) => {\n    const lines = markdownString.split('\\n')\n    const linesLength = lines.length\n    const root = node || $getRoot()\n    root.clear()\n\n    for (let i = 0; i < linesLength; i++) {\n      const lineText = lines[i]\n\n      const [imported, shiftedIndex] = $importMultiline(lines, i, byType.multilineElement, root)\n\n      if (imported) {\n        // If a multiline markdown element was imported, we don't want to process the lines that were part of it anymore.\n        // There could be other sub-markdown elements (both multiline and normal ones) matching within this matched multiline element's children.\n        // However, it would be the responsibility of the matched multiline transformer to decide how it wants to handle them.\n        // We cannot handle those, as there is no way for us to know how to maintain the correct order of generated lexical nodes for possible children.\n        i = shiftedIndex // Next loop will start from the line after the last line of the multiline element\n        continue\n      }\n\n      $importBlocks(lineText, root, byType.element, textFormatTransformersIndex, byType.textMatch)\n    }\n\n    // By default, removing empty paragraphs as md does not really\n    // allow empty lines and uses them as delimiter.\n    // If you need empty lines set shouldPreserveNewLines = true.\n    const children = root.getChildren()\n    for (const child of children) {\n      if (!shouldPreserveNewLines && isEmptyParagraph(child) && root.getChildrenSize() > 1) {\n        child.remove()\n      }\n    }\n\n    if ($getSelection() !== null) {\n      root.selectStart()\n    }\n  }\n}\n\n/**\n *\n * @returns first element of the returned tuple is a boolean indicating if a multiline element was imported. The second element is the index of the last line that was processed.\n */\nfunction $importMultiline(\n  lines: Array<string>,\n  startLineIndex: number,\n  multilineElementTransformers: Array<MultilineElementTransformer>,\n  rootNode: ElementNode,\n): [boolean, number] {\n  for (const transformer of multilineElementTransformers) {\n    const { handleImportAfterStartMatch, regExpEnd, regExpStart, replace } = transformer\n\n    const startMatch = lines[startLineIndex].match(regExpStart)\n    if (!startMatch) {\n      continue // Try next transformer\n    }\n\n    if (handleImportAfterStartMatch) {\n      const result = handleImportAfterStartMatch({\n        lines,\n        rootNode,\n        startLineIndex,\n        startMatch,\n        transformer,\n      })\n      if (result === null) {\n        continue\n      } else if (result) {\n        return result\n      }\n    }\n\n    const regexpEndRegex: RegExp | undefined =\n      typeof regExpEnd === 'object' && 'regExp' in regExpEnd ? regExpEnd.regExp : regExpEnd\n\n    const isEndOptional =\n      regExpEnd && typeof regExpEnd === 'object' && 'optional' in regExpEnd\n        ? regExpEnd.optional\n        : !regExpEnd\n\n    let endLineIndex = startLineIndex\n    const linesLength = lines.length\n\n    // check every single line for the closing match. It could also be on the same line as the opening match.\n    while (endLineIndex < linesLength) {\n      const endMatch = regexpEndRegex ? lines[endLineIndex].match(regexpEndRegex) : null\n      if (!endMatch) {\n        if (\n          !isEndOptional ||\n          (isEndOptional && endLineIndex < linesLength - 1) // Optional end, but didn't reach the end of the document yet => continue searching for potential closing match\n        ) {\n          endLineIndex++\n          continue // Search next line for closing match\n        }\n      }\n\n      // Now, check if the closing match matched is the same as the opening match.\n      // If it is, we need to continue searching for the actual closing match.\n      if (endMatch && startLineIndex === endLineIndex && endMatch.index === startMatch.index) {\n        endLineIndex++\n        continue // Search next line for closing match\n      }\n\n      // At this point, we have found the closing match. Next: calculate the lines in between open and closing match\n      // This should not include the matches themselves, and be split up by lines\n      const linesInBetween: string[] = []\n\n      if (endMatch && startLineIndex === endLineIndex) {\n        linesInBetween.push(lines[startLineIndex].slice(startMatch[0].length, -endMatch[0].length))\n      } else {\n        for (let i = startLineIndex; i <= endLineIndex; i++) {\n          if (i === startLineIndex) {\n            const text = lines[i].slice(startMatch[0].length)\n            linesInBetween.push(text) // Also include empty text\n          } else if (i === endLineIndex && endMatch) {\n            const text = lines[i].slice(0, -endMatch[0].length)\n            linesInBetween.push(text) // Also include empty text\n          } else {\n            linesInBetween.push(lines[i])\n          }\n        }\n      }\n\n      if (replace(rootNode, null, startMatch, endMatch, linesInBetween, true) !== false) {\n        // Return here. This $importMultiline function is run line by line and should only process a single multiline element at a time.\n        return [true, endLineIndex]\n      }\n\n      // The replace function returned false, despite finding the matching open and close tags => this transformer does not want to handle it.\n      // Thus, we continue letting the remaining transformers handle the passed lines of text from the beginning\n      break\n    }\n  }\n\n  // No multiline transformer handled this line successfully\n  return [false, startLineIndex]\n}\n\nfunction $importBlocks(\n  lineText: string,\n  rootNode: ElementNode,\n  elementTransformers: Array<ElementTransformer>,\n  textFormatTransformersIndex: TextFormatTransformersIndex,\n  textMatchTransformers: Array<TextMatchTransformer>,\n) {\n  const textNode = $createTextNode(lineText)\n  const elementNode = $createParagraphNode()\n  elementNode.append(textNode)\n  rootNode.append(elementNode)\n\n  for (const { regExp, replace } of elementTransformers) {\n    const match = lineText.match(regExp)\n\n    if (match) {\n      textNode.setTextContent(lineText.slice(match[0].length))\n      if (replace(elementNode, [textNode], match, true) !== false) {\n        break\n      }\n    }\n  }\n\n  importTextTransformers(textNode, textFormatTransformersIndex, textMatchTransformers)\n\n  // If no transformer found and we left with original paragraph node\n  // can check if its content can be appended to the previous node\n  // if it's a paragraph, quote or list\n  if (elementNode.isAttached() && lineText.length > 0) {\n    const previousNode = elementNode.getPreviousSibling()\n    if ($isParagraphNode(previousNode) || $isQuoteNode(previousNode) || $isListNode(previousNode)) {\n      let targetNode: ListItemNode | null | typeof previousNode = previousNode\n\n      if ($isListNode(previousNode)) {\n        const lastDescendant = previousNode.getLastDescendant()\n        if (lastDescendant == null) {\n          targetNode = null\n        } else {\n          targetNode = $findMatchingParent(lastDescendant, $isListItemNode)\n        }\n      }\n\n      if (targetNode != null && targetNode.getTextContentSize() > 0) {\n        targetNode.splice(targetNode.getChildrenSize(), 0, [\n          $createLineBreakNode(),\n          ...elementNode.getChildren(),\n        ])\n        elementNode.remove()\n      }\n    }\n  }\n}\n\nfunction createTextFormatTransformersIndex(\n  textTransformers: Array<TextFormatTransformer>,\n): TextFormatTransformersIndex {\n  const transformersByTag: Record<string, TextFormatTransformer> = {}\n  const fullMatchRegExpByTag: Record<string, RegExp> = {}\n  const openTagsRegExp: string[] = []\n  const escapeRegExp = `(?<![\\\\\\\\])`\n\n  for (const transformer of textTransformers) {\n    const { tag } = transformer\n    transformersByTag[tag] = transformer\n    const tagRegExp = tag.replace(/([*^+])/g, '\\\\$1')\n    openTagsRegExp.push(tagRegExp)\n\n    if (IS_SAFARI || IS_IOS || IS_APPLE_WEBKIT) {\n      fullMatchRegExpByTag[tag] = new RegExp(\n        `(${tagRegExp})(?![${tagRegExp}\\\\s])(.*?[^${tagRegExp}\\\\s])${tagRegExp}(?!${tagRegExp})`,\n      )\n    } else {\n      fullMatchRegExpByTag[tag] = new RegExp(\n        `(?<![\\\\\\\\${tagRegExp}])(${tagRegExp})((\\\\\\\\${tagRegExp})?.*?[^${tagRegExp}\\\\s](\\\\\\\\${tagRegExp})?)((?<!\\\\\\\\)|(?<=\\\\\\\\\\\\\\\\))(${tagRegExp})(?![\\\\\\\\${tagRegExp}])`,\n      )\n    }\n  }\n\n  return {\n    // Reg exp to find open tag + content + close tag\n    fullMatchRegExpByTag,\n    // Reg exp to find opening tags\n    openTagsRegExp: new RegExp(\n      (IS_SAFARI || IS_IOS || IS_APPLE_WEBKIT ? '' : `${escapeRegExp}`) +\n        '(' +\n        openTagsRegExp.join('|') +\n        ')',\n      'g',\n    ),\n    transformersByTag,\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/packages/@lexical/markdown/MarkdownTransformers.d.ts

@@ -117,8 +117,11 @@ export type TextMatchTransformer = Readonly<{
     regExp: RegExp;
     /**
      * Determines how the matched markdown text should be transformed into a node during the markdown import process
+     *
+     * @returns nothing, or a TextNode that may be a child of the new node that is created.
+     * If a TextNode is returned, text format matching will be applied to it (e.g. bold, italic, etc.)
      */
-    replace?: (node: TextNode, match: RegExpMatchArray) => void;
+    replace?: (node: TextNode, match: RegExpMatchArray) => TextNode | void;
     /**
      * Single character that allows the transformer to trigger when typed in the editor. This does not affect markdown imports outside of the markdown shortcut plugin.
      * If the trigger is matched, the `regExp` will be used to match the text in the second step.

package/dist/packages/@lexical/markdown/MarkdownTransformers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MarkdownTransformers.d.ts","sourceRoot":"","sources":["../../../../src/packages/@lexical/markdown/MarkdownTransformers.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"MarkdownTransformers.d.ts","sourceRoot":"","sources":["../../../../src/packages/@lexical/markdown/MarkdownTransformers.ts"],"names":[],"mappings":"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"}