@lexical/markdown 0.52.1-nightly.20261027.0 → 0.53.0

package/dist/LexicalMarkdown.dev.js

@@ -57,16 +57,342 @@ function isEmptyParagraph(node) {
   return firstChild == null || node.getChildrenSize() === 1 && $isTextNode(firstChild) && MARKDOWN_EMPTY_LINE_REG_EXP.test(firstChild.getTextContent());
 }
 
-// A decimal character reference has one to seven digits, and one that names
+// Numeric references have one to seven decimal or one to six hexadecimal digits.
+// A reference that names
 // U+0000, a surrogate or a number past U+10FFFF reads as U+FFFD instead of
 // making `String.fromCodePoint` throw.
 // https://spec.commonmark.org/0.31.2/#decimal-numeric-character
-function decodeDecimalCharacterReference(_, digits) {
-  const codePoint = Number(digits);
+function decodeCharacterReference(digits, hex) {
+  const codePoint = digits !== undefined ? Number(digits) : parseInt(hex, 16);
   return codePoint === 0 || codePoint >= 0xd800 && codePoint <= 0xdfff || codePoint > 0x10ffff ? '\uFFFD' : String.fromCodePoint(codePoint);
 }
 function unescapeText(value) {
-  return value.replace(/\\([!-/:-@[-`{-~])/g, '$1').replace(/&#(\d{1,7});/g, decodeDecimalCharacterReference);
+  // Do not decode an escaped ampersand or revisit a decoded reference.
+  return value.replace(/\\([!-/:-@[-`{-~])|&#(?:(\d{1,7})|[xX]([\da-fA-F]{1,6}));/g, (_match, escaped, digits, hex) => escaped ?? decodeCharacterReference(digits, hex));
+}
+function isEscaped(text, index) {
+  let backslashes = 0;
+  for (let i = index - 1; i >= 0 && text[i] === '\\'; i--) {
+    backslashes++;
+  }
+  return backslashes % 2 === 1;
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+function findOutermostTextFormatTransformer(textNode, textFormatTransformersIndex) {
+  const textContent = textNode.getTextContent();
+
+  // Find code spans first. Emphasis delimiters inside inline elements (e.g., code spans)
+  // should not be processed. Currently only code spans are handled; other inline elements
+  // (e.g., links, raw HTML) may need similar treatment in the future.
+  const codeTransformer = textFormatTransformersIndex.transformersByTag['`'];
+  const excludeRanges = [];
+  let codeMatch = null;
+  if (codeTransformer) {
+    const codeSpans = scanCodeSpans(textContent);
+    for (const span of codeSpans) {
+      if (!codeMatch) {
+        codeMatch = {
+          content: span.content,
+          endIndex: span.endIndex,
+          startIndex: span.startIndex,
+          tag: '`'
+        };
+      }
+      excludeRanges.push({
+        end: span.endIndex,
+        start: span.startIndex
+      });
+    }
+  }
+  const delimiters = scanDelimiters(textContent, textFormatTransformersIndex, excludeRanges);
+  const emphasisMatch = delimiters.length > 0 ? processEmphasis(textContent, delimiters, textFormatTransformersIndex) : null;
+  let resultMatch = null;
+  let resultTransformer = null;
+  if (codeMatch && emphasisMatch) {
+    if (emphasisMatch.startIndex <= codeMatch.startIndex && emphasisMatch.endIndex >= codeMatch.endIndex) {
+      resultMatch = emphasisMatch;
+      resultTransformer = textFormatTransformersIndex.transformersByTag[emphasisMatch.tag];
+    } else {
+      resultMatch = codeMatch;
+      resultTransformer = codeTransformer;
+    }
+  } else if (codeMatch) {
+    resultMatch = codeMatch;
+    resultTransformer = codeTransformer;
+  } else if (emphasisMatch) {
+    resultMatch = emphasisMatch;
+    resultTransformer = textFormatTransformersIndex.transformersByTag[emphasisMatch.tag];
+  }
+  if (!resultMatch || !resultTransformer) {
+    return null;
+  }
+  const regexMatch = [textContent.slice(resultMatch.startIndex, resultMatch.endIndex), resultMatch.tag, resultMatch.content];
+  regexMatch.index = resultMatch.startIndex;
+  regexMatch.input = textContent;
+  return {
+    endIndex: resultMatch.endIndex,
+    // resultTransformer is the registered code transformer (by identity)
+    // exactly when the chosen match is the code span.
+    isCodeSpan: resultTransformer === codeTransformer,
+    match: regexMatch,
+    startIndex: resultMatch.startIndex,
+    transformer: resultTransformer
+  };
+}
+
+// Finds all inline code spans, left to right and non-overlapping, per CommonMark
+// rules: https://spec.commonmark.org/#code-spans. A run opens a span and the
+// next run of equal length closes it. An escaped backtick (`\``) cannot open a
+// span, but backslashes are otherwise literal and don't prevent closing.
+function scanCodeSpans(text) {
+  const isEscaped = index => {
+    let count = 0;
+    for (let i = index - 1; i >= 0 && text[i] === '\\'; i--) {
+      count++;
+    }
+    return count % 2 === 1;
+  };
+
+  // Collect maximal backtick runs.
+  const runs = [];
+  let i = 0;
+  while (i < text.length) {
+    if (text[i] === '`') {
+      let length = 1;
+      while (i + length < text.length && text[i + length] === '`') {
+        length++;
+      }
+      runs.push({
+        index: i,
+        length
+      });
+      i += length;
+    } else {
+      i++;
+    }
+  }
+  const spans = [];
+  let openIdx = 0;
+  while (openIdx < runs.length) {
+    const opener = runs[openIdx];
+
+    // An escaped backtick run is a literal backtick and cannot open a span.
+    if (isEscaped(opener.index)) {
+      openIdx++;
+      continue;
+    }
+    let closeIdx = -1;
+    for (let c = openIdx + 1; c < runs.length; c++) {
+      if (runs[c].length === opener.length) {
+        closeIdx = c;
+        break;
+      }
+    }
+    if (closeIdx === -1) {
+      // No matching closer; treat this run as literal and try the next one.
+      openIdx++;
+      continue;
+    }
+    const closer = runs[closeIdx];
+    let content = text.slice(opener.index + opener.length, closer.index);
+    if (content.length >= 2 && content.startsWith(' ') && content.endsWith(' ') && /[^ ]/.test(content)) {
+      content = content.slice(1, -1);
+    }
+    spans.push({
+      content,
+      endIndex: closer.index + closer.length,
+      startIndex: opener.index
+    });
+    openIdx = closeIdx + 1;
+  }
+  return spans;
+}
+function scanDelimiters(text, transformersIndex, excludeRanges = []) {
+  const delimiters = [];
+  const delimiterChars = new Set(Object.keys(transformersIndex.transformersByTag).filter(tag => tag[0] !== '`').map(tag => tag[0]));
+  const isEscaped = index => {
+    let count = 0;
+    for (let i = index - 1; i >= 0 && text[i] === '\\'; i--) {
+      count++;
+    }
+    return count % 2 === 1;
+  };
+  const isInExcludedRange = index => {
+    return excludeRanges.some(range => index >= range.start && index < range.end);
+  };
+  let i = 0;
+  while (i < text.length) {
+    const char = text[i];
+    if (!delimiterChars.has(char) || isEscaped(i) || isInExcludedRange(i)) {
+      i++;
+      continue;
+    }
+    let len = 1;
+    while (i + len < text.length && text[i + len] === char) {
+      len++;
+    }
+    const canOpen = canEmphasis(char, text, i, len, true);
+    const canClose = canEmphasis(char, text, i, len, false);
+    if (canOpen || canClose) {
+      delimiters.push({
+        active: true,
+        canClose,
+        canOpen,
+        char,
+        index: i,
+        length: len
+      });
+    }
+    i += len;
+  }
+  return delimiters;
+}
+function processEmphasis(text, delimiters, transformersIndex) {
+  const openersBottom = {};
+  let currentPos = 0;
+  let result = null;
+  while (currentPos < delimiters.length) {
+    const closer = delimiters[currentPos];
+    if (!closer.active || !closer.canClose || closer.length === 0) {
+      currentPos++;
+      continue;
+    }
+
+    // The "no opener below this point" shortcut must be keyed by everything
+    // the opener search outcome depends on: the marker, whether the closer
+    // can also open (toggles the rule of 3), and the closer's length mod 3
+    // (the rule of 3 blocks different openers per class — CommonMark's
+    // openers_bottom is likewise per length-mod-3). The length key uses the
+    // *current* length: a partially consumed closer switches class and must
+    // rescan openers a shorter closer already gave up on (#4895).
+    const bottomKey = `${closer.char}${closer.canOpen}${closer.length % 3}`;
+    const bottom = openersBottom[bottomKey] ?? -1;
+    let foundOpener = false;
+    for (let openIdx = currentPos - 1; openIdx > bottom; openIdx--) {
+      const opener = delimiters[openIdx];
+      if (!opener.active || !opener.canOpen || opener.length === 0 || opener.char !== closer.char) {
+        continue;
+      }
+
+      // Rule of 3, on the *remaining* lengths: a delimiter run partially
+      // consumed by an earlier pairing is re-measured, matching micromark
+      // (the CommonMark reference this models). Using the original lengths
+      // instead would refuse pairings like the `**` opener with the two
+      // markers left of a `****` run in `**llo*wor****`, so the exporter's
+      // own output for overlapping formats would not re-import (#4895).
+      if (opener.canClose || closer.canOpen) {
+        const sum = opener.length + closer.length;
+        if (sum % 3 === 0 && opener.length % 3 !== 0 && closer.length % 3 !== 0) {
+          continue;
+        }
+      }
+      const maxLen = Math.min(opener.length, closer.length);
+      const matchedTag = Object.keys(transformersIndex.transformersByTag).filter(t => t[0] === opener.char && t.length <= maxLen).sort((a, b) => b.length - a.length)[0];
+      if (!matchedTag) {
+        continue;
+      }
+      foundOpener = true;
+      const matchLen = matchedTag.length;
+      const match = {
+        content: text.slice(opener.index + opener.length, closer.index),
+        endIndex: closer.index + matchLen,
+        startIndex: opener.index + (opener.length - matchLen),
+        tag: matchedTag
+      };
+      if (!result || match.startIndex < result.startIndex || match.startIndex === result.startIndex && match.endIndex > result.endIndex) {
+        result = match;
+      }
+      for (let j = openIdx + 1; j < currentPos; j++) {
+        delimiters[j].active = false;
+      }
+      opener.length -= matchLen;
+      closer.length -= matchLen;
+      opener.active = opener.length > 0;
+      if (closer.length > 0) {
+        closer.index += matchLen;
+      } else {
+        closer.active = false;
+        currentPos++;
+      }
+      break;
+    }
+    if (!foundOpener) {
+      openersBottom[bottomKey] = currentPos - 1;
+      if (!closer.canOpen) {
+        closer.active = false;
+      }
+      currentPos++;
+    }
+  }
+  return result;
+}
+function canEmphasis(char, text, index, length, isOpen) {
+  if (!isFlanking(text, index, length, isOpen)) {
+    return false;
+  }
+  if (char === '*') {
+    return true;
+  }
+  if (char === '_') {
+    if (!isFlanking(text, index, length, !isOpen)) {
+      return true;
+    }
+    const adjacentChar = isOpen ? text[index - 1] : text[index + length];
+    return adjacentChar !== undefined && PUNCTUATION.test(adjacentChar);
+  }
+  return true;
+}
+function isFlanking(text, index, length, isLeft) {
+  const charBefore = text[index - 1];
+  const charAfter = text[index + length];
+  const [primary, secondary] = isLeft ? [charAfter, charBefore] : [charBefore, charAfter];
+  if (primary === undefined || WHITESPACE.test(primary)) {
+    return false;
+  }
+  if (!PUNCTUATION.test(primary)) {
+    return true;
+  }
+  return secondary === undefined || WHITESPACE.test(secondary) || PUNCTUATION.test(secondary);
+}
+function importTextFormatTransformer(textNode, startIndex, endIndex, transformer, match) {
+  const textContent = textNode.getTextContent();
+
+  // No text matches - we can safely process the text format match
+  let transformedNode, nodeAfter, nodeBefore;
+
+  // 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) {
+    transformedNode = textNode;
+  } else {
+    if (startIndex === 0) {
+      [transformedNode, nodeAfter] = textNode.splitText(endIndex);
+    } else {
+      [nodeBefore, transformedNode, nodeAfter] = textNode.splitText(startIndex, endIndex);
+    }
+  }
+  transformedNode.setTextContent(match[2]);
+  if (transformer) {
+    for (const format of transformer.format) {
+      if (!transformedNode.hasFormat(format)) {
+        transformedNode.toggleFormat(format);
+      }
+    }
+  }
+  return {
+    nodeAfter: nodeAfter,
+    nodeBefore: nodeBefore,
+    transformedNode: transformedNode
+  };
 }
 
 /**
@@ -834,6 +1160,42 @@ function escapeCharacterReferences(value) {
   return value.replace(/&(?=#\d+;|#[Xx][\dA-Fa-f]+;|[A-Za-z][\dA-Za-z]*;)/g, '&#38;');
 }
 
+// Mask escaped/code brackets without changing source offsets, then find an inner
+// opener after a literal prefix. Return -1 for balanced labels or null when
+// unmatched closers leave no recoverable opener.
+function getLinkLabelOpener(text) {
+  const codeSpans = scanCodeSpans(text);
+  let codeIndex = 0;
+  const brackets = text.replace(/\\.|[[\]]/g, (part, index) => {
+    while (codeIndex < codeSpans.length && index >= codeSpans[codeIndex].endIndex) codeIndex++;
+    return codeIndex < codeSpans.length && index >= codeSpans[codeIndex].startIndex || part[0] === '\\' ? ' '.repeat(part.length) : part;
+  });
+  const openers = [];
+  let unmatchedCloser = false;
+  for (let index = 0; index < brackets.length; index++) {
+    const character = brackets[index];
+    if (character === '[') {
+      openers.push(index);
+    } else if (character === ']') {
+      if (openers.pop() === undefined) unmatchedCloser = true;
+    }
+  }
+  return openers.pop() ?? (unmatchedCloser ? null : -1);
+}
+function unescapeLinkPrefix(text) {
+  let output = '';
+  let previous = 0;
+  // Keep existing code-prefix source intact; only plain text has escapes.
+  for (const {
+    startIndex,
+    endIndex
+  } of scanCodeSpans(text)) {
+    output += unescapeText(text.slice(previous, startIndex)) + text.slice(startIndex, endIndex);
+    previous = endIndex;
+  }
+  return output + unescapeText(text.slice(previous));
+}
+
 // Order of text transformers matters:
 //
 // - code should go first as it prevents any transformations inside
@@ -907,7 +1269,9 @@ const LINK = {
   regExp: /(?:\[([^[\]]*(?:\[[^[\]]*\][^[\]]*)*)\])(?:\(\s*(?:(?:<((?:\\.|[^<>\n\\])*)>|((?!<)(?:\\[^\s]|\\(?=\s)|\((?:\\[^\s]|[^\s()\\]|\((?:\\[^\s]|[^\s()\\]|\((?:\\[^\s]|[^\s()\\])*\))*\))*\)|[^\s()\\])+))(?:\s+(?:"((?:[^"]*\\")*[^"]*)"|'((?:[^']*\\')*[^']*)'|\(((?:\\.|[^()\\])*)\)))?\s*)?\))$/,
   replace: (textNode, match) => {
     // https://spec.commonmark.org/0.31.2/#inline-link
-    if ($findMatchingParent(textNode, $isLinkNode)) {
+    const source = match.input || '';
+    const startIndex = match.index || 0;
+    if ($findMatchingParent(textNode, $isLinkNode) || isEscaped(source, startIndex) || isEscaped(source, startIndex + match[1].length + 1)) {
       return;
     }
     const [, linkText, pointyLinkUrl, rawLinkUrl, quotedTitle, apostrophedTitle, parenthesizedTitle] = match;
@@ -922,16 +1286,13 @@ const LINK = {
     const linkNode = $createLinkNode(linkUrl, {
       title: linkTitle
     });
-    const openBracketAmount = linkText.split('[').length - 1;
-    const closeBracketAmount = linkText.split(']').length - 1;
+    const openBracketIndex = getLinkLabelOpener(linkText);
+    if (openBracketIndex === null) return;
     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('[');
+    if (openBracketIndex !== -1) {
+      outsideLinkText = '[' + unescapeLinkPrefix(linkText.slice(0, openBracketIndex));
+      parsedLinkText = linkText.slice(openBracketIndex + 1);
     }
     // Both new nodes stand in for the TextNode being replaced, so the text
     // left outside the link carries its inline format just like the link's own
@@ -1286,7 +1647,10 @@ unclosedTags, unclosableTags, shouldPreserveNewLines = false) {
   let output = textContent;
   if (!isCode) {
     // Preserve literal backslashes when preserving source newlines.
-    output = shouldPreserveNewLines ? output.replace(/([*_`~])/g, '\\$1') : output.replace(/([*_`~\\])/g, '\\$1');
+    // Default mode guards numeric references; named references keep legacy output.
+    // Numeric escapes avoid changing emphasis flanking beside formatting.
+    // Guard ambiguous '<' and '&' at node ends for constructs split across nodes.
+    output = shouldPreserveNewLines ? output.replace(/([*_`~])/g, '\\$1') : output.replace(/([[\]*_`~\\]|<(?=\S|$)|&(?=#|$))/g, character => /[*_`~\\]/.test(character) ? `\\${character}` : `&#${character.charCodeAt(0)};`);
   }
   let leadingSpace;
   let trimmedOutput;
@@ -1299,439 +1663,122 @@ unclosedTags, unclosableTags, shouldPreserveNewLines = false) {
       fence,
       padded
     } = getCodeSpanDelimiter(textContent);
-    leadingSpace = '';
-    trailingSpace = '';
-    trimmedOutput = fence + padded + fence;
-    isWhitespaceOnly = false;
-  } else {
-    // Extract leading and trailing whitespaces.
-    // CommonMark flanking rules require formatting tags to be adjacent to non-whitespace characters.
-    const match = output.match(/^(\s*)(.*?)(\s*)$/s) || ['', '', output, ''];
-    leadingSpace = match[1];
-    trimmedOutput = match[2];
-    trailingSpace = match[3];
-    isWhitespaceOnly = trimmedOutput === '';
-  }
-
-  // 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;
-
-    // Inline code uses a content-derived fence handled above, not a static tag.
-    if (format === 'code') {
-      continue;
-    }
-
-    // dedup applied formats
-    // `checkHasFormat` reads the node's whole text, but the text being
-    // exported may be a selection slice of it. When the slice is entirely
-    // whitespace the tags are dropped by the early return below, so
-    // registering them here would leave an unclosed tag for a later node to
-    // close. In the full-document path `checkHasFormat` already rejects
-    // whitespace-only nodes, so this guard only affects sliced content.
-    if (!isWhitespaceOnly && checkHasFormat(node, format) && !applied.has(format)) {
-      applied.add(format);
-
-      // append the tag to openingTags, if it's not applied to the previous nodes,
-      // or the nodes before that (which would result in an unclosed tag)
-      if (!checkHasFormat(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;
-      }
-      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;
-  }
-  // If the node is entirely whitespace, we don't apply opening/closing tags around it.
-  // However, it must still output closing tags from previous nodes.
-  if (isWhitespaceOnly && !node.hasFormat('code')) {
-    return closingTagsBefore + output;
-  }
-
-  // Flanking Compliance: Notice how openingTags and closingTagsAfter are placed INSIDE the whitespace boundaries!
-  return closingTagsBefore + leadingSpace + openingTags + trimmedOutput + closingTagsAfter + trailingSpace;
-}
-function getTextSibling(node, backward) {
-  const sibling = backward ? node.getPreviousSibling() : node.getNextSibling();
-  if ($isTextNode(sibling)) {
-    return sibling;
-  }
-  return null;
-}
-function hasFormat(node, format) {
-  return $isTextNode(node) && node.hasFormat(format);
-}
-function checkHasFormat(n, f) {
-  if (!hasFormat(n, f)) {
-    return false;
-  }
-  if (f === 'code') {
-    return true;
-  }
-  if (n && /^\s*$/.test(n.getTextContent())) {
-    return false;
-  }
-  return true;
-}
-
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-
-function findOutermostTextFormatTransformer(textNode, textFormatTransformersIndex) {
-  const textContent = textNode.getTextContent();
-
-  // Find code spans first. Emphasis delimiters inside inline elements (e.g., code spans)
-  // should not be processed. Currently only code spans are handled; other inline elements
-  // (e.g., links, raw HTML) may need similar treatment in the future.
-  const codeTransformer = textFormatTransformersIndex.transformersByTag['`'];
-  const excludeRanges = [];
-  let codeMatch = null;
-  if (codeTransformer) {
-    const codeSpans = scanCodeSpans(textContent);
-    for (const span of codeSpans) {
-      if (!codeMatch) {
-        codeMatch = {
-          content: span.content,
-          endIndex: span.endIndex,
-          startIndex: span.startIndex,
-          tag: '`'
-        };
-      }
-      excludeRanges.push({
-        end: span.endIndex,
-        start: span.startIndex
-      });
-    }
-  }
-  const delimiters = scanDelimiters(textContent, textFormatTransformersIndex, excludeRanges);
-  const emphasisMatch = delimiters.length > 0 ? processEmphasis(textContent, delimiters, textFormatTransformersIndex) : null;
-  let resultMatch = null;
-  let resultTransformer = null;
-  if (codeMatch && emphasisMatch) {
-    if (emphasisMatch.startIndex <= codeMatch.startIndex && emphasisMatch.endIndex >= codeMatch.endIndex) {
-      resultMatch = emphasisMatch;
-      resultTransformer = textFormatTransformersIndex.transformersByTag[emphasisMatch.tag];
-    } else {
-      resultMatch = codeMatch;
-      resultTransformer = codeTransformer;
-    }
-  } else if (codeMatch) {
-    resultMatch = codeMatch;
-    resultTransformer = codeTransformer;
-  } else if (emphasisMatch) {
-    resultMatch = emphasisMatch;
-    resultTransformer = textFormatTransformersIndex.transformersByTag[emphasisMatch.tag];
-  }
-  if (!resultMatch || !resultTransformer) {
-    return null;
-  }
-  const regexMatch = [textContent.slice(resultMatch.startIndex, resultMatch.endIndex), resultMatch.tag, resultMatch.content];
-  regexMatch.index = resultMatch.startIndex;
-  regexMatch.input = textContent;
-  return {
-    endIndex: resultMatch.endIndex,
-    // resultTransformer is the registered code transformer (by identity)
-    // exactly when the chosen match is the code span.
-    isCodeSpan: resultTransformer === codeTransformer,
-    match: regexMatch,
-    startIndex: resultMatch.startIndex,
-    transformer: resultTransformer
-  };
-}
-
-// Finds all inline code spans, left to right and non-overlapping, per CommonMark
-// rules: https://spec.commonmark.org/#code-spans. A run opens a span and the
-// next run of equal length closes it. An escaped backtick (`\``) cannot open a
-// span, but backslashes are otherwise literal and don't prevent closing.
-function scanCodeSpans(text) {
-  const isEscaped = index => {
-    let count = 0;
-    for (let i = index - 1; i >= 0 && text[i] === '\\'; i--) {
-      count++;
-    }
-    return count % 2 === 1;
-  };
-
-  // Collect maximal backtick runs.
-  const runs = [];
-  let i = 0;
-  while (i < text.length) {
-    if (text[i] === '`') {
-      let length = 1;
-      while (i + length < text.length && text[i + length] === '`') {
-        length++;
-      }
-      runs.push({
-        index: i,
-        length
-      });
-      i += length;
-    } else {
-      i++;
-    }
-  }
-  const spans = [];
-  let openIdx = 0;
-  while (openIdx < runs.length) {
-    const opener = runs[openIdx];
-
-    // An escaped backtick run is a literal backtick and cannot open a span.
-    if (isEscaped(opener.index)) {
-      openIdx++;
-      continue;
-    }
-    let closeIdx = -1;
-    for (let c = openIdx + 1; c < runs.length; c++) {
-      if (runs[c].length === opener.length) {
-        closeIdx = c;
-        break;
-      }
-    }
-    if (closeIdx === -1) {
-      // No matching closer; treat this run as literal and try the next one.
-      openIdx++;
-      continue;
-    }
-    const closer = runs[closeIdx];
-    let content = text.slice(opener.index + opener.length, closer.index);
-    if (content.length >= 2 && content.startsWith(' ') && content.endsWith(' ') && /[^ ]/.test(content)) {
-      content = content.slice(1, -1);
-    }
-    spans.push({
-      content,
-      endIndex: closer.index + closer.length,
-      startIndex: opener.index
-    });
-    openIdx = closeIdx + 1;
+    leadingSpace = '';
+    trailingSpace = '';
+    trimmedOutput = fence + padded + fence;
+    isWhitespaceOnly = false;
+  } else {
+    // Extract leading and trailing whitespaces.
+    // CommonMark flanking rules require formatting tags to be adjacent to non-whitespace characters.
+    const match = output.match(/^(\s*)(.*?)(\s*)$/s) || ['', '', output, ''];
+    leadingSpace = match[1];
+    trimmedOutput = match[2];
+    trailingSpace = match[3];
+    isWhitespaceOnly = trimmedOutput === '';
   }
-  return spans;
-}
-function scanDelimiters(text, transformersIndex, excludeRanges = []) {
-  const delimiters = [];
-  const delimiterChars = new Set(Object.keys(transformersIndex.transformersByTag).filter(tag => tag[0] !== '`').map(tag => tag[0]));
-  const isEscaped = index => {
-    let count = 0;
-    for (let i = index - 1; i >= 0 && text[i] === '\\'; i--) {
-      count++;
-    }
-    return count % 2 === 1;
-  };
-  const isInExcludedRange = index => {
-    return excludeRanges.some(range => index >= range.start && index < range.end);
-  };
-  let i = 0;
-  while (i < text.length) {
-    const char = text[i];
-    if (!delimiterChars.has(char) || isEscaped(i) || isInExcludedRange(i)) {
-      i++;
+
+  // 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;
+
+    // Inline code uses a content-derived fence handled above, not a static tag.
+    if (format === 'code') {
       continue;
     }
-    let len = 1;
-    while (i + len < text.length && text[i + len] === char) {
-      len++;
-    }
-    const canOpen = canEmphasis(char, text, i, len, true);
-    const canClose = canEmphasis(char, text, i, len, false);
-    if (canOpen || canClose) {
-      delimiters.push({
-        active: true,
-        canClose,
-        canOpen,
-        char,
-        index: i,
-        length: len
-      });
+
+    // dedup applied formats
+    // `checkHasFormat` reads the node's whole text, but the text being
+    // exported may be a selection slice of it. When the slice is entirely
+    // whitespace the tags are dropped by the early return below, so
+    // registering them here would leave an unclosed tag for a later node to
+    // close. In the full-document path `checkHasFormat` already rejects
+    // whitespace-only nodes, so this guard only affects sliced content.
+    if (!isWhitespaceOnly && checkHasFormat(node, format) && !applied.has(format)) {
+      applied.add(format);
+
+      // append the tag to openingTags, if it's not applied to the previous nodes,
+      // or the nodes before that (which would result in an unclosed tag)
+      if (!checkHasFormat(prevNode, format) || !unclosedTags.find(element => element.tag === tag)) {
+        unclosedTags.push({
+          format,
+          tag
+        });
+        openingTags += tag;
+      }
     }
-    i += len;
   }
-  return delimiters;
-}
-function processEmphasis(text, delimiters, transformersIndex) {
-  const openersBottom = {};
-  let currentPos = 0;
-  let result = null;
-  while (currentPos < delimiters.length) {
-    const closer = delimiters[currentPos];
-    if (!closer.active || !closer.canClose || closer.length === 0) {
-      currentPos++;
+
+  // 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
 
-    // The "no opener below this point" shortcut must be keyed by everything
-    // the opener search outcome depends on: the marker, whether the closer
-    // can also open (toggles the rule of 3), and the closer's length mod 3
-    // (the rule of 3 blocks different openers per class — CommonMark's
-    // openers_bottom is likewise per length-mod-3). The length key uses the
-    // *current* length: a partially consumed closer switches class and must
-    // rescan openers a shorter closer already gave up on (#4895).
-    const bottomKey = `${closer.char}${closer.canOpen}${closer.length % 3}`;
-    const bottom = openersBottom[bottomKey] ?? -1;
-    let foundOpener = false;
-    for (let openIdx = currentPos - 1; openIdx > bottom; openIdx--) {
-      const opener = delimiters[openIdx];
-      if (!opener.active || !opener.canOpen || opener.length === 0 || opener.char !== closer.char) {
-        continue;
-      }
+    while (unhandledUnclosedTags.length > i) {
+      const unclosedTag = unhandledUnclosedTags.pop();
 
-      // Rule of 3, on the *remaining* lengths: a delimiter run partially
-      // consumed by an earlier pairing is re-measured, matching micromark
-      // (the CommonMark reference this models). Using the original lengths
-      // instead would refuse pairings like the `**` opener with the two
-      // markers left of a `****` run in `**llo*wor****`, so the exporter's
-      // own output for overlapping formats would not re-import (#4895).
-      if (opener.canClose || closer.canOpen) {
-        const sum = opener.length + closer.length;
-        if (sum % 3 === 0 && opener.length % 3 !== 0 && closer.length % 3 !== 0) {
-          continue;
-        }
-      }
-      const maxLen = Math.min(opener.length, closer.length);
-      const matchedTag = Object.keys(transformersIndex.transformersByTag).filter(t => t[0] === opener.char && t.length <= maxLen).sort((a, b) => b.length - a.length)[0];
-      if (!matchedTag) {
+      // 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;
       }
-      foundOpener = true;
-      const matchLen = matchedTag.length;
-      const match = {
-        content: text.slice(opener.index + opener.length, closer.index),
-        endIndex: closer.index + matchLen,
-        startIndex: opener.index + (opener.length - matchLen),
-        tag: matchedTag
-      };
-      if (!result || match.startIndex < result.startIndex || match.startIndex === result.startIndex && match.endIndex > result.endIndex) {
-        result = match;
-      }
-      for (let j = openIdx + 1; j < currentPos; j++) {
-        delimiters[j].active = false;
-      }
-      opener.length -= matchLen;
-      closer.length -= matchLen;
-      opener.active = opener.length > 0;
-      if (closer.length > 0) {
-        closer.index += matchLen;
-      } else {
-        closer.active = false;
-        currentPos++;
-      }
-      break;
-    }
-    if (!foundOpener) {
-      openersBottom[bottomKey] = currentPos - 1;
-      if (!closer.canOpen) {
-        closer.active = false;
+      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;
+        }
       }
-      currentPos++;
+      // Mutate the original array to remove the closed tag
+      unclosedTags.pop();
     }
+    break;
   }
-  return result;
-}
-function canEmphasis(char, text, index, length, isOpen) {
-  if (!isFlanking(text, index, length, isOpen)) {
-    return false;
-  }
-  if (char === '*') {
-    return true;
+  // If the node is entirely whitespace, we don't apply opening/closing tags around it.
+  // However, it must still output closing tags from previous nodes.
+  if (isWhitespaceOnly && !node.hasFormat('code')) {
+    return closingTagsBefore + output;
   }
-  if (char === '_') {
-    if (!isFlanking(text, index, length, !isOpen)) {
-      return true;
-    }
-    const adjacentChar = isOpen ? text[index - 1] : text[index + length];
-    return adjacentChar !== undefined && PUNCTUATION.test(adjacentChar);
+
+  // Flanking Compliance: Notice how openingTags and closingTagsAfter are placed INSIDE the whitespace boundaries!
+  return closingTagsBefore + leadingSpace + openingTags + trimmedOutput + closingTagsAfter + trailingSpace;
+}
+function getTextSibling(node, backward) {
+  const sibling = backward ? node.getPreviousSibling() : node.getNextSibling();
+  if ($isTextNode(sibling)) {
+    return sibling;
   }
-  return true;
+  return null;
 }
-function isFlanking(text, index, length, isLeft) {
-  const charBefore = text[index - 1];
-  const charAfter = text[index + length];
-  const [primary, secondary] = isLeft ? [charAfter, charBefore] : [charBefore, charAfter];
-  if (primary === undefined || WHITESPACE.test(primary)) {
+function hasFormat(node, format) {
+  return $isTextNode(node) && node.hasFormat(format);
+}
+function checkHasFormat(n, f) {
+  if (!hasFormat(n, f)) {
     return false;
   }
-  if (!PUNCTUATION.test(primary)) {
+  if (f === 'code') {
     return true;
   }
-  return secondary === undefined || WHITESPACE.test(secondary) || PUNCTUATION.test(secondary);
-}
-function importTextFormatTransformer(textNode, startIndex, endIndex, transformer, match) {
-  const textContent = textNode.getTextContent();
-
-  // No text matches - we can safely process the text format match
-  let transformedNode, nodeAfter, nodeBefore;
-
-  // 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) {
-    transformedNode = textNode;
-  } else {
-    if (startIndex === 0) {
-      [transformedNode, nodeAfter] = textNode.splitText(endIndex);
-    } else {
-      [nodeBefore, transformedNode, nodeAfter] = textNode.splitText(startIndex, endIndex);
-    }
-  }
-  transformedNode.setTextContent(match[2]);
-  if (transformer) {
-    for (const format of transformer.format) {
-      if (!transformedNode.hasFormat(format)) {
-        transformedNode.toggleFormat(format);
-      }
-    }
+  if (n && /^\s*$/.test(n.getTextContent())) {
+    return false;
   }
-  return {
-    nodeAfter: nodeAfter,
-    nodeBefore: nodeBefore,
-    transformedNode: transformedNode
-  };
+  return true;
 }
 
 /**
@@ -1742,6 +1789,15 @@ function importTextFormatTransformer(textNode, startIndex, endIndex, transformer
  *
  */
 
+function matchLink(text, regExp) {
+  const search = new RegExp(regExp.source, regExp.flags.replace(/[gy]/g, '') + 'g');
+  let match;
+  while ((match = search.exec(text)) !== null) {
+    if (!isEscaped(text, match.index)) return match;
+    search.lastIndex = match.index + 1;
+  }
+  return null;
+}
 function findOutermostTextMatchTransformer(textNode_, textMatchTransformers) {
   const textNode = textNode_;
   let foundMatchStartIndex = undefined;
@@ -1752,7 +1808,9 @@ function findOutermostTextMatchTransformer(textNode_, textMatchTransformers) {
     if (!transformer.replace || !transformer.importRegExp) {
       continue;
     }
-    const match = textNode.getTextContent().match(transformer.importRegExp);
+    const text = textNode.getTextContent();
+    // Transformers sharing the built-in link syntax need the same candidate rules.
+    const match = LINK.importRegExp !== undefined && transformer.importRegExp.source === LINK.importRegExp.source ? matchLink(text, transformer.importRegExp) : text.match(transformer.importRegExp);
     if (!match) {
       continue;
     }