@lexical/markdown 0.35.1-nightly.20250919.0 → 0.35.1-nightly.20250923.0

package/LexicalMarkdown.dev.js

@@ -729,320 +729,6 @@ function formatDevErrorMessage(message) {
   throw new Error(message);
 }
 
-function runElementTransformers(parentNode, anchorNode, anchorOffset, elementTransformers) {
-  const grandParentNode = parentNode.getParent();
-  if (!lexical.$isRootOrShadowRoot(grandParentNode) || parentNode.getFirstChild() !== anchorNode) {
-    return false;
-  }
-  const textContent = anchorNode.getTextContent();
-
-  // Checking for anchorOffset position to prevent any checks for cases when caret is too far
-  // from a line start to be a part of block-level markdown trigger.
-  //
-  // TODO:
-  // Can have a quick check if caret is close enough to the beginning of the string (e.g. offset less than 10-20)
-  // since otherwise it won't be a markdown shortcut, but tables are exception
-  if (textContent[anchorOffset - 1] !== ' ') {
-    return false;
-  }
-  for (const {
-    regExp,
-    replace
-  } of elementTransformers) {
-    const match = textContent.match(regExp);
-    if (match && match[0].length === (match[0].endsWith(' ') ? anchorOffset : anchorOffset - 1)) {
-      const nextSiblings = anchorNode.getNextSiblings();
-      const [leadingNode, remainderNode] = anchorNode.splitText(anchorOffset);
-      const siblings = remainderNode ? [remainderNode, ...nextSiblings] : nextSiblings;
-      if (replace(parentNode, siblings, match, false) !== false) {
-        leadingNode.remove();
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function runMultilineElementTransformers(parentNode, anchorNode, anchorOffset, elementTransformers) {
-  const grandParentNode = parentNode.getParent();
-  if (!lexical.$isRootOrShadowRoot(grandParentNode) || parentNode.getFirstChild() !== anchorNode) {
-    return false;
-  }
-  const textContent = anchorNode.getTextContent();
-
-  // Checking for anchorOffset position to prevent any checks for cases when caret is too far
-  // from a line start to be a part of block-level markdown trigger.
-  //
-  // TODO:
-  // Can have a quick check if caret is close enough to the beginning of the string (e.g. offset less than 10-20)
-  // since otherwise it won't be a markdown shortcut, but tables are exception
-  if (textContent[anchorOffset - 1] !== ' ') {
-    return false;
-  }
-  for (const {
-    regExpStart,
-    replace,
-    regExpEnd
-  } of elementTransformers) {
-    if (regExpEnd && !('optional' in regExpEnd) || regExpEnd && 'optional' in regExpEnd && !regExpEnd.optional) {
-      continue;
-    }
-    const match = textContent.match(regExpStart);
-    if (match && match[0].length === (match[0].endsWith(' ') ? anchorOffset : anchorOffset - 1)) {
-      const nextSiblings = anchorNode.getNextSiblings();
-      const [leadingNode, remainderNode] = anchorNode.splitText(anchorOffset);
-      const siblings = remainderNode ? [remainderNode, ...nextSiblings] : nextSiblings;
-      if (replace(parentNode, siblings, match, null, null, false) !== false) {
-        leadingNode.remove();
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function runTextMatchTransformers(anchorNode, anchorOffset, transformersByTrigger) {
-  let textContent = anchorNode.getTextContent();
-  const lastChar = textContent[anchorOffset - 1];
-  const transformers = transformersByTrigger[lastChar];
-  if (transformers == null) {
-    return false;
-  }
-
-  // If typing in the middle of content, remove the tail to do
-  // reg exp match up to a string end (caret position)
-  if (anchorOffset < textContent.length) {
-    textContent = textContent.slice(0, anchorOffset);
-  }
-  for (const transformer of transformers) {
-    if (!transformer.replace || !transformer.regExp) {
-      continue;
-    }
-    const match = textContent.match(transformer.regExp);
-    if (match === null) {
-      continue;
-    }
-    const startIndex = match.index || 0;
-    const endIndex = startIndex + match[0].length;
-    let replaceNode;
-    if (startIndex === 0) {
-      [replaceNode] = anchorNode.splitText(endIndex);
-    } else {
-      [, replaceNode] = anchorNode.splitText(startIndex, endIndex);
-    }
-    replaceNode.selectNext(0, 0);
-    transformer.replace(replaceNode, match);
-    return true;
-  }
-  return false;
-}
-function $runTextFormatTransformers(anchorNode, anchorOffset, textFormatTransformers) {
-  const textContent = anchorNode.getTextContent();
-  const closeTagEndIndex = anchorOffset - 1;
-  const closeChar = textContent[closeTagEndIndex];
-  // Quick check if we're possibly at the end of inline markdown style
-  const matchers = textFormatTransformers[closeChar];
-  if (!matchers) {
-    return false;
-  }
-  for (const matcher of matchers) {
-    const {
-      tag
-    } = matcher;
-    const tagLength = tag.length;
-    const closeTagStartIndex = closeTagEndIndex - tagLength + 1;
-
-    // If tag is not single char check if rest of it matches with text content
-    if (tagLength > 1) {
-      if (!isEqualSubString(textContent, closeTagStartIndex, tag, 0, tagLength)) {
-        continue;
-      }
-    }
-
-    // Space before closing tag cancels inline markdown
-    if (textContent[closeTagStartIndex - 1] === ' ') {
-      continue;
-    }
-
-    // Some tags can not be used within words, hence should have newline/space/punctuation after it
-    const afterCloseTagChar = textContent[closeTagEndIndex + 1];
-    if (matcher.intraword === false && afterCloseTagChar && !PUNCTUATION_OR_SPACE.test(afterCloseTagChar)) {
-      continue;
-    }
-    const closeNode = anchorNode;
-    let openNode = closeNode;
-    let openTagStartIndex = getOpenTagStartIndex(textContent, closeTagStartIndex, tag);
-
-    // Go through text node siblings and search for opening tag
-    // if haven't found it within the same text node as closing tag
-    let sibling = openNode;
-    while (openTagStartIndex < 0 && (sibling = sibling.getPreviousSibling())) {
-      if (lexical.$isLineBreakNode(sibling)) {
-        break;
-      }
-      if (lexical.$isTextNode(sibling)) {
-        if (sibling.hasFormat('code')) {
-          continue;
-        }
-        const siblingTextContent = sibling.getTextContent();
-        openNode = sibling;
-        openTagStartIndex = getOpenTagStartIndex(siblingTextContent, siblingTextContent.length, tag);
-      }
-    }
-
-    // Opening tag is not found
-    if (openTagStartIndex < 0) {
-      continue;
-    }
-
-    // No content between opening and closing tag
-    if (openNode === closeNode && openTagStartIndex + tagLength === closeTagStartIndex) {
-      continue;
-    }
-
-    // Checking longer tags for repeating chars (e.g. *** vs **)
-    const prevOpenNodeText = openNode.getTextContent();
-    if (openTagStartIndex > 0 && prevOpenNodeText[openTagStartIndex - 1] === closeChar) {
-      continue;
-    }
-
-    // Some tags can not be used within words, hence should have newline/space/punctuation before it
-    const beforeOpenTagChar = prevOpenNodeText[openTagStartIndex - 1];
-    if (matcher.intraword === false && beforeOpenTagChar && !PUNCTUATION_OR_SPACE.test(beforeOpenTagChar)) {
-      continue;
-    }
-
-    // Clean text from opening and closing tags (starting from closing tag
-    // to prevent any offset shifts if we start from opening one)
-    const prevCloseNodeText = closeNode.getTextContent();
-    const closeNodeText = prevCloseNodeText.slice(0, closeTagStartIndex) + prevCloseNodeText.slice(closeTagEndIndex + 1);
-    closeNode.setTextContent(closeNodeText);
-    const openNodeText = openNode === closeNode ? closeNodeText : prevOpenNodeText;
-    openNode.setTextContent(openNodeText.slice(0, openTagStartIndex) + openNodeText.slice(openTagStartIndex + tagLength));
-    const selection = lexical.$getSelection();
-    const nextSelection = lexical.$createRangeSelection();
-    lexical.$setSelection(nextSelection);
-    // Adjust offset based on deleted chars
-    const newOffset = closeTagEndIndex - tagLength * (openNode === closeNode ? 2 : 1) + 1;
-    nextSelection.anchor.set(openNode.__key, openTagStartIndex, 'text');
-    nextSelection.focus.set(closeNode.__key, newOffset, 'text');
-
-    // Apply formatting to selected text
-    for (const format of matcher.format) {
-      if (!nextSelection.hasFormat(format)) {
-        nextSelection.formatText(format);
-      }
-    }
-
-    // Collapse selection up to the focus point
-    nextSelection.anchor.set(nextSelection.focus.key, nextSelection.focus.offset, nextSelection.focus.type);
-
-    // Remove formatting from collapsed selection
-    for (const format of matcher.format) {
-      if (nextSelection.hasFormat(format)) {
-        nextSelection.toggleFormat(format);
-      }
-    }
-    if (lexical.$isRangeSelection(selection)) {
-      nextSelection.format = selection.format;
-    }
-    return true;
-  }
-  return false;
-}
-function getOpenTagStartIndex(string, maxIndex, tag) {
-  const tagLength = tag.length;
-  for (let i = maxIndex; i >= tagLength; i--) {
-    const startIndex = i - tagLength;
-    if (isEqualSubString(string, startIndex, tag, 0, tagLength) &&
-    // Space after opening tag cancels transformation
-    string[startIndex + tagLength] !== ' ') {
-      return startIndex;
-    }
-  }
-  return -1;
-}
-function isEqualSubString(stringA, aStart, stringB, bStart, length) {
-  for (let i = 0; i < length; i++) {
-    if (stringA[aStart + i] !== stringB[bStart + i]) {
-      return false;
-    }
-  }
-  return true;
-}
-function registerMarkdownShortcuts(editor, transformers = TRANSFORMERS) {
-  const byType = transformersByType(transformers);
-  const textFormatTransformersByTrigger = indexBy(byType.textFormat, ({
-    tag
-  }) => tag[tag.length - 1]);
-  const textMatchTransformersByTrigger = indexBy(byType.textMatch, ({
-    trigger
-  }) => trigger);
-  for (const transformer of transformers) {
-    const type = transformer.type;
-    if (type === 'element' || type === 'text-match' || type === 'multiline-element') {
-      const dependencies = transformer.dependencies;
-      for (const node of dependencies) {
-        if (!editor.hasNode(node)) {
-          {
-            formatDevErrorMessage(`MarkdownShortcuts: missing dependency ${node.getType()} for transformer. Ensure node dependency is included in editor initial config.`);
-          }
-        }
-      }
-    }
-  }
-  const $transform = (parentNode, anchorNode, anchorOffset) => {
-    if (runElementTransformers(parentNode, anchorNode, anchorOffset, byType.element)) {
-      return;
-    }
-    if (runMultilineElementTransformers(parentNode, anchorNode, anchorOffset, byType.multilineElement)) {
-      return;
-    }
-    if (runTextMatchTransformers(anchorNode, anchorOffset, textMatchTransformersByTrigger)) {
-      return;
-    }
-    $runTextFormatTransformers(anchorNode, anchorOffset, textFormatTransformersByTrigger);
-  };
-  return editor.registerUpdateListener(({
-    tags,
-    dirtyLeaves,
-    editorState,
-    prevEditorState
-  }) => {
-    // Ignore updates from collaboration and undo/redo (as changes already calculated)
-    if (tags.has(lexical.COLLABORATION_TAG) || tags.has(lexical.HISTORIC_TAG)) {
-      return;
-    }
-
-    // If editor is still composing (i.e. backticks) we must wait before the user confirms the key
-    if (editor.isComposing()) {
-      return;
-    }
-    const selection = editorState.read(lexical.$getSelection);
-    const prevSelection = prevEditorState.read(lexical.$getSelection);
-
-    // We expect selection to be a collapsed range and not match previous one (as we want
-    // to trigger transforms only as user types)
-    if (!lexical.$isRangeSelection(prevSelection) || !lexical.$isRangeSelection(selection) || !selection.isCollapsed() || selection.is(prevSelection)) {
-      return;
-    }
-    const anchorKey = selection.anchor.key;
-    const anchorOffset = selection.anchor.offset;
-    const anchorNode = editorState._nodeMap.get(anchorKey);
-    if (!lexical.$isTextNode(anchorNode) || !dirtyLeaves.has(anchorKey) || anchorOffset !== 1 && anchorOffset > prevSelection.anchor.offset + 1) {
-      return;
-    }
-    editor.update(() => {
-      if (!canContainTransformableMarkdown(anchorNode)) {
-        return;
-      }
-      const parentNode = anchorNode.getParent();
-      if (parentNode === null || code.$isCodeNode(parentNode)) {
-        return;
-      }
-      $transform(parentNode, anchorNode, selection.anchor.offset);
-    });
-  });
-}
-
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -1324,87 +1010,411 @@ const ITALIC_UNDERSCORE = {
   type: 'text-format'
 };
 
-// Order of text transformers matters:
-//
-// - code should go first as it prevents any transformations inside
-// - then longer tags match (e.g. ** or __ should go before * or _)
-const LINK = {
-  dependencies: [link.LinkNode],
-  export: (node, exportChildren, exportFormat) => {
-    if (!link.$isLinkNode(node) || link.$isAutoLinkNode(node)) {
-      return null;
+// Order of text transformers matters:
+//
+// - code should go first as it prevents any transformations inside
+// - then longer tags match (e.g. ** or __ should go before * or _)
+const LINK = {
+  dependencies: [link.LinkNode],
+  export: (node, exportChildren, exportFormat) => {
+    if (!link.$isLinkNode(node) || link.$isAutoLinkNode(node)) {
+      return null;
+    }
+    const title = node.getTitle();
+    const textContent = exportChildren(node);
+    const linkContent = title ? `[${textContent}](${node.getURL()} "${title}")` : `[${textContent}](${node.getURL()})`;
+    return linkContent;
+  },
+  importRegExp: /(?:\[(.*?)\])(?:\((?:([^()\s]+)(?:\s"((?:[^"]*\\")*[^"]*)"\s*)?)\))/,
+  regExp: /(?:\[(.*?)\])(?:\((?:([^()\s]+)(?:\s"((?:[^"]*\\")*[^"]*)"\s*)?)\))$/,
+  replace: (textNode, match) => {
+    const [, linkText, linkUrl, linkTitle] = match;
+    const linkNode = link.$createLinkNode(linkUrl, {
+      title: linkTitle
+    });
+    const openBracketAmount = linkText.split('[').length - 1;
+    const closeBracketAmount = linkText.split(']').length - 1;
+    let parsedLinkText = linkText;
+    let outsideLinkText = '';
+    if (openBracketAmount < closeBracketAmount) {
+      return;
+    } else if (openBracketAmount > closeBracketAmount) {
+      const linkTextParts = linkText.split('[');
+      outsideLinkText = '[' + linkTextParts[0];
+      parsedLinkText = linkTextParts.slice(1).join('[');
+    }
+    const linkTextNode = lexical.$createTextNode(parsedLinkText);
+    linkTextNode.setFormat(textNode.getFormat());
+    linkNode.append(linkTextNode);
+    textNode.replace(linkNode);
+    if (outsideLinkText) {
+      linkNode.insertBefore(lexical.$createTextNode(outsideLinkText));
+    }
+    return linkTextNode;
+  },
+  trigger: ')',
+  type: 'text-match'
+};
+const ELEMENT_TRANSFORMERS = [HEADING, QUOTE, UNORDERED_LIST, ORDERED_LIST];
+const MULTILINE_ELEMENT_TRANSFORMERS = [CODE];
+
+// Order of text format transformers matters:
+//
+// - code should go first as it prevents any transformations inside
+// - then longer tags match (e.g. ** or __ should go before * or _)
+const TEXT_FORMAT_TRANSFORMERS = [INLINE_CODE, BOLD_ITALIC_STAR, BOLD_ITALIC_UNDERSCORE, BOLD_STAR, BOLD_UNDERSCORE, HIGHLIGHT, ITALIC_STAR, ITALIC_UNDERSCORE, STRIKETHROUGH];
+const TEXT_MATCH_TRANSFORMERS = [LINK];
+const TRANSFORMERS = [...ELEMENT_TRANSFORMERS, ...MULTILINE_ELEMENT_TRANSFORMERS, ...TEXT_FORMAT_TRANSFORMERS, ...TEXT_MATCH_TRANSFORMERS];
+function normalizeMarkdown(input, shouldMergeAdjacentLines = false) {
+  const lines = input.split('\n');
+  let inCodeBlock = false;
+  const sanitizedLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lastLine = sanitizedLines[sanitizedLines.length - 1];
+
+    // Code blocks of ```single line``` don't toggle the inCodeBlock flag
+    if (CODE_SINGLE_LINE_REGEX.test(line)) {
+      sanitizedLines.push(line);
+      continue;
+    }
+
+    // Detect the start or end of a code block
+    if (CODE_START_REGEX.test(line) || CODE_END_REGEX.test(line)) {
+      inCodeBlock = !inCodeBlock;
+      sanitizedLines.push(line);
+      continue;
+    }
+
+    // If we are inside a code block, keep the line unchanged
+    if (inCodeBlock) {
+      sanitizedLines.push(line);
+      continue;
+    }
+
+    // In markdown the concept of "empty paragraphs" does not exist.
+    // Blocks must be separated by an empty line. Non-empty adjacent lines must be merged.
+    if (line === '' || lastLine === '' || !lastLine || HEADING_REGEX.test(lastLine) || HEADING_REGEX.test(line) || QUOTE_REGEX.test(line) || ORDERED_LIST_REGEX.test(line) || UNORDERED_LIST_REGEX.test(line) || CHECK_LIST_REGEX.test(line) || TABLE_ROW_REG_EXP.test(line) || TABLE_ROW_DIVIDER_REG_EXP.test(line) || !shouldMergeAdjacentLines) {
+      sanitizedLines.push(line);
+    } else {
+      sanitizedLines[sanitizedLines.length - 1] = lastLine + line;
+    }
+  }
+  return sanitizedLines.join('\n');
+}
+
+function runElementTransformers(parentNode, anchorNode, anchorOffset, elementTransformers) {
+  const grandParentNode = parentNode.getParent();
+  if (!lexical.$isRootOrShadowRoot(grandParentNode) || parentNode.getFirstChild() !== anchorNode) {
+    return false;
+  }
+  const textContent = anchorNode.getTextContent();
+
+  // Checking for anchorOffset position to prevent any checks for cases when caret is too far
+  // from a line start to be a part of block-level markdown trigger.
+  //
+  // TODO:
+  // Can have a quick check if caret is close enough to the beginning of the string (e.g. offset less than 10-20)
+  // since otherwise it won't be a markdown shortcut, but tables are exception
+  if (textContent[anchorOffset - 1] !== ' ') {
+    return false;
+  }
+  for (const {
+    regExp,
+    replace
+  } of elementTransformers) {
+    const match = textContent.match(regExp);
+    if (match && match[0].length === (match[0].endsWith(' ') ? anchorOffset : anchorOffset - 1)) {
+      const nextSiblings = anchorNode.getNextSiblings();
+      const [leadingNode, remainderNode] = anchorNode.splitText(anchorOffset);
+      const siblings = remainderNode ? [remainderNode, ...nextSiblings] : nextSiblings;
+      if (replace(parentNode, siblings, match, false) !== false) {
+        leadingNode.remove();
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function runMultilineElementTransformers(parentNode, anchorNode, anchorOffset, elementTransformers) {
+  const grandParentNode = parentNode.getParent();
+  if (!lexical.$isRootOrShadowRoot(grandParentNode) || parentNode.getFirstChild() !== anchorNode) {
+    return false;
+  }
+  const textContent = anchorNode.getTextContent();
+
+  // Checking for anchorOffset position to prevent any checks for cases when caret is too far
+  // from a line start to be a part of block-level markdown trigger.
+  //
+  // TODO:
+  // Can have a quick check if caret is close enough to the beginning of the string (e.g. offset less than 10-20)
+  // since otherwise it won't be a markdown shortcut, but tables are exception
+  if (textContent[anchorOffset - 1] !== ' ') {
+    return false;
+  }
+  for (const {
+    regExpStart,
+    replace,
+    regExpEnd
+  } of elementTransformers) {
+    if (regExpEnd && !('optional' in regExpEnd) || regExpEnd && 'optional' in regExpEnd && !regExpEnd.optional) {
+      continue;
+    }
+    const match = textContent.match(regExpStart);
+    if (match && match[0].length === (match[0].endsWith(' ') ? anchorOffset : anchorOffset - 1)) {
+      const nextSiblings = anchorNode.getNextSiblings();
+      const [leadingNode, remainderNode] = anchorNode.splitText(anchorOffset);
+      const siblings = remainderNode ? [remainderNode, ...nextSiblings] : nextSiblings;
+      if (replace(parentNode, siblings, match, null, null, false) !== false) {
+        leadingNode.remove();
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function runTextMatchTransformers(anchorNode, anchorOffset, transformersByTrigger) {
+  let textContent = anchorNode.getTextContent();
+  const lastChar = textContent[anchorOffset - 1];
+  const transformers = transformersByTrigger[lastChar];
+  if (transformers == null) {
+    return false;
+  }
+
+  // If typing in the middle of content, remove the tail to do
+  // reg exp match up to a string end (caret position)
+  if (anchorOffset < textContent.length) {
+    textContent = textContent.slice(0, anchorOffset);
+  }
+  for (const transformer of transformers) {
+    if (!transformer.replace || !transformer.regExp) {
+      continue;
+    }
+    const match = textContent.match(transformer.regExp);
+    if (match === null) {
+      continue;
+    }
+    const startIndex = match.index || 0;
+    const endIndex = startIndex + match[0].length;
+    let replaceNode;
+    if (startIndex === 0) {
+      [replaceNode] = anchorNode.splitText(endIndex);
+    } else {
+      [, replaceNode] = anchorNode.splitText(startIndex, endIndex);
+    }
+    replaceNode.selectNext(0, 0);
+    transformer.replace(replaceNode, match);
+    return true;
+  }
+  return false;
+}
+function $runTextFormatTransformers(anchorNode, anchorOffset, textFormatTransformers) {
+  const textContent = anchorNode.getTextContent();
+  const closeTagEndIndex = anchorOffset - 1;
+  const closeChar = textContent[closeTagEndIndex];
+  // Quick check if we're possibly at the end of inline markdown style
+  const matchers = textFormatTransformers[closeChar];
+  if (!matchers) {
+    return false;
+  }
+  for (const matcher of matchers) {
+    const {
+      tag
+    } = matcher;
+    const tagLength = tag.length;
+    const closeTagStartIndex = closeTagEndIndex - tagLength + 1;
+
+    // If tag is not single char check if rest of it matches with text content
+    if (tagLength > 1) {
+      if (!isEqualSubString(textContent, closeTagStartIndex, tag, 0, tagLength)) {
+        continue;
+      }
     }
-    const title = node.getTitle();
-    const textContent = exportChildren(node);
-    const linkContent = title ? `[${textContent}](${node.getURL()} "${title}")` : `[${textContent}](${node.getURL()})`;
-    return linkContent;
-  },
-  importRegExp: /(?:\[(.*?)\])(?:\((?:([^()\s]+)(?:\s"((?:[^"]*\\")*[^"]*)"\s*)?)\))/,
-  regExp: /(?:\[(.*?)\])(?:\((?:([^()\s]+)(?:\s"((?:[^"]*\\")*[^"]*)"\s*)?)\))$/,
-  replace: (textNode, match) => {
-    const [, linkText, linkUrl, linkTitle] = match;
-    const linkNode = link.$createLinkNode(linkUrl, {
-      title: linkTitle
-    });
-    const openBracketAmount = linkText.split('[').length - 1;
-    const closeBracketAmount = linkText.split(']').length - 1;
-    let parsedLinkText = linkText;
-    let outsideLinkText = '';
-    if (openBracketAmount < closeBracketAmount) {
-      return;
-    } else if (openBracketAmount > closeBracketAmount) {
-      const linkTextParts = linkText.split('[');
-      outsideLinkText = '[' + linkTextParts[0];
-      parsedLinkText = linkTextParts.slice(1).join('[');
+
+    // Space before closing tag cancels inline markdown
+    if (textContent[closeTagStartIndex - 1] === ' ') {
+      continue;
     }
-    const linkTextNode = lexical.$createTextNode(parsedLinkText);
-    linkTextNode.setFormat(textNode.getFormat());
-    linkNode.append(linkTextNode);
-    textNode.replace(linkNode);
-    if (outsideLinkText) {
-      linkNode.insertBefore(lexical.$createTextNode(outsideLinkText));
+
+    // Some tags can not be used within words, hence should have newline/space/punctuation after it
+    const afterCloseTagChar = textContent[closeTagEndIndex + 1];
+    if (matcher.intraword === false && afterCloseTagChar && !PUNCTUATION_OR_SPACE.test(afterCloseTagChar)) {
+      continue;
     }
-    return linkTextNode;
-  },
-  trigger: ')',
-  type: 'text-match'
-};
-function normalizeMarkdown(input, shouldMergeAdjacentLines = false) {
-  const lines = input.split('\n');
-  let inCodeBlock = false;
-  const sanitizedLines = [];
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const lastLine = sanitizedLines[sanitizedLines.length - 1];
+    const closeNode = anchorNode;
+    let openNode = closeNode;
+    let openTagStartIndex = getOpenTagStartIndex(textContent, closeTagStartIndex, tag);
 
-    // Code blocks of ```single line``` don't toggle the inCodeBlock flag
-    if (CODE_SINGLE_LINE_REGEX.test(line)) {
-      sanitizedLines.push(line);
+    // Go through text node siblings and search for opening tag
+    // if haven't found it within the same text node as closing tag
+    let sibling = openNode;
+    while (openTagStartIndex < 0 && (sibling = sibling.getPreviousSibling())) {
+      if (lexical.$isLineBreakNode(sibling)) {
+        break;
+      }
+      if (lexical.$isTextNode(sibling)) {
+        if (sibling.hasFormat('code')) {
+          continue;
+        }
+        const siblingTextContent = sibling.getTextContent();
+        openNode = sibling;
+        openTagStartIndex = getOpenTagStartIndex(siblingTextContent, siblingTextContent.length, tag);
+      }
+    }
+
+    // Opening tag is not found
+    if (openTagStartIndex < 0) {
       continue;
     }
 
-    // Detect the start or end of a code block
-    if (CODE_START_REGEX.test(line) || CODE_END_REGEX.test(line)) {
-      inCodeBlock = !inCodeBlock;
-      sanitizedLines.push(line);
+    // No content between opening and closing tag
+    if (openNode === closeNode && openTagStartIndex + tagLength === closeTagStartIndex) {
       continue;
     }
 
-    // If we are inside a code block, keep the line unchanged
-    if (inCodeBlock) {
-      sanitizedLines.push(line);
+    // Checking longer tags for repeating chars (e.g. *** vs **)
+    const prevOpenNodeText = openNode.getTextContent();
+    if (openTagStartIndex > 0 && prevOpenNodeText[openTagStartIndex - 1] === closeChar) {
       continue;
     }
 
-    // In markdown the concept of "empty paragraphs" does not exist.
-    // Blocks must be separated by an empty line. Non-empty adjacent lines must be merged.
-    if (line === '' || lastLine === '' || !lastLine || HEADING_REGEX.test(lastLine) || HEADING_REGEX.test(line) || QUOTE_REGEX.test(line) || ORDERED_LIST_REGEX.test(line) || UNORDERED_LIST_REGEX.test(line) || CHECK_LIST_REGEX.test(line) || TABLE_ROW_REG_EXP.test(line) || TABLE_ROW_DIVIDER_REG_EXP.test(line) || !shouldMergeAdjacentLines) {
-      sanitizedLines.push(line);
-    } else {
-      sanitizedLines[sanitizedLines.length - 1] = lastLine + line;
+    // Some tags can not be used within words, hence should have newline/space/punctuation before it
+    const beforeOpenTagChar = prevOpenNodeText[openTagStartIndex - 1];
+    if (matcher.intraword === false && beforeOpenTagChar && !PUNCTUATION_OR_SPACE.test(beforeOpenTagChar)) {
+      continue;
+    }
+
+    // Clean text from opening and closing tags (starting from closing tag
+    // to prevent any offset shifts if we start from opening one)
+    const prevCloseNodeText = closeNode.getTextContent();
+    const closeNodeText = prevCloseNodeText.slice(0, closeTagStartIndex) + prevCloseNodeText.slice(closeTagEndIndex + 1);
+    closeNode.setTextContent(closeNodeText);
+    const openNodeText = openNode === closeNode ? closeNodeText : prevOpenNodeText;
+    openNode.setTextContent(openNodeText.slice(0, openTagStartIndex) + openNodeText.slice(openTagStartIndex + tagLength));
+    const selection = lexical.$getSelection();
+    const nextSelection = lexical.$createRangeSelection();
+    lexical.$setSelection(nextSelection);
+    // Adjust offset based on deleted chars
+    const newOffset = closeTagEndIndex - tagLength * (openNode === closeNode ? 2 : 1) + 1;
+    nextSelection.anchor.set(openNode.__key, openTagStartIndex, 'text');
+    nextSelection.focus.set(closeNode.__key, newOffset, 'text');
+
+    // Apply formatting to selected text
+    for (const format of matcher.format) {
+      if (!nextSelection.hasFormat(format)) {
+        nextSelection.formatText(format);
+      }
+    }
+
+    // Collapse selection up to the focus point
+    nextSelection.anchor.set(nextSelection.focus.key, nextSelection.focus.offset, nextSelection.focus.type);
+
+    // Remove formatting from collapsed selection
+    for (const format of matcher.format) {
+      if (nextSelection.hasFormat(format)) {
+        nextSelection.toggleFormat(format);
+      }
+    }
+    if (lexical.$isRangeSelection(selection)) {
+      nextSelection.format = selection.format;
     }
+    return true;
   }
-  return sanitizedLines.join('\n');
+  return false;
+}
+function getOpenTagStartIndex(string, maxIndex, tag) {
+  const tagLength = tag.length;
+  for (let i = maxIndex; i >= tagLength; i--) {
+    const startIndex = i - tagLength;
+    if (isEqualSubString(string, startIndex, tag, 0, tagLength) &&
+    // Space after opening tag cancels transformation
+    string[startIndex + tagLength] !== ' ') {
+      return startIndex;
+    }
+  }
+  return -1;
+}
+function isEqualSubString(stringA, aStart, stringB, bStart, length) {
+  for (let i = 0; i < length; i++) {
+    if (stringA[aStart + i] !== stringB[bStart + i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function registerMarkdownShortcuts(editor, transformers = TRANSFORMERS) {
+  const byType = transformersByType(transformers);
+  const textFormatTransformersByTrigger = indexBy(byType.textFormat, ({
+    tag
+  }) => tag[tag.length - 1]);
+  const textMatchTransformersByTrigger = indexBy(byType.textMatch, ({
+    trigger
+  }) => trigger);
+  for (const transformer of transformers) {
+    const type = transformer.type;
+    if (type === 'element' || type === 'text-match' || type === 'multiline-element') {
+      const dependencies = transformer.dependencies;
+      for (const node of dependencies) {
+        if (!editor.hasNode(node)) {
+          {
+            formatDevErrorMessage(`MarkdownShortcuts: missing dependency ${node.getType()} for transformer. Ensure node dependency is included in editor initial config.`);
+          }
+        }
+      }
+    }
+  }
+  const $transform = (parentNode, anchorNode, anchorOffset) => {
+    if (runElementTransformers(parentNode, anchorNode, anchorOffset, byType.element)) {
+      return;
+    }
+    if (runMultilineElementTransformers(parentNode, anchorNode, anchorOffset, byType.multilineElement)) {
+      return;
+    }
+    if (runTextMatchTransformers(anchorNode, anchorOffset, textMatchTransformersByTrigger)) {
+      return;
+    }
+    $runTextFormatTransformers(anchorNode, anchorOffset, textFormatTransformersByTrigger);
+  };
+  return editor.registerUpdateListener(({
+    tags,
+    dirtyLeaves,
+    editorState,
+    prevEditorState
+  }) => {
+    // Ignore updates from collaboration and undo/redo (as changes already calculated)
+    if (tags.has(lexical.COLLABORATION_TAG) || tags.has(lexical.HISTORIC_TAG)) {
+      return;
+    }
+
+    // If editor is still composing (i.e. backticks) we must wait before the user confirms the key
+    if (editor.isComposing()) {
+      return;
+    }
+    const selection = editorState.read(lexical.$getSelection);
+    const prevSelection = prevEditorState.read(lexical.$getSelection);
+
+    // We expect selection to be a collapsed range and not match previous one (as we want
+    // to trigger transforms only as user types)
+    if (!lexical.$isRangeSelection(prevSelection) || !lexical.$isRangeSelection(selection) || !selection.isCollapsed() || selection.is(prevSelection)) {
+      return;
+    }
+    const anchorKey = selection.anchor.key;
+    const anchorOffset = selection.anchor.offset;
+    const anchorNode = editorState._nodeMap.get(anchorKey);
+    if (!lexical.$isTextNode(anchorNode) || !dirtyLeaves.has(anchorKey) || anchorOffset !== 1 && anchorOffset > prevSelection.anchor.offset + 1) {
+      return;
+    }
+    editor.update(() => {
+      if (!canContainTransformableMarkdown(anchorNode)) {
+        return;
+      }
+      const parentNode = anchorNode.getParent();
+      if (parentNode === null || code.$isCodeNode(parentNode)) {
+        return;
+      }
+      $transform(parentNode, anchorNode, selection.anchor.offset);
+    });
+  });
 }
 
 /**
@@ -1415,16 +1425,6 @@ function normalizeMarkdown(input, shouldMergeAdjacentLines = false) {
  *
  */
 
-const ELEMENT_TRANSFORMERS = [HEADING, QUOTE, UNORDERED_LIST, ORDERED_LIST];
-const MULTILINE_ELEMENT_TRANSFORMERS = [CODE];
-
-// Order of text format transformers matters:
-//
-// - code should go first as it prevents any transformations inside
-// - then longer tags match (e.g. ** or __ should go before * or _)
-const TEXT_FORMAT_TRANSFORMERS = [INLINE_CODE, BOLD_ITALIC_STAR, BOLD_ITALIC_UNDERSCORE, BOLD_STAR, BOLD_UNDERSCORE, HIGHLIGHT, ITALIC_STAR, ITALIC_UNDERSCORE, STRIKETHROUGH];
-const TEXT_MATCH_TRANSFORMERS = [LINK];
-const TRANSFORMERS = [...ELEMENT_TRANSFORMERS, ...MULTILINE_ELEMENT_TRANSFORMERS, ...TEXT_FORMAT_TRANSFORMERS, ...TEXT_MATCH_TRANSFORMERS];
 
 /**
  * Renders markdown from a string. The selection is moved to the start after the operation.