@ruya.sa/richtext-lexical 3.71.7

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

@@ -0,0 +1,199 @@
+/**
+ * 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.
+ *
+ */import { $isListItemNode, $isListNode } from '@lexical/list';
+import { $isQuoteNode } from '@lexical/rich-text';
+import { $findMatchingParent } from '@lexical/utils';
+import { $createLineBreakNode, $createParagraphNode, $createTextNode, $getRoot, $getSelection, $isParagraphNode } from 'lexical';
+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.
+ */
+export function createMarkdownImport(transformers, shouldPreserveNewLines = false) {
+  const byType = transformersByType(transformers);
+  const textFormatTransformersIndex = createTextFormatTransformersIndex(byType.textFormat);
+  return (markdownString, node) => {
+    const lines = markdownString.split('\n');
+    const linesLength = lines.length;
+    const root = node || $getRoot();
+    root.clear();
+    for (let i = 0; i < linesLength; i++) {
+      const lineText = lines[i];
+      const [imported, shiftedIndex] = $importMultiline(lines, i, byType.multilineElement, root);
+      if (imported) {
+        // If a multiline markdown element was imported, we don't want to process the lines that were part of it anymore.
+        // There could be other sub-markdown elements (both multiline and normal ones) matching within this matched multiline element's children.
+        // However, it would be the responsibility of the matched multiline transformer to decide how it wants to handle them.
+        // 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.
+        i = shiftedIndex; // Next loop will start from the line after the last line of the multiline element
+        continue;
+      }
+      $importBlocks(lineText, root, byType.element, textFormatTransformersIndex, byType.textMatch);
+    }
+    // By default, removing empty paragraphs as md does not really
+    // allow empty lines and uses them as delimiter.
+    // If you need empty lines set shouldPreserveNewLines = true.
+    const children = root.getChildren();
+    for (const child of children) {
+      if (!shouldPreserveNewLines && isEmptyParagraph(child) && root.getChildrenSize() > 1) {
+        child.remove();
+      }
+    }
+    if ($getSelection() !== null) {
+      root.selectStart();
+    }
+  };
+}
+/**
+ *
+ * @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.
+ */
+function $importMultiline(lines, startLineIndex, multilineElementTransformers, rootNode) {
+  for (const transformer of multilineElementTransformers) {
+    const {
+      handleImportAfterStartMatch,
+      regExpEnd,
+      regExpStart,
+      replace
+    } = transformer;
+    const startMatch = lines[startLineIndex]?.match(regExpStart);
+    if (!startMatch) {
+      continue; // Try next transformer
+    }
+    if (handleImportAfterStartMatch) {
+      const result = handleImportAfterStartMatch({
+        lines,
+        rootNode,
+        startLineIndex,
+        startMatch,
+        transformer
+      });
+      if (result === null) {
+        continue;
+      } else if (result) {
+        return result;
+      }
+    }
+    const regexpEndRegex = typeof regExpEnd === 'object' && 'regExp' in regExpEnd ? regExpEnd.regExp : regExpEnd;
+    const isEndOptional = regExpEnd && typeof regExpEnd === 'object' && 'optional' in regExpEnd ? regExpEnd.optional : !regExpEnd;
+    let endLineIndex = startLineIndex;
+    const linesLength = lines.length;
+    // check every single line for the closing match. It could also be on the same line as the opening match.
+    while (endLineIndex < linesLength) {
+      const endMatch = regexpEndRegex ? lines[endLineIndex]?.match(regexpEndRegex) : null;
+      if (!endMatch) {
+        if (!isEndOptional || isEndOptional && endLineIndex < linesLength - 1 // Optional end, but didn't reach the end of the document yet => continue searching for potential closing match
+        ) {
+          endLineIndex++;
+          continue; // Search next line for closing match
+        }
+      }
+      // Now, check if the closing match matched is the same as the opening match.
+      // If it is, we need to continue searching for the actual closing match.
+      if (endMatch && startLineIndex === endLineIndex && endMatch.index === startMatch.index) {
+        endLineIndex++;
+        continue; // Search next line for closing match
+      }
+      // At this point, we have found the closing match. Next: calculate the lines in between open and closing match
+      // This should not include the matches themselves, and be split up by lines
+      const linesInBetween = [];
+      if (endMatch && startLineIndex === endLineIndex) {
+        linesInBetween.push(lines[startLineIndex].slice(startMatch[0].length, -endMatch[0].length));
+      } else {
+        for (let i = startLineIndex; i <= endLineIndex; i++) {
+          const line = lines[i];
+          if (i === startLineIndex) {
+            const text = line.slice(startMatch[0].length);
+            linesInBetween.push(text); // Also include empty text
+          } else if (i === endLineIndex && endMatch) {
+            const text = line.slice(0, -endMatch[0].length);
+            linesInBetween.push(text); // Also include empty text
+          } else {
+            linesInBetween.push(line);
+          }
+        }
+      }
+      if (replace(rootNode, null, startMatch, endMatch, linesInBetween, true) !== false) {
+        // Return here. This $importMultiline function is run line by line and should only process a single multiline element at a time.
+        return [true, endLineIndex];
+      }
+      break;
+    }
+  }
+  // No multiline transformer handled this line successfully
+  return [false, startLineIndex];
+}
+function $importBlocks(lineText, rootNode, elementTransformers, textFormatTransformersIndex, textMatchTransformers) {
+  const textNode = $createTextNode(lineText);
+  const elementNode = $createParagraphNode();
+  elementNode.append(textNode);
+  rootNode.append(elementNode);
+  for (const {
+    regExp,
+    replace
+  } of elementTransformers) {
+    const match = lineText.match(regExp);
+    if (match) {
+      textNode.setTextContent(lineText.slice(match[0].length));
+      if (replace(elementNode, [textNode], match, true) !== false) {
+        break;
+      }
+    }
+  }
+  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
+  if (elementNode.isAttached() && lineText.length > 0) {
+    const previousNode = elementNode.getPreviousSibling();
+    if ($isParagraphNode(previousNode) || $isQuoteNode(previousNode) || $isListNode(previousNode)) {
+      let targetNode = previousNode;
+      if ($isListNode(previousNode)) {
+        const lastDescendant = previousNode.getLastDescendant();
+        if (lastDescendant == null) {
+          targetNode = null;
+        } else {
+          targetNode = $findMatchingParent(lastDescendant, $isListItemNode);
+        }
+      }
+      if (targetNode != null && targetNode.getTextContentSize() > 0) {
+        targetNode.splice(targetNode.getChildrenSize(), 0, [$createLineBreakNode(), ...elementNode.getChildren()]);
+        elementNode.remove();
+      }
+    }
+  }
+}
+function createTextFormatTransformersIndex(textTransformers) {
+  const transformersByTag = {};
+  const fullMatchRegExpByTag = {};
+  const openTagsRegExp = [];
+  const escapeRegExp = `(?<![\\\\])`;
+  for (const transformer of textTransformers) {
+    const {
+      tag
+    } = transformer;
+    transformersByTag[tag] = transformer;
+    const tagRegExp = tag.replace(/([*^+])/g, '\\$1');
+    openTagsRegExp.push(tagRegExp);
+    // Single-char tag (e.g. "*"),
+    if (tag.length === 1) {
+      fullMatchRegExpByTag[tag] = new RegExp(`(?<![\\\\${tagRegExp}])(${tagRegExp})((\\\\${tagRegExp})?.*?[^${tagRegExp}\\s](\\\\${tagRegExp})?)((?<!\\\\)|(?<=\\\\\\\\))(${tagRegExp})(?![\\\\${tagRegExp}])`);
+    } else {
+      // Multi‐char tags (e.g. "**")
+      fullMatchRegExpByTag[tag] = new RegExp(`(?<!\\\\)(${tagRegExp})((\\\\${tagRegExp})?.*?[^\\s](\\\\${tagRegExp})?)((?<!\\\\)|(?<=\\\\\\\\))(${tagRegExp})(?!\\\\)`);
+    }
+  }
+  return {
+    // Reg exp to find open tag + content + close tag
+    fullMatchRegExpByTag,
+    // Regexp to locate *any* potential opening tag (longest first).
+    // eslint-disable-next-line regexp/no-useless-character-class, regexp/no-empty-capturing-group, regexp/no-empty-group
+    openTagsRegExp: new RegExp(`${escapeRegExp}(${openTagsRegExp.join('|')})`, 'g'),
+    transformersByTag
+  };
+}
+//# sourceMappingURL=MarkdownImport.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownImport.js","names":["$isListItemNode","$isListNode","$isQuoteNode","$findMatchingParent","$createLineBreakNode","$createParagraphNode","$createTextNode","$getRoot","$getSelection","$isParagraphNode","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","line","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 { 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          const line = lines[i]!\n          if (i === startLineIndex) {\n            const text = line.slice(startMatch[0].length)\n            linesInBetween.push(text) // Also include empty text\n          } else if (i === endLineIndex && endMatch) {\n            const text = line.slice(0, -endMatch[0].length)\n            linesInBetween.push(text) // Also include empty text\n          } else {\n            linesInBetween.push(line)\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    // Single-char tag (e.g. \"*\"),\n    if (tag.length === 1) {\n      fullMatchRegExpByTag[tag] = new RegExp(\n        `(?<![\\\\\\\\${tagRegExp}])(${tagRegExp})((\\\\\\\\${tagRegExp})?.*?[^${tagRegExp}\\\\s](\\\\\\\\${tagRegExp})?)((?<!\\\\\\\\)|(?<=\\\\\\\\\\\\\\\\))(${tagRegExp})(?![\\\\\\\\${tagRegExp}])`,\n      )\n    } else {\n      // Multi‐char tags (e.g. \"**\")\n      fullMatchRegExpByTag[tag] = new RegExp(\n        `(?<!\\\\\\\\)(${tagRegExp})((\\\\\\\\${tagRegExp})?.*?[^\\\\s](\\\\\\\\${tagRegExp})?)((?<!\\\\\\\\)|(?<=\\\\\\\\\\\\\\\\))(${tagRegExp})(?!\\\\\\\\)`,\n      )\n    }\n  }\n\n  return {\n    // Reg exp to find open tag + content + close tag\n    fullMatchRegExpByTag,\n\n    // Regexp to locate *any* potential opening tag (longest first).\n    // eslint-disable-next-line regexp/no-useless-character-class, regexp/no-empty-capturing-group, regexp/no-empty-group\n    openTagsRegExp: new RegExp(`${escapeRegExp}(${openTagsRegExp.join('|')})`, 'g'),\n    transformersByTag,\n  }\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ *
+ */
+import type { LexicalEditor } from 'lexical';
+import type { Transformer } from './MarkdownTransformers.js';
+export declare function registerMarkdownShortcuts(editor: LexicalEditor, transformers?: Array<Transformer>): () => void;
+//# sourceMappingURL=MarkdownShortcuts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownShortcuts.d.ts","sourceRoot":"","sources":["../../../../src/packages/@lexical/markdown/MarkdownShortcuts.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAe,aAAa,EAAY,MAAM,SAAS,CAAA;AAYnE,OAAO,KAAK,EAKV,WAAW,EACZ,MAAM,2BAA2B,CAAA;AA4TlC,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,aAAa,EACrB,YAAY,GAAE,KAAK,CAAC,WAAW,CAAgB,GAC9C,MAAM,IAAI,CA8FZ"}

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

@@ -0,0 +1,304 @@
+/**
+ * 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.
+ *
+ */import { $createRangeSelection, $getSelection, $isLineBreakNode, $isRangeSelection, $isRootOrShadowRoot, $isTextNode, $setSelection } from 'lexical';
+import { TRANSFORMERS } from './index.js';
+import { indexBy, PUNCTUATION_OR_SPACE, transformersByType } from './utils.js';
+function runElementTransformers(parentNode, anchorNode, anchorOffset, elementTransformers) {
+  const grandParentNode = parentNode.getParent();
+  if (!$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);
+      leadingNode?.remove();
+      const siblings = remainderNode ? [remainderNode, ...nextSiblings] : nextSiblings;
+      if (replace(parentNode, siblings, match, false) !== false) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function runMultilineElementTransformers(parentNode, anchorNode, anchorOffset, elementTransformers) {
+  const grandParentNode = parentNode.getParent();
+  if (!$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 {
+    regExpEnd,
+    regExpStart,
+    replace
+  } 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);
+      leadingNode?.remove();
+      const siblings = remainderNode ? [remainderNode, ...nextSiblings] : nextSiblings;
+      if (replace(parentNode, siblings, match, null, null, false) !== false) {
+        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);
+    }
+    if (replaceNode) {
+      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 ($isLineBreakNode(sibling)) {
+        break;
+      }
+      if ($isTextNode(sibling)) {
+        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 = $getSelection();
+    const nextSelection = $createRangeSelection();
+    $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 ($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;
+}
+export 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)) {
+          throw new Error('MarkdownShortcuts: missing dependency %s for transformer. Ensure node dependency is included in editor initial config.' + node.getType());
+        }
+      }
+    }
+  }
+  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(({
+    dirtyLeaves,
+    editorState,
+    prevEditorState,
+    tags
+  }) => {
+    // Ignore updates from collaboration and undo/redo (as changes already calculated)
+    if (tags.has('collaboration') || tags.has('historic')) {
+      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($getSelection);
+    const prevSelection = prevEditorState.read($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 (!$isRangeSelection(prevSelection) || !$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 (!$isTextNode(anchorNode) || !dirtyLeaves.has(anchorKey) || anchorOffset !== 1 && anchorOffset > prevSelection.anchor.offset + 1) {
+      return;
+    }
+    editor.update(() => {
+      // Markdown is not available inside code
+      if (anchorNode.hasFormat('code')) {
+        return;
+      }
+      const parentNode = anchorNode.getParent();
+      if (parentNode === null) {
+        return;
+      }
+      $transform(parentNode, anchorNode, selection.anchor.offset);
+    });
+  });
+}
+//# sourceMappingURL=MarkdownShortcuts.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownShortcuts.js","names":["$createRangeSelection","$getSelection","$isLineBreakNode","$isRangeSelection","$isRootOrShadowRoot","$isTextNode","$setSelection","TRANSFORMERS","indexBy","PUNCTUATION_OR_SPACE","transformersByType","runElementTransformers","parentNode","anchorNode","anchorOffset","elementTransformers","grandParentNode","getParent","getFirstChild","textContent","getTextContent","regExp","replace","match","length","endsWith","nextSiblings","getNextSiblings","leadingNode","remainderNode","splitText","remove","siblings","runMultilineElementTransformers","regExpEnd","regExpStart","optional","runTextMatchTransformers","transformersByTrigger","lastChar","transformers","slice","transformer","startIndex","index","endIndex","replaceNode","selectNext","$runTextFormatTransformers","textFormatTransformers","closeTagEndIndex","closeChar","matchers","matcher","tag","tagLength","closeTagStartIndex","isEqualSubString","afterCloseTagChar","intraword","test","closeNode","openNode","openTagStartIndex","getOpenTagStartIndex","sibling","getPreviousSibling","siblingTextContent","prevOpenNodeText","beforeOpenTagChar","prevCloseNodeText","closeNodeText","setTextContent","openNodeText","selection","nextSelection","newOffset","anchor","set","__key","focus","format","hasFormat","formatText","key","offset","type","toggleFormat","string","maxIndex","i","stringA","aStart","stringB","bStart","registerMarkdownShortcuts","editor","byType","textFormatTransformersByTrigger","textFormat","textMatchTransformersByTrigger","textMatch","trigger","dependencies","node","hasNode","Error","getType","$transform","element","multilineElement","registerUpdateListener","dirtyLeaves","editorState","prevEditorState","tags","has","isComposing","read","prevSelection","isCollapsed","is","anchorKey","_nodeMap","get","update"],"sources":["../../../../src/packages/@lexical/markdown/MarkdownShortcuts.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, LexicalEditor, TextNode } from 'lexical'\n\nimport {\n  $createRangeSelection,\n  $getSelection,\n  $isLineBreakNode,\n  $isRangeSelection,\n  $isRootOrShadowRoot,\n  $isTextNode,\n  $setSelection,\n} from 'lexical'\n\nimport type {\n  ElementTransformer,\n  MultilineElementTransformer,\n  TextFormatTransformer,\n  TextMatchTransformer,\n  Transformer,\n} from './MarkdownTransformers.js'\n\nimport { TRANSFORMERS } from './index.js'\nimport { indexBy, PUNCTUATION_OR_SPACE, transformersByType } from './utils.js'\n\nfunction runElementTransformers(\n  parentNode: ElementNode,\n  anchorNode: TextNode,\n  anchorOffset: number,\n  elementTransformers: ReadonlyArray<ElementTransformer>,\n): boolean {\n  const grandParentNode = parentNode.getParent()\n\n  if (!$isRootOrShadowRoot(grandParentNode) || parentNode.getFirstChild() !== anchorNode) {\n    return false\n  }\n\n  const textContent = anchorNode.getTextContent()\n\n  // Checking for anchorOffset position to prevent any checks for cases when caret is too far\n  // from a line start to be a part of block-level markdown trigger.\n  //\n  // TODO:\n  // Can have a quick check if caret is close enough to the beginning of the string (e.g. offset less than 10-20)\n  // since otherwise it won't be a markdown shortcut, but tables are exception\n  if (textContent[anchorOffset - 1] !== ' ') {\n    return false\n  }\n\n  for (const { regExp, replace } of elementTransformers) {\n    const match = textContent.match(regExp)\n\n    if (match && match[0].length === (match[0].endsWith(' ') ? anchorOffset : anchorOffset - 1)) {\n      const nextSiblings = anchorNode.getNextSiblings()\n      const [leadingNode, remainderNode] = anchorNode.splitText(anchorOffset)\n      leadingNode?.remove()\n      const siblings = remainderNode ? [remainderNode, ...nextSiblings] : nextSiblings\n      if (replace(parentNode, siblings, match, false) !== false) {\n        return true\n      }\n    }\n  }\n\n  return false\n}\n\nfunction runMultilineElementTransformers(\n  parentNode: ElementNode,\n  anchorNode: TextNode,\n  anchorOffset: number,\n  elementTransformers: ReadonlyArray<MultilineElementTransformer>,\n): boolean {\n  const grandParentNode = parentNode.getParent()\n\n  if (!$isRootOrShadowRoot(grandParentNode) || parentNode.getFirstChild() !== anchorNode) {\n    return false\n  }\n\n  const textContent = anchorNode.getTextContent()\n\n  // Checking for anchorOffset position to prevent any checks for cases when caret is too far\n  // from a line start to be a part of block-level markdown trigger.\n  //\n  // TODO:\n  // Can have a quick check if caret is close enough to the beginning of the string (e.g. offset less than 10-20)\n  // since otherwise it won't be a markdown shortcut, but tables are exception\n  if (textContent[anchorOffset - 1] !== ' ') {\n    return false\n  }\n\n  for (const { regExpEnd, regExpStart, replace } of elementTransformers) {\n    if (\n      (regExpEnd && !('optional' in regExpEnd)) ||\n      (regExpEnd && 'optional' in regExpEnd && !regExpEnd.optional)\n    ) {\n      continue\n    }\n\n    const match = textContent.match(regExpStart)\n\n    if (match && match[0].length === (match[0].endsWith(' ') ? anchorOffset : anchorOffset - 1)) {\n      const nextSiblings = anchorNode.getNextSiblings()\n      const [leadingNode, remainderNode] = anchorNode.splitText(anchorOffset)\n      leadingNode?.remove()\n      const siblings = remainderNode ? [remainderNode, ...nextSiblings] : nextSiblings\n\n      if (replace(parentNode, siblings, match, null, null, false) !== false) {\n        return true\n      }\n    }\n  }\n\n  return false\n}\n\nfunction runTextMatchTransformers(\n  anchorNode: TextNode,\n  anchorOffset: number,\n  transformersByTrigger: Readonly<Record<string, Array<TextMatchTransformer>>>,\n): boolean {\n  let textContent = anchorNode.getTextContent()\n  const lastChar = textContent[anchorOffset - 1]!\n  const transformers = transformersByTrigger[lastChar]\n\n  if (transformers == null) {\n    return false\n  }\n\n  // If typing in the middle of content, remove the tail to do\n  // reg exp match up to a string end (caret position)\n  if (anchorOffset < textContent.length) {\n    textContent = textContent.slice(0, anchorOffset)\n  }\n\n  for (const transformer of transformers) {\n    if (!transformer.replace || !transformer.regExp) {\n      continue\n    }\n    const match = textContent.match(transformer.regExp)\n\n    if (match === null) {\n      continue\n    }\n\n    const startIndex = match.index || 0\n    const endIndex = startIndex + match[0].length\n    let replaceNode\n\n    if (startIndex === 0) {\n      ;[replaceNode] = anchorNode.splitText(endIndex)\n    } else {\n      ;[, replaceNode] = anchorNode.splitText(startIndex, endIndex)\n    }\n    if (replaceNode) {\n      replaceNode.selectNext(0, 0)\n      transformer.replace(replaceNode, match)\n    }\n    return true\n  }\n\n  return false\n}\n\nfunction $runTextFormatTransformers(\n  anchorNode: TextNode,\n  anchorOffset: number,\n  textFormatTransformers: Readonly<Record<string, ReadonlyArray<TextFormatTransformer>>>,\n): boolean {\n  const textContent = anchorNode.getTextContent()\n  const closeTagEndIndex = anchorOffset - 1\n  const closeChar = textContent[closeTagEndIndex]!\n  // Quick check if we're possibly at the end of inline markdown style\n  const matchers = textFormatTransformers[closeChar]\n\n  if (!matchers) {\n    return false\n  }\n\n  for (const matcher of matchers) {\n    const { tag } = matcher\n    const tagLength = tag.length\n    const closeTagStartIndex = closeTagEndIndex - tagLength + 1\n\n    // If tag is not single char check if rest of it matches with text content\n    if (tagLength > 1) {\n      if (!isEqualSubString(textContent, closeTagStartIndex, tag, 0, tagLength)) {\n        continue\n      }\n    }\n\n    // Space before closing tag cancels inline markdown\n    if (textContent[closeTagStartIndex - 1] === ' ') {\n      continue\n    }\n\n    // Some tags can not be used within words, hence should have newline/space/punctuation after it\n    const afterCloseTagChar = textContent[closeTagEndIndex + 1]\n\n    if (\n      matcher.intraword === false &&\n      afterCloseTagChar &&\n      !PUNCTUATION_OR_SPACE.test(afterCloseTagChar)\n    ) {\n      continue\n    }\n\n    const closeNode = anchorNode\n    let openNode = closeNode\n    let openTagStartIndex = getOpenTagStartIndex(textContent, closeTagStartIndex, tag)\n\n    // Go through text node siblings and search for opening tag\n    // if haven't found it within the same text node as closing tag\n    let sibling: null | TextNode = openNode\n\n    while (openTagStartIndex < 0 && (sibling = sibling.getPreviousSibling<TextNode>())) {\n      if ($isLineBreakNode(sibling)) {\n        break\n      }\n\n      if ($isTextNode(sibling)) {\n        const siblingTextContent = sibling.getTextContent()\n        openNode = sibling\n        openTagStartIndex = getOpenTagStartIndex(siblingTextContent, siblingTextContent.length, tag)\n      }\n    }\n\n    // Opening tag is not found\n    if (openTagStartIndex < 0) {\n      continue\n    }\n\n    // No content between opening and closing tag\n    if (openNode === closeNode && openTagStartIndex + tagLength === closeTagStartIndex) {\n      continue\n    }\n\n    // Checking longer tags for repeating chars (e.g. *** vs **)\n    const prevOpenNodeText = openNode.getTextContent()\n\n    if (openTagStartIndex > 0 && prevOpenNodeText[openTagStartIndex - 1] === closeChar) {\n      continue\n    }\n\n    // Some tags can not be used within words, hence should have newline/space/punctuation before it\n    const beforeOpenTagChar = prevOpenNodeText[openTagStartIndex - 1]\n\n    if (\n      matcher.intraword === false &&\n      beforeOpenTagChar &&\n      !PUNCTUATION_OR_SPACE.test(beforeOpenTagChar)\n    ) {\n      continue\n    }\n\n    // Clean text from opening and closing tags (starting from closing tag\n    // to prevent any offset shifts if we start from opening one)\n    const prevCloseNodeText = closeNode.getTextContent()\n    const closeNodeText =\n      prevCloseNodeText.slice(0, closeTagStartIndex) + prevCloseNodeText.slice(closeTagEndIndex + 1)\n    closeNode.setTextContent(closeNodeText)\n    const openNodeText = openNode === closeNode ? closeNodeText : prevOpenNodeText\n    openNode.setTextContent(\n      openNodeText.slice(0, openTagStartIndex) + openNodeText.slice(openTagStartIndex + tagLength),\n    )\n    const selection = $getSelection()\n    const nextSelection = $createRangeSelection()\n    $setSelection(nextSelection)\n    // Adjust offset based on deleted chars\n    const newOffset = closeTagEndIndex - tagLength * (openNode === closeNode ? 2 : 1) + 1\n    nextSelection.anchor.set(openNode.__key, openTagStartIndex, 'text')\n    nextSelection.focus.set(closeNode.__key, newOffset, 'text')\n\n    // Apply formatting to selected text\n    for (const format of matcher.format) {\n      if (!nextSelection.hasFormat(format)) {\n        nextSelection.formatText(format)\n      }\n    }\n\n    // Collapse selection up to the focus point\n    nextSelection.anchor.set(\n      nextSelection.focus.key,\n      nextSelection.focus.offset,\n      nextSelection.focus.type,\n    )\n\n    // Remove formatting from collapsed selection\n    for (const format of matcher.format) {\n      if (nextSelection.hasFormat(format)) {\n        nextSelection.toggleFormat(format)\n      }\n    }\n\n    if ($isRangeSelection(selection)) {\n      nextSelection.format = selection.format\n    }\n\n    return true\n  }\n\n  return false\n}\n\nfunction getOpenTagStartIndex(string: string, maxIndex: number, tag: string): number {\n  const tagLength = tag.length\n\n  for (let i = maxIndex; i >= tagLength; i--) {\n    const startIndex = i - tagLength\n\n    if (\n      isEqualSubString(string, startIndex, tag, 0, tagLength) && // Space after opening tag cancels transformation\n      string[startIndex + tagLength] !== ' '\n    ) {\n      return startIndex\n    }\n  }\n\n  return -1\n}\n\nfunction isEqualSubString(\n  stringA: string,\n  aStart: number,\n  stringB: string,\n  bStart: number,\n  length: number,\n): boolean {\n  for (let i = 0; i < length; i++) {\n    if (stringA[aStart + i] !== stringB[bStart + i]) {\n      return false\n    }\n  }\n\n  return true\n}\n\nexport function registerMarkdownShortcuts(\n  editor: LexicalEditor,\n  transformers: Array<Transformer> = TRANSFORMERS,\n): () => void {\n  const byType = transformersByType(transformers)\n  const textFormatTransformersByTrigger = indexBy(\n    byType.textFormat,\n    ({ tag }) => tag[tag.length - 1],\n  )\n  const textMatchTransformersByTrigger = indexBy(byType.textMatch, ({ trigger }) => trigger)\n\n  for (const transformer of transformers) {\n    const type = transformer.type\n    if (type === 'element' || type === 'text-match' || type === 'multiline-element') {\n      const dependencies = transformer.dependencies\n      for (const node of dependencies) {\n        if (!editor.hasNode(node)) {\n          throw new Error(\n            'MarkdownShortcuts: missing dependency %s for transformer. Ensure node dependency is included in editor initial config.' +\n              node.getType(),\n          )\n        }\n      }\n    }\n  }\n\n  const $transform = (parentNode: ElementNode, anchorNode: TextNode, anchorOffset: number) => {\n    if (runElementTransformers(parentNode, anchorNode, anchorOffset, byType.element)) {\n      return\n    }\n\n    if (\n      runMultilineElementTransformers(parentNode, anchorNode, anchorOffset, byType.multilineElement)\n    ) {\n      return\n    }\n\n    if (runTextMatchTransformers(anchorNode, anchorOffset, textMatchTransformersByTrigger)) {\n      return\n    }\n\n    $runTextFormatTransformers(anchorNode, anchorOffset, textFormatTransformersByTrigger)\n  }\n\n  return editor.registerUpdateListener(({ dirtyLeaves, editorState, prevEditorState, tags }) => {\n    // Ignore updates from collaboration and undo/redo (as changes already calculated)\n    if (tags.has('collaboration') || tags.has('historic')) {\n      return\n    }\n\n    // If editor is still composing (i.e. backticks) we must wait before the user confirms the key\n    if (editor.isComposing()) {\n      return\n    }\n\n    const selection = editorState.read($getSelection)\n    const prevSelection = prevEditorState.read($getSelection)\n\n    // We expect selection to be a collapsed range and not match previous one (as we want\n    // to trigger transforms only as user types)\n    if (\n      !$isRangeSelection(prevSelection) ||\n      !$isRangeSelection(selection) ||\n      !selection.isCollapsed() ||\n      selection.is(prevSelection)\n    ) {\n      return\n    }\n\n    const anchorKey = selection.anchor.key\n    const anchorOffset = selection.anchor.offset\n\n    const anchorNode = editorState._nodeMap.get(anchorKey)\n\n    if (\n      !$isTextNode(anchorNode) ||\n      !dirtyLeaves.has(anchorKey) ||\n      (anchorOffset !== 1 && anchorOffset > prevSelection.anchor.offset + 1)\n    ) {\n      return\n    }\n\n    editor.update(() => {\n      // Markdown is not available inside code\n      if (anchorNode.hasFormat('code')) {\n        return\n      }\n\n      const parentNode = anchorNode.getParent()\n\n      if (parentNode === null) {\n        return\n      }\n\n      $transform(parentNode, anchorNode, selection.anchor.offset)\n    })\n  })\n}\n"],"mappings":"AAAA;;;;;;GAUA,SACEA,qBAAqB,EACrBC,aAAa,EACbC,gBAAgB,EAChBC,iBAAiB,EACjBC,mBAAmB,EACnBC,WAAW,EACXC,aAAa,QACR;AAUP,SAASC,YAAY,QAAQ;AAC7B,SAASC,OAAO,EAAEC,oBAAoB,EAAEC,kBAAkB,QAAQ;AAElE,SAASC,uBACPC,UAAuB,EACvBC,UAAoB,EACpBC,YAAoB,EACpBC,mBAAsD;EAEtD,MAAMC,eAAA,GAAkBJ,UAAA,CAAWK,SAAS;EAE5C,IAAI,CAACb,mBAAA,CAAoBY,eAAA,KAAoBJ,UAAA,CAAWM,aAAa,OAAOL,UAAA,EAAY;IACtF,OAAO;EACT;EAEA,MAAMM,WAAA,GAAcN,UAAA,CAAWO,cAAc;EAE7C;EACA;EACA;EACA;EACA;EACA;EACA,IAAID,WAAW,CAACL,YAAA,GAAe,EAAE,KAAK,KAAK;IACzC,OAAO;EACT;EAEA,KAAK,MAAM;IAAEO,MAAM;IAAEC;EAAO,CAAE,IAAIP,mBAAA,EAAqB;IACrD,MAAMQ,KAAA,GAAQJ,WAAA,CAAYI,KAAK,CAACF,MAAA;IAEhC,IAAIE,KAAA,IAASA,KAAK,CAAC,EAAE,CAACC,MAAM,MAAMD,KAAK,CAAC,EAAE,CAACE,QAAQ,CAAC,OAAOX,YAAA,GAAeA,YAAA,GAAe,IAAI;MAC3F,MAAMY,YAAA,GAAeb,UAAA,CAAWc,eAAe;MAC/C,MAAM,CAACC,WAAA,EAAaC,aAAA,CAAc,GAAGhB,UAAA,CAAWiB,SAAS,CAAChB,YAAA;MAC1Dc,WAAA,EAAaG,MAAA;MACb,MAAMC,QAAA,GAAWH,aAAA,GAAgB,CAACA,aAAA,E,GAAkBH,YAAA,CAAa,GAAGA,YAAA;MACpE,IAAIJ,OAAA,CAAQV,UAAA,EAAYoB,QAAA,EAAUT,KAAA,EAAO,WAAW,OAAO;QACzD,OAAO;MACT;IACF;EACF;EAEA,OAAO;AACT;AAEA,SAASU,gCACPrB,UAAuB,EACvBC,UAAoB,EACpBC,YAAoB,EACpBC,mBAA+D;EAE/D,MAAMC,eAAA,GAAkBJ,UAAA,CAAWK,SAAS;EAE5C,IAAI,CAACb,mBAAA,CAAoBY,eAAA,KAAoBJ,UAAA,CAAWM,aAAa,OAAOL,UAAA,EAAY;IACtF,OAAO;EACT;EAEA,MAAMM,WAAA,GAAcN,UAAA,CAAWO,cAAc;EAE7C;EACA;EACA;EACA;EACA;EACA;EACA,IAAID,WAAW,CAACL,YAAA,GAAe,EAAE,KAAK,KAAK;IACzC,OAAO;EACT;EAEA,KAAK,MAAM;IAAEoB,SAAS;IAAEC,WAAW;IAAEb;EAAO,CAAE,IAAIP,mBAAA,EAAqB;IACrE,IACEmB,SAAC,IAAa,EAAE,cAAcA,SAAQ,KACrCA,SAAA,IAAa,cAAcA,SAAA,IAAa,CAACA,SAAA,CAAUE,QAAQ,EAC5D;MACA;IACF;IAEA,MAAMb,KAAA,GAAQJ,WAAA,CAAYI,KAAK,CAACY,WAAA;IAEhC,IAAIZ,KAAA,IAASA,KAAK,CAAC,EAAE,CAACC,MAAM,MAAMD,KAAK,CAAC,EAAE,CAACE,QAAQ,CAAC,OAAOX,YAAA,GAAeA,YAAA,GAAe,IAAI;MAC3F,MAAMY,YAAA,GAAeb,UAAA,CAAWc,eAAe;MAC/C,MAAM,CAACC,WAAA,EAAaC,aAAA,CAAc,GAAGhB,UAAA,CAAWiB,SAAS,CAAChB,YAAA;MAC1Dc,WAAA,EAAaG,MAAA;MACb,MAAMC,QAAA,GAAWH,aAAA,GAAgB,CAACA,aAAA,E,GAAkBH,YAAA,CAAa,GAAGA,YAAA;MAEpE,IAAIJ,OAAA,CAAQV,UAAA,EAAYoB,QAAA,EAAUT,KAAA,EAAO,MAAM,MAAM,WAAW,OAAO;QACrE,OAAO;MACT;IACF;EACF;EAEA,OAAO;AACT;AAEA,SAASc,yBACPxB,UAAoB,EACpBC,YAAoB,EACpBwB,qBAA4E;EAE5E,IAAInB,WAAA,GAAcN,UAAA,CAAWO,cAAc;EAC3C,MAAMmB,QAAA,GAAWpB,WAAW,CAACL,YAAA,GAAe,EAAE;EAC9C,MAAM0B,YAAA,GAAeF,qBAAqB,CAACC,QAAA,CAAS;EAEpD,IAAIC,YAAA,IAAgB,MAAM;IACxB,OAAO;EACT;EAEA;EACA;EACA,IAAI1B,YAAA,GAAeK,WAAA,CAAYK,MAAM,EAAE;IACrCL,WAAA,GAAcA,WAAA,CAAYsB,KAAK,CAAC,GAAG3B,YAAA;EACrC;EAEA,KAAK,MAAM4B,WAAA,IAAeF,YAAA,EAAc;IACtC,IAAI,CAACE,WAAA,CAAYpB,OAAO,IAAI,CAACoB,WAAA,CAAYrB,MAAM,EAAE;MAC/C;IACF;IACA,MAAME,KAAA,GAAQJ,WAAA,CAAYI,KAAK,CAACmB,WAAA,CAAYrB,MAAM;IAElD,IAAIE,KAAA,KAAU,MAAM;MAClB;IACF;IAEA,MAAMoB,UAAA,GAAapB,KAAA,CAAMqB,KAAK,IAAI;IAClC,MAAMC,QAAA,GAAWF,UAAA,GAAapB,KAAK,CAAC,EAAE,CAACC,MAAM;IAC7C,IAAIsB,WAAA;IAEJ,IAAIH,UAAA,KAAe,GAAG;MACnB,CAACG,WAAA,CAAY,GAAGjC,UAAA,CAAWiB,SAAS,CAACe,QAAA;IACxC,OAAO;MACJ,GAAGC,WAAA,CAAY,GAAGjC,UAAA,CAAWiB,SAAS,CAACa,UAAA,EAAYE,QAAA;IACtD;IACA,IAAIC,WAAA,EAAa;MACfA,WAAA,CAAYC,UAAU,CAAC,GAAG;MAC1BL,WAAA,CAAYpB,OAAO,CAACwB,WAAA,EAAavB,KAAA;IACnC;IACA,OAAO;EACT;EAEA,OAAO;AACT;AAEA,SAASyB,2BACPnC,UAAoB,EACpBC,YAAoB,EACpBmC,sBAAsF;EAEtF,MAAM9B,WAAA,GAAcN,UAAA,CAAWO,cAAc;EAC7C,MAAM8B,gBAAA,GAAmBpC,YAAA,GAAe;EACxC,MAAMqC,SAAA,GAAYhC,WAAW,CAAC+B,gBAAA,CAAiB;EAC/C;EACA,MAAME,QAAA,GAAWH,sBAAsB,CAACE,SAAA,CAAU;EAElD,IAAI,CAACC,QAAA,EAAU;IACb,OAAO;EACT;EAEA,KAAK,MAAMC,OAAA,IAAWD,QAAA,EAAU;IAC9B,MAAM;MAAEE;IAAG,CAAE,GAAGD,OAAA;IAChB,MAAME,SAAA,GAAYD,GAAA,CAAI9B,MAAM;IAC5B,MAAMgC,kBAAA,GAAqBN,gBAAA,GAAmBK,SAAA,GAAY;IAE1D;IACA,IAAIA,SAAA,GAAY,GAAG;MACjB,IAAI,CAACE,gBAAA,CAAiBtC,WAAA,EAAaqC,kBAAA,EAAoBF,GAAA,EAAK,GAAGC,SAAA,GAAY;QACzE;MACF;IACF;IAEA;IACA,IAAIpC,WAAW,CAACqC,kBAAA,GAAqB,EAAE,KAAK,KAAK;MAC/C;IACF;IAEA;IACA,MAAME,iBAAA,GAAoBvC,WAAW,CAAC+B,gBAAA,GAAmB,EAAE;IAE3D,IACEG,OAAA,CAAQM,SAAS,KAAK,SACtBD,iBAAA,IACA,CAACjD,oBAAA,CAAqBmD,IAAI,CAACF,iBAAA,GAC3B;MACA;IACF;IAEA,MAAMG,SAAA,GAAYhD,UAAA;IAClB,IAAIiD,QAAA,GAAWD,SAAA;IACf,IAAIE,iBAAA,GAAoBC,oBAAA,CAAqB7C,WAAA,EAAaqC,kBAAA,EAAoBF,GAAA;IAE9E;IACA;IACA,IAAIW,OAAA,GAA2BH,QAAA;IAE/B,OAAOC,iBAAA,GAAoB,MAAME,OAAA,GAAUA,OAAA,CAAQC,kBAAkB,EAAW,GAAI;MAClF,IAAIhE,gBAAA,CAAiB+D,OAAA,GAAU;QAC7B;MACF;MAEA,IAAI5D,WAAA,CAAY4D,OAAA,GAAU;QACxB,MAAME,kBAAA,GAAqBF,OAAA,CAAQ7C,cAAc;QACjD0C,QAAA,GAAWG,OAAA;QACXF,iBAAA,GAAoBC,oBAAA,CAAqBG,kBAAA,EAAoBA,kBAAA,CAAmB3C,MAAM,EAAE8B,GAAA;MAC1F;IACF;IAEA;IACA,IAAIS,iBAAA,GAAoB,GAAG;MACzB;IACF;IAEA;IACA,IAAID,QAAA,KAAaD,SAAA,IAAaE,iBAAA,GAAoBR,SAAA,KAAcC,kBAAA,EAAoB;MAClF;IACF;IAEA;IACA,MAAMY,gBAAA,GAAmBN,QAAA,CAAS1C,cAAc;IAEhD,IAAI2C,iBAAA,GAAoB,KAAKK,gBAAgB,CAACL,iBAAA,GAAoB,EAAE,KAAKZ,SAAA,EAAW;MAClF;IACF;IAEA;IACA,MAAMkB,iBAAA,GAAoBD,gBAAgB,CAACL,iBAAA,GAAoB,EAAE;IAEjE,IACEV,OAAA,CAAQM,SAAS,KAAK,SACtBU,iBAAA,IACA,CAAC5D,oBAAA,CAAqBmD,IAAI,CAACS,iBAAA,GAC3B;MACA;IACF;IAEA;IACA;IACA,MAAMC,iBAAA,GAAoBT,SAAA,CAAUzC,cAAc;IAClD,MAAMmD,aAAA,GACJD,iBAAA,CAAkB7B,KAAK,CAAC,GAAGe,kBAAA,IAAsBc,iBAAA,CAAkB7B,KAAK,CAACS,gBAAA,GAAmB;IAC9FW,SAAA,CAAUW,cAAc,CAACD,aAAA;IACzB,MAAME,YAAA,GAAeX,QAAA,KAAaD,SAAA,GAAYU,aAAA,GAAgBH,gBAAA;IAC9DN,QAAA,CAASU,cAAc,CACrBC,YAAA,CAAahC,KAAK,CAAC,GAAGsB,iBAAA,IAAqBU,YAAA,CAAahC,KAAK,CAACsB,iBAAA,GAAoBR,SAAA;IAEpF,MAAMmB,SAAA,GAAYzE,aAAA;IAClB,MAAM0E,aAAA,GAAgB3E,qBAAA;IACtBM,aAAA,CAAcqE,aAAA;IACd;IACA,MAAMC,SAAA,GAAY1B,gBAAA,GAAmBK,SAAA,IAAaO,QAAA,KAAaD,SAAA,GAAY,IAAI,KAAK;IACpFc,aAAA,CAAcE,MAAM,CAACC,GAAG,CAAChB,QAAA,CAASiB,KAAK,EAAEhB,iBAAA,EAAmB;IAC5DY,aAAA,CAAcK,KAAK,CAACF,GAAG,CAACjB,SAAA,CAAUkB,KAAK,EAAEH,SAAA,EAAW;IAEpD;IACA,KAAK,MAAMK,MAAA,IAAU5B,OAAA,CAAQ4B,MAAM,EAAE;MACnC,IAAI,CAACN,aAAA,CAAcO,SAAS,CAACD,MAAA,GAAS;QACpCN,aAAA,CAAcQ,UAAU,CAACF,MAAA;MAC3B;IACF;IAEA;IACAN,aAAA,CAAcE,MAAM,CAACC,GAAG,CACtBH,aAAA,CAAcK,KAAK,CAACI,GAAG,EACvBT,aAAA,CAAcK,KAAK,CAACK,MAAM,EAC1BV,aAAA,CAAcK,KAAK,CAACM,IAAI;IAG1B;IACA,KAAK,MAAML,MAAA,IAAU5B,OAAA,CAAQ4B,MAAM,EAAE;MACnC,IAAIN,aAAA,CAAcO,SAAS,CAACD,MAAA,GAAS;QACnCN,aAAA,CAAcY,YAAY,CAACN,MAAA;MAC7B;IACF;IAEA,IAAI9E,iBAAA,CAAkBuE,SAAA,GAAY;MAChCC,aAAA,CAAcM,MAAM,GAAGP,SAAA,CAAUO,MAAM;IACzC;IAEA,OAAO;EACT;EAEA,OAAO;AACT;AAEA,SAASjB,qBAAqBwB,MAAc,EAAEC,QAAgB,EAAEnC,GAAW;EACzE,MAAMC,SAAA,GAAYD,GAAA,CAAI9B,MAAM;EAE5B,KAAK,IAAIkE,CAAA,GAAID,QAAA,EAAUC,CAAA,IAAKnC,SAAA,EAAWmC,CAAA,IAAK;IAC1C,MAAM/C,UAAA,GAAa+C,CAAA,GAAInC,SAAA;IAEvB,IACEE,gBAAA,CAAiB+B,MAAA,EAAQ7C,UAAA,EAAYW,GAAA,EAAK,GAAGC,SAAA;IAAc;IAC3DiC,MAAM,CAAC7C,UAAA,GAAaY,SAAA,CAAU,KAAK,KACnC;MACA,OAAOZ,UAAA;IACT;EACF;EAEA,OAAO,CAAC;AACV;AAEA,SAASc,iBACPkC,OAAe,EACfC,MAAc,EACdC,OAAe,EACfC,MAAc,EACdtE,MAAc;EAEd,KAAK,IAAIkE,CAAA,GAAI,GAAGA,CAAA,GAAIlE,MAAA,EAAQkE,CAAA,IAAK;IAC/B,IAAIC,OAAO,CAACC,MAAA,GAASF,CAAA,CAAE,KAAKG,OAAO,CAACC,MAAA,GAASJ,CAAA,CAAE,EAAE;MAC/C,OAAO;IACT;EACF;EAEA,OAAO;AACT;AAEA,OAAO,SAASK,0BACdC,MAAqB,EACrBxD,YAAA,GAAmCjC,YAAY;EAE/C,MAAM0F,MAAA,GAASvF,kBAAA,CAAmB8B,YAAA;EAClC,MAAM0D,+BAAA,GAAkC1F,OAAA,CACtCyF,MAAA,CAAOE,UAAU,EACjB,CAAC;IAAE7C;EAAG,CAAE,KAAKA,GAAG,CAACA,GAAA,CAAI9B,MAAM,GAAG,EAAE;EAElC,MAAM4E,8BAAA,GAAiC5F,OAAA,CAAQyF,MAAA,CAAOI,SAAS,EAAE,CAAC;IAAEC;EAAO,CAAE,KAAKA,OAAA;EAElF,KAAK,MAAM5D,WAAA,IAAeF,YAAA,EAAc;IACtC,MAAM8C,IAAA,GAAO5C,WAAA,CAAY4C,IAAI;IAC7B,IAAIA,IAAA,KAAS,aAAaA,IAAA,KAAS,gBAAgBA,IAAA,KAAS,qBAAqB;MAC/E,MAAMiB,YAAA,GAAe7D,WAAA,CAAY6D,YAAY;MAC7C,KAAK,MAAMC,IAAA,IAAQD,YAAA,EAAc;QAC/B,IAAI,CAACP,MAAA,CAAOS,OAAO,CAACD,IAAA,GAAO;UACzB,MAAM,IAAIE,KAAA,CACR,2HACEF,IAAA,CAAKG,OAAO;QAElB;MACF;IACF;EACF;EAEA,MAAMC,UAAA,GAAaA,CAAChG,UAAA,EAAyBC,UAAA,EAAsBC,YAAA;IACjE,IAAIH,sBAAA,CAAuBC,UAAA,EAAYC,UAAA,EAAYC,YAAA,EAAcmF,MAAA,CAAOY,OAAO,GAAG;MAChF;IACF;IAEA,IACE5E,+BAAA,CAAgCrB,UAAA,EAAYC,UAAA,EAAYC,YAAA,EAAcmF,MAAA,CAAOa,gBAAgB,GAC7F;MACA;IACF;IAEA,IAAIzE,wBAAA,CAAyBxB,UAAA,EAAYC,YAAA,EAAcsF,8BAAA,GAAiC;MACtF;IACF;IAEApD,0BAAA,CAA2BnC,UAAA,EAAYC,YAAA,EAAcoF,+BAAA;EACvD;EAEA,OAAOF,MAAA,CAAOe,sBAAsB,CAAC,CAAC;IAAEC,WAAW;IAAEC,WAAW;IAAEC,eAAe;IAAEC;EAAI,CAAE;IACvF;IACA,IAAIA,IAAA,CAAKC,GAAG,CAAC,oBAAoBD,IAAA,CAAKC,GAAG,CAAC,aAAa;MACrD;IACF;IAEA;IACA,IAAIpB,MAAA,CAAOqB,WAAW,IAAI;MACxB;IACF;IAEA,MAAM3C,SAAA,GAAYuC,WAAA,CAAYK,IAAI,CAACrH,aAAA;IACnC,MAAMsH,aAAA,GAAgBL,eAAA,CAAgBI,IAAI,CAACrH,aAAA;IAE3C;IACA;IACA,IACE,CAACE,iBAAA,CAAkBoH,aAAA,KACnB,CAACpH,iBAAA,CAAkBuE,SAAA,KACnB,CAACA,SAAA,CAAU8C,WAAW,MACtB9C,SAAA,CAAU+C,EAAE,CAACF,aAAA,GACb;MACA;IACF;IAEA,MAAMG,SAAA,GAAYhD,SAAA,CAAUG,MAAM,CAACO,GAAG;IACtC,MAAMtE,YAAA,GAAe4D,SAAA,CAAUG,MAAM,CAACQ,MAAM;IAE5C,MAAMxE,UAAA,GAAaoG,WAAA,CAAYU,QAAQ,CAACC,GAAG,CAACF,SAAA;IAE5C,IACE,CAACrH,WAAA,CAAYQ,UAAA,KACb,CAACmG,WAAA,CAAYI,GAAG,CAACM,SAAA,KAChB5G,YAAA,KAAiB,KAAKA,YAAA,GAAeyG,aAAA,CAAc1C,MAAM,CAACQ,MAAM,GAAG,GACpE;MACA;IACF;IAEAW,MAAA,CAAO6B,MAAM,CAAC;MACZ;MACA,IAAIhH,UAAA,CAAWqE,SAAS,CAAC,SAAS;QAChC;MACF;MAEA,MAAMtE,UAAA,GAAaC,UAAA,CAAWI,SAAS;MAEvC,IAAIL,UAAA,KAAe,MAAM;QACvB;MACF;MAEAgG,UAAA,CAAWhG,UAAA,EAAYC,UAAA,EAAY6D,SAAA,CAAUG,MAAM,CAACQ,MAAM;IAC5D;EACF;AACF","ignoreList":[]}